[mlir][spirv] Add support for OpTypeSampledImage

[Weiwei-2021]

Summary

Support OpTypeSampledImage in SPIRV Dialect.

co-authored-by: Alan Liu <[e-mail]>

[antiagainst]

Awesome, looks nice. Could you also add tests to test/Dialect/SPIRV/IR/types.mlir? That one is for testing type/op validaty. test/Target/SPIRV/ is just for serialization/deserialization roundtrip.

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVBase.td

3320–3321

Hmm, the text wrapping seems a bit off. Did you use the script under utils/spirv to add it here? You can

cd utils/spirv
./define_opcodes.sh OpTypeSampledImage

It will automatically pull in the opcode from the spec and update the enum list here, including reflowing .

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVTypes.h

244

Nit: could you use a few empty lines to separate the method declarations to make it more clear like the above types?

249

Can you add a verifyConstructionInvariants to check that the enclosed type is indeed an image type? (Aslo add tests for it to check error cases.) You can use MatrixType::verifyConstructionInvariants as a reference.

mlir/lib/Dialect/SPIRV/IR/SPIRVTypes.cpp

732

We can let this method to return spirv::ImageType directly to avoid requiring all callers to cast?

[bondhugula]

mlir/lib/Dialect/SPIRV/IR/SPIRVDialect.cpp

759

Nit: I notice that you use camel case at some places "spv.globalVariable" while all lower here. Consider "sampledImage" or snake case "sampled_image" for consistency and readability.

[Weiwei-2021]

I am not familiar with adding test for mlir, please let me know whether the way I add API it right or wrong. Thanks!

[Weiwei-2021]

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVBase.td

3320–3321

Thank you for telling! I don't know that there is a script for it. I manually added it....

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVTypes.h

249

I added test and some API for it. Please let me know whether I did in a correct way!

mlir/lib/Dialect/SPIRV/IR/SPIRVDialect.cpp

759

Thanks for pointing it out!

mlir/lib/Dialect/SPIRV/IR/SPIRVTypes.cpp

732

I tried to return spirv::ImageType but triggered an error. I check MatrixTyps, it seems that it use the same approach to return its type.

[ergawy]

mlir/lib/Dialect/SPIRV/IR/SPIRVDialect.cpp

556

nit: Can you replace parseVal with parsedType? I think it makes the code more readable since the name related more closely to what it represents.

Also, as long as the var type is not that complicated/difficult to deduce (here it's just Type), then it would be better to explicitly state its type instead of auto.

556

Any reason why not inline parseAndVerifySampledImageType here and get rid of it above?

[antiagainst]

Generally LGTM. Could you also update SPIR-V.md regarding the new changes? Thanks!

mlir/lib/Dialect/SPIRV/IR/SPIRVDialect.cpp

759

Actually, we should be using all lower cases here to be consistent with other types. Could you change it to sampled_image?

Regarding spv.globalVariable, it should actually be spv.GlobalVariable to be consistent with other ops. That is something to be cleaned up but not yet done. Sorry for the confusion!

[Weiwei-2021]

mlir/lib/Dialect/SPIRV/IR/SPIRVDialect.cpp

556

I changed the variable and auto. Thanks. About the parseAndVerify function, I refer to Matrix Type to write this part. It reads like that we want to put the verify part is in a separate function, so I follow it.

759

good to know. Thanks for correction.

[antiagainst]

Thanks for contributing and also thanks for the patience to tolerate multiple runs of my nitpicking. :) The first few patches typically see more of that as a way to establish coding conventions. I expect it to happen less in the future.

[Weiwei-2021]

In D96169#2551917, @antiagainst wrote:

Thanks for contributing and also thanks for the patience to tolerate multiple runs of my nitpicking. :) The first few patches typically see more of that as a way to establish coding conventions. I expect it to happen less in the future.

