[mlir] Add bytecode encoding for the remaining builtin types

[rriddle]

Summary

After this commit we will have an efficient bytecode representation for all
of the builtin types.

mlir/include/mlir/Bytecode/BytecodeImplementation.h

 /// BytecodeDialectInterface below.
 class DialectBytecodeReader {
 public:
   virtual ~DialectBytecodeReader() = default;
 
   /// Emit an error to the reader.
   virtual InFlightDiagnostic emitError(const Twine &msg = {}) = 0;
 
-  //===--------------------------------------------------------------------===//
-  // IR
-  //===--------------------------------------------------------------------===//
-
   /// Read out a list of elements, invoking the provided callback for each
   /// element. The callback function may be in any of the following forms:
   ///   * LogicalResult(T &)
   ///   * FailureOr<T>()
   template <typename T, typename CallbackFn>
   LogicalResult readList(SmallVectorImpl<T> &result, CallbackFn &&callback) {
     uint64_t size;
     if (failed(readVarInt(size)))
for (uint64_t i = 0; i < size; ++i) {
         if (failed(element))
           return failure();
         result.emplace_back(std::move(*element));
       }
     }
     return success();
   }
 
+  //===--------------------------------------------------------------------===//
+  // IR
+  //===--------------------------------------------------------------------===//
+
   /// Read a reference to the given attribute.
   virtual LogicalResult readAttribute(Attribute &result) = 0;
   template <typename T>
   LogicalResult readAttributes(SmallVectorImpl<T> &attrs) {
     return readList(attrs, [this](T &attr) { return readAttribute(attr); });
   }
   template <typename T>
   LogicalResult readAttribute(T &result) {
public:
   // Primitives
   //===--------------------------------------------------------------------===//
 
   /// Read a variable width integer.
   virtual LogicalResult readVarInt(uint64_t &result) = 0;
 
   /// Read a signed variable width integer.
   virtual LogicalResult readSignedVarInt(int64_t &result) = 0;
+  LogicalResult readSignedVarInts(SmallVectorImpl<int64_t> &result) {
+    return readList(result,
+                    [this](int64_t &value) { return readSignedVarInt(value); });
+  }
 
   /// Read an APInt that is known to have been encoded with the given width.
   virtual FailureOr<APInt> readAPIntWithKnownWidth(unsigned bitWidth) = 0;
 
   /// Read an APFloat that is known to have been encoded with the given
   /// semantics.
   virtual FailureOr<APFloat>
   readAPFloatWithKnownSemantics(const llvm::fltSemantics &semantics) = 0;
public:
 
   /// Write a variable width integer to the output stream. This should be the
   /// preferred method for emitting integers whenever possible.
   virtual void writeVarInt(uint64_t value) = 0;
 
   /// Write a signed variable width integer to the output stream. This should be
   /// the preferred method for emitting signed integers whenever possible.
   virtual void writeSignedVarInt(int64_t value) = 0;
+  void writeSignedVarInts(ArrayRef<int64_t> value) {
+    writeList(value, [this](int64_t value) { writeSignedVarInt(value); });
+  }
 
   /// Write an APInt to the bytecode stream whose bitwidth will be known
   /// externally at read time. This method is useful for encoding APInt values
   /// when the width is known via external means, such as via a type. This
   /// method should generally only be invoked if you need an APInt, otherwise
   /// use the varint methods above. APInt values are generally encoded using
   /// zigzag encoding, to enable more efficient encodings for negative values.
   virtual void writeAPIntWithKnownWidth(const APInt &value) = 0;

mlir/lib/IR/BuiltinDialectBytecode.cpp

enum TypeCode {
   kIndexType = 1,
 
   ///   FunctionType {
   ///     inputs: Type[],
   ///     results: Type[]
   ///   }
   ///
   kFunctionType = 2,
+
+  ///   BFloat16Type {
+  ///   }
+  ///
+  kBFloat16Type = 3,
+
+  ///   Float16Type {
+  ///   }
+  ///
+  kFloat16Type = 4,
+
+  ///   Float32Type {
+  ///   }
+  ///
+  kFloat32Type = 5,
+
+  ///   Float64Type {
+  ///   }
+  ///
+  kFloat64Type = 6,
+
+  ///   Float80Type {
+  ///   }
+  ///
+  kFloat80Type = 7,
+
+  ///   Float128Type {
+  ///   }
+  ///
+  kFloat128Type = 8,
+
+  ///   ComplexType {
+  ///     elementType: Type
+  ///   }
+  ///
+  kComplexType = 9,
+
+  ///   MemRefType {
+  ///     shape: svarint[],
+  ///     elementType: Type,
+  ///     layout: Attribute
+  ///   }
+  ///
+  kMemRefType = 10,
+
+  ///   MemRefTypeWithMemSpace {
+  ///     memorySpace: Attribute,
+  ///     shape: svarint[],
+  ///     elementType: Type,
+  ///     layout: Attribute
+  ///   }
+  /// Variant of MemRefType with non-default memory space.
+  kMemRefTypeWithMemSpace = 11,
+
+  ///   NoneType {
+  ///   }
+  ///
+  kNoneType = 12,
+
+  ///   RankedTensorType {
+  ///     shape: svarint[],
+  ///     elementType: Type,
+  ///   }
+  ///
+  kRankedTensorType = 13,
+
+  ///   RankedTensorTypeWithEncoding {
+  ///     encoding: Attribute,
+  ///     shape: svarint[],
+  ///     elementType: Type
+  ///   }
+  /// Variant of RankedTensorType with an encoding.
+  kRankedTensorTypeWithEncoding = 14,
+
+  ///   TupleType {
+  ///     elementTypes: Type[]
+  ///   }
+  kTupleType = 15,
+
+  ///   UnrankedMemRefType {
+  ///     shape: svarint[]
+  ///   }
+  ///
+  kUnrankedMemRefType = 16,
+
+  ///   UnrankedMemRefTypeWithMemSpace {
+  ///     memorySpace: Attribute,
+  ///     shape: svarint[]
+  ///   }
+  /// Variant of UnrankedMemRefType with non-default memory space.
+  kUnrankedMemRefTypeWithMemSpace = 17,
+
+  ///   UnrankedTensorType {
+  ///     elementType: Type
+  ///   }
+  ///
+  kUnrankedTensorType = 18,
+
+  ///   VectorType {
+  ///     shape: svarint[],
+  ///     elementType: Type
+  ///   }
+  ///
+  kVectorType = 19,
+
+  ///   VectorTypeWithScalableDims {
+  ///     numScalableDims: varint,
+  ///     shape: svarint[],
+  ///     elementType: Type
+  ///   }
+  /// Variant of VectorType with scalable dimensions.
+  kVectorTypeWithScalableDims = 20,
 };
 
 } // namespace builtin_encoding
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // BuiltinDialectBytecodeInterface
 //===----------------------------------------------------------------------===//
