[mlir] expose standard types to C API

[ftynse]

Summary

Provide C API for MLIR standard types. Since standard types live under lib/IR
in core MLIR, place the C APIs in the IR library as well (standard ops will go
into a separate library). This also defines a placeholder for affine maps that
are necessary to construct a memref, but are not yet exposed to the C API.

[ftynse]

mlir/include/mlir-c/StandardTypes.h

135

@stellaraccident rank and shape are int64_tin C++ (not unsigned as usual), do we want to keep them as is or use intptr_t instead?

mlir/test/CAPI/ir.c

453

Apparently there is a problem with printing unranked memrefs in non-default memory space.

[ftynse]

mlir/test/CAPI/ir.c

453

https://reviews.llvm.org/D86096

[stellaraccident]

mlir/docs/CAPI.md

83

97

mlir/include/mlir-c/StandardTypes.h

135

I think these should be int64_t since that is the natural range of the value, regardless of platform. I would apply this rule: the compiler should be able to represent the same program IR regardless of whether it is built with a 32 or 64bit pointer size (within the limit of not being able to express programs that exceed internal limits of data structure sizes).

141

I think this is fine as an intptr_t: these relate to the sizes of ir internal data structures.

mlir/include/mlir/CAPI/Wrap.h

41

Shouldn't this be size_t (and I'm the function)

[ftynse]

Rebase on top of a bugfix and address review.

[ftynse]

Rebase once more

mlir/docs/CAPI.md

 
 ### Nullity
 
 A handle may refer to a _null_ object. It is the responsibility of the caller to
 check if an object is null by using `mlirXIsNull(MlirX)`. API functions do _not_
 expect null objects as arguments unless explicitly stated otherwise. API
 functions _may_ return null objects.
 
+### Type Hierarchies
+
+MLIR objects can form type hierarchies in C++. For example, all IR classes
+representing types are derived from `mlir::Type`, some of them may also be also
+derived from common base classes such as `mlir::ShapedType` or dialect-specific
+base classes. Type hierarchies are exposed to C API through naming conventions
+as follows.
+
+-   Only the top-level class of each hierarchy is exposed, e.g. `MlirType` is
+    defined as a type but `MlirShapedType` is not. This avoids the need for
+    explicit upcasting when passing an object of a derived type to a function
+    that expects a base type (this happens more often in core/standard APIs,
+    while downcasting usually involves further checks anyway).
+-   A type `Y` that derives from `X` provides a function `int mlirXIsAY(MlirX)`
+    that returns a non-zero value if the given dynamic instance of `X` is also
+    an instance of `Y`. For example, `int MlirTypeIsAInteger(MlirType)`.
+-   A function that expects a derived type as its first argument takes the base
+    type instead and documents the expectation by using `Y` in its name
+    `MlirY<...>(MlirX, ...)`. This function asserts that the dynamic instance of
+    its first argument is `Y`, and it is the responsibility of the caller to
+    ensure it is indeed the case.
+
 ### Conversion To String and Printing
 
 IR objects can be converted to a string representation, for example for
 printing, using `mlirXPrint(MlirX, MlirPrintCallback, void *)` functions. These
 functions accept take arguments a callback with signature `void (*)(const char
 *, intptr_t, void *)` and a pointer to user-defined data. They call the callback
 and supply it with chunks of the string representation, provided as a pointer to
 the first character and a length, and forward the user-defined data unmodified.
 It is up to the caller to allocate memory if the string representation must be
 stored and perform the copy. There is no guarantee that the pointer supplied to
 the callback points to a null-terminated string, the size argument should be
 used to find the end of the string. The callback may be called multiple times
 with consecutive chunks of the string representation (the printing itself is
 bufferred).
 
 *Rationale*: this approach allows the caller to have full control of the
 allocation and avoid unnecessary allocation and copying inside the printer.
 
 For convenience, `mlirXDump(MlirX)` functions are provided to print the given
 object to the standard error stream.
 
-### Common Patterns
+## Common Patterns
 
 The API adopts the following patterns for recurrent functionality in MLIR.
 
-#### Indexed Components
+### Indexed Components
 
 An object has an _indexed component_ if it has fields accessible using a
 zero-based contiguous integer index, typically arrays. For example, an
 `MlirBlock` has its arguments as a indexed component. An object may have several
 such components. For example, an `MlirOperation` has attributes, operands,
 regions, results and successors.
 
 For indexed components, the following pair of functions is provided.
 
 -   `intptr_t mlirXGetNum<Y>s(MlirX)` returns the upper bound on the index.
 -   `MlirY mlirXGet<Y>(MlirX, intptr_t pos)` returns 'pos'-th subobject.
 
 The sizes are accepted and returned as signed pointer-sized integers, i.e.
 `intptr_t`. This typedef is avalable in C99.
 
 Note that the name of subobject in the function does not necessarily match the
 type of the subobject. For example, `mlirOperationGetOperand` returns a
 `MlirValue`.
 
-#### Iterable Components
+### Iterable Components
 
 An object has an _iterable component_ if it has iterators accessing its fields
 in some order other than integer indexing, typically linked lists. For example,
 an `MlirBlock` has an iterable list of operations it contains. An object may
 have several iterable components.
 
 For iterable components, the following triple of functions is provided.
 

 
 ```c++
 MlirY iter;
 for (iter = mlirXGetFirst<Y>(x); !mlirYIsNull(iter);
      iter = mlirYGetNextIn<X>(iter)) {
   /* User 'iter'. */
 }
 ```