Thank you very much for your review and explanation all the time. Like I mentioned at the beginning, I am a newbie in both MLIR and contrinbuing code to an open source community. I do need those advices! Appreciate for you time and help!

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVBase.td

 def SPV_OC_OpCapability                : I32EnumAttrCase<"OpCapability", 17>;
 def SPV_OC_OpTypeVoid                  : I32EnumAttrCase<"OpTypeVoid", 19>;
 def SPV_OC_OpTypeBool                  : I32EnumAttrCase<"OpTypeBool", 20>;
 def SPV_OC_OpTypeInt                   : I32EnumAttrCase<"OpTypeInt", 21>;
 def SPV_OC_OpTypeFloat                 : I32EnumAttrCase<"OpTypeFloat", 22>;
 def SPV_OC_OpTypeVector                : I32EnumAttrCase<"OpTypeVector", 23>;
 def SPV_OC_OpTypeMatrix                : I32EnumAttrCase<"OpTypeMatrix", 24>;
 def SPV_OC_OpTypeImage                 : I32EnumAttrCase<"OpTypeImage", 25>;
+def SPV_OC_OpTypeSampledImage          : I32EnumAttrCase<"OpTypeSampledImage", 27>;
 def SPV_OC_OpTypeArray                 : I32EnumAttrCase<"OpTypeArray", 28>;
 def SPV_OC_OpTypeRuntimeArray          : I32EnumAttrCase<"OpTypeRuntimeArray", 29>;
 def SPV_OC_OpTypeStruct                : I32EnumAttrCase<"OpTypeStruct", 30>;
 def SPV_OC_OpTypePointer               : I32EnumAttrCase<"OpTypePointer", 32>;
 def SPV_OC_OpTypeFunction              : I32EnumAttrCase<"OpTypeFunction", 33>;
 def SPV_OC_OpTypeForwardPointer        : I32EnumAttrCase<"OpTypeForwardPointer", 39>;
 def SPV_OC_OpConstantTrue              : I32EnumAttrCase<"OpConstantTrue", 41>;
 def SPV_OC_OpConstantFalse             : I32EnumAttrCase<"OpConstantFalse", 42>;

 def SPV_OC_OpSubgroupBlockWriteINTEL   : I32EnumAttrCase<"OpSubgroupBlockWriteINTEL", 5576>;
 
 def SPV_OpcodeAttr :
     SPV_I32EnumAttr<"Opcode", "valid SPIR-V instructions", [
       SPV_OC_OpNop, SPV_OC_OpUndef, SPV_OC_OpSourceContinued, SPV_OC_OpSource,
       SPV_OC_OpSourceExtension, SPV_OC_OpName, SPV_OC_OpMemberName, SPV_OC_OpString,
       SPV_OC_OpLine, SPV_OC_OpExtension, SPV_OC_OpExtInstImport, SPV_OC_OpExtInst,
       SPV_OC_OpMemoryModel, SPV_OC_OpEntryPoint, SPV_OC_OpExecutionMode,
       SPV_OC_OpCapability, SPV_OC_OpTypeVoid, SPV_OC_OpTypeBool, SPV_OC_OpTypeInt,
-      SPV_OC_OpTypeFloat, SPV_OC_OpTypeVector, SPV_OC_OpTypeMatrix, SPV_OC_OpTypeImage,
-      SPV_OC_OpTypeArray, SPV_OC_OpTypeRuntimeArray, SPV_OC_OpTypeStruct,
-      SPV_OC_OpTypePointer, SPV_OC_OpTypeFunction, SPV_OC_OpTypeForwardPointer,
-      SPV_OC_OpConstantTrue, SPV_OC_OpConstantFalse, SPV_OC_OpConstant,
-      SPV_OC_OpConstantComposite, SPV_OC_OpConstantNull, SPV_OC_OpSpecConstantTrue,
-      SPV_OC_OpSpecConstantFalse, SPV_OC_OpSpecConstant,
-      SPV_OC_OpSpecConstantComposite, SPV_OC_OpSpecConstantOp, SPV_OC_OpFunction,
-      SPV_OC_OpFunctionParameter, SPV_OC_OpFunctionEnd, SPV_OC_OpFunctionCall,
-      SPV_OC_OpVariable, SPV_OC_OpLoad, SPV_OC_OpStore, SPV_OC_OpCopyMemory,
-      SPV_OC_OpAccessChain, SPV_OC_OpDecorate, SPV_OC_OpMemberDecorate,
-      SPV_OC_OpVectorExtractDynamic, SPV_OC_OpVectorInsertDynamic,
-      SPV_OC_OpVectorShuffle, SPV_OC_OpCompositeConstruct, SPV_OC_OpCompositeExtract,
+      SPV_OC_OpTypeFloat, SPV_OC_OpTypeVector, SPV_OC_OpTypeMatrix,
+      SPV_OC_OpTypeImage, SPV_OC_OpTypeSampledImage, SPV_OC_OpTypeArray,
+      SPV_OC_OpTypeRuntimeArray, SPV_OC_OpTypeStruct, SPV_OC_OpTypePointer,
+      SPV_OC_OpTypeFunction, SPV_OC_OpTypeForwardPointer, SPV_OC_OpConstantTrue,
+      SPV_OC_OpConstantFalse, SPV_OC_OpConstant, SPV_OC_OpConstantComposite,
+      SPV_OC_OpConstantNull, SPV_OC_OpSpecConstantTrue, SPV_OC_OpSpecConstantFalse,
+      SPV_OC_OpSpecConstant, SPV_OC_OpSpecConstantComposite, SPV_OC_OpSpecConstantOp,
+      SPV_OC_OpFunction, SPV_OC_OpFunctionParameter, SPV_OC_OpFunctionEnd,
+      SPV_OC_OpFunctionCall, SPV_OC_OpVariable, SPV_OC_OpLoad, SPV_OC_OpStore,
+      SPV_OC_OpCopyMemory, SPV_OC_OpAccessChain, SPV_OC_OpDecorate,
+      SPV_OC_OpMemberDecorate, SPV_OC_OpVectorExtractDynamic,
+      SPV_OC_OpVectorInsertDynamic, SPV_OC_OpVectorShuffle,
+      SPV_OC_OpCompositeConstruct, SPV_OC_OpCompositeExtract,
       SPV_OC_OpCompositeInsert, SPV_OC_OpTranspose, SPV_OC_OpConvertFToU,
       SPV_OC_OpConvertFToS, SPV_OC_OpConvertSToF, SPV_OC_OpConvertUToF,
       SPV_OC_OpUConvert, SPV_OC_OpSConvert, SPV_OC_OpFConvert, SPV_OC_OpBitcast,
       SPV_OC_OpSNegate, SPV_OC_OpFNegate, SPV_OC_OpIAdd, SPV_OC_OpFAdd,
       SPV_OC_OpISub, SPV_OC_OpFSub, SPV_OC_OpIMul, SPV_OC_OpFMul, SPV_OC_OpUDiv,
       SPV_OC_OpSDiv, SPV_OC_OpFDiv, SPV_OC_OpUMod, SPV_OC_OpSRem, SPV_OC_OpSMod,
       SPV_OC_OpFRem, SPV_OC_OpFMod, SPV_OC_OpMatrixTimesScalar,
       SPV_OC_OpMatrixTimesMatrix, SPV_OC_OpIsNan, SPV_OC_OpIsInf, SPV_OC_OpOrdered,

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVTypes.h

 
 namespace detail {
 struct ArrayTypeStorage;
 struct CooperativeMatrixTypeStorage;
 struct ImageTypeStorage;
 struct MatrixTypeStorage;
 struct PointerTypeStorage;
 struct RuntimeArrayTypeStorage;
+struct SampledImageTypeStorage;
 struct StructTypeStorage;
 
 } // namespace detail
 
 // Base SPIR-V type for providing availability queries.
 class SPIRVType : public Type {
 public:
   using Type::Type;
public:
   unsigned getArrayStride() const;
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
                      Optional<StorageClass> storage = llvm::None);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
                        Optional<StorageClass> storage = llvm::None);
 };
 