struct BuiltinDialectBytecodeInterface : public BytecodeDialectInterface {
   void write(FusedLoc attr, DialectBytecodeWriter &writer) const;
   void write(NameLoc attr, DialectBytecodeWriter &writer) const;
   LogicalResult write(OpaqueLoc attr, DialectBytecodeWriter &writer) const;
 
   //===--------------------------------------------------------------------===//
   // Types
 
   Type readType(DialectBytecodeReader &reader) const override;
+  ComplexType readComplexType(DialectBytecodeReader &reader) const;
   IntegerType readIntegerType(DialectBytecodeReader &reader) const;
   FunctionType readFunctionType(DialectBytecodeReader &reader) const;
+  MemRefType readMemRefType(DialectBytecodeReader &reader,
+                            bool hasMemSpace) const;
+  RankedTensorType readRankedTensorType(DialectBytecodeReader &reader,
+                                        bool hasEncoding) const;
+  TupleType readTupleType(DialectBytecodeReader &reader) const;
+  UnrankedMemRefType readUnrankedMemRefType(DialectBytecodeReader &reader,
+                                            bool hasMemSpace) const;
+  UnrankedTensorType
+  readUnrankedTensorType(DialectBytecodeReader &reader) const;
+  VectorType readVectorType(DialectBytecodeReader &reader,
+                            bool hasScalableDims) const;
 