+
+## Extending the API
+
+### Extensions for Dialect Attributes and Types
+
+Dialect attributes and types can follow the example of standard attrbutes and
+types, provided that implementations live in separate directories, i.e.
+`include/mlir-c/<...>Dialect/` and `lib/CAPI/<...>Dialect/`. The core APIs
+provide implementation-private headers in `include/mlir/CAPI/IR` that allow one
+to convert between opaque C structures for core IR components and their C++
+counterparts. `wrap` converts a C++ class into a C structure and `unwrap` does
+the inverse conversion. Once the a C++ object is available, the API
+implementation should rely on `isa` to implement `mlirXIsAY` and is expected to
+use `cast` inside other API calls.

mlir/include/mlir-c/AffineMap.h

+/*===-- mlir-c/AffineMap.h - C API for MLIR Affine maps -----------*- C -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef MLIR_C_AFFINEMAP_H
+#define MLIR_C_AFFINEMAP_H
+
+#include "mlir-c/IR.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+DEFINE_C_API_STRUCT(MlirAffineMap, const void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // MLIR_C_AFFINEMAP_H

mlir/include/mlir-c/IR.h

 DEFINE_C_API_STRUCT(MlirRegion, void);
 
 DEFINE_C_API_STRUCT(MlirValue, const void);
 DEFINE_C_API_STRUCT(MlirAttribute, const void);
 DEFINE_C_API_STRUCT(MlirType, const void);
 DEFINE_C_API_STRUCT(MlirLocation, const void);
 DEFINE_C_API_STRUCT(MlirModule, 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.
  */
 struct MlirNamedAttribute {
   const char *name;
   MlirAttribute attribute;

 
 /*============================================================================*/
 /* Type API.                                                                  */
 /*============================================================================*/
 
 /** Parses a type. The type is owned by the context. */
 MlirType mlirTypeParseGet(MlirContext context, const char *type);
 
+/** Checks if two types are equal. */
+int mlirTypeEqual(MlirType t1, MlirType t2);
+
 /** Prints a location by sending chunks of the string representation and
  * forwarding `userData to `callback`. Note that the callback may be called
  * several times with consecutive chunks of the string. */
 void mlirTypePrint(MlirType type, MlirPrintCallback callback, void *userData);
 
 /** Prints the type to the standard error stream. */
 void mlirTypeDump(MlirType type);
 

mlir/include/mlir-c/StandardTypes.h

+/*===-- mlir-c/StandardTypes.h - C API for MLIR Standard types ----*- C -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef MLIR_C_STANDARDTYPES_H
+#define MLIR_C_STANDARDTYPES_H
+
+#include "mlir-c/AffineMap.h"
+#include "mlir-c/IR.h"
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*============================================================================*/
+/* Integer types.                                                             */
+/*============================================================================*/
+
+/** Checks whether the given type is an integer type. */
+int mlirTypeIsAInteger(MlirType type);
+
+/** Creates a signless integer type of the given bitwidth in the context. The
+ * type is owned by the context. */
+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. */
+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. */
+MlirType mlirIntegerTypeUnsignedGet(MlirContext ctx, unsigned bitwidth);
+
+/** Returns the bitwidth of an integer type. */
+unsigned mlirIntegerTypeGetWidth(MlirType type);
+
+/** Checks whether the given integer type is signless. */
+int mlirIntegerTypeIsSignless(MlirType type);
+
+/** Checks whether the given integer type is signed. */
+int mlirIntegerTypeIsSigned(MlirType type);
+
+/** Checks whether the given integer type is unsigned. */
+int mlirIntegerTypeIsUnsigned(MlirType type);
+
+/*============================================================================*/
+/* Index type.                                                                */
+/*============================================================================*/
+
+/** Checks whether the given type is an index type. */
+int mlirTypeIsAIndex(MlirType type);
+
+/** Creates an index type in the given context. The type is owned by the
+ * context. */
+MlirType mlirIndexTypeGet(MlirContext ctx);
+
+/*============================================================================*/
+/* Floating-point types.                                                      */
+/*============================================================================*/
+
+/** Checks whether the given type is a bf16 type. */
+int mlirTypeIsABF16(MlirType type);
+
+/** Creates a bf16 type in the given context. The type is owned by the
+ * context. */
+MlirType mlirBF16TypeGet(MlirContext ctx);
+
+/** Checks whether the given type is an f16 type. */
+int mlirTypeIsAF16(MlirType type);
+
+/** Creates an f16 type in the given context. The type is owned by the
+ * context. */
+MlirType mlirF16TypeGet(MlirContext ctx);
+
+/** Checks whether the given type is an f32 type. */
+int mlirTypeIsAF32(MlirType type);
+
+/** Creates an f32 type in the given context. The type is owned by the
+ * context. */
+MlirType mlirF32TypeGet(MlirContext ctx);
+
+/** Checks whether the given type is an f64 type. */
+int mlirTypeIsAF64(MlirType type);
+
+/** Creates a f64 type in the given context. The type is owned by the
+ * context. */
+MlirType mlirF64TypeGet(MlirContext ctx);
+
+/*============================================================================*/
+/* None type.                                                                 */
+/*============================================================================*/
+
+/** Checks whether the given type is a None type. */
+int mlirTypeIsANone(MlirType type);
+
+/** Creates a None type in the given context. The type is owned by the
+ * context. */
+MlirType mlirNoneTypeGet(MlirContext ctx);
+
+/*============================================================================*/
+/* Complex type.                                                              */
+/*============================================================================*/
+
+/** Checks whether the given type is a Complex type. */
+int 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. */
+MlirType mlirComplexTypeGet(MlirType elementType);
+
+/** Returns the element type of the given complex type. */
+MlirType mlirComplexTypeGetElementType(MlirType type);
+
+/*============================================================================*/
+/* Shaped type.                                                               */
+/*============================================================================*/
+
+/** Checks whether the given type is a Shaped type. */
+int mlirTypeIsAShaped(MlirType type);
+
+/** Returns the element type of the shaped type. */
+MlirType mlirShapedTypeGetElementType(MlirType type);
+
+/** Checks whether the given shaped type is ranked. */
+int mlirShapedTypeHasRank(MlirType type);
+
+/** Returns the rank of the given ranked shaped type. */
+int64_t mlirShapedTypeGetRank(MlirType type);
+
+/** Checks whether the given shaped type has a static shape. */
+int mlirShapedTypeHasStaticShape(MlirType type);
+
+/** Checks wither the dim-th dimension of the given shaped type is dynamic. */
+int mlirShapedTypeIsDynamicDim(MlirType type, intptr_t dim);
+
+/** Returns the dim-th dimension of the given ranked shaped type. */
+int64_t mlirShapedTypeGetDimSize(MlirType type, intptr_t dim);
+
+/** Checks whether the given value is used as a placeholder for dynamic sizes
+ * in shaped types. */
+int mlirShapedTypeIsDynamicSize(int64_t size);
+
+/** Checks whether the given value is used as a placeholder for dynamic strides
+ * and offsets in shaped types. */
+int mlirShapedTypeIsDynamicStrideOrOffset(int64_t val);
+
+/*============================================================================*/
+/* Vector type.                                                               */
+/*============================================================================*/
+
+/** Checks whether the given type is a Vector type. */
+int mlirTypeIsAVector(MlirType type);
+
+/** Creates a vector type of the shape identified by its rank and dimensios,
+ * with the given element type in the same context as the element type. The type
+ * is owned by the context. */
+MlirType mlirVectorTypeGet(intptr_t rank, int64_t *shape, MlirType elementType);
+
+/*============================================================================*/
+/* Ranked / Unranked Tensor type.                                             */
+/*============================================================================*/
+
+/** Checks whether the given type is a Tensor type. */
+int mlirTypeIsATensor(MlirType type);
+
+/** Checks whether the given type is a ranked tensor type. */
+int mlirTypeIsARankedTensor(MlirType type);
+
+/** Checks whether the given type is an unranked tensor type. */
+int 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. */
+MlirType mlirRankedTensorTypeGet(intptr_t rank, int64_t *shape,
+                                 MlirType elementType);
+
+/** 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. */
+MlirType mlirUnrankedTensorTypeGet(MlirType elementType);
+
+/*============================================================================*/
+/* Ranked / Unranked MemRef type.                                             */
+/*============================================================================*/
+
+/** Checks whether the given type is a MemRef type. */
+int mlirTypeIsAMemRef(MlirType type);
+
+/** Checks whether the given type is an UnrankedMemRef type. */
+int 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. */
+MlirType mlirMemRefTypeGet(MlirType elementType, intptr_t rank, int64_t *shape,
+                           intptr_t numMaps, MlirAttribute *affineMaps,
+                           unsigned memorySpace);
+
+/** 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. */
+MlirType mlirMemRefTypeContiguousGet(MlirType elementType, intptr_t rank,
+                                     int64_t *shape, unsigned memorySpace);
+
+/** 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. */
+MlirType mlirUnrankedMemRefTypeGet(MlirType elementType, unsigned memorySpace);
+
+/** Returns the number of affine layout maps in the given MemRef type. */
+intptr_t mlirMemRefTypeGetNumAffineMaps(MlirType type);
+
+/** Returns the pos-th affine map of the given MemRef type. */
+MlirAffineMap mlirMemRefTypeGetAffineMap(MlirType type, intptr_t pos);
+
+/** Returns the memory space of the given MemRef type. */
+unsigned mlirMemRefTypeGetMemorySpace(MlirType type);
+
+/** Returns the memory spcae of the given Unranked MemRef type. */
+unsigned mlirUnrankedMemrefGetMemorySpace(MlirType type);
+
+/*============================================================================*/
+/* Tuple type.                                                                */
+/*============================================================================*/
+
+/** Checks whether the given type is a tuple type. */
+int mlirTypeIsATuple(MlirType type);
+
+/** Creates a tuple type that consists of the given list of elemental types. The
+ * type is owned by the context. */
+MlirType mlirTupleTypeGet(MlirContext ctx, intptr_t numElements,
+                          MlirType *elements);
+
+/** Returns the number of types contained in a tuple. */
+intptr_t mlirTupleTypeGetNumTypes(MlirType type);
+
+/** Returns the pos-th type in the tuple type. */
+MlirType mlirTupleTypeGetType(MlirType type, intptr_t pos);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // MLIR_C_STANDARDTYPES_H

mlir/include/mlir/CAPI/AffineMap.h

+//===- AffineMap.h - C API Utils for Affine Maps ----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains declarations of implementation details of the C API for
+// MLIR Affine maps. This file should not be included from C++ code other than
+// C API implementation nor from C code.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_CAPI_AFFINEMAP_H
+#define MLIR_CAPI_AFFINEMAP_H
+
+#include "mlir-c/AffineMap.h"
+#include "mlir/CAPI/Wrap.h"
+#include "mlir/IR/AffineMap.h"
+
+DEFINE_C_API_METHODS(MlirAffineMap, mlir::AffineMap)
+
+#endif // MLIR_CAPI_AFFINEMAP_H

mlir/include/mlir/CAPI/IR.h

+//===- IR.h - C API Utils for Core MLIR classes -----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains declarations of implementation details of the C API for
+// core MLIR classes. This file should not be included from C++ code other than
+// C API implementation nor from C code.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_INCLUDE_MLIR_CAPI_IR_H
+#define MLIR_INCLUDE_MLIR_CAPI_IR_H
+
+#include "mlir/CAPI/Wrap.h"
+#include "mlir/IR/MLIRContext.h"
+#include "mlir/IR/Module.h"
+#include "mlir/IR/Operation.h"
+
+DEFINE_C_API_PTR_METHODS(MlirContext, mlir::MLIRContext)
+DEFINE_C_API_PTR_METHODS(MlirOperation, mlir::Operation)
+DEFINE_C_API_PTR_METHODS(MlirBlock, mlir::Block)
+DEFINE_C_API_PTR_METHODS(MlirRegion, mlir::Region)
+
+DEFINE_C_API_METHODS(MlirAttribute, mlir::Attribute)
+DEFINE_C_API_METHODS(MlirLocation, mlir::Location)
+DEFINE_C_API_METHODS(MlirType, mlir::Type)
+DEFINE_C_API_METHODS(MlirValue, mlir::Value)
+DEFINE_C_API_METHODS(MlirModule, mlir::ModuleOp)
+
+#endif // MLIR_INCLUDE_MLIR_CAPI_IR_H

mlir/include/mlir/CAPI/Wrap.h

+//===- Wrap.h - C API Utilities ---------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains common definitions for wrapping opaque C++ pointers into
+// C structures for the purpose of C API. This file should not be included from
+// C++ code other than C API implementation nor from C code.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_CAPI_WRAP_H
+#define MLIR_CAPI_WRAP_H
+
+#include "mlir-c/IR.h"
+#include "mlir/Support/LLVM.h"
+
+/* ========================================================================== */
+/* Definitions of methods for non-owning structures used in C API.            */
+/* ========================================================================== */
+
+#define DEFINE_C_API_PTR_METHODS(name, cpptype)                                \
+  static inline name wrap(cpptype *cpp) { return name{cpp}; }                  \
+  static inline cpptype *unwrap(name c) {                                      \
+    return static_cast<cpptype *>(c.ptr);                                      \
+  }
+
+#define DEFINE_C_API_METHODS(name, cpptype)                                    \
+  static inline name wrap(cpptype cpp) {                                       \
+    return name{cpp.getAsOpaquePointer()};                                     \
+  }                                                                            \
+  static inline cpptype unwrap(name c) {                                       \
+    return cpptype::getFromOpaquePointer(c.ptr);                               \
+  }
+
+template <typename CppTy, typename CTy>
+static llvm::ArrayRef<CppTy> unwrapList(size_t size, CTy *first,
+                                        llvm::SmallVectorImpl<CppTy> &storage) {
+  static_assert(
+      std::is_same<decltype(unwrap(std::declval<CTy>())), CppTy>::value,
+      "incompatible C and C++ types");
+
+  if (size == 0)
+    return llvm::None;
+
+  assert(storage.empty() && "expected to populate storage");
+  storage.reserve(size);
+  for (size_t i = 0; i < size; ++i)
+    storage.push_back(unwrap(*(first + i)));
+  return storage;
+}
+
+#endif // MLIR_CAPI_WRAP_H

mlir/include/mlir/IR/AffineMap.h

public:
 
   /// Returns the map consisting of the most minor `numResults` results.
   /// Returns the null AffineMap if `numResults` == 0.
   /// Returns `*this` if `numResults` >= `this->getNumResults()`.
   AffineMap getMinorSubMap(unsigned numResults);
 
   friend ::llvm::hash_code hash_value(AffineMap arg);
 
+  /// Methods supporting C API.
+  const void *getAsOpaquePointer() const {
+    return static_cast<const void *>(map);
+  }
+  static AffineMap getFromOpaquePointer(const void *pointer) {
+    return AffineMap(reinterpret_cast<ImplType *>(const_cast<void *>(pointer)));
+  }
+
 private:
   ImplType *map;
 
   static AffineMap getImpl(unsigned dimCount, unsigned symbolCount,
                            ArrayRef<AffineExpr> results, MLIRContext *context);
 };
 
 // Make AffineExpr hashable.

