[mlir] Make it possible to build a DenseResourceElementsAttr from untyped memory.

[stellaraccident]

Summary

Exposes the existing get(ShapedType, StringRef, AsmResourceBlob) builder publicly (was protected) and adds a CAPI mlirUnmanagedDenseBlobResourceElementsAttrGet.

While such a generic construction interface is a big help when it comes to interop, it is also necessary for creating resources that don't have a standard C type (i.e. f16, the f8s, etc).

[jpienaar]

LGTM, I dont think we have a name else for it and being able to have an opaque instance for those non-standard types (although for those one could consider the typed one the storage class instance, but fine the accessors become less useful for these cases).

mlir/include/mlir-c/BuiltinAttributes.h

MLIR_CAPI_EXPORTED MlirAttribute mlirUnmanagedDenseFloatResourceElementsAttrGet(
     MlirType shapedType, MlirStringRef name, intptr_t numElements,
     const float *elements);
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirUnmanagedDenseDoubleResourceElementsAttrGet(MlirType shapedType,
                                                 MlirStringRef name,
                                                 intptr_t numElements,
                                                 const double *elements);
 
+/// Unlike the typed accessors above, constructs the attribute with a raw
+/// data buffer and no type/alignment checking. Use a more strongly typed
+/// accessor if possible.
+MLIR_CAPI_EXPORTED MlirAttribute mlirUnmanagedDenseBlobResourceElementsAttrGet(
+    MlirType shapedType, MlirStringRef name, const void *data,
+    size_t dataLength);
+
 /// Returns the pos-th value (flat contiguous indexing) of a specific type
 /// contained by the given dense resource elements attribute.
 MLIR_CAPI_EXPORTED bool
 mlirDenseBoolResourceElementsAttrGetValue(MlirAttribute attr, intptr_t pos);
 MLIR_CAPI_EXPORTED int8_t
 mlirDenseInt8ResourceElementsAttrGetValue(MlirAttribute attr, intptr_t pos);
 MLIR_CAPI_EXPORTED uint8_t
 mlirDenseUInt8ResourceElementsAttrGetValue(MlirAttribute attr, intptr_t pos);

mlir/include/mlir/IR/BuiltinAttributes.td

def Builtin_DenseResourceElementsAttr : Builtin_Attr<"DenseResourceElements", [
   }];
   let parameters = (ins
     AttributeSelfTypeParameter<"", "ShapedType">:$type,
     ResourceHandleParameter<"DenseResourceElementsHandle">:$rawHandle
   );
   let builders = [
     AttrBuilderWithInferredContext<(ins
       "ShapedType":$type, "DenseResourceElementsHandle":$handle
-    )>
-  ];
-  let extraClassDeclaration = [{
-  protected:
+    )>,
     /// A builder that inserts a new resource into the builtin dialect's blob
     /// manager using the provided blob. The handle of the inserted blob is used
     /// when building the attribute. The provided `blobName` is used as a hint
     /// for the key of the new handle for the `blob` resource, but may be
     /// changed if necessary to ensure uniqueness during insertion.
-    static DenseResourceElementsAttr get(
-      ShapedType type, StringRef blobName, AsmResourceBlob blob
-    );
+    /// This base class builder does no element type specific size or alignment 
+    /// checking. Use the typed subclasses for more safety unless if performing
+    /// generic operations.
+    AttrBuilderWithInferredContext<(ins
+      "ShapedType":$type, "StringRef":$blobName, "AsmResourceBlob":$blob
+    )>
+  ];
 
