add verification for explicit/implicit values

Author: yinying-lisa-li

mlir/lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp

@@ -907,6 +907,41 @@ LogicalResult SparseTensorEncodingAttr::verifyEncoding(
     return emitError()
            << "dimension-rank mismatch between encoding and tensor shape: "
            << getDimRank() << " != " << dimRank;
+  Type expType, impType;
+  if (getExplicitVal()) {
+    auto fVal = llvm::dyn_cast<FloatAttr>(getExplicitVal());
+    auto intVal = llvm::dyn_cast<IntegerAttr>(getExplicitVal());
+    if (fVal && fVal.getType() != elementType) {
+      expType = fVal.getType();
+    } else if (intVal && intVal.getType() != elementType) {
+      expType = intVal.getType();
+    }
+    if (expType) {
+      return emitError() << "explicit value type mismatch between encoding and "
+                         << "tensor element type: " << expType
+                         << " != " << elementType;
+    }
+  }
+
+  if (getImplicitVal()) {
+    auto impFVal = llvm::dyn_cast<FloatAttr>(getImplicitVal());
+    auto impIntVal = llvm::dyn_cast<IntegerAttr>(getImplicitVal());
+    if (impFVal && impFVal.getType() != elementType) {
+      impType = impFVal.getType();
+    } else if (impIntVal && impIntVal.getType() != elementType) {
+      impType = impIntVal.getType();
+    }
+    if (impType) {
+      return emitError() << "implicit value type mismatch between encoding and "
+                         << "tensor element type: " << impType
+                         << " != " << elementType;
+    }
+    // Currently, we only support zero as the implicit value.
+    if ((impFVal && impFVal.getValueAsDouble() != 0.0) ||
+        (impIntVal && impIntVal.getInt() != 0)) {
+      return emitError() << "implicit value must be zero";
+    }
+  }
   return success();
 }
 

mlir/test/Dialect/SparseTensor/invalid_encoding.mlir

@@ -443,3 +443,75 @@ func.func private @NOutOfM(%arg0: tensor<?x?x?xf64, #NOutOfM>) {
 func.func private @NOutOfM(%arg0: tensor<?x?x?xf64, #NOutOfM>) {
   return
 }
+
+// -----
+
+#CSR_ExpType = #sparse_tensor.encoding<{
+  map = (d0, d1) -> (d0 : dense, d1 : compressed),
+  posWidth = 32,
+  crdWidth = 32,
+  explicitVal = 1 : i32,
+  implicitVal = 0.0 : f32
+}>
+
+// expected-error@+1 {{explicit value type mismatch between encoding and tensor element type: 'i32' != 'f32'}}
+func.func private @sparse_csr(tensor<?x?xf32, #CSR_ExpType>)
+
+// -----
+
+#CSR_ImpType = #sparse_tensor.encoding<{
+  map = (d0, d1) -> (d0 : dense, d1 : compressed),
+  posWidth = 32,
+  crdWidth = 32,
+  explicitVal = 1 : i32,
+  implicitVal = 0.0 : f32
+}>
+
+// expected-error@+1 {{implicit value type mismatch between encoding and tensor element type: 'f32' != 'i32'}}
+func.func private @sparse_csr(tensor<?x?xi32, #CSR_ImpType>)
+
+// -----
+
+// expected-error@+1 {{expected a numeric value for explicitVal}}
+#CSR_ExpType = #sparse_tensor.encoding<{
+  map = (d0, d1) -> (d0 : dense, d1 : compressed),
+  posWidth = 32,
+  crdWidth = 32,
+  explicitVal = "str"
+}>
+func.func private @sparse_csr(tensor<?x?xi32, #CSR_ExpType>)
+
+// -----
+
+// expected-error@+1 {{expected a numeric value for implicitVal}}
+#CSR_ImpType = #sparse_tensor.encoding<{
+  map = (d0, d1) -> (d0 : dense, d1 : compressed),
+  posWidth = 32,
+  crdWidth = 32,
+  implicitVal = "str"
+}>
+func.func private @sparse_csr(tensor<?x?xi32, #CSR_ImpType>)
+
+// -----
+
+#CSR_ImpVal = #sparse_tensor.encoding<{
+  map = (d0, d1) -> (d0 : dense, d1 : compressed),
+  posWidth = 32,
+  crdWidth = 32,
+  implicitVal = 1 : i32
+}>
+
+// expected-error@+1 {{implicit value must be zero}}
+func.func private @sparse_csr(tensor<?x?xi32, #CSR_ImpVal>)
+
+// -----
+
+#CSR_ImpVal = #sparse_tensor.encoding<{
+  map = (d0, d1) -> (d0 : dense, d1 : compressed),
+  posWidth = 32,
+  crdWidth = 32,
+  implicitVal = 1.0 : f32
+}>
+
+// expected-error@+1 {{implicit value must be zero}}
+func.func private @sparse_csr(tensor<?x?xf32, #CSR_ImpVal>)