   LogicalResult writeType(Type type,
                           DialectBytecodeWriter &writer) const override;
+  void write(ComplexType type, DialectBytecodeWriter &writer) const;
   void write(IntegerType type, DialectBytecodeWriter &writer) const;
   void write(FunctionType type, DialectBytecodeWriter &writer) const;
+  void write(MemRefType type, DialectBytecodeWriter &writer) const;
+  void write(RankedTensorType type, DialectBytecodeWriter &writer) const;
+  void write(TupleType type, DialectBytecodeWriter &writer) const;
+  void write(UnrankedMemRefType type, DialectBytecodeWriter &writer) const;
+  void write(UnrankedTensorType type, DialectBytecodeWriter &writer) const;
+  void write(VectorType type, DialectBytecodeWriter &writer) const;
 };
 } // namespace
 
 void builtin_dialect_detail::addBytecodeInterface(BuiltinDialect *dialect) {
   dialect->addInterfaces<BuiltinDialectBytecodeInterface>();
 }
 
 //===----------------------------------------------------------------------===//
Type BuiltinDialectBytecodeInterface::readType(
   uint64_t code;
   if (failed(reader.readVarInt(code)))
     return Type();
   switch (code) {
   case builtin_encoding::kIntegerType:
     return readIntegerType(reader);
   case builtin_encoding::kIndexType:
     return IndexType::get(getContext());
-
   case builtin_encoding::kFunctionType:
     return readFunctionType(reader);
+  case builtin_encoding::kBFloat16Type:
+    return BFloat16Type::get(getContext());
+  case builtin_encoding::kFloat16Type:
+    return Float16Type::get(getContext());
+  case builtin_encoding::kFloat32Type:
+    return Float32Type::get(getContext());
+  case builtin_encoding::kFloat64Type:
+    return Float64Type::get(getContext());
+  case builtin_encoding::kFloat80Type:
+    return Float80Type::get(getContext());
+  case builtin_encoding::kFloat128Type:
+    return Float128Type::get(getContext());
+  case builtin_encoding::kComplexType:
+    return readComplexType(reader);
+  case builtin_encoding::kMemRefType:
+    return readMemRefType(reader, /*hasMemSpace=*/false);
+  case builtin_encoding::kMemRefTypeWithMemSpace:
+    return readMemRefType(reader, /*hasMemSpace=*/true);
+  case builtin_encoding::kNoneType:
+    return NoneType::get(getContext());
+  case builtin_encoding::kRankedTensorType:
+    return readRankedTensorType(reader, /*hasEncoding=*/false);
+  case builtin_encoding::kRankedTensorTypeWithEncoding:
+    return readRankedTensorType(reader, /*hasEncoding=*/true);
+  case builtin_encoding::kTupleType:
+    return readTupleType(reader);
+  case builtin_encoding::kUnrankedMemRefType:
+    return readUnrankedMemRefType(reader, /*hasMemSpace=*/false);
+  case builtin_encoding::kUnrankedMemRefTypeWithMemSpace:
+    return readUnrankedMemRefType(reader, /*hasMemSpace=*/true);
+  case builtin_encoding::kUnrankedTensorType:
+    return readUnrankedTensorType(reader);
+  case builtin_encoding::kVectorType:
+    return readVectorType(reader, /*hasScalableDims=*/false);
+  case builtin_encoding::kVectorTypeWithScalableDims:
+    return readVectorType(reader, /*hasScalableDims=*/true);
+
   default:
     reader.emitError() << "unknown builtin type code: " << code;
     return Type();
   }
 }
 
 LogicalResult BuiltinDialectBytecodeInterface::writeType(
     Type type, DialectBytecodeWriter &writer) const {
   return TypeSwitch<Type, LogicalResult>(type)
-      .Case<IntegerType, FunctionType>([&](auto type) {
+      .Case<ComplexType, IntegerType, FunctionType, MemRefType,
+            RankedTensorType, TupleType, UnrankedMemRefType, UnrankedTensorType,
+            VectorType>([&](auto type) {
         write(type, writer);
         return success();
       })
       .Case([&](IndexType) {
         return writer.writeVarInt(builtin_encoding::kIndexType), success();
       })
+      .Case([&](BFloat16Type) {
+        return writer.writeVarInt(builtin_encoding::kBFloat16Type), success();
+      })
+      .Case([&](Float16Type) {
+        return writer.writeVarInt(builtin_encoding::kFloat16Type), success();
+      })
+      .Case([&](Float32Type) {
+        return writer.writeVarInt(builtin_encoding::kFloat32Type), success();
+      })
+      .Case([&](Float64Type) {
+        return writer.writeVarInt(builtin_encoding::kFloat64Type), success();
+      })
+      .Case([&](Float80Type) {
+        return writer.writeVarInt(builtin_encoding::kFloat80Type), success();
+      })
+      .Case([&](Float128Type) {
+        return writer.writeVarInt(builtin_encoding::kFloat128Type), success();
+      })
+      .Case([&](NoneType) {
+        return writer.writeVarInt(builtin_encoding::kNoneType), success();
+      })
       .Default([&](Type) { return failure(); });
 }
 
 //===----------------------------------------------------------------------===//
+// ComplexType
+
+ComplexType BuiltinDialectBytecodeInterface::readComplexType(
+    DialectBytecodeReader &reader) const {
+  Type elementType;
+  if (failed(reader.readType(elementType)))
+    return ComplexType();
+  return ComplexType::get(elementType);
+}
+
+void BuiltinDialectBytecodeInterface::write(
+    ComplexType type, DialectBytecodeWriter &writer) const {
+  writer.writeVarInt(builtin_encoding::kComplexType);
+  writer.writeType(type.getElementType());
+}
+
+//===----------------------------------------------------------------------===//
 // IntegerType
 
 IntegerType BuiltinDialectBytecodeInterface::readIntegerType(
     DialectBytecodeReader &reader) const {
   uint64_t encoding;
   if (failed(reader.readVarInt(encoding)))
     return IntegerType();
   return IntegerType::get(

 }
 
 void BuiltinDialectBytecodeInterface::write(
     FunctionType type, DialectBytecodeWriter &writer) const {
   writer.writeVarInt(builtin_encoding::kFunctionType);
   writer.writeTypes(type.getInputs());
   writer.writeTypes(type.getResults());
 }
+
+//===----------------------------------------------------------------------===//
+// MemRefType
+
+MemRefType
+BuiltinDialectBytecodeInterface::readMemRefType(DialectBytecodeReader &reader,
+                                                bool hasMemSpace) const {
+  Attribute memorySpace;
+  if (hasMemSpace && failed(reader.readAttribute(memorySpace)))
+    return MemRefType();
+  SmallVector<int64_t> shape;
+  Type elementType;
+  MemRefLayoutAttrInterface layout;
+  if (failed(reader.readSignedVarInts(shape)) ||
+      failed(reader.readType(elementType)) ||
+      failed(reader.readAttribute(layout)))
+    return MemRefType();
+  return MemRefType::get(shape, elementType, layout, memorySpace);
+}
+
+void BuiltinDialectBytecodeInterface::write(
+    MemRefType type, DialectBytecodeWriter &writer) const {
+  if (Attribute memSpace = type.getMemorySpace()) {
+    writer.writeVarInt(builtin_encoding::kMemRefTypeWithMemSpace);
+    writer.writeAttribute(memSpace);
+  } else {
+    writer.writeVarInt(builtin_encoding::kMemRefType);
+  }
+  writer.writeSignedVarInts(type.getShape());
+  writer.writeType(type.getElementType());
+  writer.writeAttribute(type.getLayout());
+}
+
+//===----------------------------------------------------------------------===//
+// RankedTensorType
+
+RankedTensorType BuiltinDialectBytecodeInterface::readRankedTensorType(
+    DialectBytecodeReader &reader, bool hasEncoding) const {
+  Attribute encoding;
+  if (hasEncoding && failed(reader.readAttribute(encoding)))
+    return RankedTensorType();
+  SmallVector<int64_t> shape;
+  Type elementType;
+  if (failed(reader.readSignedVarInts(shape)) ||
+      failed(reader.readType(elementType)))
+    return RankedTensorType();
+  return RankedTensorType::get(shape, elementType, encoding);
+}
+
+void BuiltinDialectBytecodeInterface::write(
+    RankedTensorType type, DialectBytecodeWriter &writer) const {
+  if (Attribute encoding = type.getEncoding()) {
+    writer.writeVarInt(builtin_encoding::kRankedTensorTypeWithEncoding);
+    writer.writeAttribute(encoding);
+  } else {
+    writer.writeVarInt(builtin_encoding::kRankedTensorType);
+  }
+  writer.writeSignedVarInts(type.getShape());
+  writer.writeType(type.getElementType());
+}
+
+//===----------------------------------------------------------------------===//
+// TupleType
+
+TupleType BuiltinDialectBytecodeInterface::readTupleType(
+    DialectBytecodeReader &reader) const {
+  SmallVector<Type> elements;
+  if (failed(reader.readTypes(elements)))
+    return TupleType();
+  return TupleType::get(getContext(), elements);
+}
+
+void BuiltinDialectBytecodeInterface::write(
+    TupleType type, DialectBytecodeWriter &writer) const {
+  writer.writeVarInt(builtin_encoding::kTupleType);
+  writer.writeTypes(type.getTypes());
+}
+
+//===----------------------------------------------------------------------===//
+// UnrankedMemRefType
+
+UnrankedMemRefType BuiltinDialectBytecodeInterface::readUnrankedMemRefType(
+    DialectBytecodeReader &reader, bool hasMemSpace) const {
+  Attribute memorySpace;
+  if (hasMemSpace && failed(reader.readAttribute(memorySpace)))
+    return UnrankedMemRefType();
+  Type elementType;
+  if (failed(reader.readType(elementType)))
+    return UnrankedMemRefType();
+  return UnrankedMemRefType::get(elementType, memorySpace);
+}
+
+void BuiltinDialectBytecodeInterface::write(
+    UnrankedMemRefType type, DialectBytecodeWriter &writer) const {
+  if (Attribute memSpace = type.getMemorySpace()) {
+    writer.writeVarInt(builtin_encoding::kUnrankedMemRefTypeWithMemSpace);
+    writer.writeAttribute(memSpace);
+  } else {
+    writer.writeVarInt(builtin_encoding::kUnrankedMemRefType);
+  }
+  writer.writeType(type.getElementType());
+}
+
+//===----------------------------------------------------------------------===//
+// UnrankedTensorType
+
+UnrankedTensorType BuiltinDialectBytecodeInterface::readUnrankedTensorType(
+    DialectBytecodeReader &reader) const {
+  Type elementType;
+  if (failed(reader.readType(elementType)))
+    return UnrankedTensorType();
+  return UnrankedTensorType::get(elementType);
+}
+
+void BuiltinDialectBytecodeInterface::write(
+    UnrankedTensorType type, DialectBytecodeWriter &writer) const {
+  writer.writeVarInt(builtin_encoding::kUnrankedTensorType);
+  writer.writeType(type.getElementType());
+}
+
+//===----------------------------------------------------------------------===//
+// VectorType
+
+VectorType
+BuiltinDialectBytecodeInterface::readVectorType(DialectBytecodeReader &reader,
+                                                bool hasScalableDims) const {
+  uint64_t numScalableDims = 0;
+  if (hasScalableDims && failed(reader.readVarInt(numScalableDims)))
+    return VectorType();
+  SmallVector<int64_t> shape;
+  Type elementType;
+  if (failed(reader.readSignedVarInts(shape)) ||
+      failed(reader.readType(elementType)))
+    return VectorType();
+  return VectorType::get(shape, elementType, numScalableDims);
+}
+
+void BuiltinDialectBytecodeInterface::write(
+    VectorType type, DialectBytecodeWriter &writer) const {
+  if (unsigned numScalableDims = type.getNumScalableDims()) {
+    writer.writeVarInt(builtin_encoding::kVectorTypeWithScalableDims);
+    writer.writeVarInt(numScalableDims);
+  } else {
+    writer.writeVarInt(builtin_encoding::kVectorType);
+  }
+  writer.writeSignedVarInts(type.getShape());
+  writer.writeType(type.getElementType());
+}

mlir/test/Dialect/Builtin/Bytecode/types.mlir

 // RUN: mlir-opt -emit-bytecode %s | mlir-opt | FileCheck %s
 
 // Bytecode currently does not support big-endian platforms
 // UNSUPPORTED: s390x-
 
+//===----------------------------------------------------------------------===//
+// ComplexType
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestComplex
+module @TestComplex attributes {
+  // CHECK: bytecode.test = complex<i32>
+  bytecode.test = complex<i32>
+} {}
+
+//===----------------------------------------------------------------------===//
+// FloatType
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestFloat
+module @TestFloat attributes {
+  // CHECK: bytecode.test = bf16,
+  // CHECK: bytecode.test1 = f16,
+  // CHECK: bytecode.test2 = f32,
+  // CHECK: bytecode.test3 = f64,
+  // CHECK: bytecode.test4 = f80,
+  // CHECK: bytecode.test5 = f128
+  bytecode.test = bf16,
+  bytecode.test1 = f16,
+  bytecode.test2 = f32,
+  bytecode.test3 = f64,
+  bytecode.test4 = f80,
+  bytecode.test5 = f128
+} {}
+
+//===----------------------------------------------------------------------===//
+// IntegerType
+//===----------------------------------------------------------------------===//
+
 // CHECK-LABEL: @TestInteger
 module @TestInteger attributes {
   // CHECK: bytecode.int = i1024,
   // CHECK: bytecode.int1 = si32,
   // CHECK: bytecode.int2 = ui512
   bytecode.int = i1024,
   bytecode.int1 = si32,
   bytecode.int2 = ui512
 } {}
 
+//===----------------------------------------------------------------------===//
+// IndexType
+//===----------------------------------------------------------------------===//
+
 // CHECK-LABEL: @TestIndex
 module @TestIndex attributes {
   // CHECK: bytecode.index = index
   bytecode.index = index
 } {}
 
+//===----------------------------------------------------------------------===//
+// FunctionType
+//===----------------------------------------------------------------------===//
+
 // CHECK-LABEL: @TestFunc
 module @TestFunc attributes {
   // CHECK: bytecode.func = () -> (),
   // CHECK: bytecode.func1 = (i1) -> i32
   bytecode.func = () -> (),
   bytecode.func1 = (i1) -> (i32)
 } {}
+
+//===----------------------------------------------------------------------===//
+// MemRefType
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestMemRef
+module @TestMemRef attributes {
+  // CHECK: bytecode.test = memref<2xi8>,
+  // CHECK: bytecode.test1 = memref<2xi8, 1>
+  bytecode.test = memref<2xi8>,
+  bytecode.test1 = memref<2xi8, 1>
+} {}
+
+//===----------------------------------------------------------------------===//
+// NoneType
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestNone
+module @TestNone attributes {
+  // CHECK: bytecode.test = none
+  bytecode.test = none
+} {}
+
+//===----------------------------------------------------------------------===//
+// RankedTensorType
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestRankedTensor
+module @TestRankedTensor attributes {
+  // CHECK: bytecode.test = tensor<16x32x?xf64>,
+  // CHECK: bytecode.test1 = tensor<16xf64, "sparse">
+  bytecode.test = tensor<16x32x?xf64>,
+  bytecode.test1 = tensor<16xf64, "sparse">
+} {}
+
+//===----------------------------------------------------------------------===//
+// TupleType
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestTuple
+module @TestTuple attributes {
+  // CHECK: bytecode.test = tuple<>,
+  // CHECK: bytecode.test1 = tuple<i32, i1, f32>
+  bytecode.test = tuple<>,
+  bytecode.test1 = tuple<i32, i1, f32>
+} {}
+
+//===----------------------------------------------------------------------===//
+// UnrankedMemRefType
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestUnrankedMemRef
+module @TestUnrankedMemRef attributes {
+  // CHECK: bytecode.test = memref<*xi8>,
+  // CHECK: bytecode.test1 = memref<*xi8, 1>
+  bytecode.test = memref<*xi8>,
+  bytecode.test1 = memref<*xi8, 1>
+} {}
+
+//===----------------------------------------------------------------------===//
+// UnrankedTensorType
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestUnrankedTensor
+module @TestUnrankedTensor attributes {
+  // CHECK: bytecode.test = tensor<*xi8>
+  bytecode.test = tensor<*xi8>
+} {}
+
+//===----------------------------------------------------------------------===//
+// VectorType
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: @TestVector
+module @TestVector attributes {
+  // CHECK: bytecode.test = vector<8x8x128xi8>,
+  // CHECK: bytecode.test1 = vector<8x[8]xf32>
+  bytecode.test = vector<8x8x128xi8>,
+  bytecode.test1 = vector<8x[8]xf32>
+} {}