mlir/lib/CAPI/IR/AffineMap.cpp

+//===- AffineMap.cpp - C API for MLIR Affine Maps -------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir-c/AffineMap.h"
+#include "mlir-c/IR.h"
+#include "mlir/CAPI/AffineMap.h"
+#include "mlir/IR/AffineMap.h"
+
+// This is a placeholder for affine map bindings. The file is here to serve as a
+// compilation unit that includes the headers.

mlir/lib/CAPI/IR/CMakeLists.txt

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

mlir/lib/CAPI/IR/IR.cpp

 //===- IR.cpp - C Interface for Core MLIR APIs ----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir-c/IR.h"
 
+#include "mlir/CAPI/IR.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Parser.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace mlir;
 
 /* ========================================================================== */
-/* Definitions of methods for non-owning structures used in C API.            */
-/* ========================================================================== */
-
-#define DEFINE_C_API_PTR_METHODS(name, cpptype)                                \
-  static name wrap(cpptype *cpp) { return name{cpp}; }                         \
-  static cpptype *unwrap(name c) { return static_cast<cpptype *>(c.ptr); }
-
-DEFINE_C_API_PTR_METHODS(MlirContext, MLIRContext)
-DEFINE_C_API_PTR_METHODS(MlirOperation, Operation)
-DEFINE_C_API_PTR_METHODS(MlirBlock, Block)
-DEFINE_C_API_PTR_METHODS(MlirRegion, Region)
-
-#define DEFINE_C_API_METHODS(name, cpptype)                                    \
-  static name wrap(cpptype cpp) { return name{cpp.getAsOpaquePointer()}; }     \
-  static cpptype unwrap(name c) { return cpptype::getFromOpaquePointer(c.ptr); }
-
-DEFINE_C_API_METHODS(MlirAttribute, Attribute)
-DEFINE_C_API_METHODS(MlirLocation, Location);
-DEFINE_C_API_METHODS(MlirType, Type)
-DEFINE_C_API_METHODS(MlirValue, Value)
-DEFINE_C_API_METHODS(MlirModule, ModuleOp)
-
-template <typename CppTy, typename CTy>
-static ArrayRef<CppTy> unwrapList(intptr_t size, CTy *first,
-                                  SmallVectorImpl<CppTy> &storage) {
-  static_assert(
-      std::is_same<decltype(unwrap(std::declval<CTy>())), CppTy>::value,
-      "incompatible C and C++ types");
-
-  if (size == 0)
-    return llvm::None;
-
-  assert(storage.empty() && "expected to populate storage");
-  storage.reserve(size);
-  for (intptr_t i = 0; i < size; ++i)
-    storage.push_back(unwrap(*(first + i)));
-  return storage;
-}
-
-/* ========================================================================== */
 /* Printing helper.                                                           */
 /* ========================================================================== */
 
 namespace {
 /// A simple raw ostream subclass that forwards write_impl calls to the
 /// user-supplied callback together with opaque user-supplied data.
 class CallbackOstream : public llvm::raw_ostream {
 public:

 /* ========================================================================== */
 /* Type API.                                                                  */
 /* ========================================================================== */
 
 MlirType mlirTypeParseGet(MlirContext context, const char *type) {
   return wrap(mlir::parseType(type, unwrap(context)));
 }
 
+int mlirTypeEqual(MlirType t1, MlirType t2) { return unwrap(t1) == unwrap(t2); }
+
 void mlirTypePrint(MlirType type, MlirPrintCallback callback, void *userData) {
   CallbackOstream stream(callback, userData);
   unwrap(type).print(stream);
   stream.flush();
 }
 
 void mlirTypeDump(MlirType type) { unwrap(type).dump(); }
 

mlir/lib/CAPI/IR/StandardTypes.cpp

+//===- StandardTypes.cpp - C Interface to MLIR Standard Types -------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir-c/StandardTypes.h"
+#include "mlir-c/AffineMap.h"
+#include "mlir-c/IR.h"
+#include "mlir/CAPI/AffineMap.h"
+#include "mlir/CAPI/IR.h"
+#include "mlir/IR/AffineMap.h"
+#include "mlir/IR/StandardTypes.h"
+
+using namespace mlir;
+
+/* ========================================================================== */
+/* Integer types.                                                             */
+/* ========================================================================== */
+
+int mlirTypeIsAInteger(MlirType type) {
+  return unwrap(type).isa<IntegerType>();
+}
+
+MlirType mlirIntegerTypeGet(MlirContext ctx, unsigned bitwidth) {
+  return wrap(IntegerType::get(bitwidth, unwrap(ctx)));
+}
+
+MlirType mlirIntegerTypeSignedGet(MlirContext ctx, unsigned bitwidth) {
+  return wrap(IntegerType::get(bitwidth, IntegerType::Signed, unwrap(ctx)));
+}
+
+MlirType mlirIntegerTypeUnsignedGet(MlirContext ctx, unsigned bitwidth) {
+  return wrap(IntegerType::get(bitwidth, IntegerType::Unsigned, unwrap(ctx)));
+}
+
+unsigned mlirIntegerTypeGetWidth(MlirType type) {
+  return unwrap(type).cast<IntegerType>().getWidth();
+}
+
+int mlirIntegerTypeIsSignless(MlirType type) {
+  return unwrap(type).cast<IntegerType>().isSignless();
+}
+
+int mlirIntegerTypeIsSigned(MlirType type) {
+  return unwrap(type).cast<IntegerType>().isSigned();
+}
+
+int mlirIntegerTypeIsUnsigned(MlirType type) {
+  return unwrap(type).cast<IntegerType>().isUnsigned();
+}
+
+/* ========================================================================== */
+/* Index type.                                                                */
+/* ========================================================================== */
+
+int mlirTypeIsAIndex(MlirType type) { return unwrap(type).isa<IndexType>(); }
+
+MlirType mlirIndexTypeGet(MlirContext ctx) {
+  return wrap(IndexType::get(unwrap(ctx)));
+}
+
+/* ========================================================================== */
+/* Floating-point types.                                                      */
+/* ========================================================================== */
+
+int mlirTypeIsABF16(MlirType type) { return unwrap(type).isBF16(); }
+
+MlirType mlirBF16TypeGet(MlirContext ctx) {
+  return wrap(FloatType::getBF16(unwrap(ctx)));
+}
+
+int mlirTypeIsAF16(MlirType type) { return unwrap(type).isF16(); }
+
+MlirType mlirF16TypeGet(MlirContext ctx) {
+  return wrap(FloatType::getF16(unwrap(ctx)));
+}
+
+int mlirTypeIsAF32(MlirType type) { return unwrap(type).isF32(); }
+
+MlirType mlirF32TypeGet(MlirContext ctx) {
+  return wrap(FloatType::getF32(unwrap(ctx)));
+}
+
+int mlirTypeIsAF64(MlirType type) { return unwrap(type).isF64(); }
+
+MlirType mlirF64TypeGet(MlirContext ctx) {
+  return wrap(FloatType::getF64(unwrap(ctx)));
+}
+
+/* ========================================================================== */
+/* None type.                                                                 */
+/* ========================================================================== */
+
+int mlirTypeIsANone(MlirType type) { return unwrap(type).isa<NoneType>(); }
+
+MlirType mlirNoneTypeGet(MlirContext ctx) {
+  return wrap(NoneType::get(unwrap(ctx)));
+}
+
+/* ========================================================================== */
+/* Complex type.                                                              */
+/* ========================================================================== */
+
+int mlirTypeIsAComplex(MlirType type) {
+  return unwrap(type).isa<ComplexType>();
+}
+
+MlirType mlirComplexTypeGet(MlirType elementType) {
+  return wrap(ComplexType::get(unwrap(elementType)));
+}
+
+MlirType mlirComplexTypeGetElementType(MlirType type) {
+  return wrap(unwrap(type).cast<ComplexType>().getElementType());
+}
+
+/* ========================================================================== */
+/* Shaped type.                                                               */
+/* ========================================================================== */
+
+int mlirTypeIsAShaped(MlirType type) { return unwrap(type).isa<ShapedType>(); }
+
+MlirType mlirShapedTypeGetElementType(MlirType type) {
+  return wrap(unwrap(type).cast<ShapedType>().getElementType());
+}
+
+int mlirShapedTypeHasRank(MlirType type) {
+  return unwrap(type).cast<ShapedType>().hasRank();
+}
+
+int64_t mlirShapedTypeGetRank(MlirType type) {
+  return unwrap(type).cast<ShapedType>().getRank();
+}
+
+int mlirShapedTypeHasStaticShape(MlirType type) {
+  return unwrap(type).cast<ShapedType>().hasStaticShape();
+}
+
+int mlirShapedTypeIsDynamicDim(MlirType type, intptr_t dim) {
+  return unwrap(type).cast<ShapedType>().isDynamicDim(
+      static_cast<unsigned>(dim));
+}
+
+int64_t mlirShapedTypeGetDimSize(MlirType type, intptr_t dim) {
+  return unwrap(type).cast<ShapedType>().getDimSize(static_cast<unsigned>(dim));
+}
+
+int mlirShapedTypeIsDynamicSize(int64_t size) {
+  return ShapedType::isDynamic(size);
+}
+
+int mlirShapedTypeIsDynamicStrideOrOffset(int64_t val) {
+  return ShapedType::isDynamicStrideOrOffset(val);
+}
+
+/* ========================================================================== */
+/* Vector type.                                                               */
+/* ========================================================================== */
+
+int mlirTypeIsAVector(MlirType type) { return unwrap(type).isa<VectorType>(); }
+
+MlirType mlirVectorTypeGet(intptr_t rank, int64_t *shape,
+                           MlirType elementType) {
+  return wrap(
+      VectorType::get(llvm::makeArrayRef(shape, static_cast<size_t>(rank)),
+                      unwrap(elementType)));
+}
+
+/* ========================================================================== */
+/* Ranked / Unranked tensor type.                                             */
+/* ========================================================================== */
+
+int mlirTypeIsATensor(MlirType type) { return unwrap(type).isa<TensorType>(); }
+
+int mlirTypeIsARankedTensor(MlirType type) {
+  return unwrap(type).isa<RankedTensorType>();
+}
+
+int mlirTypeIsAUnrankedTensor(MlirType type) {
+  return unwrap(type).isa<UnrankedTensorType>();
+}
+
+MlirType mlirRankedTensorTypeGet(intptr_t rank, int64_t *shape,
+                                 MlirType elementType) {
+  return wrap(RankedTensorType::get(
+      llvm::makeArrayRef(shape, static_cast<size_t>(rank)),
+      unwrap(elementType)));
+}
+
+MlirType mlirUnrankedTensorTypeGet(MlirType elementType) {
+  return wrap(UnrankedTensorType::get(unwrap(elementType)));
+}
+
+/* ========================================================================== */
+/* Ranked / Unranked MemRef type.                                             */
+/* ========================================================================== */
+
+int mlirTypeIsAMemRef(MlirType type) { return unwrap(type).isa<MemRefType>(); }
+
+MlirType mlirMemRefTypeGet(MlirType elementType, intptr_t rank, int64_t *shape,
+                           intptr_t numMaps, MlirAffineMap *affineMaps,
+                           unsigned memorySpace) {
+  SmallVector<AffineMap, 1> maps;
+  (void)unwrapList(numMaps, affineMaps, maps);
+  return wrap(
+      MemRefType::get(llvm::makeArrayRef(shape, static_cast<size_t>(rank)),
+                      unwrap(elementType), maps, memorySpace));
+}
+
+MlirType mlirMemRefTypeContiguousGet(MlirType elementType, intptr_t rank,
+                                     int64_t *shape, unsigned memorySpace) {
+  return wrap(
+      MemRefType::get(llvm::makeArrayRef(shape, static_cast<size_t>(rank)),
+                      unwrap(elementType), llvm::None, memorySpace));
+}
+
+intptr_t mlirMemRefTypeGetNumAffineMaps(MlirType type) {
+  return static_cast<intptr_t>(
+      unwrap(type).cast<MemRefType>().getAffineMaps().size());
+}
+
+MlirAffineMap mlirMemRefTypeGetAffineMap(MlirType type, intptr_t pos) {
+  return wrap(unwrap(type).cast<MemRefType>().getAffineMaps()[pos]);
+}
+
+unsigned mlirMemRefTypeGetMemorySpace(MlirType type) {
+  return unwrap(type).cast<MemRefType>().getMemorySpace();
+}
+
+int mlirTypeIsAUnrankedMemRef(MlirType type) {
+  return unwrap(type).isa<UnrankedMemRefType>();
+}
+
+MlirType mlirUnrankedMemRefTypeGet(MlirType elementType, unsigned memorySpace) {
+  return wrap(UnrankedMemRefType::get(unwrap(elementType), memorySpace));
+}
+
+unsigned mlirUnrankedMemrefGetMemorySpace(MlirType type) {
+  return unwrap(type).cast<UnrankedMemRefType>().getMemorySpace();
+}
+
+/* ========================================================================== */
+/* Tuple type.                                                                */
+/* ========================================================================== */
+
+int mlirTypeIsATuple(MlirType type) { return unwrap(type).isa<TupleType>(); }
+
+MlirType mlirTupleTypeGet(MlirContext ctx, intptr_t numElements,
+                          MlirType *elements) {
+  SmallVector<Type, 4> types;
+  ArrayRef<Type> typeRef = unwrapList(numElements, elements, types);
+  return wrap(TupleType::get(typeRef, unwrap(ctx)));
+}
+
+intptr_t mlirTupleTypeGetNumTypes(MlirType type) {
+  return unwrap(type).cast<TupleType>().size();
+}
+
+MlirType mlirTupleTypeGetType(MlirType type, intptr_t pos) {
+  return wrap(unwrap(type).cast<TupleType>().getType(static_cast<size_t>(pos)));
+}

mlir/test/CAPI/ir.c

 /*===- ir.c - Simple test of C APIs ---------------------------------------===*\
 |*                                                                            *|
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
 |* Exceptions.                                                                *|
 |* See https://llvm.org/LICENSE.txt for license information.                  *|
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 /* RUN: mlir-capi-ir-test 2>&1 | FileCheck %s
  */
 
 #include "mlir-c/IR.h"
 #include "mlir-c/Registration.h"
+#include "mlir-c/StandardTypes.h"
 
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 void populateLoopBody(MlirContext ctx, MlirBlock loopBody,
                       MlirLocation location, MlirBlock funcBody) {
   MlirValue iv = mlirBlockGetArgument(loopBody, 0);
static void printFirstOfEach(MlirOperation operation) {
   mlirValuePrint(value, printToStderr, NULL);
   fprintf(stderr, "\n");
 
   MlirType type = mlirValueGetType(value);
   mlirTypePrint(type, printToStderr, NULL);
   fprintf(stderr, "\n");
 }
 
+/// Dumps instances of all standard types to check that C API works correctly.
+/// Additionally, performs simple identity checks that a standard type
+/// constructed with C API can be inspected and has the expected type. The
+/// latter achieves full coverage of C API for standard types. Returns 0 on
+/// success and a non-zero error code on failure.
+static int printStandardTypes(MlirContext ctx) {
+  // Integer types.
+  MlirType i32 = mlirIntegerTypeGet(ctx, 32);
+  MlirType si32 = mlirIntegerTypeSignedGet(ctx, 32);
+  MlirType ui32 = mlirIntegerTypeUnsignedGet(ctx, 32);
+  if (!mlirTypeIsAInteger(i32) || mlirTypeIsAF32(i32))
+    return 1;
+  if (!mlirTypeIsAInteger(si32) || !mlirIntegerTypeIsSigned(si32))
+    return 2;
+  if (!mlirTypeIsAInteger(ui32) || !mlirIntegerTypeIsUnsigned(ui32))
+    return 3;
+  if (mlirTypeEqual(i32, ui32) || mlirTypeEqual(i32, si32))
+    return 4;
+  if (mlirIntegerTypeGetWidth(i32) != mlirIntegerTypeGetWidth(si32))
+    return 5;
+  mlirTypeDump(i32);
+  fprintf(stderr, "\n");
+  mlirTypeDump(si32);
+  fprintf(stderr, "\n");
+  mlirTypeDump(ui32);
+  fprintf(stderr, "\n");
+
+  // Index type.
+  MlirType index = mlirIndexTypeGet(ctx);
+  if (!mlirTypeIsAIndex(index))
+    return 6;
+  mlirTypeDump(index);
+  fprintf(stderr, "\n");
+
+  // Floating-point types.
+  MlirType bf16 = mlirBF16TypeGet(ctx);
+  MlirType f16 = mlirF16TypeGet(ctx);
+  MlirType f32 = mlirF32TypeGet(ctx);
+  MlirType f64 = mlirF64TypeGet(ctx);
+  if (!mlirTypeIsABF16(bf16))
+    return 7;
+  if (!mlirTypeIsAF16(f16))
+    return 9;
+  if (!mlirTypeIsAF32(f32))
+    return 10;
+  if (!mlirTypeIsAF64(f64))
+    return 11;
+  mlirTypeDump(bf16);
+  fprintf(stderr, "\n");
+  mlirTypeDump(f16);
+  fprintf(stderr, "\n");
+  mlirTypeDump(f32);
+  fprintf(stderr, "\n");
+  mlirTypeDump(f64);
+  fprintf(stderr, "\n");
+
+  // None type.
+  MlirType none = mlirNoneTypeGet(ctx);
+  if (!mlirTypeIsANone(none))
+    return 12;
+  mlirTypeDump(none);
+  fprintf(stderr, "\n");
+
+  // Complex type.
+  MlirType cplx = mlirComplexTypeGet(f32);
+  if (!mlirTypeIsAComplex(cplx) ||
+      !mlirTypeEqual(mlirComplexTypeGetElementType(cplx), f32))
+    return 13;
+  mlirTypeDump(cplx);
+  fprintf(stderr, "\n");
+
+  // Vector (and Shaped) type. ShapedType is a common base class for vectors,
+  // memrefs and tensors, one cannot create instances of this class so it is
+  // tested on an instance of vector type.
+  int64_t shape[] = {2, 3};
+  MlirType vector =
+      mlirVectorTypeGet(sizeof(shape) / sizeof(int64_t), shape, f32);
+  if (!mlirTypeIsAVector(vector) || !mlirTypeIsAShaped(vector))
+    return 14;
+  if (!mlirTypeEqual(mlirShapedTypeGetElementType(vector), f32) ||
+      !mlirShapedTypeHasRank(vector) || mlirShapedTypeGetRank(vector) != 2 ||
+      mlirShapedTypeGetDimSize(vector, 0) != 2 ||
+      mlirShapedTypeIsDynamicDim(vector, 0) ||
+      mlirShapedTypeGetDimSize(vector, 1) != 3 ||
+      !mlirShapedTypeHasStaticShape(vector))
+    return 15;
+  mlirTypeDump(vector);
+  fprintf(stderr, "\n");
+
+  // Ranked tensor type.
+  MlirType rankedTensor =
+      mlirRankedTensorTypeGet(sizeof(shape) / sizeof(int64_t), shape, f32);
+  if (!mlirTypeIsATensor(rankedTensor) ||
+      !mlirTypeIsARankedTensor(rankedTensor))
+    return 16;
+  mlirTypeDump(rankedTensor);
+  fprintf(stderr, "\n");
+
+  // Unranked tensor type.
+  MlirType unrankedTensor = mlirUnrankedTensorTypeGet(f32);
+  if (!mlirTypeIsATensor(unrankedTensor) ||
+      !mlirTypeIsAUnrankedTensor(unrankedTensor) ||
+      mlirShapedTypeHasRank(unrankedTensor))
+    return 17;
+  mlirTypeDump(unrankedTensor);
+  fprintf(stderr, "\n");
+
+  // MemRef type.
+  MlirType memRef = mlirMemRefTypeContiguousGet(
+      f32, sizeof(shape) / sizeof(int64_t), shape, 2);
+  if (!mlirTypeIsAMemRef(memRef) ||
+      mlirMemRefTypeGetNumAffineMaps(memRef) != 0 ||
+      mlirMemRefTypeGetMemorySpace(memRef) != 2)
+    return 18;
+  mlirTypeDump(memRef);
+  fprintf(stderr, "\n");
+
+  // Unranked MemRef type.
+  MlirType unrankedMemRef = mlirUnrankedMemRefTypeGet(f32, 4);
+  if (!mlirTypeIsAUnrankedMemRef(unrankedMemRef) ||
+      mlirTypeIsAMemRef(unrankedMemRef) ||
+      mlirUnrankedMemrefGetMemorySpace(unrankedMemRef) != 4)
+    return 19;
+  mlirTypeDump(unrankedMemRef);
+  fprintf(stderr, "\n");
+
+  // Tuple type.
+  MlirType types[] = {unrankedMemRef, f32};
+  MlirType tuple = mlirTupleTypeGet(ctx, 2, types);
+  if (!mlirTypeIsATuple(tuple) || mlirTupleTypeGetNumTypes(tuple) != 2 ||
+      !mlirTypeEqual(mlirTupleTypeGetType(tuple, 0), unrankedMemRef) ||
+      !mlirTypeEqual(mlirTupleTypeGetType(tuple, 1), f32))
+    return 20;
+  mlirTypeDump(tuple);
+  fprintf(stderr, "\n");
+
+  return 0;
+}
+
 int main() {
   mlirRegisterAllDialects();
   MlirContext ctx = mlirContextCreate();
   MlirLocation location = mlirLocationUnknownGet(ctx);
 
   MlirModule moduleOp = makeAdd(ctx, location);
   MlirOperation module = mlirModuleGetOperation(moduleOp);
   mlirOperationDump(module);
int main() {
   // CHECK: return
   // CHECK: constant 0 : index
   // CHECK: 0 : index
   // CHECK: constant 0 : index
   // CHECK: index
   // clang-format on
 
   mlirModuleDestroy(moduleOp);
+
+  // clang-format off
+  // CHECK-LABEL: @types
+  // CHECK: i32
+  // CHECK: si32
+  // CHECK: ui32
+  // CHECK: index
+  // CHECK: bf16
+  // CHECK: f16
+  // CHECK: f32
+  // CHECK: f64
+  // CHECK: none
+  // CHECK: complex<f32>
+  // CHECK: vector<2x3xf32>
+  // CHECK: tensor<2x3xf32>
+  // CHECK: tensor<*xf32>
+  // CHECK: memref<2x3xf32, 2>
+  // CHECK: memref<*xf32, 4>
+  // CHECK: tuple<memref<*xf32, 4>, f32>
+  // CHECK: 0
+  // clang-format on
+  fprintf(stderr, "@types");
+  int errcode = printStandardTypes(ctx);
+  fprintf(stderr, "%d\n", errcode);
+
   mlirContextDestroy(ctx);
 
   return 0;
 }