[mlir] Use more C99 comments in C API header files

[ftynse]

Summary

These were left over from the original reformatting commit.

[stellaraccident]

Thanks. This has been annoying me for a while.

mlir/include/mlir-c/AffineExpr.h

 
 #include "mlir-c/IR.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 //===----------------------------------------------------------------------===//
-/** Opaque type declarations.
- *
- * Types are exposed to C bindings as structs containing opaque pointers. They
- * are not supposed to be inspected from C. This allows the underlying
- * representation to change without affecting the API users. The use of structs
- * instead of typedefs enables some type safety as structs are not implicitly
- * convertible to each other.
- *
- * Instances of these types may or may not own the underlying object. The
- * ownership semantics is defined by how an instance of the type was obtained.
- */
+// Opaque type declarations.
+//
+// Types are exposed to C bindings as structs containing opaque pointers. They
+// are not supposed to be inspected from C. This allows the underlying
+// representation to change without affecting the API users. The use of structs
+// instead of typedefs enables some type safety as structs are not implicitly
+// convertible to each other.
+//
+// Instances of these types may or may not own the underlying object. The
+// ownership semantics is defined by how an instance of the type was obtained.
 //===----------------------------------------------------------------------===//
 
 #define DEFINE_C_API_STRUCT(name, storage)                                     \
   struct name {                                                                \
     storage *ptr;                                                              \
   };                                                                           \
   typedef struct name name
 
MLIR_CAPI_EXPORTED bool mlirAffineExprEqual(MlirAffineExpr lhs,
                                             MlirAffineExpr rhs);
 
 /// Returns `true` if the given affine expression is a null expression. Note
 /// constant zero is not a null expression.
 inline static bool mlirAffineExprIsNull(MlirAffineExpr affineExpr) {
   return affineExpr.ptr == NULL;
 }
 
-/** Prints an affine expression 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. */
+/// Prints an affine expression 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.
 MLIR_CAPI_EXPORTED void mlirAffineExprPrint(MlirAffineExpr affineExpr,
                                             MlirStringCallback callback,
                                             void *userData);
 
 /// Prints the affine expression to the standard error stream.
 MLIR_CAPI_EXPORTED void mlirAffineExprDump(MlirAffineExpr affineExpr);
 
-/** Checks whether the given affine expression is made out of only symbols and
- * constants. */
+/// Checks whether the given affine expression is made out of only symbols and
+/// constants.
 MLIR_CAPI_EXPORTED bool
 mlirAffineExprIsSymbolicOrConstant(MlirAffineExpr affineExpr);
 
-/** Checks whether the given affine expression is a pure affine expression, i.e.
- * mul, floordiv, ceildic, and mod is only allowed w.r.t constants. */
+/// Checks whether the given affine expression is a pure affine expression, i.e.
+/// mul, floordiv, ceildic, and mod is only allowed w.r.t constants.
 MLIR_CAPI_EXPORTED bool mlirAffineExprIsPureAffine(MlirAffineExpr affineExpr);
 
-/** Returns the greatest known integral divisor of this affine expression. The
- * result is always positive. */
+/// Returns the greatest known integral divisor of this affine expression. The
+/// result is always positive.
 MLIR_CAPI_EXPORTED int64_t
 mlirAffineExprGetLargestKnownDivisor(MlirAffineExpr affineExpr);
 
 /// Checks whether the given affine expression is a multiple of 'factor'.
 MLIR_CAPI_EXPORTED bool mlirAffineExprIsMultipleOf(MlirAffineExpr affineExpr,
                                                    int64_t factor);
 
-/** Checks whether the given affine expression involves AffineDimExpr
- * 'position'. */
+/// Checks whether the given affine expression involves AffineDimExpr
+/// 'position'.
 MLIR_CAPI_EXPORTED bool mlirAffineExprIsFunctionOfDim(MlirAffineExpr affineExpr,
                                                       intptr_t position);
 
 //===----------------------------------------------------------------------===//
 // Affine Dimension Expression.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given affine expression is a dimension expression.

 
 //===----------------------------------------------------------------------===//
 // Affine Binary Operation Expression.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given affine expression is binary.
 MLIR_CAPI_EXPORTED bool mlirAffineExprIsABinary(MlirAffineExpr affineExpr);
 
-/** Returns the left hand side affine expression of the given affine binary
- * operation expression. */
+/// Returns the left hand side affine expression of the given affine binary
+/// operation expression.
 MLIR_CAPI_EXPORTED MlirAffineExpr
 mlirAffineBinaryOpExprGetLHS(MlirAffineExpr affineExpr);
 
-/** Returns the right hand side affine expression of the given affine binary
- * operation expression. */
+/// Returns the right hand side affine expression of the given affine binary
+/// operation expression.
 MLIR_CAPI_EXPORTED MlirAffineExpr
 mlirAffineBinaryOpExprGetRHS(MlirAffineExpr affineExpr);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_AFFINEEXPR_H

mlir/include/mlir-c/AffineMap.h

 #include "mlir-c/AffineExpr.h"
 #include "mlir-c/IR.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 //===----------------------------------------------------------------------===//
-/** Opaque type declarations.
- *
- * Types are exposed to C bindings as structs containing opaque pointers. They
- * are not supposed to be inspected from C. This allows the underlying
- * representation to change without affecting the API users. The use of structs
- * instead of typedefs enables some type safety as structs are not implicitly
- * convertible to each other.
- *
- * Instances of these types may or may not own the underlying object. The
- * ownership semantics is defined by how an instance of the type was obtained.
- */
+// Opaque type declarations.
+//
+// Types are exposed to C bindings as structs containing opaque pointers. They
+// are not supposed to be inspected from C. This allows the underlying
+// representation to change without affecting the API users. The use of structs
+// instead of typedefs enables some type safety as structs are not implicitly
+// convertible to each other.
+//
+// Instances of these types may or may not own the underlying object. The
+// ownership semantics is defined by how an instance of the type was obtained.
 //===----------------------------------------------------------------------===//
 
 #define DEFINE_C_API_STRUCT(name, storage)                                     \
   struct name {                                                                \
     storage *ptr;                                                              \
   };                                                                           \
   typedef struct name name
 
 DEFINE_C_API_STRUCT(MlirAffineMap, const void);
 
 #undef DEFINE_C_API_STRUCT
 
 /// Gets the context that the given affine map was created with
 MLIR_CAPI_EXPORTED MlirContext mlirAffineMapGetContext(MlirAffineMap affineMap);
 
 /// Checks whether an affine map is null.
 static inline bool mlirAffineMapIsNull(MlirAffineMap affineMap) {
   return !affineMap.ptr;
 }
 
 /// Checks if two affine maps are equal.
 MLIR_CAPI_EXPORTED bool mlirAffineMapEqual(MlirAffineMap a1, MlirAffineMap a2);
 
-/** Prints an affine map 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. */
+/// Prints an affine map 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.
 MLIR_CAPI_EXPORTED void mlirAffineMapPrint(MlirAffineMap affineMap,
                                            MlirStringCallback callback,
                                            void *userData);
 
 /// Prints the affine map to the standard error stream.
 MLIR_CAPI_EXPORTED void mlirAffineMapDump(MlirAffineMap affineMap);
 
-/** Creates a zero result affine map with no dimensions or symbols in the
- * context. The affine map is owned by the context. */
+/// Creates a zero result affine map with no dimensions or symbols in the
+/// context. The affine map is owned by the context.
 MLIR_CAPI_EXPORTED MlirAffineMap mlirAffineMapEmptyGet(MlirContext ctx);
 
-/** Creates a zero result affine map of the given dimensions and symbols in the
- * context. The affine map is owned by the context. */
+/// Creates a zero result affine map of the given dimensions and symbols in the
+/// context. The affine map is owned by the context.
 MLIR_CAPI_EXPORTED MlirAffineMap mlirAffineMapZeroResultGet(
     MlirContext ctx, intptr_t dimCount, intptr_t symbolCount);
 
-/** Creates an affine map with results defined by the given list of affine
- * expressions. The map resulting map also has the requested number of input
- * dimensions and symbols, regardless of them being used in the results.
- */
+/// Creates an affine map with results defined by the given list of affine
+/// expressions. The map resulting map also has the requested number of input
+/// dimensions and symbols, regardless of them being used in the results.
+
 MLIR_CAPI_EXPORTED MlirAffineMap mlirAffineMapGet(MlirContext ctx,
                                                   intptr_t dimCount,
                                                   intptr_t symbolCount,
                                                   intptr_t nAffineExprs,
                                                   MlirAffineExpr *affineExprs);
 
-/** Creates a single constant result affine map in the context. The affine map
- * is owned by the context. */
+/// Creates a single constant result affine map in the context. The affine map
+/// is owned by the context.
 MLIR_CAPI_EXPORTED MlirAffineMap mlirAffineMapConstantGet(MlirContext ctx,
                                                           int64_t val);
 
-/** Creates an affine map with 'numDims' identity in the context. The affine map
- * is owned by the context. */
+/// Creates an affine map with 'numDims' identity in the context. The affine map
+/// is owned by the context.
 MLIR_CAPI_EXPORTED MlirAffineMap
 mlirAffineMapMultiDimIdentityGet(MlirContext ctx, intptr_t numDims);
 
-/** Creates an identity affine map on the most minor dimensions in the context.
- * The affine map is owned by the context. The function asserts that the number
- * of dimensions is greater or equal to the number of results. */
+/// Creates an identity affine map on the most minor dimensions in the context.
+/// The affine map is owned by the context. The function asserts that the number
+/// of dimensions is greater or equal to the number of results.
 MLIR_CAPI_EXPORTED MlirAffineMap
 mlirAffineMapMinorIdentityGet(MlirContext ctx, intptr_t dims, intptr_t results);
 
