[mlir][CAPI] Expose [u]int8 DenseElementsAttr.

[silvas]

Summary

Also, fix a small typo where the "unsigned" splat variants were not
being created with an unsigned type.

mlir/include/mlir-c/BuiltinAttributes.h

 
 /// Creates a dense elements attribute with the given Shaped type containing a
 /// single replicated element (splat).
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrSplatGet(MlirType shapedType, MlirAttribute element);
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrBoolSplatGet(MlirType shapedType, bool element);
 MLIR_CAPI_EXPORTED MlirAttribute
+mlirDenseElementsAttrUInt8SplatGet(MlirType shapedType, uint8_t element);
+MLIR_CAPI_EXPORTED MlirAttribute
+mlirDenseElementsAttrInt8SplatGet(MlirType shapedType, int8_t element);
+MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrUInt32SplatGet(MlirType shapedType, uint32_t element);
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrInt32SplatGet(MlirType shapedType, int32_t element);
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrUInt64SplatGet(MlirType shapedType, uint64_t element);
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrInt64SplatGet(MlirType shapedType, int64_t element);
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrFloatSplatGet(MlirType shapedType, float element);
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrDoubleSplatGet(MlirType shapedType, double element);
 
 /// Creates a dense elements attribute with the given shaped type from elements
 /// of a specific type. Expects the element type of the shaped type to match the
 /// data element type.
 MLIR_CAPI_EXPORTED MlirAttribute mlirDenseElementsAttrBoolGet(
     MlirType shapedType, intptr_t numElements, const int *elements);
+MLIR_CAPI_EXPORTED MlirAttribute mlirDenseElementsAttrUInt8Get(
+    MlirType shapedType, intptr_t numElements, const uint8_t *elements);
+MLIR_CAPI_EXPORTED MlirAttribute mlirDenseElementsAttrInt8Get(
+    MlirType shapedType, intptr_t numElements, const int8_t *elements);
 MLIR_CAPI_EXPORTED MlirAttribute mlirDenseElementsAttrUInt32Get(
     MlirType shapedType, intptr_t numElements, const uint32_t *elements);
 MLIR_CAPI_EXPORTED MlirAttribute mlirDenseElementsAttrInt32Get(
     MlirType shapedType, intptr_t numElements, const int32_t *elements);
 MLIR_CAPI_EXPORTED MlirAttribute mlirDenseElementsAttrUInt64Get(
     MlirType shapedType, intptr_t numElements, const uint64_t *elements);
 MLIR_CAPI_EXPORTED MlirAttribute mlirDenseElementsAttrInt64Get(
     MlirType shapedType, intptr_t numElements, const int64_t *elements);

 MLIR_CAPI_EXPORTED bool mlirDenseElementsAttrIsSplat(MlirAttribute attr);
 
 /// Returns the single replicated value (splat) of a specific type contained by
 /// the given dense elements attribute.
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrGetSplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED int
 mlirDenseElementsAttrGetBoolSplatValue(MlirAttribute attr);
+MLIR_CAPI_EXPORTED int8_t
+mlirDenseElementsAttrGetInt8SplatValue(MlirAttribute attr);
+MLIR_CAPI_EXPORTED uint8_t
+mlirDenseElementsAttrGetUInt8SplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED int32_t
 mlirDenseElementsAttrGetInt32SplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED uint32_t
 mlirDenseElementsAttrGetUInt32SplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED int64_t
 mlirDenseElementsAttrGetInt64SplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED uint64_t
 mlirDenseElementsAttrGetUInt64SplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED float
 mlirDenseElementsAttrGetFloatSplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED double
 mlirDenseElementsAttrGetDoubleSplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED MlirStringRef
 mlirDenseElementsAttrGetStringSplatValue(MlirAttribute attr);
 
 /// Returns the pos-th value (flat contiguous indexing) of a specific type
 /// contained by the given dense elements attribute.
 MLIR_CAPI_EXPORTED bool mlirDenseElementsAttrGetBoolValue(MlirAttribute attr,
                                                           intptr_t pos);