+// SPIR-V sampled image type
+class SampledImageType
+    : public Type::TypeBase<SampledImageType, SPIRVType,
+                            detail::SampledImageTypeStorage> {
+public:
+  using Base::Base;
+
+  static SampledImageType get(Type imageType);
+
+  static SampledImageType getChecked(Type imageType, Location location);
+
+  static LogicalResult verifyConstructionInvariants(Location Loc,
+                                                    Type imageType);
+
+  Type getImageType() const;
+
+  void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
+                     Optional<spirv::StorageClass> storage = llvm::None);
+  void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
+                       Optional<spirv::StorageClass> storage = llvm::None);
+};
+
 /// SPIR-V struct type. Two kinds of struct types are supported:
 /// - Literal: a literal struct type is uniqued by its fields (types + offset
 /// info + decoration info).
 /// - Identified: an indentified struct type is uniqued by its string identifier
 /// (name). This is useful in representing recursive structs. For example, the
 /// following C struct:
 ///
 /// struct A {

mlir/lib/Dialect/SPIRV/IR/SPIRVDialect.cpp

 } // namespace
 
 //===----------------------------------------------------------------------===//
 // SPIR-V Dialect
 //===----------------------------------------------------------------------===//
 
 void SPIRVDialect::initialize() {
   addTypes<ArrayType, CooperativeMatrixNVType, ImageType, MatrixType,
-           PointerType, RuntimeArrayType, StructType>();
+           PointerType, RuntimeArrayType, SampledImageType, StructType>();
 
   addAttributes<InterfaceVarABIAttr, TargetEnvAttr, VerCapExtAttr>();
 
   // Add SPIR-V ops.
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.cpp.inc"
       >();
parser.emitError(typeLoc, "matrix must be composed using vector "
                               "type, got ")
         << type;
     return Type();
   }
 
   return type;
 }
 