-/** Creates an affine map with a permutation expression and its size in the
- * context. The permutation expression is a non-empty vector of integers.
- * The elements of the permutation vector must be continuous from 0 and cannot
- * be repeated (i.e. `[1,2,0]` is a valid permutation. `[2,0]` or `[1,1,2]` is
- * an invalid invalid permutation.) The affine map is owned by the context. */
+/// Creates an affine map with a permutation expression and its size in the
+/// context. The permutation expression is a non-empty vector of integers.
+/// The elements of the permutation vector must be continuous from 0 and cannot
+/// be repeated (i.e. `[1,2,0]` is a valid permutation. `[2,0]` or `[1,1,2]` is
+/// an invalid invalid permutation.) The affine map is owned by the context.
 MLIR_CAPI_EXPORTED MlirAffineMap mlirAffineMapPermutationGet(
     MlirContext ctx, intptr_t size, unsigned *permutation);
 
-/** Checks whether the given affine map is an identity affine map. The function
- * asserts that the number of dimensions is greater or equal to the number of
- * results. */
+/// Checks whether the given affine map is an identity affine map. The function
+/// asserts that the number of dimensions is greater or equal to the number of
+/// results.
 MLIR_CAPI_EXPORTED bool mlirAffineMapIsIdentity(MlirAffineMap affineMap);
 
 /// Checks whether the given affine map is a minor identity affine map.
 MLIR_CAPI_EXPORTED bool mlirAffineMapIsMinorIdentity(MlirAffineMap affineMap);
 
 /// Checks whether the given affine map is an empty affine map.
 MLIR_CAPI_EXPORTED bool mlirAffineMapIsEmpty(MlirAffineMap affineMap);
 
-/** Checks whether the given affine map is a single result constant affine
- * map. */
+/// Checks whether the given affine map is a single result constant affine
+/// map.
 MLIR_CAPI_EXPORTED bool mlirAffineMapIsSingleConstant(MlirAffineMap affineMap);
 
-/** Returns the constant result of the given affine map. The function asserts
- * that the map has a single constant result. */
+/// Returns the constant result of the given affine map. The function asserts
+/// that the map has a single constant result.
 MLIR_CAPI_EXPORTED int64_t
 mlirAffineMapGetSingleConstantResult(MlirAffineMap affineMap);
 
 /// Returns the number of dimensions of the given affine map.
 MLIR_CAPI_EXPORTED intptr_t mlirAffineMapGetNumDims(MlirAffineMap affineMap);
 
 /// Returns the number of symbols of the given affine map.
 MLIR_CAPI_EXPORTED intptr_t mlirAffineMapGetNumSymbols(MlirAffineMap affineMap);
 
 /// Returns the number of results of the given affine map.
 MLIR_CAPI_EXPORTED intptr_t mlirAffineMapGetNumResults(MlirAffineMap affineMap);
 
 /// Returns the result at the given position.
 MLIR_CAPI_EXPORTED MlirAffineExpr
 mlirAffineMapGetResult(MlirAffineMap affineMap, intptr_t pos);
 
-/** Returns the number of inputs (dimensions + symbols) of the given affine
- * map. */
+/// Returns the number of inputs (dimensions + symbols) of the given affine
+/// map.
 MLIR_CAPI_EXPORTED intptr_t mlirAffineMapGetNumInputs(MlirAffineMap affineMap);
 
-/** Checks whether the given affine map represents a subset of a symbol-less
- * permutation map. */
+/// Checks whether the given affine map represents a subset of a symbol-less
+/// permutation map.
 MLIR_CAPI_EXPORTED bool
 mlirAffineMapIsProjectedPermutation(MlirAffineMap affineMap);
 
-/** Checks whether the given affine map represents a symbol-less permutation
- * map. */
+/// Checks whether the given affine map represents a symbol-less permutation
+/// map.
 MLIR_CAPI_EXPORTED bool mlirAffineMapIsPermutation(MlirAffineMap affineMap);
 
 /// Returns the affine map consisting of the `resultPos` subset.
 MLIR_CAPI_EXPORTED MlirAffineMap mlirAffineMapGetSubMap(MlirAffineMap affineMap,
                                                         intptr_t size,
                                                         intptr_t *resultPos);
 
-/** Returns the affine map consisting of the most major `numResults` results.
- * Returns the null AffineMap if the `numResults` is equal to zero.
- * Returns the `affineMap` if `numResults` is greater or equals to number of
- * results of the given affine map. */
+/// Returns the affine map consisting of the most major `numResults` results.
+/// Returns the null AffineMap if the `numResults` is equal to zero.
+/// Returns the `affineMap` if `numResults` is greater or equals to number of
+/// results of the given affine map.
 MLIR_CAPI_EXPORTED MlirAffineMap
 mlirAffineMapGetMajorSubMap(MlirAffineMap affineMap, intptr_t numResults);
 
-/** Returns the affine map consisting of the most minor `numResults` results.
- * Returns the null AffineMap if the `numResults` is equal to zero.
- * Returns the `affineMap` if `numResults` is greater or equals to number of
- * results of the given affine map. */
+/// Returns the affine map consisting of the most minor `numResults` results.
+/// Returns the null AffineMap if the `numResults` is equal to zero.
+/// Returns the `affineMap` if `numResults` is greater or equals to number of
+/// results of the given affine map.
 MLIR_CAPI_EXPORTED MlirAffineMap
 mlirAffineMapGetMinorSubMap(MlirAffineMap affineMap, intptr_t numResults);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_AFFINEMAP_H

mlir/include/mlir-c/BuiltinAttributes.h

 
 //===----------------------------------------------------------------------===//
 // Affine map attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is an affine map attribute.
 MLIR_CAPI_EXPORTED bool mlirAttributeIsAAffineMap(MlirAttribute attr);
 
-/** Creates an affine map attribute wrapping the given map. The attribute
- * belongs to the same context as the affine map. */
+/// Creates an affine map attribute wrapping the given map. The attribute
+/// belongs to the same context as the affine map.
 MLIR_CAPI_EXPORTED MlirAttribute mlirAffineMapAttrGet(MlirAffineMap map);
 
 /// Returns the affine map wrapped in the given affine map attribute.
 MLIR_CAPI_EXPORTED MlirAffineMap mlirAffineMapAttrGetValue(MlirAttribute attr);
 
 //===----------------------------------------------------------------------===//
 // Array attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is an array attribute.
 MLIR_CAPI_EXPORTED bool mlirAttributeIsAArray(MlirAttribute attr);
 
-/** Creates an array element containing the given list of elements in the given
- * context. */
+/// Creates an array element containing the given list of elements in the given
+/// context.
 MLIR_CAPI_EXPORTED MlirAttribute mlirArrayAttrGet(
     MlirContext ctx, intptr_t numElements, MlirAttribute const *elements);
 
 /// Returns the number of elements stored in the given array attribute.
 MLIR_CAPI_EXPORTED intptr_t mlirArrayAttrGetNumElements(MlirAttribute attr);
 
 /// Returns pos-th element stored in the given array attribute.
 MLIR_CAPI_EXPORTED MlirAttribute mlirArrayAttrGetElement(MlirAttribute attr,
                                                          intptr_t pos);
 
 //===----------------------------------------------------------------------===//
 // Dictionary attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is a dictionary attribute.
 MLIR_CAPI_EXPORTED bool mlirAttributeIsADictionary(MlirAttribute attr);
 
-/** Creates a dictionary attribute containing the given list of elements in the
- * provided context. */
+/// Creates a dictionary attribute containing the given list of elements in the
+/// provided context.
 MLIR_CAPI_EXPORTED MlirAttribute mlirDictionaryAttrGet(
     MlirContext ctx, intptr_t numElements, MlirNamedAttribute const *elements);
 
 /// Returns the number of attributes contained in a dictionary attribute.
 MLIR_CAPI_EXPORTED intptr_t
 mlirDictionaryAttrGetNumElements(MlirAttribute attr);
 
 /// Returns pos-th element of the given dictionary attribute.
 MLIR_CAPI_EXPORTED 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. */
+/// Returns the dictionary attribute element with the given name or NULL if the
+/// given name does not exist in the dictionary.
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDictionaryAttrGetElementByName(MlirAttribute attr, MlirStringRef name);
 
 //===----------------------------------------------------------------------===//
 // Floating point attribute.
 //===----------------------------------------------------------------------===//
 
-/* TODO: add support for APFloat and APInt to LLVM IR C API, then expose the
- * relevant functions here. */
+// 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.
 MLIR_CAPI_EXPORTED bool mlirAttributeIsAFloat(MlirAttribute attr);
 
-/** Creates a floating point attribute in the given context with the given
- * double value and double-precision FP semantics. */
+/// Creates a floating point attribute in the given context with the given
+/// double value and double-precision FP semantics.
 MLIR_CAPI_EXPORTED MlirAttribute mlirFloatAttrDoubleGet(MlirContext ctx,
                                                         MlirType type,
                                                         double value);
 
-/** Same as "mlirFloatAttrDoubleGet", but if the type is not valid for a
- * construction of a FloatAttr, returns a null MlirAttribute. */
+/// Same as "mlirFloatAttrDoubleGet", but if the type is not valid for a
+/// construction of a FloatAttr, returns a null MlirAttribute.
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirFloatAttrDoubleGetChecked(MlirType type, double value, MlirLocation loc);
 
-/** Returns the value stored in the given floating point attribute, interpreting
- * the value as double. */
+/// Returns the value stored in the given floating point attribute, interpreting
+/// the value as double.
 MLIR_CAPI_EXPORTED double mlirFloatAttrGetValueDouble(MlirAttribute attr);
 
 //===----------------------------------------------------------------------===//
 // Integer attribute.
 //===----------------------------------------------------------------------===//
 
-/* TODO: add support for APFloat and APInt to LLVM IR C API, then expose the
- * relevant functions here. */
+// 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.
 MLIR_CAPI_EXPORTED bool mlirAttributeIsAInteger(MlirAttribute attr);
 
-/** Creates an integer attribute of the given type with the given integer
- * value. */
+/// Creates an integer attribute of the given type with the given integer
+/// value.
 MLIR_CAPI_EXPORTED 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. */
+/// Returns the value stored in the given integer attribute, assuming the value
+/// fits into a 64-bit integer.
 MLIR_CAPI_EXPORTED int64_t mlirIntegerAttrGetValueInt(MlirAttribute attr);
 
 //===----------------------------------------------------------------------===//
 // Bool attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is a bool attribute.
 MLIR_CAPI_EXPORTED bool mlirAttributeIsABool(MlirAttribute attr);

 
 //===----------------------------------------------------------------------===//
 // Opaque attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is an opaque attribute.
 MLIR_CAPI_EXPORTED bool 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). */