+MLIR_CAPI_EXPORTED int8_t mlirDenseElementsAttrGetInt8Value(MlirAttribute attr,
+                                                            intptr_t pos);
+MLIR_CAPI_EXPORTED uint8_t
+mlirDenseElementsAttrGetUInt8Value(MlirAttribute attr, intptr_t pos);
 MLIR_CAPI_EXPORTED int32_t
 mlirDenseElementsAttrGetInt32Value(MlirAttribute attr, intptr_t pos);
 MLIR_CAPI_EXPORTED uint32_t
 mlirDenseElementsAttrGetUInt32Value(MlirAttribute attr, intptr_t pos);
 MLIR_CAPI_EXPORTED int64_t
 mlirDenseElementsAttrGetInt64Value(MlirAttribute attr, intptr_t pos);
 MLIR_CAPI_EXPORTED uint64_t
 mlirDenseElementsAttrGetUInt64Value(MlirAttribute attr, intptr_t pos);

mlir/lib/CAPI/IR/BuiltinAttributes.cpp

MlirAttribute mlirDenseElementsAttrSplatGet(MlirType shapedType,
   return wrap(DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
                                      unwrap(element)));
 }
 MlirAttribute mlirDenseElementsAttrBoolSplatGet(MlirType shapedType,
                                                 bool element) {
   return wrap(
       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
 }
+MlirAttribute mlirDenseElementsAttrUInt8SplatGet(MlirType shapedType,
+                                                 uint8_t element) {
+  return wrap(
+      DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
+}
+MlirAttribute mlirDenseElementsAttrInt8SplatGet(MlirType shapedType,
+                                                int8_t element) {
+  return wrap(
+      DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
+}
 MlirAttribute mlirDenseElementsAttrUInt32SplatGet(MlirType shapedType,
                                                   uint32_t element) {
   return wrap(
       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
 }
 MlirAttribute mlirDenseElementsAttrInt32SplatGet(MlirType shapedType,
                                                  int32_t element) {
   return wrap(

 static MlirAttribute getDenseAttribute(MlirType shapedType,
                                        intptr_t numElements,
                                        const T *elements) {
   return wrap(
       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
                              llvm::makeArrayRef(elements, numElements)));
 }
 
+MlirAttribute mlirDenseElementsAttrUInt8Get(MlirType shapedType,
+                                            intptr_t numElements,
+                                            const uint8_t *elements) {
+  return getDenseAttribute(shapedType, numElements, elements);
+}
+MlirAttribute mlirDenseElementsAttrInt8Get(MlirType shapedType,
+                                           intptr_t numElements,
+                                           const int8_t *elements) {
+  return getDenseAttribute(shapedType, numElements, elements);
+}
 MlirAttribute mlirDenseElementsAttrUInt32Get(MlirType shapedType,
                                              intptr_t numElements,
                                              const uint32_t *elements) {
   return getDenseAttribute(shapedType, numElements, elements);
 }
 MlirAttribute mlirDenseElementsAttrInt32Get(MlirType shapedType,
                                             intptr_t numElements,
                                             const int32_t *elements) {

 }
 
 MlirAttribute mlirDenseElementsAttrGetSplatValue(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<DenseElementsAttr>().getSplatValue());
 }
 int mlirDenseElementsAttrGetBoolSplatValue(MlirAttribute attr) {
   return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<bool>();
 }
+int8_t mlirDenseElementsAttrGetInt8SplatValue(MlirAttribute attr) {
+  return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<int8_t>();
+}
+uint8_t mlirDenseElementsAttrGetUInt8SplatValue(MlirAttribute attr) {
+  return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<uint8_t>();
+}
 int32_t mlirDenseElementsAttrGetInt32SplatValue(MlirAttribute attr) {
   return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<int32_t>();
 }
 uint32_t mlirDenseElementsAttrGetUInt32SplatValue(MlirAttribute attr) {
   return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<uint32_t>();
 }
 int64_t mlirDenseElementsAttrGetInt64SplatValue(MlirAttribute attr) {
   return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<int64_t>();

 
 //===----------------------------------------------------------------------===//
 // Indexed accessors.
 
 bool mlirDenseElementsAttrGetBoolValue(MlirAttribute attr, intptr_t pos) {
   return *(unwrap(attr).cast<DenseElementsAttr>().getValues<bool>().begin() +
            pos);
 }
+int8_t mlirDenseElementsAttrGetInt8Value(MlirAttribute attr, intptr_t pos) {
+  return *(unwrap(attr).cast<DenseElementsAttr>().getValues<int8_t>().begin() +
+           pos);
+}
+uint8_t mlirDenseElementsAttrGetUInt8Value(MlirAttribute attr, intptr_t pos) {
+  return *(unwrap(attr).cast<DenseElementsAttr>().getValues<uint8_t>().begin() +
+           pos);
+}
 int32_t mlirDenseElementsAttrGetInt32Value(MlirAttribute attr, intptr_t pos) {
   return *(unwrap(attr).cast<DenseElementsAttr>().getValues<int32_t>().begin() +
            pos);
 }
 uint32_t mlirDenseElementsAttrGetUInt32Value(MlirAttribute attr, intptr_t pos) {
   return *(
       unwrap(attr).cast<DenseElementsAttr>().getValues<uint32_t>().begin() +
       pos);

mlir/test/CAPI/ir.c

int printBuiltinAttributes(MlirContext ctx) {
   if (!mlirAttributeIsAUnit(unit))
     return 13;
   mlirAttributeDump(unit);
   // CHECK: unit
 
   int64_t shape[] = {1, 2};
 
   int bools[] = {0, 1};
+  uint8_t uints8[] = {0u, 1u};
+  int8_t ints8[] = {0, 1};
   uint32_t uints32[] = {0u, 1u};
   int32_t ints32[] = {0, 1};
   uint64_t uints64[] = {0u, 1u};
   int64_t ints64[] = {0, 1};
   float floats[] = {0.0f, 1.0f};
   double doubles[] = {0.0, 1.0};
   MlirAttribute encoding = mlirAttributeGetNull();
   MlirAttribute boolElements = mlirDenseElementsAttrBoolGet(
       mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeGet(ctx, 1), encoding),
       2, bools);
+  MlirAttribute uint8Elements = mlirDenseElementsAttrUInt8Get(
+      mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeUnsignedGet(ctx, 8),
+                              encoding),
+      2, uints8);
+  MlirAttribute int8Elements = mlirDenseElementsAttrInt8Get(
+      mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeGet(ctx, 8), encoding),
+      2, ints8);
   MlirAttribute uint32Elements = mlirDenseElementsAttrUInt32Get(
       mlirRankedTensorTypeGet(2, shape,
                               mlirIntegerTypeUnsignedGet(ctx, 32), encoding),
       2, uints32);
   MlirAttribute int32Elements = mlirDenseElementsAttrInt32Get(
       mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeGet(ctx, 32), encoding),
       2, ints32);
   MlirAttribute uint64Elements = mlirDenseElementsAttrUInt64Get(
       mlirRankedTensorTypeGet(2, shape,
                               mlirIntegerTypeUnsignedGet(ctx, 64), encoding),
       2, uints64);
   MlirAttribute int64Elements = mlirDenseElementsAttrInt64Get(
       mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeGet(ctx, 64), encoding),
       2, ints64);
   MlirAttribute floatElements = mlirDenseElementsAttrFloatGet(
       mlirRankedTensorTypeGet(2, shape, mlirF32TypeGet(ctx), encoding),
       2, floats);
   MlirAttribute doubleElements = mlirDenseElementsAttrDoubleGet(
       mlirRankedTensorTypeGet(2, shape, mlirF64TypeGet(ctx), encoding),
       2, doubles);
 
   if (!mlirAttributeIsADenseElements(boolElements) ||
+      !mlirAttributeIsADenseElements(uint8Elements) ||
+      !mlirAttributeIsADenseElements(int8Elements) ||
       !mlirAttributeIsADenseElements(uint32Elements) ||
       !mlirAttributeIsADenseElements(int32Elements) ||
       !mlirAttributeIsADenseElements(uint64Elements) ||
       !mlirAttributeIsADenseElements(int64Elements) ||
       !mlirAttributeIsADenseElements(floatElements) ||
       !mlirAttributeIsADenseElements(doubleElements))
     return 14;
 
   if (mlirDenseElementsAttrGetBoolValue(boolElements, 1) != 1 ||
+      mlirDenseElementsAttrGetUInt8Value(uint8Elements, 1) != 1 ||
+      mlirDenseElementsAttrGetInt8Value(int8Elements, 1) != 1 ||
       mlirDenseElementsAttrGetUInt32Value(uint32Elements, 1) != 1 ||
       mlirDenseElementsAttrGetInt32Value(int32Elements, 1) != 1 ||
       mlirDenseElementsAttrGetUInt64Value(uint64Elements, 1) != 1 ||
       mlirDenseElementsAttrGetInt64Value(int64Elements, 1) != 1 ||
       fabsf(mlirDenseElementsAttrGetFloatValue(floatElements, 1) - 1.0f) >
           1E-6f ||
       fabs(mlirDenseElementsAttrGetDoubleValue(doubleElements, 1) - 1.0) > 1E-6)
     return 15;
 
   mlirAttributeDump(boolElements);
+  mlirAttributeDump(uint8Elements);
+  mlirAttributeDump(int8Elements);
   mlirAttributeDump(uint32Elements);
   mlirAttributeDump(int32Elements);
   mlirAttributeDump(uint64Elements);
   mlirAttributeDump(int64Elements);
   mlirAttributeDump(floatElements);
   mlirAttributeDump(doubleElements);
   // CHECK: dense<{{\[}}[false, true]]> : tensor<1x2xi1>
+  // CHECK: dense<{{\[}}[0, 1]]> : tensor<1x2xui8>
+  // CHECK: dense<{{\[}}[0, 1]]> : tensor<1x2xi8>
   // CHECK: dense<{{\[}}[0, 1]]> : tensor<1x2xui32>
   // CHECK: dense<{{\[}}[0, 1]]> : tensor<1x2xi32>
   // CHECK: dense<{{\[}}[0, 1]]> : tensor<1x2xui64>
   // CHECK: dense<{{\[}}[0, 1]]> : tensor<1x2xi64>
   // CHECK: dense<{{\[}}[0.000000e+00, 1.000000e+00]]> : tensor<1x2xf32>
   // CHECK: dense<{{\[}}[0.000000e+00, 1.000000e+00]]> : tensor<1x2xf64>
 
   MlirAttribute splatBool = mlirDenseElementsAttrBoolSplatGet(
-      mlirRankedTensorTypeGet(2, shape,
-                              mlirIntegerTypeGet(ctx, 1), encoding), 1);
+      mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeGet(ctx, 1), encoding),
+      1);
+  MlirAttribute splatUInt8 = mlirDenseElementsAttrUInt8SplatGet(
+      mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeUnsignedGet(ctx, 8),
+                              encoding),
+      1);
+  MlirAttribute splatInt8 = mlirDenseElementsAttrInt8SplatGet(
+      mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeGet(ctx, 8), encoding),
+      1);
   MlirAttribute splatUInt32 = mlirDenseElementsAttrUInt32SplatGet(
-      mlirRankedTensorTypeGet(2, shape,
-                              mlirIntegerTypeGet(ctx, 32), encoding), 1);
+      mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeUnsignedGet(ctx, 32),
+                              encoding),
+      1);
   MlirAttribute splatInt32 = mlirDenseElementsAttrInt32SplatGet(
-      mlirRankedTensorTypeGet(2, shape,
-                              mlirIntegerTypeGet(ctx, 32), encoding), 1);
+      mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeGet(ctx, 32), encoding),
+      1);
   MlirAttribute splatUInt64 = mlirDenseElementsAttrUInt64SplatGet(
-      mlirRankedTensorTypeGet(2, shape,
-                              mlirIntegerTypeGet(ctx, 64), encoding), 1);
+      mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeUnsignedGet(ctx, 64),
+                              encoding),
+      1);
   MlirAttribute splatInt64 = mlirDenseElementsAttrInt64SplatGet(
-      mlirRankedTensorTypeGet(2, shape,
-                              mlirIntegerTypeGet(ctx, 64), encoding), 1);
+      mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeGet(ctx, 64), encoding),
+      1);
   MlirAttribute splatFloat = mlirDenseElementsAttrFloatSplatGet(
       mlirRankedTensorTypeGet(2, shape, mlirF32TypeGet(ctx), encoding), 1.0f);
   MlirAttribute splatDouble = mlirDenseElementsAttrDoubleSplatGet(
       mlirRankedTensorTypeGet(2, shape, mlirF64TypeGet(ctx), encoding), 1.0);
 
   if (!mlirAttributeIsADenseElements(splatBool) ||
       !mlirDenseElementsAttrIsSplat(splatBool) ||
+      !mlirAttributeIsADenseElements(splatUInt8) ||
+      !mlirDenseElementsAttrIsSplat(splatUInt8) ||
+      !mlirAttributeIsADenseElements(splatInt8) ||
+      !mlirDenseElementsAttrIsSplat(splatInt8) ||
       !mlirAttributeIsADenseElements(splatUInt32) ||
       !mlirDenseElementsAttrIsSplat(splatUInt32) ||
       !mlirAttributeIsADenseElements(splatInt32) ||
       !mlirDenseElementsAttrIsSplat(splatInt32) ||
       !mlirAttributeIsADenseElements(splatUInt64) ||
       !mlirDenseElementsAttrIsSplat(splatUInt64) ||
       !mlirAttributeIsADenseElements(splatInt64) ||
       !mlirDenseElementsAttrIsSplat(splatInt64) ||
       !mlirAttributeIsADenseElements(splatFloat) ||
       !mlirDenseElementsAttrIsSplat(splatFloat) ||
       !mlirAttributeIsADenseElements(splatDouble) ||
       !mlirDenseElementsAttrIsSplat(splatDouble))
     return 16;
 
   if (mlirDenseElementsAttrGetBoolSplatValue(splatBool) != 1 ||
+      mlirDenseElementsAttrGetUInt8SplatValue(splatUInt8) != 1 ||
+      mlirDenseElementsAttrGetInt8SplatValue(splatInt8) != 1 ||
       mlirDenseElementsAttrGetUInt32SplatValue(splatUInt32) != 1 ||
       mlirDenseElementsAttrGetInt32SplatValue(splatInt32) != 1 ||
       mlirDenseElementsAttrGetUInt64SplatValue(splatUInt64) != 1 ||
       mlirDenseElementsAttrGetInt64SplatValue(splatInt64) != 1 ||
       fabsf(mlirDenseElementsAttrGetFloatSplatValue(splatFloat) - 1.0f) >
           1E-6f ||
       fabs(mlirDenseElementsAttrGetDoubleSplatValue(splatDouble) - 1.0) > 1E-6)
     return 17;
 
