[mlir] expose standard attributes to C API

[ftynse]

Summary

Provide C API for MLIR standard attributes. Since standard attributes live
under lib/IR in core MLIR, place the C APIs in the IR library as well (standard
ops will go in a separate library).

Affine map and integer set attributes are only exposed as placeholder types
with IsA support due to the lack of C APIs for the corresponding types.

Integer and floating point attribute APIs expecting APInt and APFloat are not
exposed pending decision on how to support APInt and APFloat.

[ftynse]

cmake

[stellaraccident]

I could go either way on my comment about style for returning uniqued, backing string data. Feel free to submit as-is and possibly resolve forward if there is a further discussion to be had.

mlir/include/mlir-c/StandardAttributes.h

182

Do we want to make any claims about the lifetime of the pointer passed to the callback? In practice, it is bounded by the containing context.

For these "always return a single chunk" cases that are more about bridging string representations, I do wonder if we should be directly giving access to the backing buffer as in:

// Populates the data buffer and returns its length.
intptr_t mlirStringAttrGetValue(MlirAttribute attr, const char **data);

Practically, with the callback, we aren't restricting that access anyway so maybe go after it more directly?

[ftynse]

mlir/include/mlir-c/StandardAttributes.h

182

I was considering to expose StringRef as struct { const char *, intptr_t }, but StringRef is an LLVM type. This hooks into the other TODOs I left here about APInt and APFloat. These all are LLVM types and we need to decide whether we want to expose them in LLVM C API and make MLIR-C depend on LLVM-C (also check with LLVM folks if they are okay with that), or expose them in MLIR-C as LLVMSupport.h. So I went with the thing we had already pending further discussion. I'll add TODOs here as well and clarify the lifetime.

[ftynse]

Add TODOs regarding StringRef modeling

[ftynse]

rebase

mlir/docs/CAPI.md

-   A type `Y` that derives from `X` provides a function `int mlirXIsAY(MlirX)`
     that returns a non-zero value if the given dynamic instance of `X` is also
     an instance of `Y`. For example, `int MlirTypeIsAInteger(MlirType)`.
 -   A function that expects a derived type as its first argument takes the base
     type instead and documents the expectation by using `Y` in its name
     `MlirY<...>(MlirX, ...)`. This function asserts that the dynamic instance of
     its first argument is `Y`, and it is the responsibility of the caller to
     ensure it is indeed the case.
 
+### Returning String References
+
+Numerous MLIR functions return instances of `StringRef` to refer to a non-owning
+segment of a string. This segment may or may not be null-terminated. In C API,
+these functions take an additional callback argument of type
+`MlirStringCallback` (pointer to a function with signature `void (*)(const char
+*, intptr_t, void *)`) and a pointer to user-defined data. This callback is
+invoked with a pointer to the string segment, its size and is forwarded the
+user-defined data. The caller is in charge of managing the string segment
+according to its memory model: for strings owned by the object (e.g., string
+attributes), the caller can store the pointer and the size and use them directly
+as long as the parent object is live or copy the string to a new location with a
+null terminator if expected; for generated strings (e.g., in printing), the
+caller is expected to copy the string segment if it intends to use it later.
+
+**Note:** this interface may be revised in the near future.
+
 ### Conversion To String and Printing
 
 IR objects can be converted to a string representation, for example for
-printing, using `mlirXPrint(MlirX, MlirPrintCallback, void *)` functions. These
+printing, using `mlirXPrint(MlirX, MlirStringCallback, void *)` functions. These
 functions accept take arguments a callback with signature `void (*)(const char
 *, intptr_t, void *)` and a pointer to user-defined data. They call the callback
 and supply it with chunks of the string representation, provided as a pointer to
 the first character and a length, and forward the user-defined data unmodified.
 It is up to the caller to allocate memory if the string representation must be
 stored and perform the copy. There is no guarantee that the pointer supplied to
 the callback points to a null-terminated string, the size argument should be
 used to find the end of the string. The callback may be called multiple times

mlir/include/mlir-c/IR.h

  * a string.
  */
 struct MlirNamedAttribute {
   const char *name;
   MlirAttribute attribute;
 };
 typedef struct MlirNamedAttribute MlirNamedAttribute;
 
-/** A callback for printing to IR objects.
+/** A callback for returning string referenes.
  *
- * This function is called back by the printing functions with the following
- * arguments:
+ * This function is called back by the functions that need to return a reference
+ * to the portion of the string with the following arguments:
  *   - a pointer to the beginning of a string;
  *   - the length of the string (the pointer may point to a larger buffer, not
  *     necessarily null-terminated);
  *   - a pointer to user data forwarded from the printing call.
  */
-typedef void (*MlirPrintCallback)(const char *, intptr_t, void *);
+typedef void (*MlirStringCallback)(const char *, intptr_t, void *);
 
 /*============================================================================*/
 /* Context API.                                                               */
 /*============================================================================*/
 
 /** Creates an MLIR context and transfers its ownership to the caller. */
 MlirContext mlirContextCreate();
 
MlirLocation mlirLocationFileLineColGet(MlirContext context,
                                         unsigned col);
 
 /** Creates a location with unknown position owned by the given context. */
 MlirLocation mlirLocationUnknownGet(MlirContext context);
 
 /** Prints a location by sending chunks of the string representation and
  * forwarding `userData to `callback`. Note that the callback may be called
  * several times with consecutive chunks of the string. */
