[mlir] Tighten verification of SparseElementsAttr

[rriddle]

Summary

SparseElementsAttr currently does not perform any verfication on construction, with the only verification existing within the parser. This revision moves the parser verification to SparseElementsAttr, and also adds additional verification for when a sparse index is not valid.

[jpienaar]

mlir/include/mlir/IR/BuiltinAttributes.h

75

Nit: 1-dimensional

mlir/lib/IR/BuiltinAttributes.cpp

1439

else failure ?

[rriddle]

Update

mlir/include/mlir/IR/BuiltinAttributes.h

public:
   /// Return the elements of this attribute as a value of type 'T'. Note:
   /// Aborts if the subclass is OpaqueElementsAttrs, these attrs do not support
   /// iteration.
   template <typename T>
   iterator_range<T> getValues() const;
 
   /// Return if the given 'index' refers to a valid element in this attribute.
   bool isValidIndex(ArrayRef<uint64_t> index) const;
+  static bool isValidIndex(ShapedType type, ArrayRef<uint64_t> index);
+
+  /// Returns the 1-dimensional flattened row-major index from the given
+  /// multi-dimensional index.
+  uint64_t getFlattenedIndex(ArrayRef<uint64_t> index) const;
+  static uint64_t getFlattenedIndex(ShapedType type, ArrayRef<uint64_t> index);
 
   /// Returns the number of elements held by this attribute.
   int64_t getNumElements() const;
 
   /// Returns the number of elements held by this attribute.
   int64_t size() const { return getNumElements(); }
 
   /// Returns if the number of elements held by this attribute is 0.
   bool empty() const { return size() == 0; }
 
   /// Generates a new ElementsAttr by mapping each int value to a new
   /// underlying APInt. The new values can represent either an integer or float.
   /// This ElementsAttr should contain integers.
   ElementsAttr mapValues(Type newElementType,
                          function_ref<APInt(const APInt &)> mapping) const;
 
   /// Generates a new ElementsAttr by mapping each float value to a new
   /// underlying APInt. The new values can represent either an integer or float.
   /// This ElementsAttr should contain floats.
   ElementsAttr mapValues(Type newElementType,
                          function_ref<APInt(const APFloat &)> mapping) const;
 
   /// Method for support type inquiry through isa, cast and dyn_cast.
   static bool classof(Attribute attr);
-
-protected:
-  /// Returns the 1 dimensional flattened row-major index from the given
-  /// multi-dimensional index.
-  uint64_t getFlattenedIndex(ArrayRef<uint64_t> index) const;
 };
 
 namespace detail {
 /// DenseElementsAttr data is aligned to uint64_t, so this traits class is
 /// necessary to interop with PointerIntPair.
 class DenseElementDataPointerTypeTraits {
 public:
   static inline const void *getAsVoidPointer(const char *ptr) { return ptr; }

mlir/include/mlir/IR/BuiltinAttributes.td

private:
     }
 
     /// Flatten, and return, all of the sparse indices in this attribute in
     /// row-major order.
     std::vector<ptrdiff_t> getFlattenedSparseIndices() const;
 
   public:
   }];
