[mlir][spirv] modify structure type member decoration and layout information handling

[Hazem]

Summary

Modify structure type in SPIRV dialect to support:

1. Multiple decorations per structure member
2. Key-value based decorations (e.g., MatrixStride)

This commit kept the Offset decoration separate from members' decorations container for easier implementation and logical clarity.
As such, all references to Structure layoutinfo are now offsetinfo, and any member layout defining decoration (e.g., RowMajor for Matrix)
will be add to the members' decorations container along with its value if any.

[rriddle]

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

285

I would have expected this to be next to memberIndex if you wanted to pack it.

286

nit: Remove the inline in class/struct definitions, it goes against LLVM style guide

https://llvm.org/docs/CodingStandards.html#don-t-use-inline-when-defining-a-function-in-a-class-definition

mlir/lib/Dialect/SPIRV/SPIRVDialect.cpp

709

nit: Merge these lines.

mlir/lib/Dialect/SPIRV/Serialization/Deserializer.cpp

1328

nit: Use braces on all or none.

[Hazem]

Updating D81426: [mlir][spirv] modify structure type member decoration and layout information handling

Minor access specifier modification.

[rriddle]

Thanks for the patch, added some stylistic nits.

[Hazem]

• address few nits after revision review

[antiagainst]

Nice!!! Thanks @Hazem for the contribution!

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

278–279

Could you put some doc for these two types?

// Type for specifying the offset of struct members

// Type for specifying the decoration(s) on struct members

285

+1. I think River meant

uint32_t memberIndex : 31;
uint32_t hasValue : 1;

355

Prefer meaningful variable names especially in APIs. The name itself can be part of the documentation. f and other one-char names should really have a very small scope inside implementation.

mlir/lib/Dialect/SPIRV/SPIRVDialect.cpp

571–587

Nit: end with . to be consistent with other comments.

579

We don't need the explicit spirv::StructType::MemberDecorationInfo with emplace_back? Or is a constructor missing for MemberDecorationInfo?

mlir/lib/Dialect/SPIRV/Serialization/Serializer.cpp

232

Use const & to avoid copying?

[Hazem]

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

285

I understand, but when I did that I noticed unexpected behavior from the code. I believe I might need to cast the memberIndex to uint32_t explicitly in certain usages. So I resorted to the easier solution and forsake the few bytes savings. I will give it another shot and see what is wrong with it.

mlir/lib/Dialect/SPIRV/SPIRVDialect.cpp

579

There is no constructor for the MemberDecorationInfo struct.

[Hazem]

• Addressing more revision comments

[Hazem]

@antigainst, I made all the changes but I am failing the build I believe because of llvm::hash_value method in clang-tidy, do you know how can I workaround this? the function has to be defined this way.

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

285

All set now with the recommended changes for packing struct fields.

[antiagainst]

Thanks again @Hazem for the contribution!

In D81426#2085482, @Hazem wrote:

@antigainst, I made all the changes but I am failing the build I believe because of llvm::hash_value method in clang-tidy, do you know how can I workaround this? the function has to be defined this way.

Don't worry about that. It's not useful for this case.

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

286

Sorry for the additional trouble there. Compilers want to generate fast code and use the least resource; but that applies to the compiler itself. ;-P

mlir/lib/Dialect/SPIRV/SPIRVDialect.cpp

579

I meant we can define a constructor for it so that we can then avoid the extra type wrapper here. Let me handle it before landing.

[rriddle]

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

286

Methods defined in the class definition are implicitly inline.

[mehdi_amini]

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

286