+  uint8_t *uint8RawData =
+      (uint8_t *)mlirDenseElementsAttrGetRawData(uint8Elements);
+  int8_t *int8RawData = (int8_t *)mlirDenseElementsAttrGetRawData(int8Elements);
   uint32_t *uint32RawData =
       (uint32_t *)mlirDenseElementsAttrGetRawData(uint32Elements);
   int32_t *int32RawData =
       (int32_t *)mlirDenseElementsAttrGetRawData(int32Elements);
   uint64_t *uint64RawData =
       (uint64_t *)mlirDenseElementsAttrGetRawData(uint64Elements);
   int64_t *int64RawData =
       (int64_t *)mlirDenseElementsAttrGetRawData(int64Elements);
   float *floatRawData = (float *)mlirDenseElementsAttrGetRawData(floatElements);
   double *doubleRawData =
       (double *)mlirDenseElementsAttrGetRawData(doubleElements);
-  if (uint32RawData[0] != 0u || uint32RawData[1] != 1u ||
+  if (uint8RawData[0] != 0u || uint8RawData[1] != 1u || int8RawData[0] != 0 ||
+      int8RawData[1] != 1 || uint32RawData[0] != 0u || uint32RawData[1] != 1u ||
       int32RawData[0] != 0 || int32RawData[1] != 1 || uint64RawData[0] != 0u ||
       uint64RawData[1] != 1u || int64RawData[0] != 0 || int64RawData[1] != 1 ||
       floatRawData[0] != 0.0f || floatRawData[1] != 1.0f ||
       doubleRawData[0] != 0.0 || doubleRawData[1] != 1.0)
     return 18;
 
   mlirAttributeDump(splatBool);
+  mlirAttributeDump(splatUInt8);
+  mlirAttributeDump(splatInt8);
   mlirAttributeDump(splatUInt32);
   mlirAttributeDump(splatInt32);
   mlirAttributeDump(splatUInt64);
   mlirAttributeDump(splatInt64);
   mlirAttributeDump(splatFloat);
   mlirAttributeDump(splatDouble);
   // CHECK: dense<true> : tensor<1x2xi1>
+  // CHECK: dense<1> : tensor<1x2xui8>
+  // CHECK: dense<1> : tensor<1x2xi8>
+  // CHECK: dense<1> : tensor<1x2xui32>
   // CHECK: dense<1> : tensor<1x2xi32>
-  // CHECK: dense<1> : tensor<1x2xi32>
-  // CHECK: dense<1> : tensor<1x2xi64>
+  // CHECK: dense<1> : tensor<1x2xui64>
   // CHECK: dense<1> : tensor<1x2xi64>
   // 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