+/// 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).
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirOpaqueAttrGet(MlirContext ctx, MlirStringRef dialectNamespace,
                   intptr_t dataLength, const char *data, MlirType type);
 
-/** Returns the namespace of the dialect with which the given opaque attribute
- * is associated. The namespace string is owned by the context. */
+/// Returns the namespace of the dialect with which the given opaque attribute
+/// is associated. The namespace string is owned by the context.
 MLIR_CAPI_EXPORTED MlirStringRef
 mlirOpaqueAttrGetDialectNamespace(MlirAttribute attr);
 
-/** Returns the raw data as a string reference. The data remains live as long as
- * the context in which the attribute lives. */
+/// Returns the raw data as a string reference. The data remains live as long as
+/// the context in which the attribute lives.
 MLIR_CAPI_EXPORTED MlirStringRef mlirOpaqueAttrGetData(MlirAttribute attr);
 
 //===----------------------------------------------------------------------===//
 // String attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is a string attribute.
 MLIR_CAPI_EXPORTED bool mlirAttributeIsAString(MlirAttribute attr);
 
-/** Creates a string attribute in the given context containing the given string.
- */
+/// Creates a string attribute in the given context containing the given string.
+
 MLIR_CAPI_EXPORTED MlirAttribute mlirStringAttrGet(MlirContext ctx,
                                                    MlirStringRef str);
 
-/** Creates a string attribute in the given context containing the given string.
- * Additionally, the attribute has the given type. */
+/// Creates a string attribute in the given context containing the given string.
+/// Additionally, the attribute has the given type.
 MLIR_CAPI_EXPORTED MlirAttribute mlirStringAttrTypedGet(MlirType type,
                                                         MlirStringRef str);
 
-/** Returns the attribute values as a string reference. The data remains live as
- * long as the context in which the attribute lives. */
+/// Returns the attribute values as a string reference. The data remains live as
+/// long as the context in which the attribute lives.
 MLIR_CAPI_EXPORTED MlirStringRef mlirStringAttrGetValue(MlirAttribute attr);
 
 //===----------------------------------------------------------------------===//
 // SymbolRef attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is a symbol reference attribute.
 MLIR_CAPI_EXPORTED bool 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. */
+/// 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.
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirSymbolRefAttrGet(MlirContext ctx, MlirStringRef symbol,
                      intptr_t numReferences, MlirAttribute const *references);
 
-/** Returns the string reference to the root referenced symbol. The data remains
- * live as long as the context in which the attribute lives. */
+/// Returns the string reference to the root referenced symbol. The data remains
+/// live as long as the context in which the attribute lives.
 MLIR_CAPI_EXPORTED MlirStringRef
 mlirSymbolRefAttrGetRootReference(MlirAttribute attr);
 
-/** Returns the string reference to the leaf referenced symbol. The data remains
- * live as long as the context in which the attribute lives. */
+/// Returns the string reference to the leaf referenced symbol. The data remains
+/// live as long as the context in which the attribute lives.
 MLIR_CAPI_EXPORTED MlirStringRef
 mlirSymbolRefAttrGetLeafReference(MlirAttribute attr);
 
-/** Returns the number of references nested in the given symbol reference
- * attribute. */
+/// Returns the number of references nested in the given symbol reference
+/// attribute.
 MLIR_CAPI_EXPORTED intptr_t
 mlirSymbolRefAttrGetNumNestedReferences(MlirAttribute attr);
 
 /// Returns pos-th reference nested in the given symbol reference attribute.
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirSymbolRefAttrGetNestedReference(MlirAttribute attr, intptr_t pos);
 
 //===----------------------------------------------------------------------===//
 // Flat SymbolRef attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is a flat symbol reference attribute.
 MLIR_CAPI_EXPORTED bool mlirAttributeIsAFlatSymbolRef(MlirAttribute attr);
 
-/** Creates a flat symbol reference attribute in the given context referencing a
- * symbol identified by the given string. */
+/// Creates a flat symbol reference attribute in the given context referencing a
+/// symbol identified by the given string.
 MLIR_CAPI_EXPORTED MlirAttribute mlirFlatSymbolRefAttrGet(MlirContext ctx,
                                                           MlirStringRef symbol);
 
-/** Returns the referenced symbol as a string reference. The data remains live
- * as long as the context in which the attribute lives. */
+/// Returns the referenced symbol as a string reference. The data remains live
+/// as long as the context in which the attribute lives.
 MLIR_CAPI_EXPORTED MlirStringRef
 mlirFlatSymbolRefAttrGetValue(MlirAttribute attr);
 
 //===----------------------------------------------------------------------===//
 // Type attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is a type attribute.
 MLIR_CAPI_EXPORTED bool mlirAttributeIsAType(MlirAttribute attr);
 
-/** Creates a type attribute wrapping the given type in the same context as the
- * type. */
+/// Creates a type attribute wrapping the given type in the same context as the
+/// type.
 MLIR_CAPI_EXPORTED MlirAttribute mlirTypeAttrGet(MlirType type);
 
 /// Returns the type stored in the given type attribute.
 MLIR_CAPI_EXPORTED MlirType mlirTypeAttrGetValue(MlirAttribute attr);
 
 //===----------------------------------------------------------------------===//
 // Unit attribute.
 //===----------------------------------------------------------------------===//

 /// Checks whether the given attribute is an elements attribute.
 MLIR_CAPI_EXPORTED bool mlirAttributeIsAElements(MlirAttribute attr);
 
 /// Returns the element at the given rank-dimensional index.
 MLIR_CAPI_EXPORTED MlirAttribute mlirElementsAttrGetValue(MlirAttribute attr,
                                                           intptr_t rank,
                                                           uint64_t *idxs);
 
-/** Checks whether the given rank-dimensional index is valid in the given
- * elements attribute. */
+/// Checks whether the given rank-dimensional index is valid in the given
+/// elements attribute.
 MLIR_CAPI_EXPORTED bool
 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. */
+/// 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.
 MLIR_CAPI_EXPORTED 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. */
+// 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.
 MLIR_CAPI_EXPORTED bool mlirAttributeIsADenseElements(MlirAttribute attr);
 MLIR_CAPI_EXPORTED bool mlirAttributeIsADenseIntElements(MlirAttribute attr);
 MLIR_CAPI_EXPORTED bool mlirAttributeIsADenseFPElements(MlirAttribute attr);
 
-/** Creates a dense elements attribute with the given Shaped type and elements
- * in the same context as the type. */
+/// Creates a dense elements attribute with the given Shaped type and elements
+/// in the same context as the type.
 MLIR_CAPI_EXPORTED MlirAttribute mlirDenseElementsAttrGet(
     MlirType shapedType, intptr_t numElements, MlirAttribute const *elements);
 
-/** Creates a dense elements attribute with the given Shaped type containing a
- * single replicated element (splat). */
+/// 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
 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. */
+/// 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 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 MlirAttribute mlirDenseElementsAttrFloatGet(
     MlirType shapedType, intptr_t numElements, const float *elements);
 MLIR_CAPI_EXPORTED MlirAttribute mlirDenseElementsAttrDoubleGet(
     MlirType shapedType, intptr_t numElements, const double *elements);
 
-/** Creates a dense elements attribute with the given shaped type from string
- * elements. */
+/// Creates a dense elements attribute with the given shaped type from string
+/// elements.
 MLIR_CAPI_EXPORTED MlirAttribute mlirDenseElementsAttrStringGet(
     MlirType shapedType, intptr_t numElements, MlirStringRef *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. */
+/// 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.
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrReshapeGet(MlirAttribute attr, MlirType shapedType);
 
-/** Checks whether the given dense elements attribute contains a single
- * replicated value (splat). */
+/// Checks whether the given dense elements attribute contains a single
+/// replicated value (splat).
 MLIR_CAPI_EXPORTED bool mlirDenseElementsAttrIsSplat(MlirAttribute attr);
 
-/** Returns the single replicated value (splat) of a specific type contained by
- * the given dense elements attribute. */
+/// 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 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. */
+/// 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 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_CAPI_EXPORTED float mlirDenseElementsAttrGetFloatValue(MlirAttribute attr,
                                                             intptr_t pos);
 MLIR_CAPI_EXPORTED double
 mlirDenseElementsAttrGetDoubleValue(MlirAttribute attr, intptr_t pos);
 MLIR_CAPI_EXPORTED MlirStringRef
 mlirDenseElementsAttrGetStringValue(MlirAttribute attr, intptr_t pos);
 
-/** Returns the raw data of the given dense elements attribute. */
+/// Returns the raw data of the given dense elements attribute.
 MLIR_CAPI_EXPORTED const void *
 mlirDenseElementsAttrGetRawData(MlirAttribute attr);
 
 //===----------------------------------------------------------------------===//
 // Opaque elements attribute.
 //===----------------------------------------------------------------------===//
 
 // TODO: expose Dialect to the bindings and implement accessors here.
 
 /// Checks whether the given attribute is an opaque elements attribute.
 MLIR_CAPI_EXPORTED bool mlirAttributeIsAOpaqueElements(MlirAttribute attr);
 
 //===----------------------------------------------------------------------===//
 // Sparse elements attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is a sparse elements attribute.
 MLIR_CAPI_EXPORTED bool 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. */
+/// 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.
 MLIR_CAPI_EXPORTED 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. */
+/// Returns the dense elements attribute containing 64-bit integer indices of
+/// non-null elements in the given sparse elements attribute.
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirSparseElementsAttrGetIndices(MlirAttribute attr);
 
-/** Returns the dense elements attribute containing the non-null elements in the
- * given sparse elements attribute. */
+/// Returns the dense elements attribute containing the non-null elements in the
+/// given sparse elements attribute.
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirSparseElementsAttrGetValues(MlirAttribute attr);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_BUILTINATTRIBUTES_H

mlir/include/mlir-c/BuiltinTypes.h

 
 //===----------------------------------------------------------------------===//
 // Integer types.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is an integer type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsAInteger(MlirType type);
 