Actually explicitly adding inline still hints the inliner to be more aggressive I believe.
(but unless you have a benchmark, just don't)

[NathanielMcVicar]

I believe this change may have broken the Windows buildbot, here: http://lab.llvm.org:8011/builders/mlir-windows/builds/3068

933.041 [440/64/2382] Building CXX object tools\mlir\lib\Dialect\SPIRV\CMakeFiles\obj.MLIRSPIRV.dir\TargetAndABI.cpp.obj
FAILED: tools/mlir/lib/Dialect/SPIRV/CMakeFiles/obj.MLIRSPIRV.dir/TargetAndABI.cpp.obj 
C:\PROGRA~2\MICROS~1\2017\COMMUN~1\VC\Tools\MSVC\1416~1.270\bin\Hostx64\x64\cl.exe ... /showIncludes /Fotools\mlir\lib\Dialect\SPIRV\CMakeFiles\obj.MLIRSPIRV.dir\TargetAndABI.cpp.obj /Fdtools\mlir\lib\Dialect\SPIRV\CMakeFiles\obj.MLIRSPIRV.dir\ /FS -c E:\build_slave\mlir-x64-windows-ninja\llvm-project\mlir\lib\Dialect\SPIRV\TargetAndABI.cpp
C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.16.27023\include\utility(319): error C2079: 'std::pair<mlir::Identifier,mlir::Attribute>::first' uses undefined class 'mlir::Identifier'
E:\build_slave\mlir-x64-windows-ninja\llvm-project\mlir\include\mlir/Dialect/SPIRV/SPIRVTypes.h(303): note: see reference to class template instantiation 'std::pair<mlir::Identifier,mlir::Attribute>' being compiled

[rriddle]

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

286

Yes, explicitly providing the keyword(at least for clang) tags functions with inline hint. The performance impact of explicitly providing the keyword in the majority(especially these) of cases is negligible/nonexistent.

[mehdi_amini]

In D81426#2086466, @NathanielMcVicar wrote:

I believe this change may have broken the Windows buildbot, here: http://lab.llvm.org:8011/builders/mlir-windows/builds/3068

I reverted earlier (it also broke the GCC build)

I checked and the windows bot is green now.

[antiagainst]

Thanks for the test failure report! I've pushed https://github.com/llvm/llvm-project/commit/5d74df5b03e46b7bd3700e3595c7008a6905b288 with the fix. I've verified that it works on GCC 8 using the configuration in https://buildkite.com/mlir/mlir-core/builds/5556#47fec22d-d9e2-4784-b660-34fe82d6dd0b. The Windows failure and GCC failure look the same.

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

286

I think I misplaced my previous comment. It was meant for the bit packing in MemberDecorationInfo.

[NathanielMcVicar]

In D81426#2088781, @antiagainst wrote:

The Windows failure and GCC failure look the same.

Unfortunately it looks like this is causing a new failure since <bits/stdint-uintn.h> isn't available on Windows. I'm not sure I understand what types it provides that wouldn't otherwise be available, but is there any alternative source? Thanks again for looking into this!
http://lab.llvm.org:8011/builders/mlir-windows/builds/3125

[mehdi_amini]

In D81426#2089110, @NathanielMcVicar wrote:

In D81426#2088781, @antiagainst wrote:

The Windows failure and GCC failure look the same.

Unfortunately it looks like this is causing a new failure since <bits/stdint-uintn.h> isn't available on Windows. I'm not sure I understand what types it provides that wouldn't otherwise be available, but is there any alternative source? Thanks again for looking into this!
http://lab.llvm.org:8011/builders/mlir-windows/builds/3125

Reverted in 6f0ce46873b609851634b2c77fc76bf8d580c3c6

[Hazem]

I am not sure I am following up, can someone explain to me why we needed to revert this change and then add "bits/stdint-uintn.h" in the first place? The link (http://lab.llvm.org:8011/builders/mlir-windows/builds/3068) to the initial change that caused the original issue wasn't related to this particular patch. Or maybe I misunderstood the messages.

In D81426#2089155, @mehdi_amini wrote:

In D81426#2089110, @NathanielMcVicar wrote:

In D81426#2088781, @antiagainst wrote:

The Windows failure and GCC failure look the same.

Unfortunately it looks like this is causing a new failure since <bits/stdint-uintn.h> isn't available on Windows. I'm not sure I understand what types it provides that wouldn't otherwise be available, but is there any alternative source? Thanks again for looking into this!
http://lab.llvm.org:8011/builders/mlir-windows/builds/3125

Reverted in 6f0ce46873b609851634b2c77fc76bf8d580c3c6

[antiagainst]

In D81426#2089155, @mehdi_amini wrote:

In D81426#2089110, @NathanielMcVicar wrote:

In D81426#2088781, @antiagainst wrote:

The Windows failure and GCC failure look the same.

Unfortunately it looks like this is causing a new failure since <bits/stdint-uintn.h> isn't available on Windows. I'm not sure I understand what types it provides that wouldn't otherwise be available, but is there any alternative source? Thanks again for looking into this!
http://lab.llvm.org:8011/builders/mlir-windows/builds/3125

Reverted in 6f0ce46873b609851634b2c77fc76bf8d580c3c6

Okay, it's clangd trying to be smart and automatically adding headers for me... This type it picked <bits/stdint-uintn.h> when I changed this->decoration < other.decoration to static_cast<uint32_t>(this->decoration) < static_cast<uint32_t>(other.decoration). Sorry about that.

[antiagainst]

In D81426#2090102, @Hazem wrote:

I am not sure I am following up, can someone explain to me why we needed to revert this change and then add "bits/stdint-uintn.h" in the first place? The link (http://lab.llvm.org:8011/builders/mlir-windows/builds/3068) to the initial change that caused the original issue wasn't related to this particular patch. Or maybe I misunderstood the messages.

GCC and MSVC is not happy with this->decoration < other.decoration. Enum classes will not implicitly convert to integers. I changed to static_cast<uint32_t>(this->decoration) < static_cast<uint32_t>(other.decoration) to fix.

[antiagainst]

Another time as https://github.com/llvm/llvm-project/commit/d7e6f116f4517952fbdf5ad4b5ff67e378600c60. I'll sit and monitor the bots.

[antiagainst]

http://lab.llvm.org:8011/builders/mlir-windows/builds/3163 Windows bot is happy now.

[mehdi_amini]

In D81426#2090102, @Hazem wrote:

I am not sure I am following up, can someone explain to me why we needed to revert this change and then add "bits/stdint-uintn.h" in the first place? The link (http://lab.llvm.org:8011/builders/mlir-windows/builds/3068) to the initial change that caused the original issue wasn't related to this particular patch. Or maybe I misunderstood the messages.

Since the build failed right after it was committed, and reverted it fixed the build, that seems like a good indication that it was related :)

[NathanielMcVicar]

In D81426#2090919, @antiagainst wrote:

http://lab.llvm.org:8011/builders/mlir-windows/builds/3163 Windows bot is happy now.

Great! Thanks for figuring this one out.

[Hazem]

In D81426#2090876, @antiagainst wrote:

In D81426#2090102, @Hazem wrote:

I am not sure I am following up, can someone explain to me why we needed to revert this change and then add "bits/stdint-uintn.h" in the first place? The link (http://lab.llvm.org:8011/builders/mlir-windows/builds/3068) to the initial change that caused the original issue wasn't related to this particular patch. Or maybe I misunderstood the messages.

GCC and MSVC is not happy with this->decoration < other.decoration. Enum classes will not implicitly convert to integers. I changed to static_cast<uint32_t>(this->decoration) < static_cast<uint32_t>(other.decoration) to fix.

Thank you for the explanation. I missed casting this when I changed them back to be bit fields from uint32_t.

[Hazem]

In D81426#2090997, @mehdi_amini wrote:

In D81426#2090102, @Hazem wrote:

I am not sure I am following up, can someone explain to me why we needed to revert this change and then add "bits/stdint-uintn.h" in the first place? The link (http://lab.llvm.org:8011/builders/mlir-windows/builds/3068) to the initial change that caused the original issue wasn't related to this particular patch. Or maybe I misunderstood the messages.

Since the build failed right after it was committed, and reverted it fixed the build, that seems like a good indication that it was related :)

This part I understand from your previous comments. However, I am new to this contribution system so I was hoping to figure out what is wrong from the log messages so that I can fix it as well whenever it fails. So my question was why the particular changes I made fail the build and whether there are other log files/reports I am missing here to help me investigate it as the indicated log was referring to a totaly different change :)
But all is good now I will figure it out in the upcoming contributions as I go. Thanks!

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

void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
                        Optional<spirv::StorageClass> storage = llvm::None);
 };
 
 // SPIR-V struct type
 class StructType : public Type::TypeBase<StructType, CompositeType,
                                          detail::StructTypeStorage> {
 public:
   using Base::Base;
 
-  // Layout information used for members in a struct in SPIR-V
-  //
-  // TODO(ravishankarm) : For now this only supports the offset type, so uses
-  // uint64_t value to represent the offset, with
-  // std::numeric_limit<uint64_t>::max indicating no offset. Change this to
-  // something that can hold all the information needed for different member
-  // types
-  using LayoutInfo = uint64_t;
+  using OffsetInfo = uint32_t;
 
-  using MemberDecorationInfo = std::pair<uint32_t, spirv::Decoration>;
+  struct MemberDecorationInfo {
+    uint32_t memberIndex : 31;
+    Decoration decoration;
+    uint32_t decorationValue;
+    uint32_t hasValue : 1;
+    inline bool operator==(const MemberDecorationInfo &other) const {
+      return (this->memberIndex == other.memberIndex) &&
+             (this->decoration == other.decoration) &&
+             (this->decorationValue == other.decorationValue);
+    }
+    inline bool operator<(const MemberDecorationInfo &other) const {
+      return this->memberIndex < other.memberIndex ||
+             (this->memberIndex == other.memberIndex &&
+              this->decoration < other.decoration);
+    }
+  };
 
   static bool kindof(unsigned kind) { return kind == TypeKind::Struct; }
 
   /// Construct a StructType with at least one member.
   static StructType get(ArrayRef<Type> memberTypes,
-                        ArrayRef<LayoutInfo> layoutInfo = {},
+                        ArrayRef<OffsetInfo> offsetInfo = {},
                         ArrayRef<MemberDecorationInfo> memberDecorations = {});
 
   /// Construct a struct with no members.
   static StructType getEmpty(MLIRContext *context);
 
   unsigned getNumElements() const;
 
   Type getElementType(unsigned) const;
private:
     }
 
     /// Allow base class access to `offset_base` and `dereference_iterator`.
     friend RangeBaseT;
   };
 
   ElementTypeRange getElementTypes() const;
 