+static Type parseAndVerifySampledImageType(SPIRVDialect const &dialect,
+                                           DialectAsmParser &parser) {
+  Type type;
+  llvm::SMLoc typeLoc = parser.getCurrentLocation();
+  if (parser.parseType(type))
+    return Type();
+
+  if (!type.isa<ImageType>()) {
+    parser.emitError(typeLoc,
+                     "sampled image must be composed using image type, got ")
+        << type;
+    return Type();
+  }
+
+  return type;
+}
+
 /// Parses an optional `, stride = N` assembly segment. If no parsing failure
 /// occurs, writes `N` to `stride` if existing and writes 0 to `stride` if
 /// missing.
 static LogicalResult parseOptionalArrayStride(const SPIRVDialect &dialect,
                                               DialectAsmParser &parser,
                                               unsigned &stride) {
   if (failed(parser.parseOptionalComma())) {
     stride = 0;
static Type parseImageType(SPIRVDialect const &dialect,
   if (!value)
     return Type();
 
   if (parser.parseGreater())
     return Type();
   return ImageType::get(value.getValue());
 }
 
+// sampledImage-type :: = `!spv.sampledImage<` image-type `>`
+static Type parseSampledImageType(SPIRVDialect const &dialect,
+                                  DialectAsmParser &parser) {
+  if (parser.parseLess())
+    return Type();
+
+  auto parseVal = parseAndVerifySampledImageType(dialect, parser);
+  if (!parseVal)
+    return Type();
+
+  if (parser.parseGreater())
+    return Type();
+  return SampledImageType::get(parseVal);
+}
+
 // Parse decorations associated with a member.
 static ParseResult parseStructMemberDecorations(
     SPIRVDialect const &dialect, DialectAsmParser &parser,
     ArrayRef<Type> memberTypes,
     SmallVectorImpl<StructType::OffsetInfo> &offsetInfo,
     SmallVectorImpl<StructType::MemberDecorationInfo> &memberDecorationInfo) {
 
   // Check if the first element is offset.
static Type parseStructType(SPIRVDialect const &dialect,
   return StructType::get(memberTypes, offsetInfo, memberDecorationInfo);
 }
 
 // spirv-type ::= array-type
 //              | element-type
 //              | image-type
 //              | pointer-type
 //              | runtime-array-type
+//              | sampledImage-type
 //              | struct-type
 Type SPIRVDialect::parseType(DialectAsmParser &parser) const {
   StringRef keyword;
   if (parser.parseKeyword(&keyword))
     return Type();
 
   if (keyword == "array")
     return parseArrayType(*this, parser);
   if (keyword == "coopmatrix")
     return parseCooperativeMatrixType(*this, parser);
   if (keyword == "image")
     return parseImageType(*this, parser);
   if (keyword == "ptr")
     return parsePointerType(*this, parser);
   if (keyword == "rtarray")
     return parseRuntimeArrayType(*this, parser);
+  if (keyword == "sampledImage")
+    return parseSampledImageType(*this, parser);
   if (keyword == "struct")
     return parseStructType(*this, parser);
   if (keyword == "matrix")
     return parseMatrixType(*this, parser);
   parser.emitError(parser.getNameLoc(), "unknown SPIR-V type: ") << keyword;
   return Type();
 }
 
static void print(ImageType type, DialectAsmPrinter &os) {
   os << "image<" << type.getElementType() << ", " << stringifyDim(type.getDim())
      << ", " << stringifyImageDepthInfo(type.getDepthInfo()) << ", "
      << stringifyImageArrayedInfo(type.getArrayedInfo()) << ", "
      << stringifyImageSamplingInfo(type.getSamplingInfo()) << ", "
      << stringifyImageSamplerUseInfo(type.getSamplerUseInfo()) << ", "
      << stringifyImageFormat(type.getImageFormat()) << ">";
 }
 
+static void print(SampledImageType type, DialectAsmPrinter &os) {
+  os << "sampledImage<" << type.getImageType() << ">";
+}
+
 static void print(StructType type, DialectAsmPrinter &os) {
   thread_local llvm::SetVector<StringRef> structContext;
 
   os << "struct<";
 
   if (type.isIdentified()) {
     os << type.getIdentifier();
 

 static void print(MatrixType type, DialectAsmPrinter &os) {
   os << "matrix<" << type.getNumColumns() << " x " << type.getColumnType();
   os << ">";
 }
 
 void SPIRVDialect::printType(Type type, DialectAsmPrinter &os) const {
   TypeSwitch<Type>(type)
       .Case<ArrayType, CooperativeMatrixNVType, PointerType, RuntimeArrayType,
-            ImageType, StructType, MatrixType>(
+            ImageType, SampledImageType, StructType, MatrixType>(
           [&](auto type) { print(type, os); })
       .Default([](Type) { llvm_unreachable("unhandled SPIR-V type"); });
 }
 
 //===----------------------------------------------------------------------===//
 // Attribute Parsing
 //===----------------------------------------------------------------------===//
 

mlir/lib/Dialect/SPIRV/IR/SPIRVTypes.cpp

 void SPIRVType::getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
                               Optional<StorageClass> storage) {
   if (auto scalarType = dyn_cast<ScalarType>()) {
     scalarType.getExtensions(extensions, storage);
   } else if (auto compositeType = dyn_cast<CompositeType>()) {
     compositeType.getExtensions(extensions, storage);
   } else if (auto imageType = dyn_cast<ImageType>()) {
     imageType.getExtensions(extensions, storage);
+  } else if (auto sampledImageType = dyn_cast<SampledImageType>()) {
+    sampledImageType.getExtensions(extensions, storage);
   } else if (auto matrixType = dyn_cast<MatrixType>()) {
     matrixType.getExtensions(extensions, storage);
   } else if (auto ptrType = dyn_cast<PointerType>()) {
     ptrType.getExtensions(extensions, storage);
   } else {
     llvm_unreachable("invalid SPIR-V Type to getExtensions");
   }
 }
 
 void SPIRVType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
     Optional<StorageClass> storage) {
   if (auto scalarType = dyn_cast<ScalarType>()) {
     scalarType.getCapabilities(capabilities, storage);
   } else if (auto compositeType = dyn_cast<CompositeType>()) {
     compositeType.getCapabilities(capabilities, storage);
   } else if (auto imageType = dyn_cast<ImageType>()) {
     imageType.getCapabilities(capabilities, storage);
+  } else if (auto sampledImageType = dyn_cast<SampledImageType>()) {
+    sampledImageType.getCapabilities(capabilities, storage);
   } else if (auto matrixType = dyn_cast<MatrixType>()) {
     matrixType.getCapabilities(capabilities, storage);
   } else if (auto ptrType = dyn_cast<PointerType>()) {
     ptrType.getCapabilities(capabilities, storage);
   } else {
     llvm_unreachable("invalid SPIR-V Type to getCapabilities");
   }
 }
 
 Optional<int64_t> SPIRVType::getSizeInBytes() {
   if (auto scalarType = dyn_cast<ScalarType>())
     return scalarType.getSizeInBytes();
   if (auto compositeType = dyn_cast<CompositeType>())
     return compositeType.getSizeInBytes();
   return llvm::None;
 }
 
 //===----------------------------------------------------------------------===//
+// SampledImageType
+//===----------------------------------------------------------------------===//
+struct spirv::detail::SampledImageTypeStorage : public TypeStorage {
+  using KeyTy = Type;
+
+  SampledImageTypeStorage(const KeyTy &key) : imageType{key} {}
+
+  bool operator==(const KeyTy &key) const { return key == KeyTy(imageType); }
+
+  static SampledImageTypeStorage *construct(TypeStorageAllocator &allocator,
+                                            const KeyTy &key) {
+    return new (allocator.allocate<SampledImageTypeStorage>())
+        SampledImageTypeStorage(key);
+  }
+
+  Type imageType;
+};
+
+SampledImageType SampledImageType::get(Type imageType) {
+  return Base::get(imageType.getContext(), imageType);
+}
+
+SampledImageType SampledImageType::getChecked(Type imageType,
+                                              Location location) {
+  return Base::getChecked(location, imageType);
+}
+
+Type SampledImageType::getImageType() const { return getImpl()->imageType; }
+
+LogicalResult SampledImageType::verifyConstructionInvariants(Location loc,
+                                                             Type imageType) {
+  if (!imageType.isa<ImageType>())
+    return emitError(loc, "expected image type");
+
+  return success();
+}
+
+void SampledImageType::getExtensions(
+    SPIRVType::ExtensionArrayRefVector &extensions,
+    Optional<StorageClass> storage) {
+  getImageType().cast<ImageType>().getExtensions(extensions, storage);
+}
+
+void SampledImageType::getCapabilities(
+    SPIRVType::CapabilityArrayRefVector &capabilities,
+    Optional<StorageClass> storage) {
+  getImageType().cast<ImageType>().getCapabilities(capabilities, storage);
+}
+
+//===----------------------------------------------------------------------===//
 // StructType
 //===----------------------------------------------------------------------===//
 
 /// Type storage for SPIR-V structure types:
 ///
 /// Structures are uniqued using:
 /// - for identified structs:
 ///   - a string identifier;

mlir/lib/Target/SPIRV/Deserialization/DeserializeOps.cpp

LogicalResult spirv::Deserializer::processInstruction(
   case spirv::Opcode::OpTypeBool:
   case spirv::Opcode::OpTypeInt:
   case spirv::Opcode::OpTypeFloat:
   case spirv::Opcode::OpTypeVector:
   case spirv::Opcode::OpTypeMatrix:
   case spirv::Opcode::OpTypeArray:
   case spirv::Opcode::OpTypeFunction:
   case spirv::Opcode::OpTypeImage:
+  case spirv::Opcode::OpTypeSampledImage:
   case spirv::Opcode::OpTypeRuntimeArray:
   case spirv::Opcode::OpTypeStruct:
   case spirv::Opcode::OpTypePointer:
   case spirv::Opcode::OpTypeCooperativeMatrixNV:
     return processType(opcode, operands);
   case spirv::Opcode::OpTypeForwardPointer:
     return processTypeForwardPointer(operands);
   case spirv::Opcode::OpConstant:

mlir/lib/Target/SPIRV/Deserialization/Deserializer.h

private:
   LogicalResult processArrayType(ArrayRef<uint32_t> operands);
 
   LogicalResult processCooperativeMatrixType(ArrayRef<uint32_t> operands);
 
   LogicalResult processFunctionType(ArrayRef<uint32_t> operands);
 
   LogicalResult processImageType(ArrayRef<uint32_t> operands);
 
+  LogicalResult processSampledImageType(ArrayRef<uint32_t> operands);
+
   LogicalResult processRuntimeArrayType(ArrayRef<uint32_t> operands);
 
   LogicalResult processStructType(ArrayRef<uint32_t> operands);
 
   LogicalResult processMatrixType(ArrayRef<uint32_t> operands);
 
   LogicalResult processTypeForwardPointer(ArrayRef<uint32_t> operands);
 

mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp

LogicalResult spirv::Deserializer::processType(spirv::Opcode opcode,
   case spirv::Opcode::OpTypeArray:
     return processArrayType(operands);
   case spirv::Opcode::OpTypeCooperativeMatrixNV:
     return processCooperativeMatrixType(operands);
   case spirv::Opcode::OpTypeFunction:
     return processFunctionType(operands);
   case spirv::Opcode::OpTypeImage:
     return processImageType(operands);
+  case spirv::Opcode::OpTypeSampledImage:
+    return processSampledImageType(operands);
   case spirv::Opcode::OpTypeRuntimeArray:
     return processRuntimeArrayType(operands);
   case spirv::Opcode::OpTypeStruct:
     return processStructType(operands);
   case spirv::Opcode::OpTypeMatrix:
     return processMatrixType(operands);
   default:
     return emitError(unknownLoc, "unhandled type instruction");
return emitError(unknownLoc, "unknown Format for OpTypeImage: ")
            << operands[7];
 
   typeMap[operands[0]] = spirv::ImageType::get(
       elementTy, dim.getValue(), depthInfo.getValue(), arrayedInfo.getValue(),
       samplingInfo.getValue(), samplerUseInfo.getValue(), format.getValue());
   return success();
 }
 
+LogicalResult
+spirv::Deserializer::processSampledImageType(ArrayRef<uint32_t> operands) {
+  if (operands.size() != 2)
+    return emitError(unknownLoc, "OpTypeSampledImage must have two operands");
+
+  Type elementTy = getType(operands[1]);
+  if (!elementTy)
+    return emitError(unknownLoc,
+                     "OpTypeSampledImage references undefined <id>: ")
+           << operands[1];
+
+  typeMap[operands[0]] = spirv::SampledImageType::get(elementTy);
+  return success();
+}
+
 //===----------------------------------------------------------------------===//
 // Constant
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::Deserializer::processConstant(ArrayRef<uint32_t> operands,
                                                    bool isSpec) {
   StringRef opname = isSpec ? "OpSpecConstant" : "OpConstant";
 

mlir/lib/Target/SPIRV/Serialization/Serialization.cpp

if (failed(processTypeImpl(loc, runtimeArrayType.getElementType(),
                                elementTypeID, serializationCtx))) {
       return failure();
     }
     typeEnum = spirv::Opcode::OpTypeRuntimeArray;
     operands.push_back(elementTypeID);
     return processTypeDecoration(loc, runtimeArrayType, resultID);
   }
 
+  if (auto sampledImageType = type.dyn_cast<spirv::SampledImageType>()) {
+    typeEnum = spirv::Opcode::OpTypeSampledImage;
+    uint32_t imageTypeID = 0;
+    if (failed(
+            processType(loc, sampledImageType.getImageType(), imageTypeID))) {
+      return failure();
+    }
+    operands.push_back(imageTypeID);
+    return success();
+  }
+
   if (auto structType = type.dyn_cast<spirv::StructType>()) {
     if (structType.isIdentified()) {
       (void)processName(resultID, structType.getIdentifier());
       serializationCtx.insert(structType.getIdentifier());
     }
 
     bool hasOffset = structType.hasOffset();
     for (auto elementIndex :

mlir/test/Dialect/SPIRV/IR/types.mlir

 // -----
 
 // expected-error @+1 {{expected ','}}
 func private @image_parameters_nocomma_5(!spv.image<f32, Dim1D, NoDepth, NonArrayed, SingleSampled, SamplerUnknown Unknown>) -> ()
 
 // -----
 
 //===----------------------------------------------------------------------===//
+// SampledImageType
+//===----------------------------------------------------------------------===//
+
+// CHECK: func private @sampled_image_type(!spv.sampledImage<!spv.image<f32, Dim1D, NoDepth, NonArrayed, SingleSampled, NoSampler, Unknown>>)
+func private @sampled_image_type(!spv.sampledImage<!spv.image<f32, Dim1D, NoDepth, NonArrayed, SingleSampled, NoSampler, Unknown>>) -> ()
+
+// -----
+
+// expected-error @+1 {{sampled image must be composed using image type, got 'f32'}}
+func private @samped_image_type_invaid_type(!spv.sampledImage<f32>) -> ()
+
+// -----
+
+//===----------------------------------------------------------------------===//
 // StructType
 //===----------------------------------------------------------------------===//
 
 // CHECK: func private @struct_type(!spv.struct<(f32)>)
 func private @struct_type(!spv.struct<(f32)>) -> ()
 
 // CHECK: func private @struct_type2(!spv.struct<(f32 [0])>)
 func private @struct_type2(!spv.struct<(f32 [0])>) -> ()

mlir/test/Target/SPIRV/sampled-image.mlir

+// RUN: mlir-translate -test-spirv-roundtrip %s | FileCheck %s
+
+spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
+  // CHECK: !spv.ptr<!spv.sampledImage<!spv.image<f32, Dim1D, NoDepth, NonArrayed, SingleSampled, NoSampler, Unknown>>, UniformConstant>
+  spv.globalVariable @var0 bind(0, 1) : !spv.ptr<!spv.sampledImage<!spv.image<f32, Dim1D, NoDepth, NonArrayed, SingleSampled, NoSampler, Unknown>>, UniformConstant>
+
+  // CHECK: !spv.ptr<!spv.sampledImage<!spv.image<si32, SubpassData, DepthUnknown, Arrayed, MultiSampled, NoSampler, Unknown>>, UniformConstant>
+  spv.globalVariable @var1 bind(0, 0) : !spv.ptr<!spv.sampledImage<!spv.image<si32, SubpassData, DepthUnknown, Arrayed, MultiSampled, NoSampler, Unknown>>, UniformConstant>
+
+  // CHECK: !spv.ptr<!spv.sampledImage<!spv.image<i32, Rect, DepthUnknown, Arrayed, MultiSampled, NeedSampler, R8ui>>, UniformConstant>
+  spv.globalVariable @var2 bind(0, 0) : !spv.ptr<!spv.sampledImage<!spv.image<i32, Rect, DepthUnknown, Arrayed, MultiSampled, NeedSampler, R8ui>>, UniformConstant>
+}