-  public:
-  }];
   let skipDefaultBuilders = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // DictionaryAttr
 //===----------------------------------------------------------------------===//
 
 def Builtin_DictionaryAttr : Builtin_Attr<"Dictionary"> {

mlir/lib/CAPI/IR/BuiltinAttributes.cpp

 MLIR_CAPI_EXPORTED MlirAttribute
 mlirUnmanagedDenseDoubleResourceElementsAttrGet(MlirType shapedType,
                                                 MlirStringRef name,
                                                 intptr_t numElements,
                                                 const double *elements) {
   return getDenseResource<DenseF64ResourceElementsAttr>(shapedType, name,
                                                         numElements, elements);
 }
+MLIR_CAPI_EXPORTED MlirAttribute mlirUnmanagedDenseBlobResourceElementsAttrGet(
+    MlirType shapedType, MlirStringRef name, const void *data,
+    size_t dataLength) {
+  return wrap(DenseResourceElementsAttr::get(
+      llvm::cast<ShapedType>(unwrap(shapedType)), unwrap(name),
+      UnmanagedAsmResourceBlob::allocateInferAlign(
+          llvm::ArrayRef(static_cast<const char *>(data), dataLength))));
+}
 
 template <typename U, typename T>
 static T getDenseResourceVal(MlirAttribute attr, intptr_t pos) {
   return (*llvm::cast<U>(unwrap(attr)).tryGetAsArrayRef())[pos];
 }
 
 MLIR_CAPI_EXPORTED bool
 mlirDenseBoolResourceElementsAttrGetValue(MlirAttribute attr, intptr_t pos) {

mlir/test/CAPI/ir.c

if (mlirDenseElementsAttrGetBoolSplatValue(splatBool) != 1 ||
       mlirDenseElementsAttrGetInt64SplatValue(splatInt64) != 1 ||
       fabsf(mlirDenseElementsAttrGetFloatSplatValue(splatFloat) - 1.0f) >
           1E-6f ||
       fabs(mlirDenseElementsAttrGetDoubleSplatValue(splatDouble) - 1.0) > 1E-6)
     return 17;
 
   const uint8_t *uint8RawData =
       (const uint8_t *)mlirDenseElementsAttrGetRawData(uint8Elements);
-  const int8_t *int8RawData = (const int8_t *)mlirDenseElementsAttrGetRawData(int8Elements);
+  const int8_t *int8RawData =
+      (const int8_t *)mlirDenseElementsAttrGetRawData(int8Elements);
   const uint32_t *uint32RawData =
       (const uint32_t *)mlirDenseElementsAttrGetRawData(uint32Elements);
   const int32_t *int32RawData =
       (const int32_t *)mlirDenseElementsAttrGetRawData(int32Elements);
   const uint64_t *uint64RawData =
       (const uint64_t *)mlirDenseElementsAttrGetRawData(uint64Elements);
   const int64_t *int64RawData =
       (const int64_t *)mlirDenseElementsAttrGetRawData(int64Elements);
-  const float *floatRawData = (const float *)mlirDenseElementsAttrGetRawData(floatElements);
+  const float *floatRawData =
+      (const float *)mlirDenseElementsAttrGetRawData(floatElements);
   const double *doubleRawData =
       (const double *)mlirDenseElementsAttrGetRawData(doubleElements);
   const uint16_t *bf16RawData =
       (const uint16_t *)mlirDenseElementsAttrGetRawData(bf16Elements);
   const uint16_t *f16RawData =
       (const uint16_t *)mlirDenseElementsAttrGetRawData(f16Elements);
   if (uint8RawData[0] != 0u || uint8RawData[1] != 1u || int8RawData[0] != 0 ||
       int8RawData[1] != 1 || uint32RawData[0] != 0u || uint32RawData[1] != 1u ||
MlirAttribute int64Blob = mlirUnmanagedDenseInt64ResourceElementsAttrGet(
       mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeGet(ctx, 64), encoding),
       mlirStringRefCreateFromCString("resource_i64"), 2, ints64);
   MlirAttribute floatsBlob = mlirUnmanagedDenseFloatResourceElementsAttrGet(
       mlirRankedTensorTypeGet(2, shape, mlirF32TypeGet(ctx), encoding),
       mlirStringRefCreateFromCString("resource_f32"), 2, floats);
   MlirAttribute doublesBlob = mlirUnmanagedDenseDoubleResourceElementsAttrGet(
       mlirRankedTensorTypeGet(2, shape, mlirF64TypeGet(ctx), encoding),
       mlirStringRefCreateFromCString("resource_f64"), 2, doubles);
+  MlirAttribute blobBlob = mlirUnmanagedDenseBlobResourceElementsAttrGet(
+      mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeGet(ctx, 64), encoding),
+      mlirStringRefCreateFromCString("resource_i64_blob"), uints64,
+      sizeof(uints64));
 
   mlirAttributeDump(uint8Blob);
   mlirAttributeDump(uint16Blob);
   mlirAttributeDump(uint32Blob);
   mlirAttributeDump(uint64Blob);
   mlirAttributeDump(int8Blob);
   mlirAttributeDump(int16Blob);
   mlirAttributeDump(int32Blob);
   mlirAttributeDump(int64Blob);
   mlirAttributeDump(floatsBlob);
   mlirAttributeDump(doublesBlob);
+  mlirAttributeDump(blobBlob);
   // CHECK: dense_resource<resource_ui8> : tensor<1x2xui8>
   // CHECK: dense_resource<resource_ui16> : tensor<1x2xui16>
   // CHECK: dense_resource<resource_ui32> : tensor<1x2xui32>
   // CHECK: dense_resource<resource_ui64> : tensor<1x2xui64>
   // CHECK: dense_resource<resource_i8> : tensor<1x2xi8>
   // CHECK: dense_resource<resource_i16> : tensor<1x2xi16>
   // CHECK: dense_resource<resource_i32> : tensor<1x2xi32>
   // CHECK: dense_resource<resource_i64> : tensor<1x2xi64>
   // CHECK: dense_resource<resource_f32> : tensor<1x2xf32>
   // CHECK: dense_resource<resource_f64> : tensor<1x2xf64>
+  // CHECK: dense_resource<resource_i64_blob> : tensor<1x2xi64>
 
   if (mlirDenseUInt8ResourceElementsAttrGetValue(uint8Blob, 1) != 1 ||
       mlirDenseUInt16ResourceElementsAttrGetValue(uint16Blob, 1) != 1 ||
       mlirDenseUInt32ResourceElementsAttrGetValue(uint32Blob, 1) != 1 ||
       mlirDenseUInt64ResourceElementsAttrGetValue(uint64Blob, 1) != 1 ||
       mlirDenseInt8ResourceElementsAttrGetValue(int8Blob, 1) != 1 ||
       mlirDenseInt16ResourceElementsAttrGetValue(int16Blob, 1) != 1 ||
       mlirDenseInt32ResourceElementsAttrGetValue(int32Blob, 1) != 1 ||
       mlirDenseInt64ResourceElementsAttrGetValue(int64Blob, 1) != 1 ||
       fabsf(mlirDenseF32ArrayGetElement(floatArray, 1) - 1.0f) > 1E-6f ||
       fabsf(mlirDenseFloatResourceElementsAttrGetValue(floatsBlob, 1) - 1.0f) >
           1e-6 ||
       fabs(mlirDenseDoubleResourceElementsAttrGetValue(doublesBlob, 1) - 1.0f) >
-          1e-6)
+          1e-6 ||
+      mlirDenseUInt64ResourceElementsAttrGetValue(blobBlob, 1) != 1)
     return 23;
 
   MlirLocation loc = mlirLocationUnknownGet(ctx);
   MlirAttribute locAttr = mlirLocationGetAttribute(loc);
   if (!mlirAttributeIsALocation(locAttr))
     return 24;
 
   return 0;