-/** Creates a signless integer type of the given bitwidth in the context. The
- * type is owned by the context. */
+/// Creates a signless integer type of the given bitwidth in the context. The
+/// type is owned by the context.
 MLIR_CAPI_EXPORTED MlirType mlirIntegerTypeGet(MlirContext ctx,
                                                unsigned bitwidth);
 
-/** Creates a signed integer type of the given bitwidth in the context. The type
- * is owned by the context. */
+/// Creates a signed integer type of the given bitwidth in the context. The type
+/// is owned by the context.
 MLIR_CAPI_EXPORTED MlirType mlirIntegerTypeSignedGet(MlirContext ctx,
                                                      unsigned bitwidth);
 
-/** Creates an unsigned integer type of the given bitwidth in the context. The
- * type is owned by the context. */
+/// Creates an unsigned integer type of the given bitwidth in the context. The
+/// type is owned by the context.
 MLIR_CAPI_EXPORTED MlirType mlirIntegerTypeUnsignedGet(MlirContext ctx,
                                                        unsigned bitwidth);
 
 /// Returns the bitwidth of an integer type.
 MLIR_CAPI_EXPORTED unsigned mlirIntegerTypeGetWidth(MlirType type);
 
 /// Checks whether the given integer type is signless.
 MLIR_CAPI_EXPORTED bool mlirIntegerTypeIsSignless(MlirType type);
 
 /// Checks whether the given integer type is signed.
 MLIR_CAPI_EXPORTED bool mlirIntegerTypeIsSigned(MlirType type);
 
 /// Checks whether the given integer type is unsigned.
 MLIR_CAPI_EXPORTED bool mlirIntegerTypeIsUnsigned(MlirType type);
 
 //===----------------------------------------------------------------------===//
 // Index type.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is an index type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsAIndex(MlirType type);
 
-/** Creates an index type in the given context. The type is owned by the
- * context. */
+/// Creates an index type in the given context. The type is owned by the
+/// context.
 MLIR_CAPI_EXPORTED MlirType mlirIndexTypeGet(MlirContext ctx);
 
 //===----------------------------------------------------------------------===//
 // Floating-point types.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is a bf16 type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsABF16(MlirType type);
 
-/** Creates a bf16 type in the given context. The type is owned by the
- * context. */
+/// Creates a bf16 type in the given context. The type is owned by the
+/// context.
 MLIR_CAPI_EXPORTED MlirType mlirBF16TypeGet(MlirContext ctx);
 
 /// Checks whether the given type is an f16 type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsAF16(MlirType type);
 
-/** Creates an f16 type in the given context. The type is owned by the
- * context. */
+/// Creates an f16 type in the given context. The type is owned by the
+/// context.
 MLIR_CAPI_EXPORTED MlirType mlirF16TypeGet(MlirContext ctx);
 
 /// Checks whether the given type is an f32 type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsAF32(MlirType type);
 
-/** Creates an f32 type in the given context. The type is owned by the
- * context. */
+/// Creates an f32 type in the given context. The type is owned by the
+/// context.
 MLIR_CAPI_EXPORTED MlirType mlirF32TypeGet(MlirContext ctx);
 
 /// Checks whether the given type is an f64 type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsAF64(MlirType type);
 
-/** Creates a f64 type in the given context. The type is owned by the
- * context. */
+/// Creates a f64 type in the given context. The type is owned by the
+/// context.
 MLIR_CAPI_EXPORTED MlirType mlirF64TypeGet(MlirContext ctx);
 
 //===----------------------------------------------------------------------===//
 // None type.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is a None type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsANone(MlirType type);
 
-/** Creates a None type in the given context. The type is owned by the
- * context. */
+/// Creates a None type in the given context. The type is owned by the
+/// context.
 MLIR_CAPI_EXPORTED MlirType mlirNoneTypeGet(MlirContext ctx);
 
 //===----------------------------------------------------------------------===//
 // Complex type.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is a Complex type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsAComplex(MlirType type);
 
-/** Creates a complex type with the given element type in the same context as
- * the element type. The type is owned by the context. */
+/// Creates a complex type with the given element type in the same context as
+/// the element type. The type is owned by the context.
 MLIR_CAPI_EXPORTED MlirType mlirComplexTypeGet(MlirType elementType);
 
 /// Returns the element type of the given complex type.
 MLIR_CAPI_EXPORTED MlirType mlirComplexTypeGetElementType(MlirType type);
 
 //===----------------------------------------------------------------------===//
 // Shaped type.
 //===----------------------------------------------------------------------===//

 
 /// Checks wither the dim-th dimension of the given shaped type is dynamic.
 MLIR_CAPI_EXPORTED bool mlirShapedTypeIsDynamicDim(MlirType type, intptr_t dim);
 
 /// Returns the dim-th dimension of the given ranked shaped type.
 MLIR_CAPI_EXPORTED int64_t mlirShapedTypeGetDimSize(MlirType type,
                                                     intptr_t dim);
 
-/** Checks whether the given value is used as a placeholder for dynamic sizes
- * in shaped types. */
+/// Checks whether the given value is used as a placeholder for dynamic sizes
+/// in shaped types.
 MLIR_CAPI_EXPORTED bool mlirShapedTypeIsDynamicSize(int64_t size);
 
-/** Checks whether the given value is used as a placeholder for dynamic strides
- * and offsets in shaped types. */
+/// Checks whether the given value is used as a placeholder for dynamic strides
+/// and offsets in shaped types.
 MLIR_CAPI_EXPORTED bool mlirShapedTypeIsDynamicStrideOrOffset(int64_t val);
 
 //===----------------------------------------------------------------------===//
 // Vector type.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is a Vector type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsAVector(MlirType type);
 
-/** Creates a vector type of the shape identified by its rank and dimensions,
- * with the given element type in the same context as the element type. The type
- * is owned by the context. */
+/// Creates a vector type of the shape identified by its rank and dimensions,
+/// with the given element type in the same context as the element type. The
+/// type is owned by the context.
 MLIR_CAPI_EXPORTED MlirType mlirVectorTypeGet(intptr_t rank,
                                               const int64_t *shape,
                                               MlirType elementType);
 
-/** Same as "mlirVectorTypeGet" but returns a nullptr wrapping MlirType on
- * illegal arguments, emitting appropriate diagnostics. */
+/// Same as "mlirVectorTypeGet" but returns a nullptr wrapping MlirType on
+/// illegal arguments, emitting appropriate diagnostics.
 MLIR_CAPI_EXPORTED MlirType mlirVectorTypeGetChecked(intptr_t rank,
                                                      const int64_t *shape,
                                                      MlirType elementType,
                                                      MlirLocation loc);
 
 //===----------------------------------------------------------------------===//
 // Ranked / Unranked Tensor type.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is a Tensor type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsATensor(MlirType type);
 
 /// Checks whether the given type is a ranked tensor type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsARankedTensor(MlirType type);
 
 /// Checks whether the given type is an unranked tensor type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsAUnrankedTensor(MlirType type);
 
-/** Creates a tensor type of a fixed rank with the given shape and element type
- * in the same context as the element type. The type is owned by the context. */
+/// Creates a tensor type of a fixed rank with the given shape and element type
+/// in the same context as the element type. The type is owned by the context.
 MLIR_CAPI_EXPORTED MlirType mlirRankedTensorTypeGet(intptr_t rank,
                                                     const int64_t *shape,
                                                     MlirType elementType);
 
-/** Same as "mlirRankedTensorTypeGet" but returns a nullptr wrapping MlirType on
- * illegal arguments, emitting appropriate diagnostics. */
+/// Same as "mlirRankedTensorTypeGet" but returns a nullptr wrapping MlirType on
+/// illegal arguments, emitting appropriate diagnostics.
 MLIR_CAPI_EXPORTED MlirType mlirRankedTensorTypeGetChecked(intptr_t rank,
                                                            const int64_t *shape,
                                                            MlirType elementType,
                                                            MlirLocation loc);
 
-/** Creates an unranked tensor type with the given element type in the same
- * context as the element type. The type is owned by the context. */
+/// Creates an unranked tensor type with the given element type in the same
+/// context as the element type. The type is owned by the context.
 MLIR_CAPI_EXPORTED MlirType mlirUnrankedTensorTypeGet(MlirType elementType);
 
-/** Same as "mlirUnrankedTensorTypeGet" but returns a nullptr wrapping MlirType
- * on illegal arguments, emitting appropriate diagnostics. */
+/// Same as "mlirUnrankedTensorTypeGet" but returns a nullptr wrapping MlirType
+/// on illegal arguments, emitting appropriate diagnostics.
 MLIR_CAPI_EXPORTED MlirType
 mlirUnrankedTensorTypeGetChecked(MlirType elementType, MlirLocation loc);
 
 //===----------------------------------------------------------------------===//
 // Ranked / Unranked MemRef type.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is a MemRef type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsAMemRef(MlirType type);
 
 /// Checks whether the given type is an UnrankedMemRef type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsAUnrankedMemRef(MlirType type);
 
-/** Creates a MemRef type with the given rank and shape, a potentially empty
- * list of affine layout maps, the given memory space and element type, in the
- * same context as element type. The type is owned by the context. */
+/// Creates a MemRef type with the given rank and shape, a potentially empty
+/// list of affine layout maps, the given memory space and element type, in the
+/// same context as element type. The type is owned by the context.
 MLIR_CAPI_EXPORTED MlirType mlirMemRefTypeGet(
     MlirType elementType, intptr_t rank, const int64_t *shape, intptr_t numMaps,
     MlirAffineMap const *affineMaps, unsigned memorySpace);
 
-/** Same as "mlirMemRefTypeGet" but returns a nullptr-wrapping MlirType o
- * illegal arguments, emitting appropriate diagnostics. */
+/// Same as "mlirMemRefTypeGet" but returns a nullptr-wrapping MlirType o
+/// illegal arguments, emitting appropriate diagnostics.
 MLIR_CAPI_EXPORTED MlirType mlirMemRefTypeGetChecked(
     MlirType elementType, intptr_t rank, const int64_t *shape, intptr_t numMaps,
     MlirAffineMap const *affineMaps, unsigned memorySpace, MlirLocation loc);
 