+  let genVerifyDecl = 1;
   let skipDefaultBuilders = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // StringAttr
 //===----------------------------------------------------------------------===//
 
 def Builtin_StringAttr : Builtin_Attr<"String"> {

mlir/lib/IR/BuiltinAttributes.cpp

 Attribute ElementsAttr::getValue(ArrayRef<uint64_t> index) const {
   if (auto denseAttr = dyn_cast<DenseElementsAttr>())
     return denseAttr.getValue(index);
   if (auto opaqueAttr = dyn_cast<OpaqueElementsAttr>())
     return opaqueAttr.getValue(index);
   return cast<SparseElementsAttr>().getValue(index);
 }
 
-/// Return if the given 'index' refers to a valid element in this attribute.
 bool ElementsAttr::isValidIndex(ArrayRef<uint64_t> index) const {
-  auto type = getType();
-
+  return isValidIndex(getType(), index);
+}
+bool ElementsAttr::isValidIndex(ShapedType type, ArrayRef<uint64_t> index) {
   // Verify that the rank of the indices matches the held type.
-  auto rank = type.getRank();
+  int64_t rank = type.getRank();
   if (rank == 0 && index.size() == 1 && index[0] == 0)
     return true;
   if (rank != static_cast<int64_t>(index.size()))
     return false;
 
   // Verify that all of the indices are within the shape dimensions.
-  auto shape = type.getShape();
+  ArrayRef<int64_t> shape = type.getShape();
   return llvm::all_of(llvm::seq<int>(0, rank), [&](int i) {
     int64_t dim = static_cast<int64_t>(index[i]);
     return 0 <= dim && dim < shape[i];
   });
 }
 
+uint64_t ElementsAttr::getFlattenedIndex(ArrayRef<uint64_t> index) const {
+  return getFlattenedIndex(getType(), index);
+}
+uint64_t ElementsAttr::getFlattenedIndex(ShapedType type,
+                                         ArrayRef<uint64_t> index) {
+  assert(isValidIndex(type, index) && "expected valid multi-dimensional index");
+
+  // Reduce the provided multidimensional index into a flattended 1D row-major
+  // index.
+  auto rank = type.getRank();
+  auto shape = type.getShape();
+  uint64_t valueIndex = 0;
+  uint64_t dimMultiplier = 1;
+  for (int i = rank - 1; i >= 0; --i) {
+    valueIndex += index[i] * dimMultiplier;
+    dimMultiplier *= shape[i];
+  }
+  return valueIndex;
+}
+
 ElementsAttr
 ElementsAttr::mapValues(Type newElementType,
                         function_ref<APInt(const APInt &)> mapping) const {
   if (auto intOrFpAttr = dyn_cast<DenseElementsAttr>())
     return intOrFpAttr.mapValues(newElementType, mapping);
   llvm_unreachable("unsupported ElementsAttr subtype");
 }
 
 ElementsAttr
 ElementsAttr::mapValues(Type newElementType,
                         function_ref<APInt(const APFloat &)> mapping) const {
   if (auto intOrFpAttr = dyn_cast<DenseElementsAttr>())
     return intOrFpAttr.mapValues(newElementType, mapping);
   llvm_unreachable("unsupported ElementsAttr subtype");
 }
 
 /// Method for support type inquiry through isa, cast and dyn_cast.
 bool ElementsAttr::classof(Attribute attr) {
   return attr.isa<DenseIntOrFPElementsAttr, DenseStringElementsAttr,
                   OpaqueElementsAttr, SparseElementsAttr>();
 }
 
-/// Returns the 1 dimensional flattened row-major index from the given
-/// multi-dimensional index.
-uint64_t ElementsAttr::getFlattenedIndex(ArrayRef<uint64_t> index) const {
-  assert(isValidIndex(index) && "expected valid multi-dimensional index");
-  auto type = getType();
-
-  // Reduce the provided multidimensional index into a flattended 1D row-major
-  // index.
-  auto rank = type.getRank();
-  auto shape = type.getShape();
-  uint64_t valueIndex = 0;
-  uint64_t dimMultiplier = 1;
-  for (int i = rank - 1; i >= 0; --i) {
-    valueIndex += index[i] * dimMultiplier;
-    dimMultiplier *= shape[i];
-  }
-  return valueIndex;
-}
-
 //===----------------------------------------------------------------------===//
 // DenseElementsAttr Utilities
 //===----------------------------------------------------------------------===//
 
 /// Get the bitwidth of a dense element type within the buffer.
 /// DenseElementsAttr requires bitwidths greater than 1 to be aligned by 8.
 static size_t getDenseElementStorageWidth(size_t origWidth) {
   return origWidth == 1 ? origWidth : llvm::alignTo<8>(origWidth);
std::vector<ptrdiff_t> SparseElementsAttr::getFlattenedSparseIndices() const {
   auto numSparseIndices = sparseIndices.getType().getDimSize(0);
   size_t rank = getType().getRank();
   for (size_t i = 0, e = numSparseIndices; i != e; ++i)
     flatSparseIndices.push_back(getFlattenedIndex(
         {&*std::next(sparseIndexValues.begin(), i * rank), rank}));
   return flatSparseIndices;
 }
 
+LogicalResult
+SparseElementsAttr::verify(function_ref<InFlightDiagnostic()> emitError,
+                           ShapedType type, DenseIntElementsAttr sparseIndices,
+                           DenseElementsAttr values) {
+  ShapedType valuesType = values.getType();
+  if (valuesType.getRank() != 1)
+    return emitError() << "expected 1-d tensor for sparse element values";
+
+  // Verify the indices and values shape.
+  ShapedType indicesType = sparseIndices.getType();
+  auto emitShapeError = [&]() {
+    return emitError() << "expected shape ([" << type.getShape()
+                       << "]); inferred shape of indices literal (["
+                       << indicesType.getShape()
+                       << "]); inferred shape of values literal (["
+                       << valuesType.getShape() << "])";
+  };
+  // Verify indices shape.
+  size_t rank = type.getRank(), indicesRank = indicesType.getRank();
+  if (indicesRank == 2) {
+    if (indicesType.getDimSize(1) != rank)
+      return emitShapeError();
+  } else if (indicesRank != 1 || rank != 1) {
+    return emitShapeError();
+  }
+  // Verify the values shape.
+  int64_t numSparseIndices = indicesType.getDimSize(0);
+  if (numSparseIndices != valuesType.getDimSize(0))
+    return emitShapeError();
+
+  // Verify that the sparse indices are within the value shape.
+  auto emitIndexError = [&](unsigned indexNum, ArrayRef<uint64_t> index) {
+    return emitError()
+           << "sparse index #" << indexNum
+           << " is not contained within the value shape, with index=[" << index
+           << "], and type=" << type;
+  };
+
+  // Handle the case where the index values are a splat.
+  auto sparseIndexValues = sparseIndices.getValues<uint64_t>();
+  if (sparseIndices.isSplat()) {
+    SmallVector<uint64_t> indices(rank, *sparseIndexValues.begin());
+    if (!ElementsAttr::isValidIndex(type, indices))
+      return emitIndexError(0, indices);
+    return success();
+  }
+
+  // Otherwise, reinterpret each index as an ArrayRef.
+  for (size_t i = 0, e = numSparseIndices; i != e; ++i) {
+    ArrayRef<uint64_t> index(&*std::next(sparseIndexValues.begin(), i * rank),
+                             rank);
+    if (!ElementsAttr::isValidIndex(type, index))
+      return emitIndexError(i, index);
+  }
+
+  return success();
+}
+
 //===----------------------------------------------------------------------===//
 // TypeAttr
 //===----------------------------------------------------------------------===//
 
 void TypeAttr::walkImmediateSubElements(
     function_ref<void(Attribute)> walkAttrsFn,
     function_ref<void(Type)> walkTypesFn) const {
   walkTypesFn(getValue());
 }

mlir/lib/Parser/AttributeParser.cpp

ShapedType Parser::parseElementsLiteralType(Type type) {
   if (!sType.hasStaticShape())
     return (emitError("elements literal type must have static shape"), nullptr);
 
   return sType;
 }
 
 /// Parse a sparse elements attribute.
 Attribute Parser::parseSparseElementsAttr(Type attrType) {
+  llvm::SMLoc loc = getToken().getLoc();
   consumeToken(Token::kw_sparse);
   if (parseToken(Token::less, "Expected '<' after 'sparse'"))
     return nullptr;
 
   // Check for the case where all elements are sparse. The indices are
   // represented by a 2-dimensional shape where the second dimension is the rank
   // of the type.
   Type indiceEltType = builder.getIntegerType(64);
   if (consumeIf(Token::greater)) {
     ShapedType type = parseElementsLiteralType(attrType);
     if (!type)
       return nullptr;
 
     // Construct the sparse elements attr using zero element indice/value
     // attributes.
     ShapedType indicesType =
         RankedTensorType::get({0, type.getRank()}, indiceEltType);
     ShapedType valuesType = RankedTensorType::get({0}, type.getElementType());
-    return SparseElementsAttr::get(
-        type, DenseElementsAttr::get(indicesType, ArrayRef<Attribute>()),
+    return getChecked<SparseElementsAttr>(
+        loc, type, DenseElementsAttr::get(indicesType, ArrayRef<Attribute>()),
         DenseElementsAttr::get(valuesType, ArrayRef<Attribute>()));
   }
 
   /// Parse the indices. We don't allow hex values here as we may need to use
   /// the inferred shape.
   auto indicesLoc = getToken().getLoc();
   TensorLiteralParser indiceParser(*this);
   if (indiceParser.parse(/*allowHex=*/false))
Attribute Parser::parseSparseElementsAttr(Type attrType) {
   // indice shape type.
   auto valuesEltType = type.getElementType();
   ShapedType valuesType =
       valuesParser.getShape().empty()
           ? RankedTensorType::get({indicesType.getDimSize(0)}, valuesEltType)
           : RankedTensorType::get(valuesParser.getShape(), valuesEltType);
   auto values = valuesParser.getAttr(valuesLoc, valuesType);
 
-  /// Sanity check.
-  if (valuesType.getRank() != 1)
-    return (emitError("expected 1-d tensor for values"), nullptr);
-
-  auto sameShape = (indicesType.getRank() == 1) ||
-                   (type.getRank() == indicesType.getDimSize(1));
-  auto sameElementNum = indicesType.getDimSize(0) == valuesType.getDimSize(0);
-  if (!sameShape || !sameElementNum) {
-    emitError() << "expected shape ([" << type.getShape()
-                << "]); inferred shape of indices literal (["
-                << indicesType.getShape()
-                << "]); inferred shape of values literal (["
-                << valuesType.getShape() << "])";
-    return nullptr;
-  }
-
   // Build the sparse elements attribute by the indices and values.
-  return SparseElementsAttr::get(type, indices, values);
+  return getChecked<SparseElementsAttr>(loc, type, indices, values);
 }

mlir/lib/Parser/Parser.h

ParseResult parseFloatFromIntegerLiteral(Optional<APFloat> &result,
                                            const Token &tok, bool isNegative,
                                            const llvm::fltSemantics &semantics,
                                            size_t typeSizeInBits);
 
   //===--------------------------------------------------------------------===//
   // Type Parsing
   //===--------------------------------------------------------------------===//
 
+  /// Invoke the `getChecked` method of the given Attribute or Type class, using
+  /// the provided location to emit errors in the case of failure. Note that
+  /// unlike `OpBuilder::getType`, this method does not implicitly insert a
+  /// context parameter.
+  template <typename T, typename... ParamsT>
+  T getChecked(llvm::SMLoc loc, ParamsT &&...params) {
+    return T::getChecked([&] { return emitError(loc); },
+                         std::forward<ParamsT>(params)...);
+  }
+
   ParseResult parseFunctionResultTypes(SmallVectorImpl<Type> &elements);
   ParseResult parseTypeListNoParens(SmallVectorImpl<Type> &elements);
   ParseResult parseTypeListParens(SmallVectorImpl<Type> &elements);
 
   /// Optionally parse a type.
   OptionalParseResult parseOptionalType(Type &type);
 
   /// Parse an arbitrary type.

mlir/lib/Parser/TypeParser.cpp

 ///
 ///   stride-list ::= `[` (dimension (`,` dimension)*)? `]`
 ///   strided-layout ::= `offset:` dimension `,` `strides: ` stride-list
 ///   semi-affine-map-composition ::= (semi-affine-map `,` )* semi-affine-map
 ///   layout-specification ::= semi-affine-map-composition | strided-layout
 ///   memory-space ::= integer-literal /* | TODO: address-space-id */
 ///
 Type Parser::parseMemRefType() {
+  llvm::SMLoc loc = getToken().getLoc();
   consumeToken(Token::kw_memref);
 
   if (parseToken(Token::less, "expected '<' in memref type"))
     return nullptr;
 
   bool isUnranked;
   SmallVector<int64_t, 4> dimensions;
 
if (!consumeIf(Token::greater)) {
     // Parse comma separated list of affine maps, followed by memory space.
     if (parseToken(Token::comma, "expected ',' or '>' in memref type") ||
         parseCommaSeparatedListUntil(Token::greater, parseElt,
                                      /*allowEmptyList=*/false)) {
       return nullptr;
     }
   }
 
-  if (isUnranked) {
-    return UnrankedMemRefType::getChecked(
-        [&]() -> InFlightDiagnostic { return emitError(); }, elementType,
-        memorySpace);
-  }
+  if (isUnranked)
+    return getChecked<UnrankedMemRefType>(loc, elementType, memorySpace);
 
-  return MemRefType::getChecked(
-      [&]() -> InFlightDiagnostic { return emitError(); }, dimensions,
-      elementType, affineMapComposition, memorySpace);
+  return getChecked<MemRefType>(loc, dimensions, elementType,
+                                affineMapComposition, memorySpace);
 }
 
 /// Parse any type except the function type.
 ///
 ///   non-function-type ::= integer-type
 ///                       | index-type
 ///                       | float-type
 ///                       | extended-type

mlir/test/CAPI/ir.c

int printBuiltinAttributes(MlirContext ctx) {
   // CHECK: dense<1.000000e+00> : tensor<1x2xf32>
   // CHECK: dense<1.000000e+00> : tensor<1x2xf64>
 
   mlirAttributeDump(mlirElementsAttrGetValue(floatElements, 2, uints64));
   mlirAttributeDump(mlirElementsAttrGetValue(doubleElements, 2, uints64));
   // CHECK: 1.000000e+00 : f32
   // CHECK: 1.000000e+00 : f64
 
-  int64_t indices[] = {4, 7};
-  int64_t two = 2;
+  int64_t indices[] = {0, 1};
+  int64_t one = 1;
   MlirAttribute indicesAttr = mlirDenseElementsAttrInt64Get(
-      mlirRankedTensorTypeGet(1, &two, mlirIntegerTypeGet(ctx, 64), encoding),
+      mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeGet(ctx, 64), encoding),
       2, indices);
   MlirAttribute valuesAttr = mlirDenseElementsAttrFloatGet(
-      mlirRankedTensorTypeGet(1, &two, mlirF32TypeGet(ctx), encoding), 2,
+      mlirRankedTensorTypeGet(1, &one, mlirF32TypeGet(ctx), encoding), 1,
       floats);
   MlirAttribute sparseAttr = mlirSparseElementsAttribute(
       mlirRankedTensorTypeGet(2, shape, mlirF32TypeGet(ctx), encoding),
       indicesAttr, valuesAttr);
   mlirAttributeDump(sparseAttr);
-  // CHECK: sparse<[4, 7], [0.000000e+00, 1.000000e+00]> : tensor<1x2xf32>
+  // CHECK: sparse<{{\[}}[0, 1]], 0.000000e+00> : tensor<1x2xf32>
 
   return 0;
 }
 
 int printAffineMap(MlirContext ctx) {
   MlirAffineMap emptyAffineMap = mlirAffineMapEmptyGet(ctx);
   MlirAffineMap affineMap = mlirAffineMapZeroResultGet(ctx, 3, 2);
   MlirAffineMap constAffineMap = mlirAffineMapConstantGet(ctx, 2);

mlir/test/Dialect/Quant/convert-const.mlir

func @const_dense_tensor_i8_fixedpoint() -> tensor<7xf32> {
   %1 = "quant.qcast"(%cst) : (tensor<7xf32>) -> tensor<7x!quant.uniform<i8:f32, 7.812500e-03>>
   %2 = "quant.dcast"(%1) : (tensor<7x!quant.uniform<i8:f32, 7.812500e-03>>) -> (tensor<7xf32>)
   return %2 : tensor<7xf32>
 }
 
 // -----
 // Verifies i8 fixedpoint quantization on a sparse tensor, sweeping values.
 // CHECK-LABEL: const_sparse_tensor_i8_fixedpoint
-func @const_sparse_tensor_i8_fixedpoint() -> tensor<7x2xf32> {
+func @const_sparse_tensor_i8_fixedpoint() -> tensor<2x7xf32> {
   // NOTE: Ugly regex match pattern for opening "[[" of indices tensor.
-  // CHECK: %cst = constant sparse<{{\[}}[0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [0, 5], [0, 6]], [-128, -128, -64, 0, 64, 127, 127]> : tensor<7x2xi8>
+  // CHECK: %cst = constant sparse<{{\[}}[0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [0, 5], [0, 6]], [-128, -128, -64, 0, 64, 127, 127]> : tensor<2x7xi8>
   %cst = constant sparse<
       [[0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [0, 5], [0, 6]],
-      [-2.0, -1.0, -0.5, 0.0, 0.5, 1.0, 2.0]> : tensor<7x2xf32>
-  %1 = "quant.qcast"(%cst) : (tensor<7x2xf32>) -> tensor<7x2x!quant.uniform<i8:f32, 7.812500e-03>>
-  %2 = "quant.dcast"(%1) : (tensor<7x2x!quant.uniform<i8:f32, 7.812500e-03>>) -> (tensor<7x2xf32>)
-  return %2 : tensor<7x2xf32>
+      [-2.0, -1.0, -0.5, 0.0, 0.5, 1.0, 2.0]> : tensor<2x7xf32>
+  %1 = "quant.qcast"(%cst) : (tensor<2x7xf32>) -> tensor<2x7x!quant.uniform<i8:f32, 7.812500e-03>>
+  %2 = "quant.dcast"(%1) : (tensor<2x7x!quant.uniform<i8:f32, 7.812500e-03>>) -> (tensor<2x7xf32>)
+  return %2 : tensor<2x7xf32>
 }
 
 // -----
 // Verifies i8 fixedpoint quantization on a primitive const.
 // CHECK-LABEL: const_primitive_float_i8_fixedpoint
 func @const_primitive_float_i8_fixedpoint() -> f32 {
   // CHECK: %c64_i8 = constant 64 : i8
   // CHECK-NEXT: %0 = "quant.scast"(%c64_i8) : (i8) -> !quant.uniform<i8:f32, 7.812500e-03>

mlir/test/Dialect/Tensor/canonicalize.mlir

func @fold_extract(%arg0 : index) -> (f32, f16, f16, i32) {
   %0 = constant dense<4.0> : tensor<4xf32>
   %ext_1 = tensor.extract %0[%arg0] : tensor<4xf32>
 
   // Fold an extract into a sparse with a sparse index.
   %1 = constant sparse<[[0, 0, 0], [1, 1, 1]],  [-5.0, -2.0]> : tensor<4x4x4xf16>
   %ext_2 = tensor.extract %1[%const_1, %const_1, %const_1] : tensor<4x4x4xf16>
 
   // Fold an extract into a sparse with a non sparse index.
-  %2 = constant sparse<[[1, 1, 1]],  [-2.0]> : tensor<1x1x1xf16>
-  %ext_3 = tensor.extract %2[%const_0, %const_0, %const_0] : tensor<1x1x1xf16>
+  %2 = constant sparse<[[1, 1, 1]],  [-2.0]> : tensor<2x2x2xf16>
+  %ext_3 = tensor.extract %2[%const_0, %const_0, %const_0] : tensor<2x2x2xf16>
 
   // Fold an extract into a dense tensor.
    %3 = constant dense<[[[1, -2, 1, 36]], [[0, 2, -1, 64]]]> : tensor<2x1x4xi32>
   %ext_4 = tensor.extract %3[%const_1, %const_0, %const_3] : tensor<2x1x4xi32>
 
   // CHECK-NEXT: return [[C4]], [[CM2]], [[C0]], [[C64]]
   return %ext_1, %ext_2, %ext_3, %ext_4 : f32, f16, f16, i32
 }

mlir/test/IR/invalid.mlir

 
 func @mi() {
   // expected-error @+1 {{expected element literal of primitive type}}
   "fooi64"(){bar = sparse<vector<1xi64>,[,[,1]
 
 // -----
 
 func @invalid_tensor_literal() {
-  // expected-error @+1 {{expected 1-d tensor for values}}
+  // expected-error @+1 {{expected 1-d tensor for sparse element values}}
   "foof16"(){bar = sparse<[[0, 0, 0]],  [[-2.0]]> : vector<1x1x1xf16>} : () -> ()
 
 // -----
 
 func @invalid_tensor_literal() {
   // expected-error @+1 {{expected element literal of primitive type}}
   "fooi16"(){bar = sparse<[[1, 1, 0], [0, 1, 0], [0,, [[0, 0, 0]], [-2.0]> : tensor<2x2x2xi16>} : () -> ()
 
 // -----
 
+func @invalid_tensor_literal() {
+  // expected-error @+1 {{sparse index #0 is not contained within the value shape, with index=[1, 1], and type='tensor<1x1xi16>'}}
+  "fooi16"(){bar = sparse<1, 10> : tensor<1x1xi16>} : () -> ()
+
+// -----
+
 func @invalid_affine_structure() {
   %c0 = constant 0 : index
   %idx = affine.apply affine_map<(d0, d1)> (%c0, %c0) // expected-error {{expected '->' or ':'}}
   return
 }
 
 // -----
 

mlir/test/IR/parser.mlir

 // NOTE: The {{\[\[}} syntax is because "[[" confuses FileCheck.
 // CHECK: "fooi8"() {bar = sparse<0, -2> : tensor<1x1x1xi8>} : () -> ()
   "fooi8"(){bar = sparse<0, -2> : tensor<1x1x1xi8>} : () -> ()
 // CHECK: "fooi16"() {bar = sparse<{{\[\[}}1, 1, 0], {{\[}}0, 1, 0], {{\[}}0, 0, 1]], {{\[}}2, -1, 5]> : tensor<2x2x2xi16>} : () -> ()
   "fooi16"(){bar = sparse<[[1, 1, 0], [0, 1, 0], [0, 0, 1]], [2, -1, 5]> : tensor<2x2x2xi16>} : () -> ()
 // CHECK: "fooi32"() {bar = sparse<> : tensor<1x1xi32>} : () -> ()
   "fooi32"(){bar = sparse<> : tensor<1x1xi32>} : () -> ()
 // CHECK: "fooi64"() {bar = sparse<0, -1> : tensor<1xi64>} : () -> ()
-  "fooi64"(){bar = sparse<[[0]], [-1]> : tensor<1xi64>} : () -> ()
+  "fooi64"(){bar = sparse<[0], [-1]> : tensor<1xi64>} : () -> ()
 // CHECK: "foo2"() {bar = sparse<> : tensor<0xi32>} : () -> ()
   "foo2"(){bar = sparse<> : tensor<0xi32>} : () -> ()
 // CHECK: "foo3"() {bar = sparse<> : tensor<i32>} : () -> ()
   "foo3"(){bar = sparse<> : tensor<i32>} : () -> ()
 
 // CHECK: "foof16"() {bar = sparse<0, -2.000000e+00> : tensor<1x1x1xf16>} : () -> ()
   "foof16"(){bar = sparse<0, -2.0> : tensor<1x1x1xf16>} : () -> ()
 // CHECK: "foobf16"() {bar = sparse<{{\[\[}}1, 1, 0], {{\[}}0, 1, 0], {{\[}}0, 0, 1]], {{\[}}2.000000e+00, -1.000000e+00, 5.000000e+00]> : tensor<2x2x2xbf16>} : () -> ()

mlir/test/IR/pretty-attributes.mlir

 // RUN: mlir-opt %s -mlir-elide-elementsattrs-if-larger=2 | FileCheck %s
 // Ensure that the elided version is still parseable, although depending on
 // what has been elided, it may not be semantically meaningful.
 // In the typical case where what is being elided is a very large constant
 // tensor which passes don't look at directly, this isn't an issue.
 // RUN: mlir-opt %s -mlir-elide-elementsattrs-if-larger=2 | mlir-opt
 
 // CHECK: opaque<"_", "0xDEADBEEF"> : tensor<3xi32>
 "test.dense_attr"() {foo.dense_attr = dense<[1, 2, 3]> : tensor<3xi32>} : () -> ()
 
 // CHECK: dense<[1, 2]> : tensor<2xi32>
 "test.non_elided_dense_attr"() {foo.dense_attr = dense<[1, 2]> : tensor<2xi32>} : () -> ()
 
-// CHECK: opaque<"_", "0xDEADBEEF"> : vector<1x1x1xf16>
-"test.sparse_attr"() {foo.sparse_attr = sparse<[[1, 2, 3]],  -2.0> : vector<1x1x1xf16>} : () -> ()
+// CHECK: opaque<"_", "0xDEADBEEF"> : vector<1x1x10xf16>
+"test.sparse_attr"() {foo.sparse_attr = sparse<[[0, 0, 5]],  -2.0> : vector<1x1x10xf16>} : () -> ()
 
 // CHECK: opaque<"_", "0xDEADBEEF"> : tensor<100xf32>
 "test.opaque_attr"() {foo.opaque_attr = opaque<"_", "0xEBFE"> : tensor<100xf32> } : () -> ()
 
 // CHECK: dense<1> : tensor<3xi32>
 "test.dense_splat"() {foo.dense_attr = dense<1> : tensor<3xi32>} : () -> ()

mlir/test/Target/LLVMIR/llvmir.mlir

llvm.func @alloca(%size : i64) {
   // CHECK-NEXT: alloca {{.*}} align 8
   llvm.alloca %size x i32 {alignment = 8} : (i64) -> (!llvm.ptr<i32>)
   llvm.return
 }
 
 // CHECK-LABEL: @constants
 llvm.func @constants() -> vector<4xf32> {
   // CHECK: ret <4 x float> <float 4.2{{0*}}e+01, float 0.{{0*}}e+00, float 0.{{0*}}e+00, float 0.{{0*}}e+00>
-  %0 = llvm.mlir.constant(sparse<[[0]], [4.2e+01]> : vector<4xf32>) : vector<4xf32>
+  %0 = llvm.mlir.constant(sparse<[0], [4.2e+01]> : vector<4xf32>) : vector<4xf32>
   llvm.return %0 : vector<4xf32>
 }
 
 // CHECK-LABEL: @fp_casts
 llvm.func @fp_casts(%fp1 : f32, %fp2 : f64) -> i16 {
 // CHECK:    fptrunc double {{.*}} to float
   %a = llvm.fptrunc %fp2 : f64 to f32
 // CHECK:    fpext float {{.*}} to double