-  bool hasLayout() const;
+  bool hasOffset() const;
 
-  uint64_t getOffset(unsigned) const;
+  uint64_t getMemberOffset(unsigned) const;
 
   // Returns in `allMemberDecorations` the spirv::Decorations (apart from
   // Offset) associated with all members of the StructType.
   void getMemberDecorations(SmallVectorImpl<StructType::MemberDecorationInfo>
                                 &allMemberDecorations) const;
 
   // Returns in `memberDecorations` all the spirv::Decorations (apart from
   // Offset) associated with the `i`-th member of the StructType.
-  void getMemberDecorations(
-      unsigned i, SmallVectorImpl<spirv::Decoration> &memberDecorations) const;
+  void getMemberDecorations(unsigned i,
+                            SmallVectorImpl<StructType::MemberDecorationInfo>
+                                &memberDecorations) const;
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
                      Optional<spirv::StorageClass> storage = llvm::None);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
                        Optional<spirv::StorageClass> storage = llvm::None);
 };
 
+llvm::hash_code hash_value(const StructType::MemberDecorationInfo &f);
+
 // SPIR-V cooperative matrix type
 class CooperativeMatrixNVType
     : public Type::TypeBase<CooperativeMatrixNVType, CompositeType,
                             detail::CooperativeMatrixTypeStorage> {
 public:
   using Base::Base;
 
   static bool kindof(unsigned kind) {

mlir/include/mlir/IR/DialectImplementation.h

public:
   virtual ParseResult parseComma() = 0;
 
   /// Parse a `,` token if present.
   virtual ParseResult parseOptionalComma() = 0;
 
   /// Parse a `=` token.
   virtual ParseResult parseEqual() = 0;
 
+  /// Parse a `=` token if present.
+  virtual ParseResult parseOptionalEqual() = 0;
+
   /// Parse a given keyword.
   ParseResult parseKeyword(StringRef keyword, const Twine &msg = "") {
     auto loc = getCurrentLocation();
     if (parseOptionalKeyword(keyword))
       return emitError(loc, "expected '") << keyword << "'" << msg;
     return success();
   }
 

mlir/lib/Dialect/SPIRV/LayoutUtils.cpp

 VulkanLayoutUtils::decorateType(spirv::StructType structType,
                                 VulkanLayoutUtils::Size &size,
                                 VulkanLayoutUtils::Size &alignment) {
   if (structType.getNumElements() == 0) {
     return structType;
   }
 
   SmallVector<Type, 4> memberTypes;
-  SmallVector<Size, 4> layoutInfo;
+  SmallVector<spirv::StructType::OffsetInfo, 4> offsetInfo;
   SmallVector<spirv::StructType::MemberDecorationInfo, 4> memberDecorations;
 
   Size structMemberOffset = 0;
   Size maxMemberAlignment = 1;
 
   for (uint32_t i = 0, e = structType.getNumElements(); i < e; ++i) {
     Size memberSize = 0;
     Size memberAlignment = 1;
 
     auto memberType =
         decorateType(structType.getElementType(i), memberSize, memberAlignment);
     structMemberOffset = llvm::alignTo(structMemberOffset, memberAlignment);
     memberTypes.push_back(memberType);
-    layoutInfo.push_back(structMemberOffset);
+    offsetInfo.push_back(
+        static_cast<spirv::StructType::OffsetInfo>(structMemberOffset));
     // If the member's size is the max value, it must be the last member and it
     // must be a runtime array.
     assert(memberSize != std::numeric_limits<Size>().max() ||
            (i + 1 == e &&
             structType.getElementType(i).isa<spirv::RuntimeArrayType>()));
     // According to the Vulkan spec:
     // "A structure has a base alignment equal to the largest base alignment of
     // any of its members."
     structMemberOffset += memberSize;
     maxMemberAlignment = std::max(maxMemberAlignment, memberAlignment);
   }
 
   // According to the Vulkan spec:
   // "The Offset decoration of a member must not place it between the end of a
   // structure or an array and the next multiple of the alignment of that
   // structure or array."
   size = llvm::alignTo(structMemberOffset, maxMemberAlignment);
   alignment = maxMemberAlignment;
   structType.getMemberDecorations(memberDecorations);
-  return spirv::StructType::get(memberTypes, layoutInfo, memberDecorations);
+  return spirv::StructType::get(memberTypes, offsetInfo, memberDecorations);
 }
 
 Type VulkanLayoutUtils::decorateType(Type type, VulkanLayoutUtils::Size &size,
                                      VulkanLayoutUtils::Size &alignment) {
   if (type.isa<spirv::ScalarType>()) {
     alignment = getScalarTypeAlignment(type);
     // Vulkan spec does not specify any padding for a scalar type.
     size = alignment;
if (!structType) {
     return true;
   }
 
   switch (storageClass) {
   case spirv::StorageClass::Uniform:
   case spirv::StorageClass::StorageBuffer:
   case spirv::StorageClass::PushConstant:
   case spirv::StorageClass::PhysicalStorageBuffer:
-    return structType.hasLayout() || !structType.getNumElements();
+    return structType.hasOffset() || !structType.getNumElements();
   default:
     return true;
   }
 }

mlir/lib/Dialect/SPIRV/SPIRVDialect.cpp

if (parser.parseGreater())
     return Type();
   return ImageType::get(value.getValue());
 }
 
 // Parse decorations associated with a member.
 static ParseResult parseStructMemberDecorations(
     SPIRVDialect const &dialect, DialectAsmParser &parser,
     ArrayRef<Type> memberTypes,
-    SmallVectorImpl<StructType::LayoutInfo> &layoutInfo,
+    SmallVectorImpl<StructType::OffsetInfo> &offsetInfo,
     SmallVectorImpl<StructType::MemberDecorationInfo> &memberDecorationInfo) {
 
   // Check if the first element is offset.
-  llvm::SMLoc layoutLoc = parser.getCurrentLocation();
-  StructType::LayoutInfo layout = 0;
-  OptionalParseResult layoutParseResult = parser.parseOptionalInteger(layout);
-  if (layoutParseResult.hasValue()) {
-    if (failed(*layoutParseResult))
+  llvm::SMLoc offsetLoc = parser.getCurrentLocation();
+  StructType::OffsetInfo offset = 0;
+  OptionalParseResult offsetParseResult = parser.parseOptionalInteger(offset);
+  if (offsetParseResult.hasValue()) {
+    if (failed(*offsetParseResult))
       return failure();
 
-    if (layoutInfo.size() != memberTypes.size() - 1) {
-      return parser.emitError(
-          layoutLoc, "layout specification must be given for all members");
+    if (offsetInfo.size() != memberTypes.size() - 1) {
+      return parser.emitError(offsetLoc,
+                              "offset specification must be given for "
+                              "all members");
     }
-    layoutInfo.push_back(layout);
+    offsetInfo.push_back(offset);
   }
 
   // Check for no spirv::Decorations.
   if (succeeded(parser.parseOptionalRSquare()))
     return success();
 
-  // If there was a layout, make sure to parse the comma.
-  if (layoutParseResult.hasValue() && parser.parseComma())
+  // If there was an offset, make sure to parse the comma.
+  if (offsetParseResult.hasValue() && parser.parseComma())
     return failure();
 
   // Check for spirv::Decorations.
   do {
     auto memberDecoration = parseAndVerify<spirv::Decoration>(dialect, parser);
     if (!memberDecoration)
       return failure();
 
-    memberDecorationInfo.emplace_back(
-        static_cast<uint32_t>(memberTypes.size() - 1),
-        memberDecoration.getValue());
+    // Parse member decoration value if it exists
+    if (succeeded(parser.parseOptionalEqual())) {
+      auto memberDecorationValue =
+          parseAndVerifyInteger<uint32_t>(dialect, parser);
+
+      if (!memberDecorationValue)
+        return failure();
+
+      memberDecorationInfo.emplace_back(spirv::StructType::MemberDecorationInfo(
+          {static_cast<uint32_t>(memberTypes.size() - 1),
+           memberDecoration.getValue(), memberDecorationValue.getValue(), 1}));
+    } else {
+      memberDecorationInfo.emplace_back(spirv::StructType::MemberDecorationInfo(
+          {static_cast<uint32_t>(memberTypes.size() - 1),
+           memberDecoration.getValue(), 0, 0}));
+    }
+
   } while (succeeded(parser.parseOptionalComma()));
 
   return parser.parseRSquare();
 }
 
 // struct-member-decoration ::= integer-literal? spirv-decoration*
 // struct-type ::= `!spv.struct<` spirv-type (`[` struct-member-decoration `]`)?
 //                     (`, ` spirv-type (`[` struct-member-decoration `]`)? `>`
 static Type parseStructType(SPIRVDialect const &dialect,
                             DialectAsmParser &parser) {
   if (parser.parseLess())
     return Type();
 
   if (succeeded(parser.parseOptionalGreater()))
     return StructType::getEmpty(dialect.getContext());
 
   SmallVector<Type, 4> memberTypes;
-  SmallVector<StructType::LayoutInfo, 4> layoutInfo;
+  SmallVector<StructType::OffsetInfo, 4> offsetInfo;
   SmallVector<StructType::MemberDecorationInfo, 4> memberDecorationInfo;
 
   do {
     Type memberType;
     if (parser.parseType(memberType))
       return Type();
     memberTypes.push_back(memberType);
 
     if (succeeded(parser.parseOptionalLSquare())) {
-      if (parseStructMemberDecorations(dialect, parser, memberTypes, layoutInfo,
+      if (parseStructMemberDecorations(dialect, parser, memberTypes, offsetInfo,
                                        memberDecorationInfo)) {
         return Type();
       }
     }
   } while (succeeded(parser.parseOptionalComma()));
 
-  if (!layoutInfo.empty() && memberTypes.size() != layoutInfo.size()) {
+  if (!offsetInfo.empty() && memberTypes.size() != offsetInfo.size()) {
     parser.emitError(parser.getNameLoc(),
-                     "layout specification must be given for all members");
+                     "offset specification must be given for all members");
     return Type();
   }
   if (parser.parseGreater())
     return Type();
-  return StructType::get(memberTypes, layoutInfo, memberDecorationInfo);
+  return StructType::get(memberTypes, offsetInfo, memberDecorationInfo);
 }
 
 // spirv-type ::= array-type
 //              | element-type
 //              | image-type
 //              | pointer-type
 //              | runtime-array-type
 //              | struct-type
os << "image<" << type.getElementType() << ", " << stringifyDim(type.getDim())
      << stringifyImageSamplerUseInfo(type.getSamplerUseInfo()) << ", "
      << stringifyImageFormat(type.getImageFormat()) << ">";
 }
 
 static void print(StructType type, DialectAsmPrinter &os) {
   os << "struct<";
   auto printMember = [&](unsigned i) {
     os << type.getElementType(i);
-    SmallVector<spirv::Decoration, 0> decorations;
+    SmallVector<spirv::StructType::MemberDecorationInfo, 0> decorations;
     type.getMemberDecorations(i, decorations);
-    if (type.hasLayout() || !decorations.empty()) {
+    if (type.hasOffset() || !decorations.empty()) {
       os << " [";
-      if (type.hasLayout()) {
-        os << type.getOffset(i);
+      if (type.hasOffset()) {
+        os << type.getMemberOffset(i);
         if (!decorations.empty())
           os << ", ";
       }
-      auto eachFn = [&os](spirv::Decoration decoration) {
-        os << stringifyDecoration(decoration);
+      auto eachFn = [&os](spirv::StructType::MemberDecorationInfo decoration) {
+        os << stringifyDecoration(decoration.decoration);
+        if (decoration.hasValue) {
+          os << "=";
+          os << decoration.decorationValue;
+        }
       };
       llvm::interleaveComma(decorations, os, eachFn);
       os << "]";
     }
   };
   llvm::interleaveComma(llvm::seq<unsigned>(0, type.getNumElements()), os,
                         printMember);
   os << ">";

mlir/lib/Dialect/SPIRV/SPIRVTypes.cpp

 
 //===----------------------------------------------------------------------===//
 // StructType
 //===----------------------------------------------------------------------===//
 
 struct spirv::detail::StructTypeStorage : public TypeStorage {
   StructTypeStorage(
       unsigned numMembers, Type const *memberTypes,
-      StructType::LayoutInfo const *layoutInfo, unsigned numMemberDecorations,
+      StructType::OffsetInfo const *layoutInfo, unsigned numMemberDecorations,
       StructType::MemberDecorationInfo const *memberDecorationsInfo)
       : TypeStorage(numMembers), memberTypes(memberTypes),
-        layoutInfo(layoutInfo), numMemberDecorations(numMemberDecorations),
+        offsetInfo(layoutInfo), numMemberDecorations(numMemberDecorations),
         memberDecorationsInfo(memberDecorationsInfo) {}
 
-  using KeyTy = std::tuple<ArrayRef<Type>, ArrayRef<StructType::LayoutInfo>,
+  using KeyTy = std::tuple<ArrayRef<Type>, ArrayRef<StructType::OffsetInfo>,
                            ArrayRef<StructType::MemberDecorationInfo>>;
   bool operator==(const KeyTy &key) const {
     return key ==
-           KeyTy(getMemberTypes(), getLayoutInfo(), getMemberDecorationsInfo());
+           KeyTy(getMemberTypes(), getOffsetInfo(), getMemberDecorationsInfo());
   }
 
   static StructTypeStorage *construct(TypeStorageAllocator &allocator,
                                       const KeyTy &key) {
     ArrayRef<Type> keyTypes = std::get<0>(key);
 
     // Copy the member type and layout information into the bump pointer
     const Type *typesList = nullptr;
     if (!keyTypes.empty()) {
       typesList = allocator.copyInto(keyTypes).data();
     }
 
-    const StructType::LayoutInfo *layoutInfoList = nullptr;
+    const StructType::OffsetInfo *offsetInfoList = nullptr;
     if (!std::get<1>(key).empty()) {
-      ArrayRef<StructType::LayoutInfo> keyLayoutInfo = std::get<1>(key);
-      assert(keyLayoutInfo.size() == keyTypes.size() &&
-             "size of layout information must be same as the size of number of "
+      ArrayRef<StructType::OffsetInfo> keyOffsetInfo = std::get<1>(key);
+      assert(keyOffsetInfo.size() == keyTypes.size() &&
+             "size of offset information must be same as the size of number of "
              "elements");
-      layoutInfoList = allocator.copyInto(keyLayoutInfo).data();
+      offsetInfoList = allocator.copyInto(keyOffsetInfo).data();
     }
 
     const StructType::MemberDecorationInfo *memberDecorationList = nullptr;
     unsigned numMemberDecorations = 0;
     if (!std::get<2>(key).empty()) {
       auto keyMemberDecorations = std::get<2>(key);
       numMemberDecorations = keyMemberDecorations.size();
       memberDecorationList = allocator.copyInto(keyMemberDecorations).data();
     }
     return new (allocator.allocate<StructTypeStorage>())
-        StructTypeStorage(keyTypes.size(), typesList, layoutInfoList,
+        StructTypeStorage(keyTypes.size(), typesList, offsetInfoList,
                           numMemberDecorations, memberDecorationList);
   }
 
   ArrayRef<Type> getMemberTypes() const {
     return ArrayRef<Type>(memberTypes, getSubclassData());
   }
 
-  ArrayRef<StructType::LayoutInfo> getLayoutInfo() const {
-    if (layoutInfo) {
-      return ArrayRef<StructType::LayoutInfo>(layoutInfo, getSubclassData());
+  ArrayRef<StructType::OffsetInfo> getOffsetInfo() const {
+    if (offsetInfo) {
+      return ArrayRef<StructType::OffsetInfo>(offsetInfo, getSubclassData());
     }
     return {};
   }
 
   ArrayRef<StructType::MemberDecorationInfo> getMemberDecorationsInfo() const {
     if (memberDecorationsInfo) {
       return ArrayRef<StructType::MemberDecorationInfo>(memberDecorationsInfo,
                                                         numMemberDecorations);
     }
     return {};
   }
 
   Type const *memberTypes;
-  StructType::LayoutInfo const *layoutInfo;
+  StructType::OffsetInfo const *offsetInfo;
   unsigned numMemberDecorations;
   StructType::MemberDecorationInfo const *memberDecorationsInfo;
 };
 
 StructType
 StructType::get(ArrayRef<Type> memberTypes,
-                ArrayRef<StructType::LayoutInfo> layoutInfo,
+                ArrayRef<StructType::OffsetInfo> offsetInfo,
                 ArrayRef<StructType::MemberDecorationInfo> memberDecorations) {
   assert(!memberTypes.empty() && "Struct needs at least one member type");
   // Sort the decorations.
   SmallVector<StructType::MemberDecorationInfo, 4> sortedDecorations(
       memberDecorations.begin(), memberDecorations.end());
   llvm::array_pod_sort(sortedDecorations.begin(), sortedDecorations.end());
   return Base::get(memberTypes.vec().front().getContext(), TypeKind::Struct,
-                   memberTypes, layoutInfo, sortedDecorations);
+                   memberTypes, offsetInfo, sortedDecorations);
 }
 
 StructType StructType::getEmpty(MLIRContext *context) {
   return Base::get(context, TypeKind::Struct, ArrayRef<Type>(),
-                   ArrayRef<StructType::LayoutInfo>(),
+                   ArrayRef<StructType::OffsetInfo>(),
                    ArrayRef<StructType::MemberDecorationInfo>());
 }
 
 unsigned StructType::getNumElements() const {
   return getImpl()->getSubclassData();
 }
 
 Type StructType::getElementType(unsigned index) const {
   assert(getNumElements() > index && "member index out of range");
   return getImpl()->memberTypes[index];
 }
 
 StructType::ElementTypeRange StructType::getElementTypes() const {
   return ElementTypeRange(getImpl()->memberTypes, getNumElements());
 }
 
-bool StructType::hasLayout() const { return getImpl()->layoutInfo; }
+bool StructType::hasOffset() const { return getImpl()->offsetInfo; }
 
-uint64_t StructType::getOffset(unsigned index) const {
+uint64_t StructType::getMemberOffset(unsigned index) const {
   assert(getNumElements() > index && "member index out of range");
-  return getImpl()->layoutInfo[index];
+  return getImpl()->offsetInfo[index];
 }
 
 void StructType::getMemberDecorations(
     SmallVectorImpl<StructType::MemberDecorationInfo> &memberDecorations)
     const {
   memberDecorations.clear();
   auto implMemberDecorations = getImpl()->getMemberDecorationsInfo();
   memberDecorations.append(implMemberDecorations.begin(),
                            implMemberDecorations.end());
 }
 
 void StructType::getMemberDecorations(
-    unsigned index, SmallVectorImpl<spirv::Decoration> &decorations) const {
+    unsigned index,
+    SmallVectorImpl<StructType::MemberDecorationInfo> &decorationsInfo) const {
   assert(getNumElements() > index && "member index out of range");
   auto memberDecorations = getImpl()->getMemberDecorationsInfo();
-  decorations.clear();
-  for (auto &memberDecoration : memberDecorations) {
-    if (memberDecoration.first == index) {
-      decorations.push_back(memberDecoration.second);
+  decorationsInfo.clear();
+  for (const auto &memberDecoration : memberDecorations) {
+    if (memberDecoration.memberIndex == index) {
+      decorationsInfo.push_back(memberDecoration);
     }
-    if (memberDecoration.first > index) {
+    if (memberDecoration.memberIndex > index) {
       // Early exit since the decorations are stored sorted.
       return;
     }
   }
 }
 
 void StructType::getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
                                Optional<StorageClass> storage) {
   for (Type elementType : getElementTypes())
     elementType.cast<SPIRVType>().getExtensions(extensions, storage);
 }
 
 void StructType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
     Optional<StorageClass> storage) {
   for (Type elementType : getElementTypes())
     elementType.cast<SPIRVType>().getCapabilities(capabilities, storage);
 }
 
+llvm::hash_code spirv::hash_value(const StructType::MemberDecorationInfo &f) {
+  return llvm::hash_combine(f.memberIndex, f.decoration);
+}
+
 //===----------------------------------------------------------------------===//
 // MatrixType
 //===----------------------------------------------------------------------===//
 
 struct spirv::detail::MatrixTypeStorage : public TypeStorage {
   MatrixTypeStorage(Type columnType, uint32_t columnCount)
       : TypeStorage(), columnType(columnType), columnCount(columnCount) {}
 

mlir/lib/Dialect/SPIRV/Serialization/Deserializer.cpp

for (auto op : llvm::drop_begin(operands, 1)) {
     Type memberType = getType(op);
     if (!memberType) {
       return emitError(unknownLoc, "OpTypeStruct references undefined <id> ")
              << op;
     }
     memberTypes.push_back(memberType);
   }
 
-  SmallVector<spirv::StructType::LayoutInfo, 0> layoutInfo;
+  SmallVector<spirv::StructType::OffsetInfo, 0> offsetInfo;
   SmallVector<spirv::StructType::MemberDecorationInfo, 0> memberDecorationsInfo;
   if (memberDecorationMap.count(operands[0])) {
     auto &allMemberDecorations = memberDecorationMap[operands[0]];
     for (auto memberIndex : llvm::seq<uint32_t>(0, memberTypes.size())) {
       if (allMemberDecorations.count(memberIndex)) {
         for (auto &memberDecoration : allMemberDecorations[memberIndex]) {
           // Check for offset.
           if (memberDecoration.first == spirv::Decoration::Offset) {
-            // If layoutInfo is empty, resize to the number of members;
-            if (layoutInfo.empty()) {
-              layoutInfo.resize(memberTypes.size());
+            // If offset info is empty, resize to the number of members;
+            if (offsetInfo.empty()) {
+              offsetInfo.resize(memberTypes.size());
             }
-            layoutInfo[memberIndex] = memberDecoration.second[0];
+            offsetInfo[memberIndex] = memberDecoration.second[0];
           } else {
             if (!memberDecoration.second.empty()) {
-              return emitError(unknownLoc,
-                               "unhandled OpMemberDecoration with decoration ")
-                     << stringifyDecoration(memberDecoration.first)
-                     << " which has additional operands";
-            }
-            memberDecorationsInfo.emplace_back(memberIndex,
-                                               memberDecoration.first);
+              memberDecorationsInfo.emplace_back(
+                  spirv::StructType::MemberDecorationInfo(
+                      {memberIndex, memberDecoration.first,
+                       memberDecoration.second[0], 1}));
+            } else
+              memberDecorationsInfo.emplace_back(
+                  spirv::StructType::MemberDecorationInfo(
+                      {memberIndex, memberDecoration.first, 0, 0}));
           }
         }
       }
     }
   }
   typeMap[operands[0]] =
-      spirv::StructType::get(memberTypes, layoutInfo, memberDecorationsInfo);
+      spirv::StructType::get(memberTypes, offsetInfo, memberDecorationsInfo);
   // TODO(ravishankarm): Update StructType to have member name as attribute as
   // well.
   return success();
 }
 
 LogicalResult Deserializer::processMatrixType(ArrayRef<uint32_t> operands) {
   if (operands.size() != 3) {
     // Three operands are needed: result_id, column_type, and column_count

mlir/lib/Dialect/SPIRV/Serialization/Serializer.cpp

private:
 
   template <typename DType>
   LogicalResult processTypeDecoration(Location loc, DType type,
                                       uint32_t resultId) {
     return emitError(loc, "unhandled decoration for type:") << type;
   }
 
   /// Process member decoration
-  LogicalResult processMemberDecoration(uint32_t structID, uint32_t memberIndex,
-                                        spirv::Decoration decorationType,
-                                        ArrayRef<uint32_t> values = {});
+  LogicalResult processMemberDecoration(
+      uint32_t structID,
+      spirv::StructType::MemberDecorationInfo memberDecorationInfo);
 
   //===--------------------------------------------------------------------===//
   // Types
   //===--------------------------------------------------------------------===//
 
   uint32_t getTypeID(Type type) const { return typeIDMap.lookup(type); }
 
   Type getVoidType() { return mlirBuilder.getNoneType(); }
LogicalResult Serializer::processTypeDecoration<spirv::RuntimeArrayType>(
     Location Loc, spirv::RuntimeArrayType type, uint32_t resultID) {
   if (unsigned stride = type.getArrayStride()) {
     // OpDecorate %arrayTypeSSA ArrayStride strideLiteral
     return emitDecoration(resultID, spirv::Decoration::ArrayStride, {stride});
   }
   return success();
 }
 
-LogicalResult
-Serializer::processMemberDecoration(uint32_t structID, uint32_t memberIndex,
-                                    spirv::Decoration decorationType,
-                                    ArrayRef<uint32_t> values) {
+LogicalResult Serializer::processMemberDecoration(
+    uint32_t structID,
+    spirv::StructType::MemberDecorationInfo memberDecoration) {
   SmallVector<uint32_t, 4> args(
-      {structID, memberIndex, static_cast<uint32_t>(decorationType)});
-  if (!values.empty()) {
-    args.append(values.begin(), values.end());
+      {structID, memberDecoration.memberIndex,
+       static_cast<uint32_t>(memberDecoration.decoration)});
+  if (memberDecoration.hasValue) {
+    args.push_back(memberDecoration.decorationValue);
   }
   return encodeInstructionInto(decorations, spirv::Opcode::OpMemberDecorate,
                                args);
 }
 } // namespace
 
 LogicalResult Serializer::processFuncOp(spirv::FuncOp op) {
   LLVM_DEBUG(llvm::dbgs() << "-- start function '" << op.getName() << "' --\n");
if (failed(processType(loc, runtimeArrayType.getElementType(),
       return failure();
     }
     typeEnum = spirv::Opcode::OpTypeRuntimeArray;
     operands.push_back(elementTypeID);
     return processTypeDecoration(loc, runtimeArrayType, resultID);
   }
 
   if (auto structType = type.dyn_cast<spirv::StructType>()) {
-    bool hasLayout = structType.hasLayout();
+    bool hasOffset = structType.hasOffset();
     for (auto elementIndex :
          llvm::seq<uint32_t>(0, structType.getNumElements())) {
       uint32_t elementTypeID = 0;
       if (failed(processType(loc, structType.getElementType(elementIndex),
                              elementTypeID))) {
         return failure();
       }
       operands.push_back(elementTypeID);
-      if (hasLayout) {
+      if (hasOffset) {
         // Decorate each struct member with an offset
-        if (failed(processMemberDecoration(
-                resultID, elementIndex, spirv::Decoration::Offset,
-                static_cast<uint32_t>(structType.getOffset(elementIndex))))) {
+        spirv::StructType::MemberDecorationInfo offsetDecoration;
+        offsetDecoration.memberIndex = elementIndex;
+        offsetDecoration.decoration = spirv::Decoration::Offset;
+        offsetDecoration.decorationValue =
+            static_cast<uint32_t>(structType.getMemberOffset(elementIndex));
+        offsetDecoration.hasValue = 1;
+        if (failed(processMemberDecoration(resultID, offsetDecoration))) {
           return emitError(loc, "cannot decorate ")
                  << elementIndex << "-th member of " << structType
                  << " with its offset";
         }
       }
     }
     SmallVector<spirv::StructType::MemberDecorationInfo, 4> memberDecorations;
     structType.getMemberDecorations(memberDecorations);
     for (auto &memberDecoration : memberDecorations) {
-      if (failed(processMemberDecoration(resultID, memberDecoration.first,
-                                         memberDecoration.second))) {
+      if (failed(processMemberDecoration(resultID, memberDecoration))) {
         return emitError(loc, "cannot decorate ")
-               << memberDecoration.first << "-th member of " << structType
-               << " with " << stringifyDecoration(memberDecoration.second);
+               << static_cast<uint32_t>(memberDecoration.memberIndex)
+               << "-th member of " << structType << " with "
+               << stringifyDecoration(memberDecoration.decoration);
       }
     }
     typeEnum = spirv::Opcode::OpTypeStruct;
     return success();
   }
 
   if (auto cooperativeMatrixType =
           type.dyn_cast<spirv::CooperativeMatrixNVType>()) {

mlir/lib/Parser/Parser.cpp

ParseResult parseOptionalEllipsis() override {
     return success(parser.consumeIf(Token::ellipsis));
   }
 
   /// Parse a `=` token.
   ParseResult parseEqual() override {
     return parser.parseToken(Token::equal, "expected '='");
   }
 
+  /// Parse a `=` token if present.
+  ParseResult parseOptionalEqual() override {
+    return success(parser.consumeIf(Token::equal));
+  }
+
   /// Parse a '<' token.
   ParseResult parseLess() override {
     return parser.parseToken(Token::less, "expected '<'");
   }
 
   /// Parse a `<` token if present.
   ParseResult parseOptionalLess() override {
     return success(parser.consumeIf(Token::less));

mlir/test/Dialect/SPIRV/Serialization/struct.mlir

spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
   spv.globalVariable @var4 : !spv.ptr<!spv.struct<f32 [0, NonWritable], i32 [4]>, StorageBuffer>
 
   // CHECK: !spv.ptr<!spv.struct<f32 [NonWritable], i32 [NonWritable, NonReadable]>, StorageBuffer>
   spv.globalVariable @var5 : !spv.ptr<!spv.struct<f32 [NonWritable], i32 [NonWritable, NonReadable]>, StorageBuffer>
 
   // CHECK: !spv.ptr<!spv.struct<f32 [0, NonWritable], i32 [4, NonWritable, NonReadable]>, StorageBuffer>
   spv.globalVariable @var6 : !spv.ptr<!spv.struct<f32 [0, NonWritable], i32 [4, NonWritable, NonReadable]>, StorageBuffer>
 
+  // CHECK: !spv.ptr<!spv.struct<!spv.matrix<3 x vector<3xf32>> [0, ColMajor, MatrixStride=16]>, StorageBuffer>
+  spv.globalVariable @var7 : !spv.ptr<!spv.struct<!spv.matrix<3 x vector<3xf32>> [0, ColMajor, MatrixStride=16]>, StorageBuffer>
+
   // CHECK: !spv.ptr<!spv.struct<>, StorageBuffer>
   spv.globalVariable @empty : !spv.ptr<!spv.struct<>, StorageBuffer>
 
   // CHECK: !spv.ptr<!spv.struct<!spv.array<128 x f32, stride=4> [0]>, Input>,
   // CHECK-SAME: !spv.ptr<!spv.struct<!spv.array<128 x f32, stride=4> [0]>, Output>
   spv.func @kernel(%arg0: !spv.ptr<!spv.struct<!spv.array<128 x f32, stride=4> [0]>, Input>, %arg1: !spv.ptr<!spv.struct<!spv.array<128 x f32, stride=4> [0]>, Output>) -> () "None" {
     spv.Return
   }
 }

mlir/test/Dialect/SPIRV/types.mlir

 func @struct_type_with_decoration6(!spv.struct<f32, !spv.struct<i32 [NonWritable, NonReadable]>>)
 
 // CHECK: func @struct_type_with_decoration7(!spv.struct<f32 [0], !spv.struct<i32, f32 [NonReadable]> [4]>)
 func @struct_type_with_decoration7(!spv.struct<f32 [0], !spv.struct<i32, f32 [NonReadable]> [4]>)
 
 // CHECK: func @struct_type_with_decoration8(!spv.struct<f32, !spv.struct<i32 [0], f32 [4, NonReadable]>>)
 func @struct_type_with_decoration8(!spv.struct<f32, !spv.struct<i32 [0], f32 [4, NonReadable]>>)
 
+// CHECK: func @struct_type_with_matrix_1(!spv.struct<!spv.matrix<3 x vector<3xf32>> [0, ColMajor, MatrixStride=16]>)
+func @struct_type_with_matrix_1(!spv.struct<!spv.matrix<3 x vector<3xf32>> [0, ColMajor, MatrixStride=16]>)
+
+// CHECK: func @struct_type_with_matrix_2(!spv.struct<!spv.matrix<3 x vector<3xf32>> [0, RowMajor, MatrixStride=16]>)
+func @struct_type_with_matrix_2(!spv.struct<!spv.matrix<3 x vector<3xf32>> [0, RowMajor, MatrixStride=16]>)
+
 // CHECK: func @struct_empty(!spv.struct<>)
 func @struct_empty(!spv.struct<>)
 
 // -----
 
-// expected-error @+1 {{layout specification must be given for all members}}
+// expected-error @+1 {{offset specification must be given for all members}}
 func @struct_type_missing_offset1((!spv.struct<f32, i32 [4]>) -> ()
 
 // -----
 
-// expected-error @+1 {{layout specification must be given for all members}}
+// expected-error @+1 {{offset specification must be given for all members}}
 func @struct_type_missing_offset2(!spv.struct<f32 [3], i32>) -> ()
 
 // -----
 
 // expected-error @+1 {{expected '>'}}
 func @struct_type_missing_comma1(!spv.struct<f32 i32>) -> ()
 
 // -----

 
 // -----
 
 // expected-error @+1 {{expected ']'}}
 func @struct_type_missing_comma(!spv.struct<f32 [0, NonWritable NonReadable], i32 [4]>)
 
 // -----
 
+// expected-error @+1 {{expected ']'}}
+func @struct_type_missing_comma(!spv.struct<!spv.matrix<3 x vector<3xf32>> [0, RowMajor MatrixStride=16]>)
+
+// -----
+
+// expected-error @+1 {{expected integer value}}
+func @struct_missing_member_decorator_value(!spv.struct<!spv.matrix<3 x vector<3xf32>> [0, RowMajor, MatrixStride=]>)
+
+// -----
+
 //===----------------------------------------------------------------------===//
 // CooperativeMatrix
 //===----------------------------------------------------------------------===//
 
 // CHECK: func @coop_matrix_type(!spv.coopmatrix<8x16xi32, Subgroup>, !spv.coopmatrix<8x8xf32, Workgroup>)
 func @coop_matrix_type(!spv.coopmatrix<8x16xi32, Subgroup>, !spv.coopmatrix<8x8xf32, Workgroup>) -> ()
 
 // -----

 func @matrix_size_type(!spv.matrix< x vector<3xi32>>) -> ()
 
 // -----
 
 // expected-error @+1 {{expected single unsigned integer for number of columns}}
 func @matrix_size_type(!spv.matrix<2.0 x vector<3xi32>>) -> ()
 
 // -----
 No newline at end of file

mlir/unittests/Dialect/SPIRV/SerializationTest.cpp

state.addAttribute("vce_triple",
                            ArrayRef<spirv::Extension>(), &context));
     spirv::ModuleOp::build(builder, state);
     module = cast<spirv::ModuleOp>(Operation::create(state));
   }
 
   Type getFloatStructType() {
     OpBuilder opBuilder(module.body());
     llvm::SmallVector<Type, 1> elementTypes{opBuilder.getF32Type()};
-    llvm::SmallVector<spirv::StructType::LayoutInfo, 1> layoutInfo{0};
-    auto structType = spirv::StructType::get(elementTypes, layoutInfo);
+    llvm::SmallVector<spirv::StructType::OffsetInfo, 1> offsetInfo{0};
+    auto structType = spirv::StructType::get(elementTypes, offsetInfo);
     return structType;
   }
 
   void addGlobalVar(Type type, llvm::StringRef name) {
     OpBuilder opBuilder(module.body());
     auto ptrType = spirv::PointerType::get(type, spirv::StorageClass::Uniform);
     opBuilder.create<spirv::GlobalVariableOp>(
         UnknownLoc::get(&context), TypeAttr::get(ptrType),