-/** Creates a MemRef type with the given rank, shape, memory space and element
- * type in the same context as the element type. The type has no affine maps,
- * i.e. represents a default row-major contiguous memref. The type is owned by
- * the context. */
+/// Creates a MemRef type with the given rank, shape, memory space and element
+/// type in the same context as the element type. The type has no affine maps,
+/// i.e. represents a default row-major contiguous memref. The type is owned by
+/// the context.
 MLIR_CAPI_EXPORTED MlirType mlirMemRefTypeContiguousGet(MlirType elementType,
                                                         intptr_t rank,
                                                         const int64_t *shape,
                                                         unsigned memorySpace);
 
-/** Same as "mlirMemRefTypeContiguousGet" but returns a nullptr wrapping
- * MlirType on illegal arguments, emitting appropriate diagnostics. */
+/// Same as "mlirMemRefTypeContiguousGet" but returns a nullptr wrapping
+/// MlirType on illegal arguments, emitting appropriate diagnostics.
 MLIR_CAPI_EXPORTED MlirType mlirMemRefTypeContiguousGetChecked(
     MlirType elementType, intptr_t rank, const int64_t *shape,
     unsigned memorySpace, MlirLocation loc);
 
-/** Creates an Unranked MemRef type with the given element type and in the given
- * memory space. The type is owned by the context of element type. */
+/// Creates an Unranked MemRef type with the given element type and in the given
+/// memory space. The type is owned by the context of element type.
 MLIR_CAPI_EXPORTED MlirType mlirUnrankedMemRefTypeGet(MlirType elementType,
                                                       unsigned memorySpace);
 
-/** Same as "mlirUnrankedMemRefTypeGet" but returns a nullptr wrapping
- * MlirType on illegal arguments, emitting appropriate diagnostics. */
+/// Same as "mlirUnrankedMemRefTypeGet" but returns a nullptr wrapping
+/// MlirType on illegal arguments, emitting appropriate diagnostics.
 MLIR_CAPI_EXPORTED MlirType mlirUnrankedMemRefTypeGetChecked(
     MlirType elementType, unsigned memorySpace, MlirLocation loc);
 
 /// Returns the number of affine layout maps in the given MemRef type.
 MLIR_CAPI_EXPORTED intptr_t mlirMemRefTypeGetNumAffineMaps(MlirType type);
 
 /// Returns the pos-th affine map of the given MemRef type.
 MLIR_CAPI_EXPORTED MlirAffineMap mlirMemRefTypeGetAffineMap(MlirType type,
                                                             intptr_t pos);
 
 /// Returns the memory space of the given MemRef type.
 MLIR_CAPI_EXPORTED unsigned mlirMemRefTypeGetMemorySpace(MlirType type);
 
 /// Returns the memory spcae of the given Unranked MemRef type.
 MLIR_CAPI_EXPORTED unsigned mlirUnrankedMemrefGetMemorySpace(MlirType type);
 
 //===----------------------------------------------------------------------===//
 // Tuple type.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is a tuple type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsATuple(MlirType type);
 
-/** Creates a tuple type that consists of the given list of elemental types. The
- * type is owned by the context. */
+/// Creates a tuple type that consists of the given list of elemental types. The
+/// type is owned by the context.
 MLIR_CAPI_EXPORTED MlirType mlirTupleTypeGet(MlirContext ctx,
                                              intptr_t numElements,
                                              MlirType const *elements);
 
 /// Returns the number of types contained in a tuple.
 MLIR_CAPI_EXPORTED intptr_t mlirTupleTypeGetNumTypes(MlirType type);
 
 /// Returns the pos-th type in the tuple type.

mlir/include/mlir-c/Diagnostics.h

 
 #include "mlir-c/IR.h"
 #include "mlir-c/Support.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/** An opaque reference to a diagnostic, always owned by the diagnostics engine
- * (context). Must not be stored outside of the diagnostic handler. */
+/// An opaque reference to a diagnostic, always owned by the diagnostics engine
+/// (context). Must not be stored outside of the diagnostic handler.
 struct MlirDiagnostic {
   void *ptr;
 };
 typedef struct MlirDiagnostic MlirDiagnostic;
 
 /// Severity of a diagnostic.
 enum MlirDiagnosticSeverity {
   MlirDiagnosticError,
   MlirDiagnosticWarning,
   MlirDiagnosticNote,
   MlirDiagnosticRemark
 };
 typedef enum MlirDiagnosticSeverity MlirDiagnosticSeverity;
 
 /// Opaque identifier of a diagnostic handler, useful to detach a handler.
 typedef uint64_t MlirDiagnosticHandlerID;
 
-/** Diagnostic handler type. Accepts a reference to a diagnostic, which is only
- * guaranteed to be live during the call. The handler is passed the `userData`
- * that was provided when the handler was attached to a context. If the handler
- * processed the diagnostic completely, it is expected to return success.
- * Otherwise, it is expected to return failure to indicate that other handlers
- * should attempt to process the diagnostic. */
+/// Diagnostic handler type. Accepts a reference to a diagnostic, which is only
+/// guaranteed to be live during the call. The handler is passed the `userData`
+/// that was provided when the handler was attached to a context. If the handler
+/// processed the diagnostic completely, it is expected to return success.
+/// Otherwise, it is expected to return failure to indicate that other handlers
+/// should attempt to process the diagnostic.
 typedef MlirLogicalResult (*MlirDiagnosticHandler)(MlirDiagnostic,
                                                    void *userData);
 
 /// Prints a diagnostic using the provided callback.
 MLIR_CAPI_EXPORTED void mlirDiagnosticPrint(MlirDiagnostic diagnostic,
                                             MlirStringCallback callback,
                                             void *userData);
 
 /// Returns the location at which the diagnostic is reported.
 MLIR_CAPI_EXPORTED MlirLocation
 mlirDiagnosticGetLocation(MlirDiagnostic diagnostic);
 
 /// Returns the severity of the diagnostic.
 MLIR_CAPI_EXPORTED MlirDiagnosticSeverity
 mlirDiagnosticGetSeverity(MlirDiagnostic diagnostic);
 
 /// Returns the number of notes attached to the diagnostic.
 MLIR_CAPI_EXPORTED intptr_t
 mlirDiagnosticGetNumNotes(MlirDiagnostic diagnostic);
 
-/** Returns `pos`-th note attached to the diagnostic. Expects `pos` to be a
- * valid zero-based index into the list of notes. */
+/// Returns `pos`-th note attached to the diagnostic. Expects `pos` to be a
+/// valid zero-based index into the list of notes.
 MLIR_CAPI_EXPORTED MlirDiagnostic
 mlirDiagnosticGetNote(MlirDiagnostic diagnostic, intptr_t pos);
 
-/** Attaches the diagnostic handler to the context. Handlers are invoked in the
- * reverse order of attachment until one of them processes the diagnostic
- * completely. When a handler is invoked it is passed the `userData` that was
- * provided when it was attached. If non-NULL, `deleteUserData` is called once
- * the system no longer needs to call the handler (for instance after the
- * handler is detached or the context is destroyed). Returns an identifier that
- * can be used to detach the handler.
- */
+/// Attaches the diagnostic handler to the context. Handlers are invoked in the
+/// reverse order of attachment until one of them processes the diagnostic
+/// completely. When a handler is invoked it is passed the `userData` that was
+/// provided when it was attached. If non-NULL, `deleteUserData` is called once
+/// the system no longer needs to call the handler (for instance after the
+/// handler is detached or the context is destroyed). Returns an identifier that
+/// can be used to detach the handler.
+
 MLIR_CAPI_EXPORTED MlirDiagnosticHandlerID mlirContextAttachDiagnosticHandler(
     MlirContext context, MlirDiagnosticHandler handler, void *userData,
     void (*deleteUserData)(void *));
 
-/** Detaches an attached diagnostic handler from the context given its
- * identifier. */
+/// Detaches an attached diagnostic handler from the context given its
+/// identifier.
 MLIR_CAPI_EXPORTED void
 mlirContextDetachDiagnosticHandler(MlirContext context,
                                    MlirDiagnosticHandlerID id);
 
-/** Emits an error at the given location through the diagnostics engine. Used
- * for testing purposes. */
+/// Emits an error at the given location through the diagnostics engine. Used
+/// for testing purposes.
 MLIR_CAPI_EXPORTED void mlirEmitError(MlirLocation location,
                                       const char *message);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_DIAGNOSTICS_H

mlir/include/mlir-c/IR.h

 
 #include "mlir-c/Support.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 //===----------------------------------------------------------------------===//
-/** Opaque type declarations.
- *
- * Types are exposed to C bindings as structs containing opaque pointers. They
- * are not supposed to be inspected from C. This allows the underlying
- * representation to change without affecting the API users. The use of structs
- * instead of typedefs enables some type safety as structs are not implicitly
- * convertible to each other.
- *
- * Instances of these types may or may not own the underlying object (most often
- * only point to an IR fragment without owning it). The ownership semantics is
- * defined by how an instance of the type was obtained.
- */
+/// Opaque type declarations.
+///
+/// Types are exposed to C bindings as structs containing opaque pointers. They
+/// are not supposed to be inspected from C. This allows the underlying
+/// representation to change without affecting the API users. The use of structs
+/// instead of typedefs enables some type safety as structs are not implicitly
+/// convertible to each other.
+///
+/// Instances of these types may or may not own the underlying object (most
+/// often only point to an IR fragment without owning it). The ownership
+/// semantics is defined by how an instance of the type was obtained.
+
 //===----------------------------------------------------------------------===//
 
 #define DEFINE_C_API_STRUCT(name, storage)                                     \
   struct name {                                                                \
     storage *ptr;                                                              \
   };                                                                           \
   typedef struct name name
 
 DEFINE_C_API_STRUCT(MlirContext, void);
 DEFINE_C_API_STRUCT(MlirDialect, void);
 DEFINE_C_API_STRUCT(MlirOperation, void);
 DEFINE_C_API_STRUCT(MlirOpPrintingFlags, void);
 DEFINE_C_API_STRUCT(MlirBlock, void);
 DEFINE_C_API_STRUCT(MlirRegion, void);
 
 DEFINE_C_API_STRUCT(MlirAttribute, const void);
 DEFINE_C_API_STRUCT(MlirIdentifier, const void);
 DEFINE_C_API_STRUCT(MlirLocation, const void);
 DEFINE_C_API_STRUCT(MlirModule, const void);
 DEFINE_C_API_STRUCT(MlirType, const void);
 DEFINE_C_API_STRUCT(MlirValue, const void);
 
 #undef DEFINE_C_API_STRUCT
 