-void mlirLocationPrint(MlirLocation location, MlirPrintCallback callback,
+void mlirLocationPrint(MlirLocation location, MlirStringCallback callback,
                        void *userData);
 
 /*============================================================================*/
 /* Module API.                                                                */
 /*============================================================================*/
 
 /** Creates a new, empty module and transfers ownership to the caller. */
 MlirModule mlirModuleCreateEmpty(MlirLocation location);

 
 /** Returns an attrbute attached to the operation given its name. */
 MlirAttribute mlirOperationGetAttributeByName(MlirOperation op,
                                               const char *name);
 
 /** Prints an operation by sending chunks of the string representation and
  * forwarding `userData to `callback`. Note that the callback may be called
  * several times with consecutive chunks of the string. */
-void mlirOperationPrint(MlirOperation op, MlirPrintCallback callback,
+void mlirOperationPrint(MlirOperation op, MlirStringCallback callback,
                         void *userData);
 
 /** Prints an operation to stderr. */
 void mlirOperationDump(MlirOperation op);
 
 /*============================================================================*/
 /* Region API.                                                                */
 /*============================================================================*/

 intptr_t mlirBlockGetNumArguments(MlirBlock block);
 
 /** Returns `pos`-th argument of the block. */
 MlirValue mlirBlockGetArgument(MlirBlock block, intptr_t pos);
 
 /** Prints a block by sending chunks of the string representation and
  * forwarding `userData to `callback`. Note that the callback may be called
  * several times with consecutive chunks of the string. */
-void mlirBlockPrint(MlirBlock block, MlirPrintCallback callback,
+void mlirBlockPrint(MlirBlock block, MlirStringCallback callback,
                     void *userData);
 
 /*============================================================================*/
 /* Value API.                                                                 */
 /*============================================================================*/
 
 /** Returns the type of the value. */
 MlirType mlirValueGetType(MlirValue value);
 
 /** Prints a value by sending chunks of the string representation and
  * forwarding `userData to `callback`. Note that the callback may be called
  * several times with consecutive chunks of the string. */
-void mlirValuePrint(MlirValue value, MlirPrintCallback callback,
+void mlirValuePrint(MlirValue value, MlirStringCallback callback,
                     void *userData);
 
 /*============================================================================*/
 /* Type API.                                                                  */
 /*============================================================================*/
 
 /** Parses a type. The type is owned by the context. */
 MlirType mlirTypeParseGet(MlirContext context, const char *type);
 
 /** Checks whether a type is null. */
 inline int mlirTypeIsNull(MlirType type) { return !type.ptr; }
 
 /** Checks if two types are equal. */
 int mlirTypeEqual(MlirType t1, MlirType t2);
 
 /** Prints a location by sending chunks of the string representation and
  * forwarding `userData to `callback`. Note that the callback may be called
  * several times with consecutive chunks of the string. */
-void mlirTypePrint(MlirType type, MlirPrintCallback callback, void *userData);
+void mlirTypePrint(MlirType type, MlirStringCallback callback, void *userData);
 
 /** Prints the type to the standard error stream. */
 void mlirTypeDump(MlirType type);
 
 /*============================================================================*/
 /* Attribute API.                                                             */
 /*============================================================================*/
 
 /** Parses an attribute. The attribute is owned by the context. */
 MlirAttribute mlirAttributeParseGet(MlirContext context, const char *attr);
 
+/** Checks if two attributes are equal. */
+int mlirAttributeEqual(MlirAttribute a1, MlirAttribute a2);
+
 /** Prints an attribute by sending chunks of the string representation and
  * forwarding `userData to `callback`. Note that the callback may be called
  * several times with consecutive chunks of the string. */
-void mlirAttributePrint(MlirAttribute attr, MlirPrintCallback callback,
+void mlirAttributePrint(MlirAttribute attr, MlirStringCallback callback,
                         void *userData);
 
 /** Prints the attrbute to the standard error stream. */
 void mlirAttributeDump(MlirAttribute attr);
 
 /** Associates an attribute with the name. Takes ownership of neither. */
 MlirNamedAttribute mlirNamedAttributeGet(const char *name, MlirAttribute attr);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_IR_H

mlir/include/mlir-c/StandardAttributes.h

+/*===-- mlir-c/StandardAttributes.h - C API for Std Attributes-----*- C -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This header declares the C interface to MLIR Standard attributes.          *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef MLIR_C_STANDARDATTRIBUTES_H
+#define MLIR_C_STANDARDATTRIBUTES_H
+
+#include "mlir-c/AffineMap.h"
+#include "mlir-c/IR.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*============================================================================*/
+/* Affine map attribute.                                                      */
+/*============================================================================*/
+
+/** Checks whether the given attribute is an affine map attribute. */
+int mlirAttributeIsAAffineMap(MlirAttribute attr);
+
+/** Creates an affine map attribute wrapping the given map. The attribute
+ * belongs to the same context as the affine map. */
+MlirAttribute mlirAffineMapAttrGet(MlirAffineMap map);
+
+/** Returns the affine map wrapped in the given affine map attribute. */
+MlirAffineMap mlirAffineMapAttrGetValue(MlirAttribute attr);
+
+/*============================================================================*/
+/* Array attribute.                                                           */
+/*============================================================================*/
+
+/** Checks whether the given attribute is an array attribute. */
+int mlirAttributeIsAArray(MlirAttribute attr);
+
+/** Creates an array element containing the given list of elements in the given
+ * context. */
+MlirAttribute mlirArrayAttrGet(MlirContext ctx, intptr_t numElements,
+                               MlirAttribute *elements);
+
+/** Returns the number of elements stored in the given array attribute. */
+intptr_t mlirArrayAttrGetNumElements(MlirAttribute attr);
+
+/** Returns pos-th element stored in the given array attribute. */
+MlirAttribute mlirArrayAttrGetElement(MlirAttribute attr, intptr_t pos);
+
+/*============================================================================*/
+/* Dictionary attribute.                                                      */
+/*============================================================================*/
+
+/** Checks whether the given attribute is a dictionary attribute. */
+int mlirAttributeIsADictionary(MlirAttribute attr);
+
+/** Creates a dictionary attribute containing the given list of elements in the
+ * provided context. */
+MlirAttribute mlirDictionaryAttrGet(MlirContext ctx, intptr_t numElements,
+                                    MlirNamedAttribute *elements);
+
+/** Returns the number of attributes contained in a dictionary attribute. */
+intptr_t mlirDictionaryAttrGetNumElements(MlirAttribute attr);
+
+/** Returns pos-th element of the given dictionary attribute. */
+MlirNamedAttribute mlirDictionaryAttrGetElement(MlirAttribute attr,
+                                                intptr_t pos);
+
+/** Returns the dictionary attribute element with the given name or NULL if the
+ * given name does not exist in the dictionary. */
+MlirAttribute mlirDictionaryAttrGetElementByName(MlirAttribute attr,
+                                                 const char *name);
+
+/*============================================================================*/
+/* Floating point attribute.                                                  */
+/*============================================================================*/
+
+/* TODO: add support for APFloat and APInt to LLVM IR C API, then expose the
+ * relevant functions here. */
+
+/** Checks whether the given attribute is a floating point attribute. */
+int mlirAttributeIsAFloat(MlirAttribute attr);
+
+/** Creates a floating point attribute in the given context with the given
+ * double value and double-precision FP semantics. */
+MlirAttribute mlirFloatAttrDoubleGet(MlirContext ctx, MlirType type,
+                                     double value);
+
+/** Returns the value stored in the given floating point attribute, interpreting
+ * the value as double. */
+double mlirFloatAttrGetValueDouble(MlirAttribute attr);
+
+/*============================================================================*/
+/* Integer attribute.                                                         */
+/*============================================================================*/
+
+/* TODO: add support for APFloat and APInt to LLVM IR C API, then expose the
+ * relevant functions here. */
+
+/** Checks whether the given attribute is an integer attribute. */
+int mlirAttributeIsAInteger(MlirAttribute attr);
+
+/** Creates an integer attribute of the given type with the given integer
+ * value. */
+MlirAttribute mlirIntegerAttrGet(MlirType type, int64_t value);
+
+/** Returns the value stored in the given integer attribute, assuming the value
+ * fits into a 64-bit integer. */
+int64_t mlirIntegerAttrGetValueInt(MlirAttribute attr);
+
+/*============================================================================*/
+/* Bool attribute.                                                            */
+/*============================================================================*/
+
+/** Checks whether the given attribute is a bool attribute. */
+int mlirAttributeIsABool(MlirAttribute attr);
+
+/** Creates a bool attribute in the given context with the given value. */
+MlirAttribute mlirBoolAttrGet(MlirContext ctx, int value);
+
+/** Returns the value stored in the given bool attribute. */
+int mlirBoolAttrGetValue(MlirAttribute attr);
+
+/*============================================================================*/
+/* Integer set attribute.                                                     */
+/*============================================================================*/
+
+/** Checks whether the given attribute is an integer set attribute. */
+int mlirAttributeIsAIntegerSet(MlirAttribute attr);
+
+/*============================================================================*/
+/* Opaque attribute.                                                          */
+/*============================================================================*/
+
+/** Checks whether the given attribute is an opaque attribute. */
+int mlirAttributeIsAOpaque(MlirAttribute attr);
+
+/** Creates an opaque attribute in the given context associated with the dialect
+ * identified by its namespace. The attribute contains opaque byte data of the
+ * specified length (data need not be null-terminated). */
+MlirAttribute mlirOpaqueAttrGet(MlirContext ctx, const char *dialectNamespace,
+                                intptr_t dataLength, const char *data,
+                                MlirType type);
+
+/** Returns the namepsace of the dialect with which the given opaque attribute
+ * is associated. The namespace string is owned by the context. */
+const char *mlirOpaqueAttrGetDialectNamespace(MlirAttribute attr);
+
+/** Calls the provided callback with the opaque byte data stored in the given
+ * opaque attribute. The callback is invoked once, and the data it receives is
+ * not necessarily null terminated. The data remains live as long as the context
+ * in which the attribute lives. */
+/* TODO: consider exposing StringRef and using it instead of the callback. */
+void mlirOpaqueAttrGetData(MlirAttribute attr, MlirStringCallback callback,
+                           void *userData);
+
+/*============================================================================*/
+/* String attribute.                                                          */
+/*============================================================================*/
+
+/** Checks whether the given attribute is a string attribute. */
+int mlirAttributeIsAString(MlirAttribute attr);
+
+/** Creates a string attribute in the given context containing the given string.
+ * The string need not be null-terminated and its length must be specified. */
+MlirAttribute mlirStringAttrGet(MlirContext ctx, intptr_t length,
+                                const char *data);
+
+/** Creates a string attribute in the given context containing the given string.
+ * The string need not be null-terminated and its length must be specified.
+ * Additionally, the attribute has the given type. */
+MlirAttribute mlirStringAttrTypedGet(MlirType type, intptr_t length,
+                                     const char *data);
+
+/** Calls the provided callback with the string stored in the given string
+ * attribute. The callback is invoked once, and the data it receives is not
+ * necessarily null terminated. The data remains live as long as the context in
+ * which the attribute lives. */
+/* TODO: consider exposing StringRef and using it instead of the callback. */
+void mlirStringAttrGetValue(MlirAttribute attr, MlirStringCallback callback,
+                            void *userData);
+
+/*============================================================================*/
+/* SymbolRef attribute.                                                       */
+/*============================================================================*/
+
+/** Checks whether the given attribute is a symbol reference attribute. */
+int mlirAttributeIsASymbolRef(MlirAttribute attr);
+
+/** Creates a symbol reference attribute in the given context referencing a
+ * symbol identified by the given string inside a list of nested references.
+ * Each of the references in the list must not be nested. The string need not be
+ * null-terminated and its length must be specified. */
+MlirAttribute mlirSymbolRefAttrGet(MlirContext ctx, intptr_t length,
+                                   const char *symbol, intptr_t numReferences,
+                                   MlirAttribute *references);
+
+/** Calls the provided callback with the string containing the root referenced
+ * symbol. The callback is invoked once, and the data it receives is not
+ * necessarily null terminated. The data remains live as long as the context in
+ * which the attribute lives. */
+/* TODO: consider exposing StringRef and using it instead of the callback. */
+void mlirSymbolRefAttrGetRootReference(MlirAttribute attr,
+                                       MlirStringCallback callback,
+                                       void *userData);
+
+/** Calls the provided callback with the string containing the leaf referenced
+ * symbol. The callback is invoked once, and the data it receives is not
+ * necessarily null terminated. The data remains live as long as the context in
+ * which the attribute lives. */
+/* TODO: consider exposing StringRef and using it instead of the callback. */
+void mlirSymbolRefAttrGetLeafReference(MlirAttribute attr,
+                                       MlirStringCallback callback,
+                                       void *userData);
+
+/** Returns the number of references nested in the given symbol reference
+ * attribute. */
+intptr_t mlirSymbolRefAttrGetNumNestedReferences(MlirAttribute attr);
+
+/** Returns pos-th reference nested in the given symbol reference attribute. */
+MlirAttribute mlirSymbolRefAttrGetNestedReference(MlirAttribute attr,
+                                                  intptr_t pos);
+
+/*============================================================================*/
+/* Flat SymbolRef attribute.                                                  */
+/*============================================================================*/
+
+/** Checks whether the given attribute is a flat symbol reference attribute. */
+int mlirAttributeIsAFlatSymbolRef(MlirAttribute attr);
+
+/** Creates a flat symbol reference attribute in the given context referencing a
+ * symbol identified by the given string. The string need not be null-terminated
+ * and its length must be specified. */
+MlirAttribute mlirFlatSymbolRefAttrGet(MlirContext ctx, intptr_t length,
+                                       const char *symbol);
+
+/** Calls the provided callback with the string containing the referenced
+ * symbol. The callback is invoked once, and the data it receives is not
+ * necessarily null terminated. The data remains live as long as the context in
+ * which the attribute lives. */
+/* TODO: consider exposing StringRef and using it instead of the callback. */
+void mlirFloatSymbolRefAttrGetValue(MlirAttribute attr,
+                                    MlirStringCallback callback,
+                                    void *userData);
+
+/*============================================================================*/
+/* Type attribute.                                                            */
+/*============================================================================*/
+
+/** Checks whether the given attribute is a type attribute. */
+int mlirAttributeIsAType(MlirAttribute attr);
+
+/** Creates a type attribute wrapping the given type in the same context as the
+ * type. */
+MlirAttribute mlirTypeAttrGet(MlirType type);
+
+/** Returns the type stored in the given type attribute. */
+MlirType mlirTypeAttrGetValue(MlirAttribute attr);
+
+/*============================================================================*/
+/* Unit attribute.                                                            */
+/*============================================================================*/
+
+/** Checks whether the given attribute is a unit attribute. */
+int mlirAttributeIsAUnit(MlirAttribute attr);
+
+/** Creates a unit attribute in the given context. */
+MlirAttribute mlirUnitAttrGet(MlirContext ctx);
+
+/*============================================================================*/
+/* Elements attributes.                                                       */
+/*============================================================================*/
+
+/** Checks whether the given attribute is an elements attribute. */
+int mlirAttributeIsAElements(MlirAttribute attr);
+
+/** Returns the element at the given rank-dimensional index. */
+MlirAttribute mlirElementsAttrGetValue(MlirAttribute attr, intptr_t rank,
+                                       uint64_t *idxs);
+
+/** Checks whether the given rank-dimensional index is valid in the given
+ * elements attribute. */
+int mlirElementsAttrIsValidIndex(MlirAttribute attr, intptr_t rank,
+                                 uint64_t *idxs);
+
+/** Gets the total number of elements in the given elements attribute. In order
+ * to iterate over the attribute, obtain its type, which must be a statically
+ * shaped type and use its sizes to build a multi-dimensional index. */
+int64_t mlirElementsAttrGetNumElements(MlirAttribute attr);
+
+/*============================================================================*/
+/* Dense elements attribute.                                                  */
+/*============================================================================*/
+
+/* TODO: decide on the interface and add support for complex elements. */
+/* TODO: add support for APFloat and APInt to LLVM IR C API, then expose the
+ * relevant functions here. */
+
+/** Checks whether the given attribute is a dense elements attribute. */
+int mlirAttributeIsADenseElements(MlirAttribute attr);
+int mlirAttributeIsADenseIntElements(MlirAttribute attr);
+int mlirAttributeIsADenseFPElements(MlirAttribute attr);
+
+/** Creates a dense elements attribute with the given Shaped type and elements
+ * in the same context as the type. */
+MlirAttribute mlirDenseElementsAttrGet(MlirType shapedType,
+                                       intptr_t numElements,
+                                       MlirAttribute *elements);
+
+/** Creates a dense elements attribute with the given Shaped type containing a
+ * single replicated element (splat). */
+MlirAttribute mlirDenseElementsAttrSplatGet(MlirType shapedType,
+                                            MlirAttribute element);
+MlirAttribute mlirDenseElementsAttrBoolSplatGet(MlirType shapedType,
+                                                int element);
+MlirAttribute mlirDenseElementsAttrUInt32SplatGet(MlirType shapedType,
+                                                  uint32_t element);
+MlirAttribute mlirDenseElementsAttrInt32SplatGet(MlirType shapedType,
+                                                 int32_t element);
+MlirAttribute mlirDenseElementsAttrUInt64SplatGet(MlirType shapedType,
+                                                  uint64_t element);
+MlirAttribute mlirDenseElementsAttrInt64SplatGet(MlirType shapedType,
+                                                 int64_t element);
+MlirAttribute mlirDenseElementsAttrFloatSplatGet(MlirType shapedType,
+                                                 float element);
+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. */
+MlirAttribute mlirDenseElementsAttrBoolGet(MlirType shapedType,
+                                           intptr_t numElements, int *elements);
+MlirAttribute mlirDenseElementsAttrUInt32Get(MlirType shapedType,
+                                             intptr_t numElements,
+                                             uint32_t *elements);
+MlirAttribute mlirDenseElementsAttrInt32Get(MlirType shapedType,
+                                            intptr_t numElements,
+                                            int32_t *elements);
+MlirAttribute mlirDenseElementsAttrUInt64Get(MlirType shapedType,
+                                             intptr_t numElements,
+                                             uint64_t *elements);
+MlirAttribute mlirDenseElementsAttrInt64Get(MlirType shapedType,
+                                            intptr_t numElements,
+                                            int64_t *elements);
+MlirAttribute mlirDenseElementsAttrFloatGet(MlirType shapedType,
+                                            intptr_t numElements,
+                                            float *elements);
+MlirAttribute mlirDenseElementsAttrDoubleGet(MlirType shapedType,
+                                             intptr_t numElements,
+                                             double *elements);
+
+/** Creates a dense elements attribute with the given shaped type from string
+ * elements. The strings need not be null-terminated and their lengths are
+ * provided as a separate argument co-indexed with the strs argument. */
+MlirAttribute mlirDenseElementsAttrStringGet(MlirType shapedType,
+                                             intptr_t numElements,
+                                             intptr_t *strLengths,
+                                             const char **strs);
+/** Creates a dense elements attribute that has the same data as the given dense
+ * elements attribute and a different shaped type. The new type must have the
+ * same total number of elements. */
+MlirAttribute mlirDenseElementsAttrReshapeGet(MlirAttribute attr,
+                                              MlirType shapedType);
+
+/** Checks whether the given dense elements attribute contains a single
+ * replicated value (splat). */
+int mlirDenseElementsAttrIsSplat(MlirAttribute attr);
+
+/** Returns the single replicated value (splat) of a specific type contained by
+ * the given dense elements attribute. */
+MlirAttribute mlirDenseElementsAttrGetSplatValue(MlirAttribute attr);
+int mlirDenseElementsAttrGetBoolSplatValue(MlirAttribute attr);
+int32_t mlirDenseElementsAttrGetInt32SplatValue(MlirAttribute attr);
+uint32_t mlirDenseElementsAttrGetUInt32SplatValue(MlirAttribute attr);
+int64_t mlirDenseElementsAttrGetInt64SplatValue(MlirAttribute attr);
+uint64_t mlirDenseElementsAttrGetUInt64SplatValue(MlirAttribute attr);
+float mlirDenseElementsAttrGetFloatSplatValue(MlirAttribute attr);
+double mlirDenseElementsAttrGetDoubleSplatValue(MlirAttribute attr);
+/* TODO: consider exposing StringRef and using it instead of the callback. */
+void mlirDenseElementsAttrGetStringSplatValue(MlirAttribute attr,
+                                              MlirStringCallback callback,
+                                              void *userData);
+
+/** Returns the pos-th value (flat contiguous indexing) of a specific type
+ * contained by the given dense elements attribute. */
+int mlirDenseElementsAttrGetBoolValue(MlirAttribute attr, intptr_t pos);
+int32_t mlirDenseElementsAttrGetInt32Value(MlirAttribute attr, intptr_t pos);
+uint32_t mlirDenseElementsAttrGetUInt32Value(MlirAttribute attr, intptr_t pos);
+int64_t mlirDenseElementsAttrGetInt64Value(MlirAttribute attr, intptr_t pos);
+uint64_t mlirDenseElementsAttrGetUInt64Value(MlirAttribute attr, intptr_t pos);
+float mlirDenseElementsAttrGetFloatValue(MlirAttribute attr, intptr_t pos);
+double mlirDenseElementsAttrGetDoubleValue(MlirAttribute attr, intptr_t pos);
+/* TODO: consider exposing StringRef and using it instead of the callback. */
+void mlirDenseElementsAttrGetStringValue(MlirAttribute attr, intptr_t pos,
+                                         MlirStringCallback callback,
+                                         void *userData);
+
+/*============================================================================*/
+/* Opaque elements attribute.                                                 */
+/*============================================================================*/
+
+/* TODO: expose Dialect to the bindings and implement accessors here. */
+
+/** Checks whether the given attribute is an opaque elements attribute. */
+int mlirAttributeIsAOpaqueElements(MlirAttribute attr);
+
+/*============================================================================*/
+/* Sparse elements attribute.                                                 */
+/*============================================================================*/
+
+/** Checks whether the given attribute is a sparse elements attribute. */
+int mlirAttributeIsASparseElements(MlirAttribute attr);
+
+/** Creates a sparse elements attribute of the given shape from a list of
+ * indices and a list of associated values. Both lists are expected to be dense
+ * elements attributes with the same number of elements. The list of indices is
+ * expected to contain 64-bit integers. The attribute is created in the same
+ * context as the type. */
+MlirAttribute mlirSparseElementsAttribute(MlirType shapedType,
+                                          MlirAttribute denseIndices,
+                                          MlirAttribute denseValues);
+
+/** Returns the dense elements attribute containing 64-bit integer indices of
+ * non-null elements in the given sparse elements attribute. */
+MlirAttribute mlirSparseElementsAttrGetIndices(MlirAttribute attr);
+
+/** Returns the dense elements attribute containing the non-null elements in the
+ * given sparse elements attribute. */
+MlirAttribute mlirSparseElementsAttrGetValues(MlirAttribute attr);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // MLIR_C_STANDARDATTRIBUTES_H

mlir/lib/Bindings/Python/IRModules.cpp

 
 //------------------------------------------------------------------------------
 // Conversion utilities.
 //------------------------------------------------------------------------------
 
 namespace {
 
 /// Accumulates into a python string from a method that accepts an
-/// MlirPrintCallback.
+/// MlirStringCallback.
 struct PyPrintAccumulator {
   py::list parts;
 
   void *getUserData() { return this; }
 
-  MlirPrintCallback getCallback() {
+  MlirStringCallback getCallback() {
     return [](const char *part, intptr_t size, void *userData) {
       PyPrintAccumulator *printAccum =
           static_cast<PyPrintAccumulator *>(userData);
       py::str pyPart(part, size); // Decodes as UTF-8 by default.
       printAccum->parts.append(std::move(pyPart));
     };
   }
 

mlir/lib/CAPI/IR/CMakeLists.txt

 # Main API.
 add_mlir_library(MLIRCAPIIR
   AffineMap.cpp
   IR.cpp
+  StandardAttributes.cpp
   StandardTypes.cpp
 
   EXCLUDE_FROM_LIBMLIR
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir-c
 
   LINK_LIBS PUBLIC
   MLIRIR
   MLIRParser
   MLIRSupport
   )

mlir/lib/CAPI/IR/IR.cpp

MlirLocation mlirLocationFileLineColGet(MlirContext context,
                                         unsigned col) {
   return wrap(FileLineColLoc::get(filename, line, col, unwrap(context)));
 }
 
 MlirLocation mlirLocationUnknownGet(MlirContext context) {
   return wrap(UnknownLoc::get(unwrap(context)));
 }
 
-void mlirLocationPrint(MlirLocation location, MlirPrintCallback callback,
+void mlirLocationPrint(MlirLocation location, MlirStringCallback callback,
                        void *userData) {
   CallbackOstream stream(callback, userData);
   unwrap(location).print(stream);
   stream.flush();
 }
 
 /* ========================================================================== */
 /* Module API.                                                                */
MlirNamedAttribute mlirOperationGetAttribute(MlirOperation op, intptr_t pos) {
   return MlirNamedAttribute{attr.first.c_str(), wrap(attr.second)};
 }
 
 MlirAttribute mlirOperationGetAttributeByName(MlirOperation op,
                                               const char *name) {
   return wrap(unwrap(op)->getAttr(name));
 }
 
-void mlirOperationPrint(MlirOperation op, MlirPrintCallback callback,
+void mlirOperationPrint(MlirOperation op, MlirStringCallback callback,
                         void *userData) {
   CallbackOstream stream(callback, userData);
   unwrap(op)->print(stream);
   stream.flush();
 }
 
 void mlirOperationDump(MlirOperation op) { return unwrap(op)->dump(); }
 

 intptr_t mlirBlockGetNumArguments(MlirBlock block) {
   return static_cast<intptr_t>(unwrap(block)->getNumArguments());
 }
 
 MlirValue mlirBlockGetArgument(MlirBlock block, intptr_t pos) {
   return wrap(unwrap(block)->getArgument(static_cast<unsigned>(pos)));
 }
 
-void mlirBlockPrint(MlirBlock block, MlirPrintCallback callback,
+void mlirBlockPrint(MlirBlock block, MlirStringCallback callback,
                     void *userData) {
   CallbackOstream stream(callback, userData);
   unwrap(block)->print(stream);
   stream.flush();
 }
 
 /* ========================================================================== */
 /* Value API.                                                                 */
 /* ========================================================================== */
 
 MlirType mlirValueGetType(MlirValue value) {
   return wrap(unwrap(value).getType());
 }
 
-void mlirValuePrint(MlirValue value, MlirPrintCallback callback,
+void mlirValuePrint(MlirValue value, MlirStringCallback callback,
                     void *userData) {
   CallbackOstream stream(callback, userData);
   unwrap(value).print(stream);
   stream.flush();
 }
 
 /* ========================================================================== */
 /* Type API.                                                                  */
 /* ========================================================================== */
 
 MlirType mlirTypeParseGet(MlirContext context, const char *type) {
   return wrap(mlir::parseType(type, unwrap(context)));
 }
 
 int mlirTypeEqual(MlirType t1, MlirType t2) { return unwrap(t1) == unwrap(t2); }
 
-void mlirTypePrint(MlirType type, MlirPrintCallback callback, void *userData) {
+void mlirTypePrint(MlirType type, MlirStringCallback callback, void *userData) {
   CallbackOstream stream(callback, userData);
   unwrap(type).print(stream);
   stream.flush();
 }
 
 void mlirTypeDump(MlirType type) { unwrap(type).dump(); }
 
 /* ========================================================================== */
 /* Attribute API.                                                             */
 /* ========================================================================== */
 
 MlirAttribute mlirAttributeParseGet(MlirContext context, const char *attr) {
   return wrap(mlir::parseAttribute(attr, unwrap(context)));
 }
 
-void mlirAttributePrint(MlirAttribute attr, MlirPrintCallback callback,
+int mlirAttributeEqual(MlirAttribute a1, MlirAttribute a2) {
+  return unwrap(a1) == unwrap(a2);
+}
+
+void mlirAttributePrint(MlirAttribute attr, MlirStringCallback callback,
                         void *userData) {
   CallbackOstream stream(callback, userData);
   unwrap(attr).print(stream);
   stream.flush();
 }
 
 void mlirAttributeDump(MlirAttribute attr) { unwrap(attr).dump(); }
 
 MlirNamedAttribute mlirNamedAttributeGet(const char *name, MlirAttribute attr) {
   return MlirNamedAttribute{name, attr};
 }

mlir/lib/CAPI/IR/StandardAttributes.cpp

+//===- StandardAttributes.cpp - C Interface to MLIR Standard Attributes ---===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir-c/StandardAttributes.h"
+#include "mlir/CAPI/AffineMap.h"
+#include "mlir/CAPI/IR.h"
+#include "mlir/IR/Attributes.h"
+#include "mlir/IR/StandardTypes.h"
+
+using namespace mlir;
+
+/*============================================================================*/
+/* Affine map attribute.                                                      */
+/*============================================================================*/
+
+int mlirAttributeIsAAffineMap(MlirAttribute attr) {
+  return unwrap(attr).isa<AffineMapAttr>();
+}
+
+MlirAttribute mlirAffineMapAttrGet(MlirAffineMap map) {
+  return wrap(AffineMapAttr::get(unwrap(map)));
+}
+
+MlirAffineMap mlirAffineMapAttrGetValue(MlirAttribute attr) {
+  return wrap(unwrap(attr).cast<AffineMapAttr>().getValue());
+}
+
+/*============================================================================*/
+/* Array attribute.                                                           */
+/*============================================================================*/
+
+int mlirAttributeIsAArray(MlirAttribute attr) {
+  return unwrap(attr).isa<ArrayAttr>();
+}
+
+MlirAttribute mlirArrayAttrGet(MlirContext ctx, intptr_t numElements,
+                               MlirAttribute *elements) {
+  SmallVector<Attribute, 8> attrs;
+  return wrap(ArrayAttr::get(
+      unwrapList(static_cast<size_t>(numElements), elements, attrs),
+      unwrap(ctx)));
+}
+
+intptr_t mlirArrayAttrGetNumElements(MlirAttribute attr) {
+  return static_cast<intptr_t>(unwrap(attr).cast<ArrayAttr>().size());
+}
+
+MlirAttribute mlirArrayAttrGetElement(MlirAttribute attr, intptr_t pos) {
+  return wrap(unwrap(attr).cast<ArrayAttr>().getValue()[pos]);
+}
+
+/*============================================================================*/
+/* Dictionary attribute.                                                      */
+/*============================================================================*/
+
+int mlirAttributeIsADictionary(MlirAttribute attr) {
+  return unwrap(attr).isa<DictionaryAttr>();
+}
+
+MlirAttribute mlirDictionaryAttrGet(MlirContext ctx, intptr_t numElements,
+                                    MlirNamedAttribute *elements) {
+  SmallVector<NamedAttribute, 8> attributes;
+  attributes.reserve(numElements);
+  for (intptr_t i = 0; i < numElements; ++i)
+    attributes.emplace_back(Identifier::get(elements[i].name, unwrap(ctx)),
+                            unwrap(elements[i].attribute));
+  return wrap(DictionaryAttr::get(attributes, unwrap(ctx)));
+}
+
+intptr_t mlirDictionaryAttrGetNumElements(MlirAttribute attr) {
+  return static_cast<intptr_t>(unwrap(attr).cast<DictionaryAttr>().size());
+}
+
+MlirNamedAttribute mlirDictionaryAttrGetElement(MlirAttribute attr,
+                                                intptr_t pos) {
+  NamedAttribute attribute =
+      unwrap(attr).cast<DictionaryAttr>().getValue()[pos];
+  return {attribute.first.c_str(), wrap(attribute.second)};
+}
+
+MlirAttribute mlirDictionaryAttrGetElementByName(MlirAttribute attr,
+                                                 const char *name) {
+  return wrap(unwrap(attr).cast<DictionaryAttr>().get(name));
+}
+
+/*============================================================================*/
+/* Floating point attribute.                                                  */
+/*============================================================================*/
+
+int mlirAttributeIsAFloat(MlirAttribute attr) {
+  return unwrap(attr).isa<FloatAttr>();
+}
+
+MlirAttribute mlirFloatAttrDoubleGet(MlirContext ctx, MlirType type,
+                                     double value) {
+  return wrap(FloatAttr::get(unwrap(type), value));
+}
+
+double mlirFloatAttrGetValueDouble(MlirAttribute attr) {
+  return unwrap(attr).cast<FloatAttr>().getValueAsDouble();
+}
+
+/*============================================================================*/
+/* Integer attribute.                                                         */
+/*============================================================================*/
+
+int mlirAttributeIsAInteger(MlirAttribute attr) {
+  return unwrap(attr).isa<IntegerAttr>();
+}
+
+MlirAttribute mlirIntegerAttrGet(MlirType type, int64_t value) {
+  return wrap(IntegerAttr::get(unwrap(type), value));
+}
+
+int64_t mlirIntegerAttrGetValueInt(MlirAttribute attr) {
+  return unwrap(attr).cast<IntegerAttr>().getInt();
+}
+
+/*============================================================================*/
+/* Bool attribute.                                                            */
+/*============================================================================*/
+
+int mlirAttributeIsABool(MlirAttribute attr) {
+  return unwrap(attr).isa<BoolAttr>();
+}
+
+MlirAttribute mlirBoolAttrGet(MlirContext ctx, int value) {
+  return wrap(BoolAttr::get(value, unwrap(ctx)));
+}
+
+int mlirBoolAttrGetValue(MlirAttribute attr) {
+  return unwrap(attr).cast<BoolAttr>().getValue();
+}
+
+/*============================================================================*/
+/* Integer set attribute.                                                     */
+/*============================================================================*/
+
+int mlirAttributeIsAIntegerSet(MlirAttribute attr) {
+  return unwrap(attr).isa<IntegerSetAttr>();
+}
+
+/*============================================================================*/
+/* Opaque attribute.                                                          */
+/*============================================================================*/
+
+int mlirAttributeIsAOpaque(MlirAttribute attr) {
+  return unwrap(attr).isa<OpaqueAttr>();
+}
+
+MlirAttribute mlirOpaqueAttrGet(MlirContext ctx, const char *dialectNamespace,
+                                intptr_t dataLength, const char *data,
+                                MlirType type) {
+  return wrap(OpaqueAttr::get(Identifier::get(dialectNamespace, unwrap(ctx)),
+                              StringRef(data, dataLength), unwrap(type),
+                              unwrap(ctx)));
+}
+
+const char *mlirOpaqueAttrGetDialectNamespace(MlirAttribute attr) {
+  return unwrap(attr).cast<OpaqueAttr>().getDialectNamespace().c_str();
+}
+
+void mlirOpaqueAttrGetData(MlirAttribute attr, MlirStringCallback callback,
+                           void *userData) {
+  StringRef data = unwrap(attr).cast<OpaqueAttr>().getAttrData();
+  callback(data.data(), static_cast<intptr_t>(data.size()), userData);
+}
+
+/*============================================================================*/
+/* String attribute.                                                          */
+/*============================================================================*/
+
+int mlirAttributeIsAString(MlirAttribute attr) {
+  return unwrap(attr).isa<StringAttr>();
+}
+
+MlirAttribute mlirStringAttrGet(MlirContext ctx, intptr_t length,
+                                const char *data) {
+  return wrap(StringAttr::get(StringRef(data, length), unwrap(ctx)));
+}
+
+MlirAttribute mlirStringAttrTypedGet(MlirType type, intptr_t length,
+                                     const char *data) {
+  return wrap(StringAttr::get(StringRef(data, length), unwrap(type)));
+}
+
+void mlirStringAttrGetValue(MlirAttribute attr, MlirStringCallback callback,
+                            void *userData) {
+  StringRef data = unwrap(attr).cast<StringAttr>().getValue();
+  callback(data.data(), static_cast<intptr_t>(data.size()), userData);
+}
+
+/*============================================================================*/
+/* SymbolRef attribute.                                                       */
+/*============================================================================*/
+
+int mlirAttributeIsASymbolRef(MlirAttribute attr) {
+  return unwrap(attr).isa<SymbolRefAttr>();
+}
+
+MlirAttribute mlirSymbolRefAttrGet(MlirContext ctx, intptr_t length,
+                                   const char *symbol, intptr_t numReferences,
+                                   MlirAttribute *references) {
+  SmallVector<FlatSymbolRefAttr, 4> refs;
+  refs.reserve(numReferences);
+  for (intptr_t i = 0; i < numReferences; ++i)
+    refs.push_back(unwrap(references[i]).cast<FlatSymbolRefAttr>());
+  return wrap(SymbolRefAttr::get(StringRef(symbol, length), refs, unwrap(ctx)));
+}
+
+void mlirSymbolRefAttrGetRootReference(MlirAttribute attr,
+                                       MlirStringCallback callback,
+                                       void *userData) {
+  StringRef ref = unwrap(attr).cast<SymbolRefAttr>().getRootReference();
+  callback(ref.data(), ref.size(), userData);
+}
+
+void mlirSymbolRefAttrGetLeafReference(MlirAttribute attr,
+                                       MlirStringCallback callback,
+                                       void *userData) {
+  StringRef ref = unwrap(attr).cast<SymbolRefAttr>().getLeafReference();
+  callback(ref.data(), ref.size(), userData);
+}
+
+intptr_t mlirSymbolRefAttrGetNumNestedReferences(MlirAttribute attr) {
+  return static_cast<intptr_t>(
+      unwrap(attr).cast<SymbolRefAttr>().getNestedReferences().size());
+}
+
+MlirAttribute mlirSymbolRefAttrGetNestedReference(MlirAttribute attr,
+                                                  intptr_t pos) {
+  return wrap(unwrap(attr).cast<SymbolRefAttr>().getNestedReferences()[pos]);
+}
+
+/*============================================================================*/
+/* Flat SymbolRef attribute.                                                  */
+/*============================================================================*/
+
+int mlirAttributeIsAFlatSymbolRef(MlirAttribute attr) {
+  return unwrap(attr).isa<FlatSymbolRefAttr>();
+}
+
+MlirAttribute mlirFlatSymbolRefAttrGet(MlirContext ctx, intptr_t length,
+                                       const char *symbol) {
+  return wrap(FlatSymbolRefAttr::get(StringRef(symbol, length), unwrap(ctx)));
+}
+
+void mlirFloatSymbolRefAttrGetValue(MlirAttribute attr,
+                                    MlirStringCallback callback,
+                                    void *userData) {
+  StringRef symbol = unwrap(attr).cast<FlatSymbolRefAttr>().getValue();
+  callback(symbol.data(), symbol.size(), userData);
+}
+
+/*============================================================================*/
+/* Type attribute.                                                            */
+/*============================================================================*/
+
+int mlirAttributeIsAType(MlirAttribute attr) {
+  return unwrap(attr).isa<TypeAttr>();
+}
+
+MlirAttribute mlirTypeAttrGet(MlirType type) {
+  return wrap(TypeAttr::get(unwrap(type)));
+}
+
+MlirType mlirTypeAttrGetValue(MlirAttribute attr) {
+  return wrap(unwrap(attr).cast<TypeAttr>().getValue());
+}
+
+/*============================================================================*/
+/* Unit attribute.                                                            */
+/*============================================================================*/
+
+int mlirAttributeIsAUnit(MlirAttribute attr) {
+  return unwrap(attr).isa<UnitAttr>();
+}
+
+MlirAttribute mlirUnitAttrGet(MlirContext ctx) {
+  return wrap(UnitAttr::get(unwrap(ctx)));
+}
+
+/*============================================================================*/
+/* Elements attributes.                                                       */
+/*============================================================================*/
+
+int mlirAttributeIsAElements(MlirAttribute attr) {
+  return unwrap(attr).isa<ElementsAttr>();
+}
+
+MlirAttribute mlirElementsAttrGetValue(MlirAttribute attr, intptr_t rank,
+                                       uint64_t *idxs) {
+  return wrap(unwrap(attr).cast<ElementsAttr>().getValue(
+      llvm::makeArrayRef(idxs, rank)));
+}
+
+int mlirElementsAttrIsValidIndex(MlirAttribute attr, intptr_t rank,
+                                 uint64_t *idxs) {
+  return unwrap(attr).cast<ElementsAttr>().isValidIndex(
+      llvm::makeArrayRef(idxs, rank));
+}
+
+int64_t mlirElementsAttrGetNumElements(MlirAttribute attr) {
+  return unwrap(attr).cast<ElementsAttr>().getNumElements();
+}
+
+/*============================================================================*/
+/* Dense elements attribute.                                                  */
+/*============================================================================*/
+
+//===----------------------------------------------------------------------===//
+// IsA support.
+
+int mlirAttributeIsADenseElements(MlirAttribute attr) {
+  return unwrap(attr).isa<DenseElementsAttr>();
+}
+int mlirAttributeIsADenseIntElements(MlirAttribute attr) {
+  return unwrap(attr).isa<DenseIntElementsAttr>();
+}
+int mlirAttributeIsADenseFPElements(MlirAttribute attr) {
+  return unwrap(attr).isa<DenseFPElementsAttr>();
+}
+
+//===----------------------------------------------------------------------===//
+// Constructors.
+
+MlirAttribute mlirDenseElementsAttrGet(MlirType shapedType,
+                                       intptr_t numElements,
+                                       MlirAttribute *elements) {
+  SmallVector<Attribute, 8> attributes;
+  return wrap(
+      DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
+                             unwrapList(numElements, elements, attributes)));
+}
+
+MlirAttribute mlirDenseElementsAttrSplatGet(MlirType shapedType,
+                                            MlirAttribute element) {
+  return wrap(DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
+                                     unwrap(element)));
+}
+MlirAttribute mlirDenseElementsAttrBoolSplatGet(MlirType shapedType,
+                                                int element) {
+  return wrap(DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
+                                     static_cast<bool>(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(
+      DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
+}
+MlirAttribute mlirDenseElementsAttrUInt64SplatGet(MlirType shapedType,
+                                                  uint64_t element) {
+  return wrap(
+      DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
+}
+MlirAttribute mlirDenseElementsAttrInt64SplatGet(MlirType shapedType,
+                                                 int64_t element) {
+  return wrap(
+      DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
+}
+MlirAttribute mlirDenseElementsAttrFloatSplatGet(MlirType shapedType,
+                                                 float element) {
+  return wrap(
+      DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
+}
+MlirAttribute mlirDenseElementsAttrDoubleSplatGet(MlirType shapedType,
+                                                  double element) {
+  return wrap(
+      DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
+}
+
+MlirAttribute mlirDenseElementsAttrBoolGet(MlirType shapedType,
+                                           intptr_t numElements,
+                                           int *elements) {
+  SmallVector<bool, 8> values(elements, elements + numElements);
+  return wrap(
+      DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), values));
+}
+
+/// Creates a dense attribute with elements of the type deduced by templates.
+template <typename T>
+static MlirAttribute getDenseAttribute(MlirType shapedType,
+                                       intptr_t numElements, T *elements) {
+  return wrap(
+      DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
+                             llvm::makeArrayRef(elements, numElements)));
+}
+
+MlirAttribute mlirDenseElementsAttrUInt32Get(MlirType shapedType,
+                                             intptr_t numElements,
+                                             uint32_t *elements) {
+  return getDenseAttribute(shapedType, numElements, elements);
+}
+MlirAttribute mlirDenseElementsAttrInt32Get(MlirType shapedType,
+                                            intptr_t numElements,
+                                            int32_t *elements) {
+  return getDenseAttribute(shapedType, numElements, elements);
+}
+MlirAttribute mlirDenseElementsAttrUInt64Get(MlirType shapedType,
+                                             intptr_t numElements,
+                                             uint64_t *elements) {
+  return getDenseAttribute(shapedType, numElements, elements);
+}
+MlirAttribute mlirDenseElementsAttrInt64Get(MlirType shapedType,
+                                            intptr_t numElements,
+                                            int64_t *elements) {
+  return getDenseAttribute(shapedType, numElements, elements);
+}
+MlirAttribute mlirDenseElementsAttrFloatGet(MlirType shapedType,
+                                            intptr_t numElements,
+                                            float *elements) {
+  return getDenseAttribute(shapedType, numElements, elements);
+}
+MlirAttribute mlirDenseElementsAttrDoubleGet(MlirType shapedType,
+                                             intptr_t numElements,
+                                             double *elements) {
+  return getDenseAttribute(shapedType, numElements, elements);
+}
+
+MlirAttribute mlirDenseElementsAttrStringGet(MlirType shapedType,
+                                             intptr_t numElements,
+                                             intptr_t *strLengths,
+                                             const char **strs) {
+  SmallVector<StringRef, 8> values;
+  values.reserve(numElements);
+  for (intptr_t i = 0; i < numElements; ++i)
+    values.push_back(StringRef(strs[i], strLengths[i]));
+
+  return wrap(
+      DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), values));
+}
+
+MlirAttribute mlirDenseElementsAttrReshapeGet(MlirAttribute attr,
+                                              MlirType shapedType) {
+  return wrap(unwrap(attr).cast<DenseElementsAttr>().reshape(
+      unwrap(shapedType).cast<ShapedType>()));
+}
+
+//===----------------------------------------------------------------------===//
+// Splat accessors.
+
+int mlirDenseElementsAttrIsSplat(MlirAttribute attr) {
+  return unwrap(attr).cast<DenseElementsAttr>().isSplat();
+}
+
+MlirAttribute mlirDenseElementsAttrGetSplatValue(MlirAttribute attr) {
+  return wrap(unwrap(attr).cast<DenseElementsAttr>().getSplatValue());
+}
+int mlirDenseElementsAttrGetBoolSplatValue(MlirAttribute attr) {
+  return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<bool>();
+}
+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>();
+}
+uint64_t mlirDenseElementsAttrGetUInt64SplatValue(MlirAttribute attr) {
+  return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<uint64_t>();
+}
+float mlirDenseElementsAttrGetFloatSplatValue(MlirAttribute attr) {
+  return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<float>();
+}
+double mlirDenseElementsAttrGetDoubleSplatValue(MlirAttribute attr) {
+  return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<double>();
+}
+void mlirDenseElementsAttrGetStringSplatValue(MlirAttribute attr,
+                                              MlirStringCallback callback,
+                                              void *userData) {
+  StringRef str =
+      unwrap(attr).cast<DenseElementsAttr>().getSplatValue<StringRef>();
+  callback(str.data(), str.size(), userData);
+}
+
+//===----------------------------------------------------------------------===//
+// Indexed accessors.
+
+int mlirDenseElementsAttrGetBoolValue(MlirAttribute attr, intptr_t pos) {
+  return *(unwrap(attr).cast<DenseElementsAttr>().getValues<bool>().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);
+}
+int64_t mlirDenseElementsAttrGetInt64Value(MlirAttribute attr, intptr_t pos) {
+  return *(unwrap(attr).cast<DenseElementsAttr>().getValues<int64_t>().begin() +
+           pos);
+}
+uint64_t mlirDenseElementsAttrGetUInt64Value(MlirAttribute attr, intptr_t pos) {
+  return *(
+      unwrap(attr).cast<DenseElementsAttr>().getValues<uint64_t>().begin() +
+      pos);
+}
+float mlirDenseElementsAttrGetFloatValue(MlirAttribute attr, intptr_t pos) {
+  return *(unwrap(attr).cast<DenseElementsAttr>().getValues<float>().begin() +
+           pos);
+}
+double mlirDenseElementsAttrGetDoubleValue(MlirAttribute attr, intptr_t pos) {
+  return *(unwrap(attr).cast<DenseElementsAttr>().getValues<double>().begin() +
+           pos);
+}
+void mlirDenseElementsAttrGetStringValue(MlirAttribute attr, intptr_t pos,
+                                         MlirStringCallback callback,
+                                         void *userData) {
+  StringRef str =
+      *(unwrap(attr).cast<DenseElementsAttr>().getValues<StringRef>().begin() +
+        pos);
+  callback(str.data(), str.size(), userData);
+}
+
+/*============================================================================*/
+/* Opaque elements attribute.                                                 */
+/*============================================================================*/
+
+int mlirAttributeIsAOpaqueElements(MlirAttribute attr) {
+  return unwrap(attr).isa<OpaqueElementsAttr>();
+}
+
+/*============================================================================*/
+/* Sparse elements attribute.                                                 */
+/*============================================================================*/
+
+int mlirAttributeIsASparseElements(MlirAttribute attr) {
+  return unwrap(attr).isa<SparseElementsAttr>();
+}
+
+MlirAttribute mlirSparseElementsAttribute(MlirType shapedType,
+                                          MlirAttribute denseIndices,
+                                          MlirAttribute denseValues) {
+  return wrap(
+      SparseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
+                              unwrap(denseIndices).cast<DenseElementsAttr>(),
+                              unwrap(denseValues).cast<DenseElementsAttr>()));
+}
+
+MlirAttribute mlirSparseElementsAttrGetIndices(MlirAttribute attr) {
+  return wrap(unwrap(attr).cast<SparseElementsAttr>().getIndices());
+}
+
+MlirAttribute mlirSparseElementsAttrGetValues(MlirAttribute attr) {
+  return wrap(unwrap(attr).cast<SparseElementsAttr>().getValues());
+}

mlir/test/CAPI/ir.c

 /*===- ir.c - Simple test of C APIs ---------------------------------------===*\
 |*                                                                            *|
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
 |* Exceptions.                                                                *|
 |* See https://llvm.org/LICENSE.txt for license information.                  *|
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 /* RUN: mlir-capi-ir-test 2>&1 | FileCheck %s
  */
 
 #include "mlir-c/IR.h"
 #include "mlir-c/Registration.h"
+#include "mlir-c/StandardAttributes.h"
 #include "mlir-c/StandardTypes.h"
 
 #include <assert.h>
+#include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 void populateLoopBody(MlirContext ctx, MlirBlock loopBody,
                       MlirLocation location, MlirBlock funcBody) {
   MlirValue iv = mlirBlockGetArgument(loopBody, 0);
   MlirValue funcArg0 = mlirBlockGetArgument(funcBody, 0);
   MlirValue funcArg1 = mlirBlockGetArgument(funcBody, 1);
   MlirType f32Type = mlirTypeParseGet(ctx, "f32");
 
if (!mlirTypeIsATuple(tuple) || mlirTupleTypeGetNumTypes(tuple) != 2 ||
       !mlirTypeEqual(mlirTupleTypeGetType(tuple, 1), f32))
     return 20;
   mlirTypeDump(tuple);
   fprintf(stderr, "\n");
 
   return 0;
 }
 
+void callbackSetFixedLengthString(const char *data, intptr_t len,
+                                  void *userData) {
+  strncpy(userData, data, len);
+}
+
+int printStandardAttributes(MlirContext ctx) {
+  MlirAttribute floating =
+      mlirFloatAttrDoubleGet(ctx, mlirF64TypeGet(ctx), 2.0);
+  if (!mlirAttributeIsAFloat(floating) ||
+      fabs(mlirFloatAttrGetValueDouble(floating) - 2.0) > 1E-6)
+    return 1;
+  mlirAttributeDump(floating);
+
+  MlirAttribute integer = mlirIntegerAttrGet(mlirIntegerTypeGet(ctx, 32), 42);
+  if (!mlirAttributeIsAInteger(integer) ||
+      mlirIntegerAttrGetValueInt(integer) != 42)
+    return 2;
+  mlirAttributeDump(integer);
+
+  MlirAttribute boolean = mlirBoolAttrGet(ctx, 1);
+  if (!mlirAttributeIsABool(boolean) || !mlirBoolAttrGetValue(boolean))
+    return 3;
+  mlirAttributeDump(boolean);
+
+  const char data[] = "abcdefghijklmnopqestuvwxyz";
+  char buffer[10];
+  MlirAttribute opaque =
+      mlirOpaqueAttrGet(ctx, "std", 3, data, mlirNoneTypeGet(ctx));
+  if (!mlirAttributeIsAOpaque(opaque) ||
+      strcmp("std", mlirOpaqueAttrGetDialectNamespace(opaque)))
+    return 4;
+  mlirOpaqueAttrGetData(opaque, callbackSetFixedLengthString, buffer);
+  if (buffer[0] != 'a' || buffer[1] != 'b' || buffer[2] != 'c')
+    return 5;
+  mlirAttributeDump(opaque);
+
+  MlirAttribute string = mlirStringAttrGet(ctx, 2, data + 3);
+  if (!mlirAttributeIsAString(string))
+    return 6;
+  mlirStringAttrGetValue(string, callbackSetFixedLengthString, buffer);
+  if (buffer[0] != 'd' || buffer[1] != 'e')
+    return 7;
+  mlirAttributeDump(string);
+
+  MlirAttribute flatSymbolRef = mlirFlatSymbolRefAttrGet(ctx, 3, data + 5);
+  if (!mlirAttributeIsAFlatSymbolRef(flatSymbolRef))
+    return 8;
+  mlirFloatSymbolRefAttrGetValue(flatSymbolRef, callbackSetFixedLengthString,
+                                 buffer);
+  if (buffer[0] != 'f' || buffer[1] != 'g' || buffer[2] != 'h')
+    return 9;
+  mlirAttributeDump(flatSymbolRef);
+
+  MlirAttribute symbols[] = {flatSymbolRef, flatSymbolRef};
+  MlirAttribute symbolRef = mlirSymbolRefAttrGet(ctx, 2, data + 8, 2, symbols);
+  if (!mlirAttributeIsASymbolRef(symbolRef) ||
+      mlirSymbolRefAttrGetNumNestedReferences(symbolRef) != 2 ||
+      !mlirAttributeEqual(mlirSymbolRefAttrGetNestedReference(symbolRef, 0),
+                          flatSymbolRef) ||
+      !mlirAttributeEqual(mlirSymbolRefAttrGetNestedReference(symbolRef, 1),
+                          flatSymbolRef))
+    return 10;
+  mlirSymbolRefAttrGetLeafReference(symbolRef, callbackSetFixedLengthString,
+                                    buffer);
+  mlirSymbolRefAttrGetRootReference(symbolRef, callbackSetFixedLengthString,
+                                    buffer + 3);
+  if (buffer[0] != 'f' || buffer[1] != 'g' || buffer[2] != 'h' ||
+      buffer[3] != 'i' || buffer[4] != 'j')
+    return 11;
+  mlirAttributeDump(symbolRef);
+
+  MlirAttribute type = mlirTypeAttrGet(mlirF32TypeGet(ctx));
+  if (!mlirAttributeIsAType(type) ||
+      !mlirTypeEqual(mlirF32TypeGet(ctx), mlirTypeAttrGetValue(type)))
+    return 12;
+  mlirAttributeDump(type);
+
+  MlirAttribute unit = mlirUnitAttrGet(ctx);
+  if (!mlirAttributeIsAUnit(unit))
+    return 13;
+  mlirAttributeDump(unit);
+
+  int64_t shape[] = {1, 2};
+
+  int bools[] = {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 boolElements = mlirDenseElementsAttrBoolGet(
+      mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeGet(ctx, 1)), 2, bools);
+  MlirAttribute uint32Elements = mlirDenseElementsAttrUInt32Get(
+      mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeUnsignedGet(ctx, 32)), 2,
+      uints32);
+  MlirAttribute int32Elements = mlirDenseElementsAttrInt32Get(
+      mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeGet(ctx, 32)), 2,
+      ints32);
+  MlirAttribute uint64Elements = mlirDenseElementsAttrUInt64Get(
+      mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeUnsignedGet(ctx, 64)), 2,
+      uints64);
+  MlirAttribute int64Elements = mlirDenseElementsAttrInt64Get(
+      mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeGet(ctx, 64)), 2,
+      ints64);
+  MlirAttribute floatElements = mlirDenseElementsAttrFloatGet(
+      mlirRankedTensorTypeGet(2, shape, mlirF32TypeGet(ctx)), 2, floats);
+  MlirAttribute doubleElements = mlirDenseElementsAttrDoubleGet(
+      mlirRankedTensorTypeGet(2, shape, mlirF64TypeGet(ctx)), 2, doubles);
+
+  if (!mlirAttributeIsADenseElements(boolElements) ||
+      !mlirAttributeIsADenseElements(uint32Elements) ||
+      !mlirAttributeIsADenseElements(int32Elements) ||
+      !mlirAttributeIsADenseElements(uint64Elements) ||
+      !mlirAttributeIsADenseElements(int64Elements) ||
+      !mlirAttributeIsADenseElements(floatElements) ||
+      !mlirAttributeIsADenseElements(doubleElements))
+    return 14;
+
+  if (mlirDenseElementsAttrGetBoolValue(boolElements, 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(uint32Elements);
+  mlirAttributeDump(int32Elements);
+  mlirAttributeDump(uint64Elements);
+  mlirAttributeDump(int64Elements);
+  mlirAttributeDump(floatElements);
+  mlirAttributeDump(doubleElements);
+
+  MlirAttribute splatBool = mlirDenseElementsAttrBoolSplatGet(
+      mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeGet(ctx, 1)), 1);
+  MlirAttribute splatUInt32 = mlirDenseElementsAttrUInt32SplatGet(
+      mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeGet(ctx, 32)), 1);
+  MlirAttribute splatInt32 = mlirDenseElementsAttrInt32SplatGet(
+      mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeGet(ctx, 32)), 1);
+  MlirAttribute splatUInt64 = mlirDenseElementsAttrUInt64SplatGet(
+      mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeGet(ctx, 64)), 1);
+  MlirAttribute splatInt64 = mlirDenseElementsAttrInt64SplatGet(
+      mlirRankedTensorTypeGet(2, shape, mlirIntegerTypeGet(ctx, 64)), 1);
+  MlirAttribute splatFloat = mlirDenseElementsAttrFloatSplatGet(
+      mlirRankedTensorTypeGet(2, shape, mlirF32TypeGet(ctx)), 1.0f);
+  MlirAttribute splatDouble = mlirDenseElementsAttrDoubleSplatGet(
+      mlirRankedTensorTypeGet(2, shape, mlirF64TypeGet(ctx)), 1.0);
+
+  if (!mlirAttributeIsADenseElements(splatBool) ||
+      !mlirDenseElementsAttrIsSplat(splatBool) ||
+      !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 ||
+      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;
+
+  mlirAttributeDump(splatBool);
+  mlirAttributeDump(splatUInt32);
+  mlirAttributeDump(splatInt32);
+  mlirAttributeDump(splatUInt64);
+  mlirAttributeDump(splatInt64);
+  mlirAttributeDump(splatFloat);
+  mlirAttributeDump(splatDouble);
+
+  mlirAttributeDump(mlirElementsAttrGetValue(floatElements, 2, uints64));
+  mlirAttributeDump(mlirElementsAttrGetValue(doubleElements, 2, uints64));
+
+  int64_t indices[] = {4, 7};
+  int64_t two = 2;
+  MlirAttribute indicesAttr = mlirDenseElementsAttrInt64Get(
+      mlirRankedTensorTypeGet(1, &two, mlirIntegerTypeGet(ctx, 64)), 2,
+      indices);
+  MlirAttribute valuesAttr = mlirDenseElementsAttrFloatGet(
+      mlirRankedTensorTypeGet(1, &two, mlirF32TypeGet(ctx)), 2, floats);
+  MlirAttribute sparseAttr = mlirSparseElementsAttribute(
+      mlirRankedTensorTypeGet(2, shape, mlirF32TypeGet(ctx)), indicesAttr,
+      valuesAttr);
+  mlirAttributeDump(sparseAttr);
+
+  return 0;
+}
+
 int main() {
   MlirContext ctx = mlirContextCreate();
   mlirRegisterAllDialects(ctx);
   MlirLocation location = mlirLocationUnknownGet(ctx);
 
   MlirModule moduleOp = makeAdd(ctx, location);
   MlirOperation module = mlirModuleGetOperation(moduleOp);
   mlirOperationDump(module);
int main() {
   // CHECK: vector<2x3xf32>
   // CHECK: tensor<2x3xf32>
   // CHECK: tensor<*xf32>
   // CHECK: memref<2x3xf32, 2>
   // CHECK: memref<*xf32, 4>
   // CHECK: tuple<memref<*xf32, 4>, f32>
   // CHECK: 0
   // clang-format on
-  fprintf(stderr, "@types");
+  fprintf(stderr, "@types\n");
   int errcode = printStandardTypes(ctx);
   fprintf(stderr, "%d\n", errcode);
 
+  // clang-format off
+  // CHECK-LABEL: @attrs
+  // CHECK: 2.000000e+00 : f64
+  // CHECK: 42 : i32
+  // CHECK: true
+  // CHECK: #std.abc
+  // CHECK: "de"
+  // CHECK: @fgh
+  // CHECK: @ij::@fgh::@fgh
+  // CHECK: f32
+  // CHECK: unit
+  // CHECK: dense<{{\[}}[false, true]]> : tensor<1x2xi1>
+  // 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>
+  // CHECK: dense<true> : tensor<1x2xi1>
+  // CHECK: dense<1> : tensor<1x2xi32>
+  // CHECK: dense<1> : tensor<1x2xi32>
+  // CHECK: dense<1> : tensor<1x2xi64>
+  // CHECK: dense<1> : tensor<1x2xi64>
+  // CHECK: dense<1.000000e+00> : tensor<1x2xf32>
+  // CHECK: dense<1.000000e+00> : tensor<1x2xf64>
+  // CHECK: 1.000000e+00 : f32
+  // CHECK: 1.000000e+00 : f64
+  // CHECK: sparse<[4, 7], [0.000000e+00, 1.000000e+00]> : tensor<1x2xf32>
+  // clang-format on
+  fprintf(stderr, "@attrs\n");
+  errcode = printStandardAttributes(ctx);
+  fprintf(stderr, "%d\n", errcode);
+
   mlirContextDestroy(ctx);
 
   return 0;
 }