-/** Named MLIR attribute.
- *
- * A named attribute is essentially a (name, attribute) pair where the name is
- * a string.
- */
+/// Named MLIR attribute.
+///
+/// A named attribute is essentially a (name, attribute) pair where the name is
+/// a string.
+
 struct MlirNamedAttribute {
   MlirIdentifier name;
   MlirAttribute attribute;
 };
 typedef struct MlirNamedAttribute MlirNamedAttribute;
 
 //===----------------------------------------------------------------------===//
 // Context API.

 /// Sets whether unregistered dialects are allowed in this context.
 MLIR_CAPI_EXPORTED void
 mlirContextSetAllowUnregisteredDialects(MlirContext context, bool allow);
 
 /// Returns whether the context allows unregistered dialects.
 MLIR_CAPI_EXPORTED bool
 mlirContextGetAllowUnregisteredDialects(MlirContext context);
 
-/** Returns the number of dialects registered with the given context. A
- * registered dialect will be loaded if needed by the parser. */
+/// Returns the number of dialects registered with the given context. A
+/// registered dialect will be loaded if needed by the parser.
 MLIR_CAPI_EXPORTED intptr_t
 mlirContextGetNumRegisteredDialects(MlirContext context);
 
-/** Returns the number of dialects loaded by the context.
- */
+/// Returns the number of dialects loaded by the context.
+
 MLIR_CAPI_EXPORTED intptr_t
 mlirContextGetNumLoadedDialects(MlirContext context);
 
-/** Gets the dialect instance owned by the given context using the dialect
- * namespace to identify it, loads (i.e., constructs the instance of) the
- * dialect if necessary. If the dialect is not registered with the context,
- * returns null. Use mlirContextLoad<Name>Dialect to load an unregistered
- * dialect. */
+/// Gets the dialect instance owned by the given context using the dialect
+/// namespace to identify it, loads (i.e., constructs the instance of) the
+/// dialect if necessary. If the dialect is not registered with the context,
+/// returns null. Use mlirContextLoad<Name>Dialect to load an unregistered
+/// dialect.
 MLIR_CAPI_EXPORTED MlirDialect mlirContextGetOrLoadDialect(MlirContext context,
                                                            MlirStringRef name);
 
 //===----------------------------------------------------------------------===//
 // Dialect API.
 //===----------------------------------------------------------------------===//
 
 /// Returns the context that owns the dialect.
 MLIR_CAPI_EXPORTED MlirContext mlirDialectGetContext(MlirDialect dialect);
 
 /// Checks if the dialect is null.
 static inline bool mlirDialectIsNull(MlirDialect dialect) {
   return !dialect.ptr;
 }
 
-/** Checks if two dialects that belong to the same context are equal. Dialects
- * from different contexts will not compare equal. */
+/// Checks if two dialects that belong to the same context are equal. Dialects
+/// from different contexts will not compare equal.
 MLIR_CAPI_EXPORTED bool mlirDialectEqual(MlirDialect dialect1,
                                          MlirDialect dialect2);
 
 /// Returns the namespace of the given dialect.
 MLIR_CAPI_EXPORTED MlirStringRef mlirDialectGetNamespace(MlirDialect dialect);
 
 //===----------------------------------------------------------------------===//
 // Location API.

 /// Checks if the location is null.
 static inline bool mlirLocationIsNull(MlirLocation location) {
   return !location.ptr;
 }
 
 /// Checks if two locations are equal.
 MLIR_CAPI_EXPORTED bool mlirLocationEqual(MlirLocation l1, MlirLocation l2);
 
-/** 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. */
+/// 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.
 MLIR_CAPI_EXPORTED void mlirLocationPrint(MlirLocation location,
                                           MlirStringCallback callback,
                                           void *userData);
 
 //===----------------------------------------------------------------------===//
 // Module API.
 //===----------------------------------------------------------------------===//
 

 
 /// Views the module as a generic operation.
 MLIR_CAPI_EXPORTED MlirOperation mlirModuleGetOperation(MlirModule module);
 
 //===----------------------------------------------------------------------===//
 // Operation state.
 //===----------------------------------------------------------------------===//
 
-/** An auxiliary class for constructing operations.
- *
- * This class contains all the information necessary to construct the operation.
- * It owns the MlirRegions it has pointers to and does not own anything else.
- * By default, the state can be constructed from a name and location, the latter
- * being also used to access the context, and has no other components. These
- * components can be added progressively until the operation is constructed.
- * Users are not expected to rely on the internals of this class and should use
- * mlirOperationState* functions instead.
- */
+/// An auxiliary class for constructing operations.
+///
+/// This class contains all the information necessary to construct the
+/// operation. It owns the MlirRegions it has pointers to and does not own
+/// anything else. By default, the state can be constructed from a name and
+/// location, the latter being also used to access the context, and has no other
+/// components. These components can be added progressively until the operation
+/// is constructed. Users are not expected to rely on the internals of this
+/// class and should use mlirOperationState* functions instead.
+
 struct MlirOperationState {
   MlirStringRef name;
   MlirLocation location;
   intptr_t nResults;
   MlirType *results;
   intptr_t nOperands;
   MlirValue *operands;
   intptr_t nRegions;

 
 //===----------------------------------------------------------------------===//
 // Op Printing flags API.
 // While many of these are simple settings that could be represented in a
 // struct, they are wrapped in a heap allocated object and accessed via
 // functions to maximize the possibility of compatibility over time.
 //===----------------------------------------------------------------------===//
 
-/** Creates new printing flags with defaults, intended for customization.
- * Must be freed with a call to mlirOpPrintingFlagsDestroy(). */
+/// Creates new printing flags with defaults, intended for customization.
+/// Must be freed with a call to mlirOpPrintingFlagsDestroy().
 MLIR_CAPI_EXPORTED MlirOpPrintingFlags mlirOpPrintingFlagsCreate();
 
 /// Destroys printing flags created with mlirOpPrintingFlagsCreate.
 MLIR_CAPI_EXPORTED void mlirOpPrintingFlagsDestroy(MlirOpPrintingFlags flags);
 
-/** Enables the elision of large elements attributes by printing a lexically
- * valid but otherwise meaningless form instead of the element data. The
- * `largeElementLimit` is used to configure what is considered to be a "large"
- * ElementsAttr by providing an upper limit to the number of elements. */
+/// Enables the elision of large elements attributes by printing a lexically
+/// valid but otherwise meaningless form instead of the element data. The
+/// `largeElementLimit` is used to configure what is considered to be a "large"
+/// ElementsAttr by providing an upper limit to the number of elements.
 MLIR_CAPI_EXPORTED void
 mlirOpPrintingFlagsElideLargeElementsAttrs(MlirOpPrintingFlags flags,
                                            intptr_t largeElementLimit);
 
-/** Enable printing of debug information. If 'prettyForm' is set to true,
- * debug information is printed in a more readable 'pretty' form. Note: The
- * IR generated with 'prettyForm' is not parsable. */
+/// Enable printing of debug information. If 'prettyForm' is set to true,
+/// debug information is printed in a more readable 'pretty' form. Note: The
+/// IR generated with 'prettyForm' is not parsable.
 MLIR_CAPI_EXPORTED void
 mlirOpPrintingFlagsEnableDebugInfo(MlirOpPrintingFlags flags, bool prettyForm);
 
 /// Always print operations in the generic form.
 MLIR_CAPI_EXPORTED void
 mlirOpPrintingFlagsPrintGenericOpForm(MlirOpPrintingFlags flags);
 
-/** Use local scope when printing the operation. This allows for using the
- * printer in a more localized and thread-safe setting, but may not
- * necessarily be identical to what the IR will look like when dumping
- * the full module. */
+/// Use local scope when printing the operation. This allows for using the
+/// printer in a more localized and thread-safe setting, but may not
+/// necessarily be identical to what the IR will look like when dumping
+/// the full module.
 MLIR_CAPI_EXPORTED void
 mlirOpPrintingFlagsUseLocalScope(MlirOpPrintingFlags flags);
 
 //===----------------------------------------------------------------------===//
 // Operation API.
 //===----------------------------------------------------------------------===//
 
 /// Creates an operation and transfers ownership to the caller.
 /// Note that caller owned child objects are transferred in this call and must
 /// not be further used. Particularly, this applies to any regions added to
 /// the state (the implementation may invalidate any such pointers).
 ///
 /// This call can fail under the following conditions, in which case, it will
 /// return a null operation and emit diagnostics:
 ///   - Result type inference is enabled and cannot be performed.
 MLIR_CAPI_EXPORTED MlirOperation mlirOperationCreate(MlirOperationState *state);
 
 /// Takes an operation owned by the caller and destroys it.
 MLIR_CAPI_EXPORTED void mlirOperationDestroy(MlirOperation op);
 
 /// Checks whether the underlying operation is null.
 static inline bool mlirOperationIsNull(MlirOperation op) { return !op.ptr; }
 
-/** Checks whether two operation handles point to the same operation. This does
- * not perform deep comparison. */
+/// Checks whether two operation handles point to the same operation. This does
+/// not perform deep comparison.
 MLIR_CAPI_EXPORTED bool mlirOperationEqual(MlirOperation op,
                                            MlirOperation other);
 
 /// Gets the name of the operation as an identifier.
 MLIR_CAPI_EXPORTED MlirIdentifier mlirOperationGetName(MlirOperation op);
 
-/** Gets the block that owns this operation, returning null if the operation is
- * not owned. */
+/// Gets the block that owns this operation, returning null if the operation is
+/// not owned.
 MLIR_CAPI_EXPORTED MlirBlock mlirOperationGetBlock(MlirOperation op);
 
-/** Gets the operation that owns this operation, returning null if the operation
- * is not owned. */
+/// Gets the operation that owns this operation, returning null if the operation
+/// is not owned.
 MLIR_CAPI_EXPORTED MlirOperation
 mlirOperationGetParentOperation(MlirOperation op);
 
 /// Returns the number of regions attached to the given operation.
 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumRegions(MlirOperation op);
 
 /// Returns `pos`-th region attached to the operation.
 MLIR_CAPI_EXPORTED MlirRegion mlirOperationGetRegion(MlirOperation op,
                                                      intptr_t pos);
 
-/** Returns an operation immediately following the given operation it its
- * enclosing block. */
+/// Returns an operation immediately following the given operation it its
+/// enclosing block.
 MLIR_CAPI_EXPORTED MlirOperation mlirOperationGetNextInBlock(MlirOperation op);
 
 /// Returns the number of operands of the operation.
 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumOperands(MlirOperation op);
 
 /// Returns `pos`-th operand of the operation.
 MLIR_CAPI_EXPORTED MlirValue mlirOperationGetOperand(MlirOperation op,
                                                      intptr_t pos);

 /// Return `pos`-th attribute of the operation.
 MLIR_CAPI_EXPORTED MlirNamedAttribute
 mlirOperationGetAttribute(MlirOperation op, intptr_t pos);
 
 /// Returns an attribute attached to the operation given its name.
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirOperationGetAttributeByName(MlirOperation op, MlirStringRef name);
 
-/** Sets an attribute by name, replacing the existing if it exists or
- * adding a new one otherwise. */
+/// Sets an attribute by name, replacing the existing if it exists or
+/// adding a new one otherwise.
 MLIR_CAPI_EXPORTED void mlirOperationSetAttributeByName(MlirOperation op,
                                                         MlirStringRef name,
                                                         MlirAttribute attr);
 
-/** Removes an attribute by name. Returns false if the attribute was not found
- * and true if removed. */
+/// Removes an attribute by name. Returns false if the attribute was not found
+/// and true if removed.
 MLIR_CAPI_EXPORTED bool mlirOperationRemoveAttributeByName(MlirOperation op,
                                                            MlirStringRef 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. */
+/// 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.
 MLIR_CAPI_EXPORTED void mlirOperationPrint(MlirOperation op,
                                            MlirStringCallback callback,
                                            void *userData);
 
-/** Same as mlirOperationPrint but accepts flags controlling the printing
- * behavior. */
+/// Same as mlirOperationPrint but accepts flags controlling the printing
+/// behavior.
 MLIR_CAPI_EXPORTED void mlirOperationPrintWithFlags(MlirOperation op,
                                                     MlirOpPrintingFlags flags,
                                                     MlirStringCallback callback,
                                                     void *userData);
 
 /// Prints an operation to stderr.
 MLIR_CAPI_EXPORTED void mlirOperationDump(MlirOperation op);
 

 
 /// Gets the first block in the region.
 MLIR_CAPI_EXPORTED MlirBlock mlirRegionGetFirstBlock(MlirRegion region);
 
 /// Takes a block owned by the caller and appends it to the given region.
 MLIR_CAPI_EXPORTED void mlirRegionAppendOwnedBlock(MlirRegion region,
                                                    MlirBlock block);
 
-/** Takes a block owned by the caller and inserts it at `pos` to the given
- * region. This is an expensive operation that linearly scans the region, prefer
- * insertAfter/Before instead. */
+/// Takes a block owned by the caller and inserts it at `pos` to the given
+/// region. This is an expensive operation that linearly scans the region,
+/// prefer insertAfter/Before instead.
 MLIR_CAPI_EXPORTED void
 mlirRegionInsertOwnedBlock(MlirRegion region, intptr_t pos, MlirBlock block);
 
-/** Takes a block owned by the caller and inserts it after the (non-owned)
- * reference block in the given region. The reference block must belong to the
- * region. If the reference block is null, prepends the block to the region. */
+/// Takes a block owned by the caller and inserts it after the (non-owned)
+/// reference block in the given region. The reference block must belong to the
+/// region. If the reference block is null, prepends the block to the region.
 MLIR_CAPI_EXPORTED void mlirRegionInsertOwnedBlockAfter(MlirRegion region,
                                                         MlirBlock reference,
                                                         MlirBlock block);
 
-/** Takes a block owned by the caller and inserts it before the (non-owned)
- * reference block in the given region. The reference block must belong to the
- * region. If the reference block is null, appends the block to the region. */
+/// Takes a block owned by the caller and inserts it before the (non-owned)
+/// reference block in the given region. The reference block must belong to the
+/// region. If the reference block is null, appends the block to the region.
 MLIR_CAPI_EXPORTED void mlirRegionInsertOwnedBlockBefore(MlirRegion region,
                                                          MlirBlock reference,
                                                          MlirBlock block);
 
 //===----------------------------------------------------------------------===//
 // Block API.
 //===----------------------------------------------------------------------===//
 
-/** Creates a new empty block with the given argument types and transfers
- * ownership to the caller. */
+/// Creates a new empty block with the given argument types and transfers
+/// ownership to the caller.
 MLIR_CAPI_EXPORTED MlirBlock mlirBlockCreate(intptr_t nArgs,
                                              MlirType const *args);
 
 /// Takes a block owned by the caller and destroys it.
 MLIR_CAPI_EXPORTED void mlirBlockDestroy(MlirBlock block);
 
 /// Checks whether a block is null.
 static inline bool mlirBlockIsNull(MlirBlock block) { return !block.ptr; }
 
-/** Checks whether two blocks handles point to the same block. This does not
- * perform deep comparison. */
+/// Checks whether two blocks handles point to the same block. This does not
+/// perform deep comparison.
 MLIR_CAPI_EXPORTED bool mlirBlockEqual(MlirBlock block, MlirBlock other);
 
-/** Returns the block immediately following the given block in its parent
- * region. */
+/// Returns the block immediately following the given block in its parent
+/// region.
 MLIR_CAPI_EXPORTED MlirBlock mlirBlockGetNextInRegion(MlirBlock block);
 
 /// Returns the first operation in the block.
 MLIR_CAPI_EXPORTED MlirOperation mlirBlockGetFirstOperation(MlirBlock block);
 
 /// Returns the terminator operation in the block or null if no terminator.
 MLIR_CAPI_EXPORTED MlirOperation mlirBlockGetTerminator(MlirBlock block);
 
 /// Takes an operation owned by the caller and appends it to the block.
 MLIR_CAPI_EXPORTED void mlirBlockAppendOwnedOperation(MlirBlock block,
                                                       MlirOperation operation);
 
-/** Takes an operation owned by the caller and inserts it as `pos` to the block.
-   This is an expensive operation that scans the block linearly, prefer
-   insertBefore/After instead. */
+/// Takes an operation owned by the caller and inserts it as `pos` to the block.
+/// This is an expensive operation that scans the block linearly, prefer
+/// insertBefore/After instead.
 MLIR_CAPI_EXPORTED void mlirBlockInsertOwnedOperation(MlirBlock block,
                                                       intptr_t pos,
                                                       MlirOperation operation);
 
-/** Takes an operation owned by the caller and inserts it after the (non-owned)
- * reference operation in the given block. If the reference is null, prepends
- * the operation. Otherwise, the reference must belong to the block. */
+/// Takes an operation owned by the caller and inserts it after the (non-owned)
+/// reference operation in the given block. If the reference is null, prepends
+/// the operation. Otherwise, the reference must belong to the block.
 MLIR_CAPI_EXPORTED void
 mlirBlockInsertOwnedOperationAfter(MlirBlock block, MlirOperation reference,
                                    MlirOperation operation);
 
-/** Takes an operation owned by the caller and inserts it before the (non-owned)
- * reference operation in the given block. If the reference is null, appends the
- * operation. Otherwise, the reference must belong to the block. */
+/// Takes an operation owned by the caller and inserts it before the (non-owned)
+/// reference operation in the given block. If the reference is null, appends
+/// the operation. Otherwise, the reference must belong to the block.
 MLIR_CAPI_EXPORTED void
 mlirBlockInsertOwnedOperationBefore(MlirBlock block, MlirOperation reference,
                                     MlirOperation operation);
 
 /// Returns the number of arguments of the block.
 MLIR_CAPI_EXPORTED intptr_t mlirBlockGetNumArguments(MlirBlock block);
 
 /// Returns `pos`-th argument of the block.
 MLIR_CAPI_EXPORTED 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. */
+/// 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.
 MLIR_CAPI_EXPORTED void
 mlirBlockPrint(MlirBlock block, MlirStringCallback callback, void *userData);
 
 //===----------------------------------------------------------------------===//
 // Value API.
 //===----------------------------------------------------------------------===//
 
 /// Returns whether the value is null.
 static inline bool mlirValueIsNull(MlirValue value) { return !value.ptr; }
 
 /// Returns 1 if two values are equal, 0 otherwise.
 bool mlirValueEqual(MlirValue value1, MlirValue value2);
 
 /// Returns 1 if the value is a block argument, 0 otherwise.
 MLIR_CAPI_EXPORTED bool mlirValueIsABlockArgument(MlirValue value);
 
 /// Returns 1 if the value is an operation result, 0 otherwise.
 MLIR_CAPI_EXPORTED bool mlirValueIsAOpResult(MlirValue value);
 
-/** Returns the block in which this value is defined as an argument. Asserts if
- * the value is not a block argument. */
+/// Returns the block in which this value is defined as an argument. Asserts if
+/// the value is not a block argument.
 MLIR_CAPI_EXPORTED MlirBlock mlirBlockArgumentGetOwner(MlirValue value);
 
 /// Returns the position of the value in the argument list of its block.
 MLIR_CAPI_EXPORTED intptr_t mlirBlockArgumentGetArgNumber(MlirValue value);
 
 /// Sets the type of the block argument to the given type.
 MLIR_CAPI_EXPORTED void mlirBlockArgumentSetType(MlirValue value,
                                                  MlirType type);
 
-/** Returns an operation that produced this value as its result. Asserts if the
- * value is not an op result. */
+/// Returns an operation that produced this value as its result. Asserts if the
+/// value is not an op result.
 MLIR_CAPI_EXPORTED MlirOperation mlirOpResultGetOwner(MlirValue value);
 
-/** Returns the position of the value in the list of results of the operation
- * that produced it. */
+/// Returns the position of the value in the list of results of the operation
+/// that produced it.
 MLIR_CAPI_EXPORTED intptr_t mlirOpResultGetResultNumber(MlirValue value);
 
 /// Returns the type of the value.
 MLIR_CAPI_EXPORTED MlirType mlirValueGetType(MlirValue value);
 
 /// Prints the value to the standard error stream.
 MLIR_CAPI_EXPORTED void mlirValueDump(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. */
+/// 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.
 MLIR_CAPI_EXPORTED void
 mlirValuePrint(MlirValue value, MlirStringCallback callback, void *userData);
 
 //===----------------------------------------------------------------------===//
 // Type API.
 //===----------------------------------------------------------------------===//
 
 /// Parses a type. The type is owned by the context.
 MLIR_CAPI_EXPORTED MlirType mlirTypeParseGet(MlirContext context,
                                              MlirStringRef type);
 
 /// Gets the context that a type was created with.
 MLIR_CAPI_EXPORTED MlirContext mlirTypeGetContext(MlirType type);
 
 /// Checks whether a type is null.
 static inline bool mlirTypeIsNull(MlirType type) { return !type.ptr; }
 
 /// Checks if two types are equal.
 MLIR_CAPI_EXPORTED bool 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. */
+/// 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.
 MLIR_CAPI_EXPORTED void
 mlirTypePrint(MlirType type, MlirStringCallback callback, void *userData);
 
 /// Prints the type to the standard error stream.
 MLIR_CAPI_EXPORTED void mlirTypeDump(MlirType type);
 
 //===----------------------------------------------------------------------===//
 // Attribute API.

 MLIR_CAPI_EXPORTED MlirType mlirAttributeGetType(MlirAttribute attribute);
 
 /// Checks whether an attribute is null.
 static inline bool mlirAttributeIsNull(MlirAttribute attr) { return !attr.ptr; }
 
 /// Checks if two attributes are equal.
 MLIR_CAPI_EXPORTED bool 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. */
+/// 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.
 MLIR_CAPI_EXPORTED void mlirAttributePrint(MlirAttribute attr,
                                            MlirStringCallback callback,
                                            void *userData);
 
 /// Prints the attribute to the standard error stream.
 MLIR_CAPI_EXPORTED void mlirAttributeDump(MlirAttribute attr);
 
 /// Associates an attribute with the name. Takes ownership of neither.

mlir/include/mlir-c/Pass.h

 #include "mlir-c/IR.h"
 #include "mlir-c/Support.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 //===----------------------------------------------------------------------===//
-/** Opaque type declarations.
- *
- * Types are exposed to C bindings as structs containing opaque pointers. They
- * are not supposed to be inspected from C. This allows the underlying
- * representation to change without affecting the API users. The use of structs
- * instead of typedefs enables some type safety as structs are not implicitly
- * convertible to each other.
- *
- * Instances of these types may or may not own the underlying object. The
- * ownership semantics is defined by how an instance of the type was obtained.
- */
+// Opaque type declarations.
+//
+// Types are exposed to C bindings as structs containing opaque pointers. They
+// are not supposed to be inspected from C. This allows the underlying
+// representation to change without affecting the API users. The use of structs
+// instead of typedefs enables some type safety as structs are not implicitly
+// convertible to each other.
+//
+// Instances of these types may or may not own the underlying object. The
+// ownership semantics is defined by how an instance of the type was obtained.
 //===----------------------------------------------------------------------===//
 
 #define DEFINE_C_API_STRUCT(name, storage)                                     \
   struct name {                                                                \
     storage *ptr;                                                              \
   };                                                                           \
   typedef struct name name
 

 /// Cast a top-level PassManager to a generic OpPassManager.
 MLIR_CAPI_EXPORTED MlirOpPassManager
 mlirPassManagerGetAsOpPassManager(MlirPassManager passManager);
 
 /// Run the provided `passManager` on the given `module`.
 MLIR_CAPI_EXPORTED MlirLogicalResult
 mlirPassManagerRun(MlirPassManager passManager, MlirModule module);
 
-/** Nest an OpPassManager under the top-level PassManager, the nested
- * passmanager will only run on operations matching the provided name.
- * The returned OpPassManager will be destroyed when the parent is destroyed.
- * To further nest more OpPassManager under the newly returned one, see
- * `mlirOpPassManagerNest` below. */
+/// Nest an OpPassManager under the top-level PassManager, the nested
+/// passmanager will only run on operations matching the provided name.
+/// The returned OpPassManager will be destroyed when the parent is destroyed.
+/// To further nest more OpPassManager under the newly returned one, see
+/// `mlirOpPassManagerNest` below.
 MLIR_CAPI_EXPORTED MlirOpPassManager mlirPassManagerGetNestedUnder(
     MlirPassManager passManager, MlirStringRef operationName);
 
-/** Nest an OpPassManager under the provided OpPassManager, the nested
- * passmanager will only run on operations matching the provided name.
- * The returned OpPassManager will be destroyed when the parent is destroyed. */
+/// Nest an OpPassManager under the provided OpPassManager, the nested
+/// passmanager will only run on operations matching the provided name.
+/// The returned OpPassManager will be destroyed when the parent is destroyed.
 MLIR_CAPI_EXPORTED MlirOpPassManager mlirOpPassManagerGetNestedUnder(
     MlirOpPassManager passManager, MlirStringRef operationName);
 
-/** Add a pass and transfer ownership to the provided top-level mlirPassManager.
- * If the pass is not a generic operation pass or a ModulePass, a new
- * OpPassManager is implicitly nested under the provided PassManager. */
+/// Add a pass and transfer ownership to the provided top-level mlirPassManager.
+/// If the pass is not a generic operation pass or a ModulePass, a new
+/// OpPassManager is implicitly nested under the provided PassManager.
 MLIR_CAPI_EXPORTED void mlirPassManagerAddOwnedPass(MlirPassManager passManager,
                                                     MlirPass pass);
 
-/** Add a pass and transfer ownership to the provided mlirOpPassManager. If the
- * pass is not a generic operation pass or matching the type of the provided
- * PassManager, a new OpPassManager is implicitly nested under the provided
- * PassManager. */
+/// Add a pass and transfer ownership to the provided mlirOpPassManager. If the
+/// pass is not a generic operation pass or matching the type of the provided
+/// PassManager, a new OpPassManager is implicitly nested under the provided
+/// PassManager.
 MLIR_CAPI_EXPORTED void
 mlirOpPassManagerAddOwnedPass(MlirOpPassManager passManager, MlirPass pass);
 
-/** Print a textual MLIR pass pipeline 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. */
+/// Print a textual MLIR pass pipeline 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.
 MLIR_CAPI_EXPORTED void mlirPrintPassPipeline(MlirOpPassManager passManager,
                                               MlirStringCallback callback,
                                               void *userData);
 
-/** Parse a textual MLIR pass pipeline and add it to the provided OpPassManager.
- */
+/// Parse a textual MLIR pass pipeline and add it to the provided OpPassManager.
+
 MLIR_CAPI_EXPORTED MlirLogicalResult
 mlirParsePassPipeline(MlirOpPassManager passManager, MlirStringRef pipeline);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_PASS_H

mlir/include/mlir-c/Support.h

 #ifdef __cplusplus
 extern "C" {
 #endif
 
 //===----------------------------------------------------------------------===//
 // MlirStringRef.
 //===----------------------------------------------------------------------===//
 
-/** A pointer to a sized fragment of a string, not necessarily null-terminated.
- * Does not own the underlying string. This is equivalent to llvm::StringRef.
- */
+/// A pointer to a sized fragment of a string, not necessarily null-terminated.
+/// Does not own the underlying string. This is equivalent to llvm::StringRef.
+
 struct MlirStringRef {
-  const char *data; /**< Pointer to the first symbol. */
-  size_t length;    /**< Length of the fragment. */
+  const char *data; ///< Pointer to the first symbol.
+  size_t length;    ///< Length of the fragment.
 };
 typedef struct MlirStringRef MlirStringRef;
 
-/** Constructs a string reference from the pointer and length. The pointer need
- * not reference to a null-terminated string.
- */
+/// Constructs a string reference from the pointer and length. The pointer need
+/// not reference to a null-terminated string.
+
 inline static MlirStringRef mlirStringRefCreate(const char *str,
                                                 size_t length) {
   MlirStringRef result;
   result.data = str;
   result.length = length;
   return result;
 }
 
-/** Constructs a string reference from a null-terminated C string. Prefer
- * mlirStringRefCreate if the length of the string is known.
- */
+/// Constructs a string reference from a null-terminated C string. Prefer
+/// mlirStringRefCreate if the length of the string is known.
 MLIR_CAPI_EXPORTED MlirStringRef
 mlirStringRefCreateFromCString(const char *str);
 
-/** A callback for returning string references.
- *
- * This function is called back by the functions that need to return a reference
- * to the portion of the string with the following arguments:
- *   - an MlirStringRef representing the current portion of the string
- *   - a pointer to user data forwarded from the printing call.
- */
+/// A callback for returning string references.
+///
+/// This function is called back by the functions that need to return a
+/// reference to the portion of the string with the following arguments:
+///  - an MlirStringRef representing the current portion of the string
+///  - a pointer to user data forwarded from the printing call.
 typedef void (*MlirStringCallback)(MlirStringRef, void *);
 
 //===----------------------------------------------------------------------===//
 // MlirLogicalResult.
 //===----------------------------------------------------------------------===//
 
-/** A logical result value, essentially a boolean with named states. LLVM
- * convention for using boolean values to designate success or failure of an
- * operation is a moving target, so MLIR opted for an explicit class.
- * Instances of MlirLogicalResult must only be inspected using the associated
- * functions. */
+/// A logical result value, essentially a boolean with named states. LLVM
+/// convention for using boolean values to designate success or failure of an
+/// operation is a moving target, so MLIR opted for an explicit class.
+/// Instances of MlirLogicalResult must only be inspected using the associated
+/// functions.
 struct MlirLogicalResult {
   int8_t value;
 };
 typedef struct MlirLogicalResult MlirLogicalResult;
 
 /// Checks if the given logical result represents a success.
 inline static bool mlirLogicalResultIsSuccess(MlirLogicalResult res) {
   return res.value != 0;