Move MLIR CAPI to mlir/core (NFC)

[mehdi_amini]

Summary

Followup on D121562 as a step as part of:
https://discourse.llvm.org/t/rfc-restructuring-of-the-mlir-repo/4927

[mehdi_amini]

mlir/lib/CMakeLists.txt

27

@stellaraccident : I'm trying to work around the issue that using a global property exposes us to the order of traversal in CMake.

If the core/ directory is traversed before the dialects are visited, the MLIR_DIALECT_LIBS property is still empty.
Instead I'm defining a library which cmake resolves after parsing completes (or something like that).

Ideally we'd use an "INTERFACE" library in cmake, but because it won't work with the install and export_set, I ended up adding an empty source file. Any better suggestion here?

[stellaraccident]

mlir/lib/CMakeLists.txt

27

I'm going to need to stare at this for a few minutes to have a concrete suggestion. I can think of some obvious quick fixes but would like to see if there is a way to avoid the weird coupling.

Have some meetings now but have a good chunk of time later today and will see if I can work this out.

[stellaraccident]

mlir/lib/CMakeLists.txt

27

I think that INTERFACE libraries can be installed (we use them that way elsewhere), but I also recall there being weirdness that may make them not great options. In the absence of that, this kind of empty.cpp is sota. I think you need the contents to be something like:

typedef int dummy;

(In order to avoid empty translation unit warnings in all cases).

See llvm/cmake/dummy.cpp.

I'd like to take a look at the tree and propose a better place for these kinds of things that need access to everything.

mlir/CMakeLists.txt

set(MLIR_DETECT_PYTHON_ENV_PRIME_SEARCH 1 CACHE BOOL
        "Prime the python detection by searching for a full 'Development' \
        component first (temporary while diagnosing environment specific Python \
        detection issues)")
 if(MLIR_ENABLE_BINDINGS_PYTHON)
   include(MLIRDetectPythonEnv)
   mlir_configure_python_dev_packages()
 endif()
 
+# For upstream, we accumulate all libraries into the MLIR_CAPI_LIBRARIES
+# property via a custom wrapper function. This is then used to create an
+# aggregate below.
+set_property(GLOBAL APPEND PROPERTY MLIR_CAPI_LIBRARIES)
+function(add_mlir_upstream_c_api_library name)
+  add_mlir_public_c_api_library(${name} ${ARGN})
+  set_property(GLOBAL APPEND PROPERTY MLIR_CAPI_LIBRARIES ${name})
+endfunction()
+
+
 include_directories( "include")
 include_directories( ${MLIR_INCLUDE_DIR})
 
 # Adding tools/mlir-tblgen here as calling add_tablegen sets some variables like
 # MLIR_TABLEGEN_EXE in PARENT_SCOPE which gets lost if that folder is included
 # from another directory like tools
 add_subdirectory(tools/mlir-tblgen)
 add_subdirectory(tools/mlir-linalg-ods-gen)

mlir/core/include/mlir-c/AffineExpr.h

 //===-- mlir-c/AffineExpr.h - C API for MLIR Affine Expressions ---*- 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_AFFINEEXPR_H
 #define 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.
 //===----------------------------------------------------------------------===//
 
 #define DEFINE_C_API_STRUCT(name, storage)                                     \
   struct name {                                                                \
     storage *ptr;                                                              \
   };                                                                           \
   typedef struct name name
 
 DEFINE_C_API_STRUCT(MlirAffineExpr, const void);
 
 #undef DEFINE_C_API_STRUCT
 
 struct MlirAffineMap;
 
 /// Gets the context that owns the affine expression.
 MLIR_CAPI_EXPORTED MlirContext
 mlirAffineExprGetContext(MlirAffineExpr affineExpr);
 
 /// Returns `true` if the two affine expressions are equal.
 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.
 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.
 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.
 MLIR_CAPI_EXPORTED bool mlirAffineExprIsPureAffine(MlirAffineExpr affineExpr);
 
 /// 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'.
 MLIR_CAPI_EXPORTED bool mlirAffineExprIsFunctionOfDim(MlirAffineExpr affineExpr,
                                                       intptr_t position);
 
 /// Composes the given map with the given expression.
 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineExprCompose(
     MlirAffineExpr affineExpr, struct MlirAffineMap affineMap);
 
 //===----------------------------------------------------------------------===//
 // Affine Dimension Expression.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given affine expression is a dimension expression.
 MLIR_CAPI_EXPORTED bool mlirAffineExprIsADim(MlirAffineExpr affineExpr);
 
 /// Creates an affine dimension expression with 'position' in the context.
 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineDimExprGet(MlirContext ctx,
                                                        intptr_t position);
 
 /// Returns the position of the given affine dimension expression.
 MLIR_CAPI_EXPORTED intptr_t
 mlirAffineDimExprGetPosition(MlirAffineExpr affineExpr);
 
 //===----------------------------------------------------------------------===//
 // Affine Symbol Expression.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given affine expression is a symbol expression.
 MLIR_CAPI_EXPORTED bool mlirAffineExprIsASymbol(MlirAffineExpr affineExpr);
 
 /// Creates an affine symbol expression with 'position' in the context.
 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineSymbolExprGet(MlirContext ctx,
                                                           intptr_t position);
 
 /// Returns the position of the given affine symbol expression.
 MLIR_CAPI_EXPORTED intptr_t
 mlirAffineSymbolExprGetPosition(MlirAffineExpr affineExpr);
 
 //===----------------------------------------------------------------------===//
 // Affine Constant Expression.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given affine expression is a constant expression.
 MLIR_CAPI_EXPORTED bool mlirAffineExprIsAConstant(MlirAffineExpr affineExpr);
 
 /// Creates an affine constant expression with 'constant' in the context.
 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineConstantExprGet(MlirContext ctx,
                                                             int64_t constant);
 
 /// Returns the value of the given affine constant expression.
 MLIR_CAPI_EXPORTED int64_t
 mlirAffineConstantExprGetValue(MlirAffineExpr affineExpr);
 
 //===----------------------------------------------------------------------===//
 // Affine Add Expression.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given affine expression is an add expression.
 MLIR_CAPI_EXPORTED bool mlirAffineExprIsAAdd(MlirAffineExpr affineExpr);
 
 /// Creates an affine add expression with 'lhs' and 'rhs'.
 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineAddExprGet(MlirAffineExpr lhs,
                                                        MlirAffineExpr rhs);
 
 //===----------------------------------------------------------------------===//
 // Affine Mul Expression.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given affine expression is an mul expression.
 MLIR_CAPI_EXPORTED bool mlirAffineExprIsAMul(MlirAffineExpr affineExpr);
 
 /// Creates an affine mul expression with 'lhs' and 'rhs'.
 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineMulExprGet(MlirAffineExpr lhs,
                                                        MlirAffineExpr rhs);
 
 //===----------------------------------------------------------------------===//
 // Affine Mod Expression.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given affine expression is an mod expression.
 MLIR_CAPI_EXPORTED bool mlirAffineExprIsAMod(MlirAffineExpr affineExpr);
 
 /// Creates an affine mod expression with 'lhs' and 'rhs'.
 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineModExprGet(MlirAffineExpr lhs,
                                                        MlirAffineExpr rhs);
 
 //===----------------------------------------------------------------------===//
 // Affine FloorDiv Expression.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given affine expression is an floordiv expression.
 MLIR_CAPI_EXPORTED bool mlirAffineExprIsAFloorDiv(MlirAffineExpr affineExpr);
 
 /// Creates an affine floordiv expression with 'lhs' and 'rhs'.
 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineFloorDivExprGet(MlirAffineExpr lhs,
                                                             MlirAffineExpr rhs);
 
 //===----------------------------------------------------------------------===//
 // Affine CeilDiv Expression.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given affine expression is an ceildiv expression.
 MLIR_CAPI_EXPORTED bool mlirAffineExprIsACeilDiv(MlirAffineExpr affineExpr);
 
 /// Creates an affine ceildiv expression with 'lhs' and 'rhs'.
 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineCeilDivExprGet(MlirAffineExpr lhs,
                                                            MlirAffineExpr rhs);
 
 //===----------------------------------------------------------------------===//
 // 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.
 MLIR_CAPI_EXPORTED MlirAffineExpr
 mlirAffineBinaryOpExprGetLHS(MlirAffineExpr affineExpr);
 
 /// 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/core/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/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.
 //===----------------------------------------------------------------------===//
 
 #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.
 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.
 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.
 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.
 
 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.
 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.
 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.
 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.
 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.
 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.
 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.
 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.
 MLIR_CAPI_EXPORTED intptr_t mlirAffineMapGetNumInputs(MlirAffineMap affineMap);
 
 /// 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.
 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.
 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.
 MLIR_CAPI_EXPORTED MlirAffineMap
 mlirAffineMapGetMinorSubMap(MlirAffineMap affineMap, intptr_t numResults);
 
 /// Apply AffineExpr::replace(`map`) to each of the results and return a new
 /// new AffineMap with the new results and the specified number of dims and
 /// symbols.
 MLIR_CAPI_EXPORTED MlirAffineMap mlirAffineMapReplace(
     MlirAffineMap affineMap, MlirAffineExpr expression,
     MlirAffineExpr replacement, intptr_t numResultDims, intptr_t numResultSyms);
 
 /// Returns the simplified affine map resulting from dropping the symbols that
 /// do not appear in any of the individual maps in `affineMaps`.
 /// Asserts that all maps in `affineMaps` are normalized to the same number of
 /// dims and symbols.
 /// Takes a callback `populateResult` to fill the `res` container with value
 /// `m` at entry `idx`. This allows returning without worrying about ownership
 /// considerations.
 MLIR_CAPI_EXPORTED void mlirAffineMapCompressUnusedSymbols(
     MlirAffineMap *affineMaps, intptr_t size, void *result,
     void (*populateResult)(void *res, intptr_t idx, MlirAffineMap m));
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_AFFINEMAP_H

mlir/core/include/mlir-c/BuiltinAttributes.h

 //===-- mlir-c/BuiltinAttributes.h - C API for Builtin Attributes -*- C -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM
 // Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This header declares the C interface to MLIR Builtin attributes.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_C_BUILTINATTRIBUTES_H
 #define MLIR_C_BUILTINATTRIBUTES_H
 
 #include "mlir-c/AffineMap.h"
 #include "mlir-c/IR.h"
 #include "mlir-c/Support.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /// Returns an empty attribute.
 MLIR_CAPI_EXPORTED MlirAttribute mlirAttributeGetNull();
 
 //===----------------------------------------------------------------------===//
 // 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.
 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.
 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.
 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.
 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.
 
 /// 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.
 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.
 MLIR_CAPI_EXPORTED MlirAttribute mlirFloatAttrDoubleGetChecked(MlirLocation loc,
                                                                MlirType type,
                                                                double value);
 
 /// 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.
 
 /// 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.
 MLIR_CAPI_EXPORTED MlirAttribute mlirIntegerAttrGet(MlirType type,
                                                     int64_t value);
 
 /// Returns the value stored in the given integer attribute, assuming the value
 /// is of signless type and fits into a signed 64-bit integer.
 MLIR_CAPI_EXPORTED int64_t mlirIntegerAttrGetValueInt(MlirAttribute attr);
 
 /// Returns the value stored in the given integer attribute, assuming the value
 /// is of signed type and fits into a signed 64-bit integer.
 MLIR_CAPI_EXPORTED int64_t mlirIntegerAttrGetValueSInt(MlirAttribute attr);
 
 /// Returns the value stored in the given integer attribute, assuming the value
 /// is of unsigned type and fits into an unsigned 64-bit integer.
 MLIR_CAPI_EXPORTED uint64_t mlirIntegerAttrGetValueUInt(MlirAttribute attr);
 
 //===----------------------------------------------------------------------===//
 // Bool attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is a bool attribute.
 MLIR_CAPI_EXPORTED bool mlirAttributeIsABool(MlirAttribute attr);
 
 /// Creates a bool attribute in the given context with the given value.
 MLIR_CAPI_EXPORTED MlirAttribute mlirBoolAttrGet(MlirContext ctx, int value);
 
 /// Returns the value stored in the given bool attribute.
 MLIR_CAPI_EXPORTED bool mlirBoolAttrGetValue(MlirAttribute attr);
 
 //===----------------------------------------------------------------------===//
 // Integer set attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is an integer set attribute.
 MLIR_CAPI_EXPORTED bool mlirAttributeIsAIntegerSet(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).
 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.
 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.
 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.
 
 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.
 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.
 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.
 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.
 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.
 MLIR_CAPI_EXPORTED MlirStringRef
 mlirSymbolRefAttrGetLeafReference(MlirAttribute attr);
 
 /// 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.
 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.
 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.
 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 a unit attribute.
 MLIR_CAPI_EXPORTED bool mlirAttributeIsAUnit(MlirAttribute attr);
 
 /// Creates a unit attribute in the given context.
 MLIR_CAPI_EXPORTED MlirAttribute mlirUnitAttrGet(MlirContext ctx);
 
 //===----------------------------------------------------------------------===//
 // Elements attributes.
 //===----------------------------------------------------------------------===//
 
 /// 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.
 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.
 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.
 
 /// 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.
 MLIR_CAPI_EXPORTED MlirAttribute mlirDenseElementsAttrGet(
     MlirType shapedType, intptr_t numElements, MlirAttribute const *elements);
 
 /// Creates a dense elements attribute with the given Shaped type and elements
 /// populated from a packed, row-major opaque buffer of contents.
 ///
 /// The format of the raw buffer is a densely packed array of values that
 /// can be bitcast to the storage format of the element type specified.
 /// Types that are not byte aligned will be:
 ///   - For bitwidth > 1: Rounded up to the next byte.
 ///   - For bitwidth = 1: Packed into 8bit bytes with bits corresponding to
 ///     the linear order of the shape type from MSB to LSB, padded to on the
 ///     right.
 ///
 /// A raw buffer of a single element (or for 1-bit, a byte of value 0 or 255)
 /// will be interpreted as a splat. User code should be prepared for additional,
 /// conformant patterns to be identified as splats in the future.
 MLIR_CAPI_EXPORTED MlirAttribute mlirDenseElementsAttrRawBufferGet(
     MlirType shapedType, size_t rawBufferSize, const void *rawBuffer);
 
 /// Creates a dense elements attribute with the given Shaped type containing a
 /// single replicated element (splat).
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrSplatGet(MlirType shapedType, MlirAttribute element);
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrBoolSplatGet(MlirType shapedType, bool element);
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrUInt8SplatGet(MlirType shapedType, uint8_t element);
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrInt8SplatGet(MlirType shapedType, int8_t element);
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrUInt32SplatGet(MlirType shapedType, uint32_t element);
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrInt32SplatGet(MlirType shapedType, int32_t element);
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrUInt64SplatGet(MlirType shapedType, uint64_t element);
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrInt64SplatGet(MlirType shapedType, int64_t element);
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrFloatSplatGet(MlirType shapedType, float element);
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrDoubleSplatGet(MlirType shapedType, double element);
 
 /// Creates a dense elements attribute with the given shaped type from elements
 /// of a specific type. Expects the element type of the shaped type to match the
 /// data element type.
 MLIR_CAPI_EXPORTED MlirAttribute mlirDenseElementsAttrBoolGet(
     MlirType shapedType, intptr_t numElements, const int *elements);
 MLIR_CAPI_EXPORTED MlirAttribute mlirDenseElementsAttrUInt8Get(
     MlirType shapedType, intptr_t numElements, const uint8_t *elements);
 MLIR_CAPI_EXPORTED MlirAttribute mlirDenseElementsAttrInt8Get(
     MlirType shapedType, intptr_t numElements, const int8_t *elements);
 MLIR_CAPI_EXPORTED MlirAttribute mlirDenseElementsAttrUInt16Get(
     MlirType shapedType, intptr_t numElements, const uint16_t *elements);
 MLIR_CAPI_EXPORTED MlirAttribute mlirDenseElementsAttrInt16Get(
     MlirType shapedType, intptr_t numElements, const int16_t *elements);
 MLIR_CAPI_EXPORTED MlirAttribute mlirDenseElementsAttrUInt32Get(
     MlirType shapedType, intptr_t numElements, const uint32_t *elements);
 MLIR_CAPI_EXPORTED MlirAttribute mlirDenseElementsAttrInt32Get(
     MlirType shapedType, intptr_t numElements, const int32_t *elements);
 MLIR_CAPI_EXPORTED MlirAttribute mlirDenseElementsAttrUInt64Get(
     MlirType shapedType, intptr_t numElements, const uint64_t *elements);
 MLIR_CAPI_EXPORTED MlirAttribute mlirDenseElementsAttrInt64Get(
     MlirType shapedType, intptr_t numElements, const int64_t *elements);
 MLIR_CAPI_EXPORTED 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.
 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.
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrReshapeGet(MlirAttribute attr, MlirType shapedType);
 
 /// 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.
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrGetSplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED int
 mlirDenseElementsAttrGetBoolSplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED int8_t
 mlirDenseElementsAttrGetInt8SplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED uint8_t
 mlirDenseElementsAttrGetUInt8SplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED int32_t
 mlirDenseElementsAttrGetInt32SplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED uint32_t
 mlirDenseElementsAttrGetUInt32SplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED int64_t
 mlirDenseElementsAttrGetInt64SplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED uint64_t
 mlirDenseElementsAttrGetUInt64SplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED float
 mlirDenseElementsAttrGetFloatSplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED double
 mlirDenseElementsAttrGetDoubleSplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED MlirStringRef
 mlirDenseElementsAttrGetStringSplatValue(MlirAttribute attr);
 
 /// Returns the pos-th value (flat contiguous indexing) of a specific type
 /// contained by the given dense elements attribute.
 MLIR_CAPI_EXPORTED bool mlirDenseElementsAttrGetBoolValue(MlirAttribute attr,
                                                           intptr_t pos);
 MLIR_CAPI_EXPORTED int8_t mlirDenseElementsAttrGetInt8Value(MlirAttribute attr,
                                                             intptr_t pos);
 MLIR_CAPI_EXPORTED uint8_t
 mlirDenseElementsAttrGetUInt8Value(MlirAttribute attr, intptr_t pos);
 MLIR_CAPI_EXPORTED int16_t
 mlirDenseElementsAttrGetInt16Value(MlirAttribute attr, intptr_t pos);
 MLIR_CAPI_EXPORTED uint16_t
 mlirDenseElementsAttrGetUInt16Value(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.
 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.
 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.
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirSparseElementsAttrGetIndices(MlirAttribute attr);
 
 /// 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/core/include/mlir-c/BuiltinTypes.h

 //===-- mlir-c/BuiltinTypes.h - C API for MLIR Builtin 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_BUILTINTYPES_H
 #define MLIR_C_BUILTINTYPES_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.
 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.
 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.
 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.
 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.
 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.
 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.
 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.
 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.
 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.
 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.
 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 whether the given type is a Shaped type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsAShaped(MlirType type);
 
 /// Returns the element type of the shaped type.
 MLIR_CAPI_EXPORTED MlirType mlirShapedTypeGetElementType(MlirType type);
 
 /// Checks whether the given shaped type is ranked.
 MLIR_CAPI_EXPORTED bool mlirShapedTypeHasRank(MlirType type);
 
 /// Returns the rank of the given ranked shaped type.
 MLIR_CAPI_EXPORTED int64_t mlirShapedTypeGetRank(MlirType type);
 
 /// Checks whether the given shaped type has a static shape.
 MLIR_CAPI_EXPORTED bool mlirShapedTypeHasStaticShape(MlirType 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.
 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.
 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.
 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.
 MLIR_CAPI_EXPORTED MlirType mlirVectorTypeGetChecked(MlirLocation loc,
                                                      intptr_t rank,
                                                      const int64_t *shape,
                                                      MlirType elementType);
 
 //===----------------------------------------------------------------------===//
 // 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, element type,
 /// and optional encoding in the same context as the element type. The type is
 /// owned by the context. Tensor types without any specific encoding field
 /// should assign mlirAttributeGetNull() to this parameter.
 MLIR_CAPI_EXPORTED MlirType mlirRankedTensorTypeGet(intptr_t rank,
                                                     const int64_t *shape,
                                                     MlirType elementType,
                                                     MlirAttribute encoding);
 
 /// Same as "mlirRankedTensorTypeGet" but returns a nullptr wrapping MlirType on
 /// illegal arguments, emitting appropriate diagnostics.
 MLIR_CAPI_EXPORTED MlirType mlirRankedTensorTypeGetChecked(
     MlirLocation loc, intptr_t rank, const int64_t *shape, MlirType elementType,
     MlirAttribute encoding);
 
 /// Gets the 'encoding' attribute from the ranked tensor type, returning a null
 /// attribute if none.
 MLIR_CAPI_EXPORTED MlirAttribute mlirRankedTensorTypeGetEncoding(MlirType type);
 
 /// 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.
 MLIR_CAPI_EXPORTED MlirType
 mlirUnrankedTensorTypeGetChecked(MlirLocation loc, MlirType elementType);
 
 //===----------------------------------------------------------------------===//
 // 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.
 MLIR_CAPI_EXPORTED MlirType mlirMemRefTypeGet(MlirType elementType,
                                               intptr_t rank,
                                               const int64_t *shape,
                                               MlirAttribute layout,
                                               MlirAttribute memorySpace);
 
 /// Same as "mlirMemRefTypeGet" but returns a nullptr-wrapping MlirType o
 /// illegal arguments, emitting appropriate diagnostics.
 MLIR_CAPI_EXPORTED MlirType mlirMemRefTypeGetChecked(
     MlirLocation loc, MlirType elementType, intptr_t rank, const int64_t *shape,
     MlirAttribute layout, MlirAttribute 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.
 MLIR_CAPI_EXPORTED MlirType
 mlirMemRefTypeContiguousGet(MlirType elementType, intptr_t rank,
                             const int64_t *shape, MlirAttribute memorySpace);
 
 /// Same as "mlirMemRefTypeContiguousGet" but returns a nullptr wrapping
 /// MlirType on illegal arguments, emitting appropriate diagnostics.
 MLIR_CAPI_EXPORTED MlirType mlirMemRefTypeContiguousGetChecked(
     MlirLocation loc, MlirType elementType, intptr_t rank, const int64_t *shape,
     MlirAttribute 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.
 MLIR_CAPI_EXPORTED MlirType
 mlirUnrankedMemRefTypeGet(MlirType elementType, MlirAttribute memorySpace);
 
 /// Same as "mlirUnrankedMemRefTypeGet" but returns a nullptr wrapping
 /// MlirType on illegal arguments, emitting appropriate diagnostics.
 MLIR_CAPI_EXPORTED MlirType mlirUnrankedMemRefTypeGetChecked(
     MlirLocation loc, MlirType elementType, MlirAttribute memorySpace);
 
 /// Returns the layout of the given MemRef type.
 MLIR_CAPI_EXPORTED MlirAttribute mlirMemRefTypeGetLayout(MlirType type);
 
 /// Returns the affine map of the given MemRef type.
 MLIR_CAPI_EXPORTED MlirAffineMap mlirMemRefTypeGetAffineMap(MlirType type);
 
 /// Returns the memory space of the given MemRef type.
 MLIR_CAPI_EXPORTED MlirAttribute mlirMemRefTypeGetMemorySpace(MlirType type);
 
 /// Returns the memory spcae of the given Unranked MemRef type.
 MLIR_CAPI_EXPORTED MlirAttribute
 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.
 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_CAPI_EXPORTED MlirType mlirTupleTypeGetType(MlirType type, intptr_t pos);
 
 //===----------------------------------------------------------------------===//
 // Function type.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is a function type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsAFunction(MlirType type);
 
 /// Creates a function type, mapping a list of input types to result types.
 MLIR_CAPI_EXPORTED MlirType mlirFunctionTypeGet(MlirContext ctx,
                                                 intptr_t numInputs,
                                                 MlirType const *inputs,
                                                 intptr_t numResults,
                                                 MlirType const *results);
 
 /// Returns the number of input types.
 MLIR_CAPI_EXPORTED intptr_t mlirFunctionTypeGetNumInputs(MlirType type);
 
 /// Returns the number of result types.
 MLIR_CAPI_EXPORTED intptr_t mlirFunctionTypeGetNumResults(MlirType type);
 
 /// Returns the pos-th input type.
 MLIR_CAPI_EXPORTED MlirType mlirFunctionTypeGetInput(MlirType type,
                                                      intptr_t pos);
 
 /// Returns the pos-th result type.
 MLIR_CAPI_EXPORTED MlirType mlirFunctionTypeGetResult(MlirType type,
                                                       intptr_t pos);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_BUILTINTYPES_H

mlir/core/include/mlir-c/Debug.h

 //===-- mlir-c/Debug.h - C API for MLIR/LLVM debugging functions --*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir-c/Support.h"
 
 #include <stdbool.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /// Sets the global debugging flag.
 MLIR_CAPI_EXPORTED void mlirEnableGlobalDebug(bool enable);
 
 /// Retuns `true` if the global debugging flag is set, false otherwise.
 MLIR_CAPI_EXPORTED bool mlirIsGlobalDebugEnabled();
 
 #ifdef __cplusplus
 }
 #endif
 
 #ifndef MLIR_C_DEBUG_H
 #define MLIR_C_DEBUG_H
 #endif // MLIR_C_DEBUG_H

mlir/core/include/mlir-c/Diagnostics.h

 //===-- mlir-c/Diagnostics.h - MLIR Diagnostic subsystem C API ----*- C -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM
 // Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This header declares the C APIs accessing MLIR Diagnostics subsystem.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_C_DIAGNOSTICS_H
 #define 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.
 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.
 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.
 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.
 
 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.
 MLIR_CAPI_EXPORTED void
 mlirContextDetachDiagnosticHandler(MlirContext context,
                                    MlirDiagnosticHandlerID id);
 
 /// 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/core/include/mlir-c/IR.h

 //===-- mlir-c/IR.h - C API to Core MLIR IR 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 header declares the C interface to MLIR core IR classes.
 //
 // Many exotic languages can interoperate with C code but have a harder time
 // with C++ due to name mangling. So in addition to C, this interface enables
 // tools written in such languages.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_C_IR_H
 #define MLIR_C_IR_H
 
 #include <stdbool.h>
 #include <stdint.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.
 
 //===----------------------------------------------------------------------===//
 
 #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(MlirDialectRegistry, 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(MlirSymbolTable, 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(MlirTypeID, 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.
 
 struct MlirNamedAttribute {
   MlirIdentifier name;
   MlirAttribute attribute;
 };
 typedef struct MlirNamedAttribute MlirNamedAttribute;
 
 //===----------------------------------------------------------------------===//
 // Context API.
 //===----------------------------------------------------------------------===//
 
 /// Creates an MLIR context and transfers its ownership to the caller.
 MLIR_CAPI_EXPORTED MlirContext mlirContextCreate();
 
 /// Checks if two contexts are equal.
 MLIR_CAPI_EXPORTED bool mlirContextEqual(MlirContext ctx1, MlirContext ctx2);
 
 /// Checks whether a context is null.
 static inline bool mlirContextIsNull(MlirContext context) {
   return !context.ptr;
 }
 
 /// Takes an MLIR context owned by the caller and destroys it.
 MLIR_CAPI_EXPORTED void mlirContextDestroy(MlirContext context);
 
 /// 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.
 MLIR_CAPI_EXPORTED intptr_t
 mlirContextGetNumRegisteredDialects(MlirContext context);
 
 /// Append the contents of the given dialect registry to the registry associated
 /// with the context.
 MLIR_CAPI_EXPORTED void
 mlirContextAppendDialectRegistry(MlirContext ctx, MlirDialectRegistry registry);
 
 /// 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.
 MLIR_CAPI_EXPORTED MlirDialect mlirContextGetOrLoadDialect(MlirContext context,
                                                            MlirStringRef name);
 
 /// Set threading mode (must be set to false to print-ir-after-all).
 MLIR_CAPI_EXPORTED void mlirContextEnableMultithreading(MlirContext context,
                                                         bool enable);
 
 /// Returns whether the given fully-qualified operation (i.e.
 /// 'dialect.operation') is registered with the context. This will return true
 /// if the dialect is loaded and the operation is registered within the
 /// dialect.
 MLIR_CAPI_EXPORTED bool mlirContextIsRegisteredOperation(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.
 MLIR_CAPI_EXPORTED bool mlirDialectEqual(MlirDialect dialect1,
                                          MlirDialect dialect2);
 
 /// Returns the namespace of the given dialect.
 MLIR_CAPI_EXPORTED MlirStringRef mlirDialectGetNamespace(MlirDialect dialect);
 
 //===----------------------------------------------------------------------===//
 // DialectRegistry API.
 //===----------------------------------------------------------------------===//
 
 /// Creates a dialect registry and transfers its ownership to the caller.
 MLIR_CAPI_EXPORTED MlirDialectRegistry mlirDialectRegistryCreate();
 
 /// Checks if the dialect registry is null.
 static inline bool mlirDialectRegistryIsNull(MlirDialectRegistry registry) {
   return !registry.ptr;
 }
 
 /// Takes a dialect registry owned by the caller and destroys it.
 MLIR_CAPI_EXPORTED void
 mlirDialectRegistryDestroy(MlirDialectRegistry registry);
 
 //===----------------------------------------------------------------------===//
 // Location API.
 //===----------------------------------------------------------------------===//
 
 /// Creates an File/Line/Column location owned by the given context.
 MLIR_CAPI_EXPORTED MlirLocation mlirLocationFileLineColGet(
     MlirContext context, MlirStringRef filename, unsigned line, unsigned col);
 
 /// Creates a call site location with a callee and a caller.
 MLIR_CAPI_EXPORTED MlirLocation mlirLocationCallSiteGet(MlirLocation callee,
                                                         MlirLocation caller);
 
 /// Creates a fused location with an array of locations and metadata.
 MLIR_CAPI_EXPORTED MlirLocation
 mlirLocationFusedGet(MlirContext ctx, intptr_t nLocations,
                      MlirLocation const *locations, MlirAttribute metadata);
 
 /// Creates a name location owned by the given context. Providing null location
 /// for childLoc is allowed and if childLoc is null location, then the behavior
 /// is the same as having unknown child location.
 MLIR_CAPI_EXPORTED MlirLocation mlirLocationNameGet(MlirContext context,
                                                     MlirStringRef name,
                                                     MlirLocation childLoc);
 
 /// Creates a location with unknown position owned by the given context.
 MLIR_CAPI_EXPORTED MlirLocation mlirLocationUnknownGet(MlirContext context);
 
 /// Gets the context that a location was created with.
 MLIR_CAPI_EXPORTED MlirContext mlirLocationGetContext(MlirLocation location);
 
 /// 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.
 MLIR_CAPI_EXPORTED void mlirLocationPrint(MlirLocation location,
                                           MlirStringCallback callback,
                                           void *userData);
 
 //===----------------------------------------------------------------------===//
 // Module API.
 //===----------------------------------------------------------------------===//
 
 /// Creates a new, empty module and transfers ownership to the caller.
 MLIR_CAPI_EXPORTED MlirModule mlirModuleCreateEmpty(MlirLocation location);
 
 /// Parses a module from the string and transfers ownership to the caller.
 MLIR_CAPI_EXPORTED MlirModule mlirModuleCreateParse(MlirContext context,
                                                     MlirStringRef module);
 
 /// Gets the context that a module was created with.
 MLIR_CAPI_EXPORTED MlirContext mlirModuleGetContext(MlirModule module);
 
 /// Gets the body of the module, i.e. the only block it contains.
 MLIR_CAPI_EXPORTED MlirBlock mlirModuleGetBody(MlirModule module);
 
 /// Checks whether a module is null.
 static inline bool mlirModuleIsNull(MlirModule module) { return !module.ptr; }
 
 /// Takes a module owned by the caller and deletes it.
 MLIR_CAPI_EXPORTED void mlirModuleDestroy(MlirModule module);
 
 /// Views the module as a generic operation.
 MLIR_CAPI_EXPORTED MlirOperation mlirModuleGetOperation(MlirModule module);
 
 /// Views the generic operation as a module.
 /// The returned module is null when the input operation was not a ModuleOp.
 MLIR_CAPI_EXPORTED MlirModule mlirModuleFromOperation(MlirOperation op);
 
 //===----------------------------------------------------------------------===//
 // 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.
 
 struct MlirOperationState {
   MlirStringRef name;
   MlirLocation location;
   intptr_t nResults;
   MlirType *results;
   intptr_t nOperands;
   MlirValue *operands;
   intptr_t nRegions;
   MlirRegion *regions;
   intptr_t nSuccessors;
   MlirBlock *successors;
   intptr_t nAttributes;
   MlirNamedAttribute *attributes;
   bool enableResultTypeInference;
 };
 typedef struct MlirOperationState MlirOperationState;
 
 /// Constructs an operation state from a name and a location.
 MLIR_CAPI_EXPORTED MlirOperationState mlirOperationStateGet(MlirStringRef name,
                                                             MlirLocation loc);
 
 /// Adds a list of components to the operation state.
 MLIR_CAPI_EXPORTED void mlirOperationStateAddResults(MlirOperationState *state,
                                                      intptr_t n,
                                                      MlirType const *results);
 MLIR_CAPI_EXPORTED void
 mlirOperationStateAddOperands(MlirOperationState *state, intptr_t n,
                               MlirValue const *operands);
 MLIR_CAPI_EXPORTED void
 mlirOperationStateAddOwnedRegions(MlirOperationState *state, intptr_t n,
                                   MlirRegion const *regions);
 MLIR_CAPI_EXPORTED void
 mlirOperationStateAddSuccessors(MlirOperationState *state, intptr_t n,
                                 MlirBlock const *successors);
 MLIR_CAPI_EXPORTED void
 mlirOperationStateAddAttributes(MlirOperationState *state, intptr_t n,
                                 MlirNamedAttribute const *attributes);
 
 /// Enables result type inference for the operation under construction. If
 /// enabled, then the caller must not have called
 /// mlirOperationStateAddResults(). Note that if enabled, the
 /// mlirOperationCreate() call is failable: it will return a null operation
 /// on inference failure and will emit diagnostics.
 MLIR_CAPI_EXPORTED void
 mlirOperationStateEnableResultTypeInference(MlirOperationState *state);
 
 //===----------------------------------------------------------------------===//
 // 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().
 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.
 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.
 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.
 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);
 
 /// Creates a deep copy of an operation. The operation is not inserted and
 /// ownership is transferred to the caller.
 MLIR_CAPI_EXPORTED MlirOperation mlirOperationClone(MlirOperation op);
 
 /// Takes an operation owned by the caller and destroys it.
 MLIR_CAPI_EXPORTED void mlirOperationDestroy(MlirOperation op);
 
 /// Removes the given operation from its parent block. The operation is not
 /// destroyed. The ownership of the operation is transferred to the caller.
 MLIR_CAPI_EXPORTED void mlirOperationRemoveFromParent(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.
 MLIR_CAPI_EXPORTED bool mlirOperationEqual(MlirOperation op,
                                            MlirOperation other);
 
 /// Gets the context this operation is associated with
 MLIR_CAPI_EXPORTED MlirContext mlirOperationGetContext(MlirOperation op);
 
 /// Gets the location of the operation.
 MLIR_CAPI_EXPORTED MlirLocation mlirOperationGetLocation(MlirOperation op);
 
 /// Gets the type id of the operation.
 /// Returns null if the operation does not have a registered operation
 /// description.
 MLIR_CAPI_EXPORTED MlirTypeID mlirOperationGetTypeID(MlirOperation op);
 
 /// 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.
 MLIR_CAPI_EXPORTED MlirBlock mlirOperationGetBlock(MlirOperation op);
 
 /// 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.
 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);
 
 /// Sets the `pos`-th operand of the operation.
 MLIR_CAPI_EXPORTED void mlirOperationSetOperand(MlirOperation op, intptr_t pos,
                                                 MlirValue newValue);
 
 /// Returns the number of results of the operation.
 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumResults(MlirOperation op);
 
 /// Returns `pos`-th result of the operation.
 MLIR_CAPI_EXPORTED MlirValue mlirOperationGetResult(MlirOperation op,
                                                     intptr_t pos);
 
 /// Returns the number of successor blocks of the operation.
 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumSuccessors(MlirOperation op);
 
 /// Returns `pos`-th successor of the operation.
 MLIR_CAPI_EXPORTED MlirBlock mlirOperationGetSuccessor(MlirOperation op,
                                                        intptr_t pos);
 
 /// Returns the number of attributes attached to the operation.
 MLIR_CAPI_EXPORTED intptr_t mlirOperationGetNumAttributes(MlirOperation op);
 
 /// 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.
 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.
 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.
 MLIR_CAPI_EXPORTED void mlirOperationPrint(MlirOperation op,
                                            MlirStringCallback callback,
                                            void *userData);
 
 /// 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);
 
 /// Verify the operation and return true if it passes, false if it fails.
 MLIR_CAPI_EXPORTED bool mlirOperationVerify(MlirOperation op);
 
 /// Moves the given operation immediately after the other operation in its
 /// parent block. The given operation may be owned by the caller or by its
 /// current block. The other operation must belong to a block. In any case, the
 /// ownership is transferred to the block of the other operation.
 MLIR_CAPI_EXPORTED void mlirOperationMoveAfter(MlirOperation op,
                                                MlirOperation other);
 
 /// Moves the given operation immediately before the other operation in its
 /// parent block. The given operation may be owner by the caller or by its
 /// current block. The other operation must belong to a block. In any case, the
 /// ownership is transferred to the block of the other operation.
 MLIR_CAPI_EXPORTED void mlirOperationMoveBefore(MlirOperation op,
                                                 MlirOperation other);
 //===----------------------------------------------------------------------===//
 // Region API.
 //===----------------------------------------------------------------------===//
 
 /// Creates a new empty region and transfers ownership to the caller.
 MLIR_CAPI_EXPORTED MlirRegion mlirRegionCreate();
 
 /// Takes a region owned by the caller and destroys it.
 MLIR_CAPI_EXPORTED void mlirRegionDestroy(MlirRegion region);
 
 /// Checks whether a region is null.
 static inline bool mlirRegionIsNull(MlirRegion region) { return !region.ptr; }
 
 /// Checks whether two region handles point to the same region. This does not
 /// perform deep comparison.
 MLIR_CAPI_EXPORTED bool mlirRegionEqual(MlirRegion region, MlirRegion other);
 
 /// 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.
 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.
 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.
 MLIR_CAPI_EXPORTED void mlirRegionInsertOwnedBlockBefore(MlirRegion region,
                                                          MlirBlock reference,
                                                          MlirBlock block);
 
 /// Returns first region attached to the operation.
 MLIR_CAPI_EXPORTED MlirRegion mlirOperationGetFirstRegion(MlirOperation op);
 
 /// Returns the region immediately following the given region in its parent
 /// operation.
 MLIR_CAPI_EXPORTED MlirRegion mlirRegionGetNextInOperation(MlirRegion region);
 
 //===----------------------------------------------------------------------===//
 // Block API.
 //===----------------------------------------------------------------------===//
 
 /// 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,
                                              MlirLocation const *locs);
 
 /// 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.
 MLIR_CAPI_EXPORTED bool mlirBlockEqual(MlirBlock block, MlirBlock other);
 
 /// Returns the closest surrounding operation that contains this block.
 MLIR_CAPI_EXPORTED MlirOperation mlirBlockGetParentOperation(MlirBlock);
 
 /// Returns the region that contains this block.
 MLIR_CAPI_EXPORTED MlirRegion mlirBlockGetParentRegion(MlirBlock block);
 
 /// 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.
 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.
 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.
 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);
 
 /// Appends an argument of the specified type to the block. Returns the newly
 /// added argument.
 MLIR_CAPI_EXPORTED MlirValue mlirBlockAddArgument(MlirBlock block,
                                                   MlirType type,
                                                   MlirLocation loc);
 
 /// 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.
 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.
 MLIR_CAPI_EXPORTED 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.
 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.
 MLIR_CAPI_EXPORTED MlirOperation mlirOpResultGetOwner(MlirValue value);
 
 /// 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.
 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);
 
 /// Gets the type ID of the type.
 MLIR_CAPI_EXPORTED MlirTypeID mlirTypeGetTypeID(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.
 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.
 //===----------------------------------------------------------------------===//
 
 /// Parses an attribute. The attribute is owned by the context.
 MLIR_CAPI_EXPORTED MlirAttribute mlirAttributeParseGet(MlirContext context,
                                                        MlirStringRef attr);
 
 /// Gets the context that an attribute was created with.
 MLIR_CAPI_EXPORTED MlirContext mlirAttributeGetContext(MlirAttribute attribute);
 
 /// Gets the type of this attribute.
 MLIR_CAPI_EXPORTED MlirType mlirAttributeGetType(MlirAttribute attribute);
 
 /// Gets the type id of the attribute.
 MLIR_CAPI_EXPORTED MlirTypeID mlirAttributeGetTypeID(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.
 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_CAPI_EXPORTED MlirNamedAttribute mlirNamedAttributeGet(MlirIdentifier name,
                                                             MlirAttribute attr);
 
 //===----------------------------------------------------------------------===//
 // Identifier API.
 //===----------------------------------------------------------------------===//
 
 /// Gets an identifier with the given string value.
 MLIR_CAPI_EXPORTED MlirIdentifier mlirIdentifierGet(MlirContext context,
                                                     MlirStringRef str);
 
 /// Returns the context associated with this identifier
 MLIR_CAPI_EXPORTED MlirContext mlirIdentifierGetContext(MlirIdentifier);
 
 /// Checks whether two identifiers are the same.
 MLIR_CAPI_EXPORTED bool mlirIdentifierEqual(MlirIdentifier ident,
                                             MlirIdentifier other);
 
 /// Gets the string value of the identifier.
 MLIR_CAPI_EXPORTED MlirStringRef mlirIdentifierStr(MlirIdentifier ident);
 
 //===----------------------------------------------------------------------===//
 // TypeID API.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether a type id is null.
 static inline bool mlirTypeIDIsNull(MlirTypeID typeID) { return !typeID.ptr; }
 
 /// Checks if two type ids are equal.
 MLIR_CAPI_EXPORTED bool mlirTypeIDEqual(MlirTypeID typeID1, MlirTypeID typeID2);
 
 /// Returns the hash value of the type id.
 MLIR_CAPI_EXPORTED size_t mlirTypeIDHashValue(MlirTypeID typeID);
 
 //===----------------------------------------------------------------------===//
 // Symbol and SymbolTable API.
 //===----------------------------------------------------------------------===//
 
 /// Returns the name of the attribute used to store symbol names compatible with
 /// symbol tables.
 MLIR_CAPI_EXPORTED MlirStringRef mlirSymbolTableGetSymbolAttributeName();
 
 /// Returns the name of the attribute used to store symbol visibility.
 MLIR_CAPI_EXPORTED MlirStringRef mlirSymbolTableGetVisibilityAttributeName();
 
 /// Creates a symbol table for the given operation. If the operation does not
 /// have the SymbolTable trait, returns a null symbol table.
 MLIR_CAPI_EXPORTED MlirSymbolTable
 mlirSymbolTableCreate(MlirOperation operation);
 
 /// Returns true if the symbol table is null.
 static inline bool mlirSymbolTableIsNull(MlirSymbolTable symbolTable) {
   return !symbolTable.ptr;
 }
 
 /// Destroys the symbol table created with mlirSymbolTableCreate. This does not
 /// affect the operations in the table.
 MLIR_CAPI_EXPORTED void mlirSymbolTableDestroy(MlirSymbolTable symbolTable);
 
 /// Looks up a symbol with the given name in the given symbol table and returns
 /// the operation that corresponds to the symbol. If the symbol cannot be found,
 /// returns a null operation.
 MLIR_CAPI_EXPORTED MlirOperation
 mlirSymbolTableLookup(MlirSymbolTable symbolTable, MlirStringRef name);
 
 /// Inserts the given operation into the given symbol table. The operation must
 /// have the symbol trait. If the symbol table already has a symbol with the
 /// same name, renames the symbol being inserted to ensure name uniqueness. Note
 /// that this does not move the operation itself into the block of the symbol
 /// table operation, this should be done separately. Returns the name of the
 /// symbol after insertion.
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirSymbolTableInsert(MlirSymbolTable symbolTable, MlirOperation operation);
 
 /// Removes the given operation from the symbol table and erases it.
 MLIR_CAPI_EXPORTED void mlirSymbolTableErase(MlirSymbolTable symbolTable,
                                              MlirOperation operation);
 
 /// Attempt to replace all uses that are nested within the given operation
 /// of the given symbol 'oldSymbol' with the provided 'newSymbol'. This does
 /// not traverse into nested symbol tables. Will fail atomically if there are
 /// any unknown operations that may be potential symbol tables.
 MLIR_CAPI_EXPORTED MlirLogicalResult mlirSymbolTableReplaceAllSymbolUses(
     MlirStringRef oldSymbol, MlirStringRef newSymbol, MlirOperation from);
 
 /// Walks all symbol table operations nested within, and including, `op`. For
 /// each symbol table operation, the provided callback is invoked with the op
 /// and a boolean signifying if the symbols within that symbol table can be
 /// treated as if all uses within the IR are visible to the caller.
 /// `allSymUsesVisible` identifies whether all of the symbol uses of symbols
 /// within `op` are visible.
 MLIR_CAPI_EXPORTED void mlirSymbolTableWalkSymbolTables(
     MlirOperation from, bool allSymUsesVisible,
     void (*callback)(MlirOperation, bool, void *userData), void *userData);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_IR_H

mlir/core/include/mlir-c/IntegerSet.h

 //===-- mlir-c/IntegerSet.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_INTEGERSET_H
 #define MLIR_C_INTEGERSET_H
 
 #include "mlir-c/AffineExpr.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.
 //===----------------------------------------------------------------------===//
 
 #define DEFINE_C_API_STRUCT(name, storage)                                     \
   struct name {                                                                \
     storage *ptr;                                                              \
   };                                                                           \
   typedef struct name name
 
 DEFINE_C_API_STRUCT(MlirIntegerSet, const void);
 
 #undef DEFINE_C_API_STRUCT
 
 /// Gets the context in which the given integer set lives.
 MLIR_CAPI_EXPORTED MlirContext mlirIntegerSetGetContext(MlirIntegerSet set);
 
 /// Checks whether an integer set is a null object.
 static inline bool mlirIntegerSetIsNull(MlirIntegerSet set) { return !set.ptr; }
 
 /// Checks if two integer set objects are equal. This is a "shallow" comparison
 /// of two objects. Only the sets with some small number of constraints are
 /// uniqued and compare equal here. Set objects that represent the same integer
 /// set with different constraints may be considered non-equal by this check.
 /// Set difference followed by an (expensive) emptiness check should be used to
 /// check equivalence of the underlying integer sets.
 MLIR_CAPI_EXPORTED bool mlirIntegerSetEqual(MlirIntegerSet s1,
                                             MlirIntegerSet s2);
 
 /// Prints an integer set 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 mlirIntegerSetPrint(MlirIntegerSet set,
                                             MlirStringCallback callback,
                                             void *userData);
 
 /// Prints an integer set to the standard error stream.
 MLIR_CAPI_EXPORTED void mlirIntegerSetDump(MlirIntegerSet set);
 
 /// Gets or creates a new canonically empty integer set with the give number of
 /// dimensions and symbols in the given context.
 MLIR_CAPI_EXPORTED MlirIntegerSet mlirIntegerSetEmptyGet(MlirContext context,
                                                          intptr_t numDims,
                                                          intptr_t numSymbols);
 
 /// Gets or creates a new integer set in the given context. The set is defined
 /// by a list of affine constraints, with the given number of input dimensions
 /// and symbols, which are treated as either equalities (eqFlags is 1) or
 /// inequalities (eqFlags is 0). Both `constraints` and `eqFlags` are expected
 /// to point to at least `numConstraint` consecutive values.
 MLIR_CAPI_EXPORTED MlirIntegerSet
 mlirIntegerSetGet(MlirContext context, intptr_t numDims, intptr_t numSymbols,
                   intptr_t numConstraints, const MlirAffineExpr *constraints,
                   const bool *eqFlags);
 
 /// Gets or creates a new integer set in which the values and dimensions of the
 /// given set are replaced with the given affine expressions. `dimReplacements`
 /// and `symbolReplacements` are expected to point to at least as many
 /// consecutive expressions as the given set has dimensions and symbols,
 /// respectively. The new set will have `numResultDims` and `numResultSymbols`
 /// dimensions and symbols, respectively.
 MLIR_CAPI_EXPORTED MlirIntegerSet mlirIntegerSetReplaceGet(
     MlirIntegerSet set, const MlirAffineExpr *dimReplacements,
     const MlirAffineExpr *symbolReplacements, intptr_t numResultDims,
     intptr_t numResultSymbols);
 
 /// Checks whether the given set is a canonical empty set, e.g., the set
 /// returned by mlirIntegerSetEmptyGet.
 MLIR_CAPI_EXPORTED bool mlirIntegerSetIsCanonicalEmpty(MlirIntegerSet set);
 
 /// Returns the number of dimensions in the given set.
 MLIR_CAPI_EXPORTED intptr_t mlirIntegerSetGetNumDims(MlirIntegerSet set);
 
 /// Returns the number of symbols in the given set.
 MLIR_CAPI_EXPORTED intptr_t mlirIntegerSetGetNumSymbols(MlirIntegerSet set);
 
 /// Returns the number of inputs (dimensions + symbols) in the given set.
 MLIR_CAPI_EXPORTED intptr_t mlirIntegerSetGetNumInputs(MlirIntegerSet set);
 
 /// Returns the number of constraints (equalities + inequalities) in the given
 /// set.
 MLIR_CAPI_EXPORTED intptr_t mlirIntegerSetGetNumConstraints(MlirIntegerSet set);
 
 /// Returns the number of equalities in the given set.
 MLIR_CAPI_EXPORTED intptr_t mlirIntegerSetGetNumEqualities(MlirIntegerSet set);
 
 /// Returns the number of inequalities in the given set.
 MLIR_CAPI_EXPORTED intptr_t
 mlirIntegerSetGetNumInequalities(MlirIntegerSet set);
 
 /// Returns `pos`-th constraint of the set.
 MLIR_CAPI_EXPORTED MlirAffineExpr
 mlirIntegerSetGetConstraint(MlirIntegerSet set, intptr_t pos);
 
 /// Returns `true` of the `pos`-th constraint of the set is an equality
 /// constraint, `false` otherwise.
 MLIR_CAPI_EXPORTED bool mlirIntegerSetIsConstraintEq(MlirIntegerSet set,
                                                      intptr_t pos);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_INTEGERSET_H

mlir/core/include/mlir-c/Interfaces.h

 //===-- mlir-c/Interfaces.h - C API to Core MLIR IR interfaces ----*- C -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM
 // Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This header declares the C interface to MLIR interface classes. It is
 // intended to contain interfaces defined in lib/Interfaces.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_C_INTERFACES_H
 #define MLIR_C_INTERFACES_H
 
 #include "mlir-c/IR.h"
 #include "mlir-c/Support.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /// Returns `true` if the given operation implements an interface identified by
 /// its TypeID.
 MLIR_CAPI_EXPORTED bool
 mlirOperationImplementsInterface(MlirOperation operation,
                                  MlirTypeID interfaceTypeID);
 
 /// Returns `true` if the operation identified by its canonical string name
 /// implements the interface identified by its TypeID in the given context.
 /// Note that interfaces may be attached to operations in some contexts and not
 /// others.
 MLIR_CAPI_EXPORTED bool
 mlirOperationImplementsInterfaceStatic(MlirStringRef operationName,
                                        MlirContext context,
                                        MlirTypeID interfaceTypeID);
 
 //===----------------------------------------------------------------------===//
 // InferTypeOpInterface.
 //===----------------------------------------------------------------------===//
 
 /// Returns the interface TypeID of the InferTypeOpInterface.
 MLIR_CAPI_EXPORTED MlirTypeID mlirInferTypeOpInterfaceTypeID();
 
 /// These callbacks are used to return multiple types from functions while
 /// transferring ownership to the caller. The first argument is the number of
 /// consecutive elements pointed to by the second argument. The third argument
 /// is an opaque pointer forwarded to the callback by the caller.
 typedef void (*MlirTypesCallback)(intptr_t, MlirType *, void *);
 
 /// Infers the return types of the operation identified by its canonical given
 /// the arguments that will be supplied to its generic builder. Calls `callback`
 /// with the types of inferred arguments, potentially several times, on success.
 /// Returns failure otherwise.
 MLIR_CAPI_EXPORTED MlirLogicalResult mlirInferTypeOpInterfaceInferReturnTypes(
     MlirStringRef opName, MlirContext context, MlirLocation location,
     intptr_t nOperands, MlirValue *operands, MlirAttribute attributes,
     intptr_t nRegions, MlirRegion *regions, MlirTypesCallback callback,
     void *userData);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_INTERFACES_H

mlir/core/include/mlir-c/Pass.h

 //===-- mlir-c/Pass.h - C API to Pass Management ------------------*- C -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM
 // Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This header declares the C interface to MLIR pass manager.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_C_PASS_H
 #define 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.
 //===----------------------------------------------------------------------===//
 
 #define DEFINE_C_API_STRUCT(name, storage)                                     \
   struct name {                                                                \
     storage *ptr;                                                              \
   };                                                                           \
   typedef struct name name
 
 DEFINE_C_API_STRUCT(MlirPass, void);
 DEFINE_C_API_STRUCT(MlirPassManager, void);
 DEFINE_C_API_STRUCT(MlirOpPassManager, void);
 
 #undef DEFINE_C_API_STRUCT
 
 /// Create a new top-level PassManager.
 MLIR_CAPI_EXPORTED MlirPassManager mlirPassManagerCreate(MlirContext ctx);
 
 /// Destroy the provided PassManager.
 MLIR_CAPI_EXPORTED void mlirPassManagerDestroy(MlirPassManager passManager);
 
 /// Checks if a PassManager is null.
 static inline bool mlirPassManagerIsNull(MlirPassManager passManager) {
   return !passManager.ptr;
 }
 
 /// 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);
 
 /// Enable print-ir-after-all.
 MLIR_CAPI_EXPORTED void
 mlirPassManagerEnableIRPrinting(MlirPassManager passManager);
 
 /// Enable / disable verify-each.
 MLIR_CAPI_EXPORTED void
 mlirPassManagerEnableVerifier(MlirPassManager passManager, bool enable);
 
 /// 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.
 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.
 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.
 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.
 MLIR_CAPI_EXPORTED void mlirPrintPassPipeline(MlirOpPassManager passManager,
                                               MlirStringCallback callback,
                                               void *userData);
 
 /// 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/core/include/mlir-c/Registration.h

 //===-- mlir-c/Registration.h - Registration functions for MLIR ---*- 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_REGISTRATION_H
 #define MLIR_C_REGISTRATION_H
 
 #include "mlir-c/IR.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 //===----------------------------------------------------------------------===//
 // Dialect registration declarations.
 // Registration entry-points for each dialect are declared using the common
 // MLIR_DECLARE_DIALECT_REGISTRATION_CAPI macro, which takes the dialect
 // API name (i.e. "Func", "Tensor", "Linalg") and namespace (i.e. "func",
 // "tensor", "linalg"). The following declarations are produced:
 //
 //   /// Gets the above hook methods in struct form for a dialect by namespace.
 //   /// This is intended to facilitate dynamic lookup and registration of
 //   /// dialects via a plugin facility based on shared library symbol lookup.
 //   const MlirDialectHandle *mlirGetDialectHandle__{NAMESPACE}__();
 //
 // This is done via a common macro to facilitate future expansion to
 // registration schemes.
 //===----------------------------------------------------------------------===//
 
 struct MlirDialectHandle {
   const void *ptr;
 };
 typedef struct MlirDialectHandle MlirDialectHandle;
 
 #define MLIR_DECLARE_CAPI_DIALECT_REGISTRATION(Name, Namespace)                \
   MLIR_CAPI_EXPORTED MlirDialectHandle mlirGetDialectHandle__##Namespace##__()
 
 /// Returns the namespace associated with the provided dialect handle.
 MLIR_CAPI_EXPORTED
 MlirStringRef mlirDialectHandleGetNamespace(MlirDialectHandle);
 
 /// Inserts the dialect associated with the provided dialect handle into the
 /// provided dialect registry
 MLIR_CAPI_EXPORTED void mlirDialectHandleInsertDialect(MlirDialectHandle,
                                                        MlirDialectRegistry);
 
 /// Registers the dialect associated with the provided dialect handle.
 MLIR_CAPI_EXPORTED void mlirDialectHandleRegisterDialect(MlirDialectHandle,
                                                          MlirContext);
 
 /// Loads the dialect associated with the provided dialect handle.
 MLIR_CAPI_EXPORTED MlirDialect mlirDialectHandleLoadDialect(MlirDialectHandle,
                                                             MlirContext);
 
 /// Registers all dialects known to core MLIR with the provided Context.
 /// This is needed before creating IR for these Dialects.
 /// TODO: Remove this function once the real registration API is finished.
 MLIR_CAPI_EXPORTED void mlirRegisterAllDialects(MlirContext context);
 
 /// Register all translations to LLVM IR for dialects that can support it.
 MLIR_CAPI_EXPORTED void mlirRegisterAllLLVMTranslations(MlirContext context);
 
 /// Register all compiler passes of MLIR.
 MLIR_CAPI_EXPORTED void mlirRegisterAllPasses();
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_REGISTRATION_H

mlir/core/include/mlir-c/Support.h

 //===-- mlir-c/Support.h - Helpers for C API to Core MLIR ---------*- C -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM
 // Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This header declares the auxiliary data structures used in C APIs to core
 // MLIR functionality.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_C_SUPPORT_H
 #define MLIR_C_SUPPORT_H
 
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 
 //===----------------------------------------------------------------------===//
 // Visibility annotations.
 // Use MLIR_CAPI_EXPORTED for exported functions.
 //
 // On Windows, if MLIR_CAPI_ENABLE_WINDOWS_DLL_DECLSPEC is defined, then
 // __declspec(dllexport) and __declspec(dllimport) will be generated. This
 // can only be enabled if actually building DLLs. It is generally, mutually
 // exclusive with the use of other mechanisms for managing imports/exports
 // (i.e. CMake's WINDOWS_EXPORT_ALL_SYMBOLS feature).
 //===----------------------------------------------------------------------===//
 
 #if (defined(_WIN32) || defined(__CYGWIN__)) &&                                \
     !defined(MLIR_CAPI_ENABLE_WINDOWS_DLL_DECLSPEC)
 // Visibility annotations disabled.
 #define MLIR_CAPI_EXPORTED
 #elif defined(_WIN32) || defined(__CYGWIN__)
 // Windows visibility declarations.
 #if MLIR_CAPI_BUILDING_LIBRARY
 #define MLIR_CAPI_EXPORTED __declspec(dllexport)
 #else
 #define MLIR_CAPI_EXPORTED __declspec(dllimport)
 #endif
 #else
 // Non-windows: use visibility attributes.
 #define MLIR_CAPI_EXPORTED __attribute__((visibility("default")))
 #endif
 
 #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.
 
 struct MlirStringRef {
   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.
 
 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.
 MLIR_CAPI_EXPORTED MlirStringRef
 mlirStringRefCreateFromCString(const char *str);
 
 /// Returns true if two string references are equal, false otherwise.
 MLIR_CAPI_EXPORTED bool mlirStringRefEqual(MlirStringRef string,
                                            MlirStringRef other);
 
 /// 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.
 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;
 }
 
 /// Checks if the given logical result represents a failure.
 inline static bool mlirLogicalResultIsFailure(MlirLogicalResult res) {
   return res.value == 0;
 }
 
 /// Creates a logical result representing a success.
 inline static MlirLogicalResult mlirLogicalResultSuccess() {
   MlirLogicalResult res = {1};
   return res;
 }
 
 /// Creates a logical result representing a failure.
 inline static MlirLogicalResult mlirLogicalResultFailure() {
   MlirLogicalResult res = {0};
   return res;
 }
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_SUPPORT_H

mlir/core/include/mlir/CAPI/AffineExpr.h

 //===- AffineExpr.h - C API Utils for Affine Expressions --------*- 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 Expression. This file should not be included from C++ code other
 // than C API implementation nor from C code.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_CAPI_AFFINEEXPR_H
 #define MLIR_CAPI_AFFINEEXPR_H
 
 #include "mlir-c/AffineExpr.h"
 #include "mlir/CAPI/Wrap.h"
 #include "mlir/IR/AffineExpr.h"
 
 DEFINE_C_API_METHODS(MlirAffineExpr, mlir::AffineExpr)
 
 #endif // MLIR_CAPI_AFFINEEXPR_H

mlir/core/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/core/include/mlir/CAPI/Diagnostics.h

 //===- IR.h - C API Utils for MLIR Diagnostics ------------------*- 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_CAPI_DIAGNOSTICS_H
 #define MLIR_CAPI_DIAGNOSTICS_H
 
 #include "mlir-c/Diagnostics.h"
 #include <cassert>
 
 namespace mlir {
 class Diagnostic;
 } // namespace mlir
 
 inline mlir::Diagnostic &unwrap(MlirDiagnostic diagnostic) {
   assert(diagnostic.ptr && "unexpected null diagnostic");
   return *(static_cast<mlir::Diagnostic *>(diagnostic.ptr));
 }
 
 inline MlirDiagnostic wrap(mlir::Diagnostic &diagnostic) {
   return {&diagnostic};
 }
 
 #endif // MLIR_CAPI_DIAGNOSTICS_H

mlir/core/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_CAPI_IR_H
 #define MLIR_CAPI_IR_H
 
 #include "mlir/CAPI/Wrap.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Operation.h"
 
 DEFINE_C_API_PTR_METHODS(MlirContext, mlir::MLIRContext)
 DEFINE_C_API_PTR_METHODS(MlirDialect, mlir::Dialect)
 DEFINE_C_API_PTR_METHODS(MlirDialectRegistry, mlir::DialectRegistry)
 DEFINE_C_API_PTR_METHODS(MlirOperation, mlir::Operation)
 DEFINE_C_API_PTR_METHODS(MlirBlock, mlir::Block)
 DEFINE_C_API_PTR_METHODS(MlirOpPrintingFlags, mlir::OpPrintingFlags)
 DEFINE_C_API_PTR_METHODS(MlirRegion, mlir::Region)
 DEFINE_C_API_PTR_METHODS(MlirSymbolTable, mlir::SymbolTable)
 
 DEFINE_C_API_METHODS(MlirAttribute, mlir::Attribute)
 DEFINE_C_API_METHODS(MlirIdentifier, mlir::StringAttr)
 DEFINE_C_API_METHODS(MlirLocation, mlir::Location)
 DEFINE_C_API_METHODS(MlirModule, mlir::ModuleOp)
 DEFINE_C_API_METHODS(MlirType, mlir::Type)
 DEFINE_C_API_METHODS(MlirTypeID, mlir::TypeID)
 DEFINE_C_API_METHODS(MlirValue, mlir::Value)
 
 #endif // MLIR_CAPI_IR_H

mlir/core/include/mlir/CAPI/IntegerSet.h

 //===- IntegerSet.h - C API Utils for Integer Sets --------------*- 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 IntegerSets. This file should not be included from C++ code other than C
 // API implementation nor from C code.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_CAPI_INTEGERSET_H
 #define MLIR_CAPI_INTEGERSET_H
 
 #include "mlir-c/IntegerSet.h"
 #include "mlir/CAPI/Wrap.h"
 #include "mlir/IR/IntegerSet.h"
 
 DEFINE_C_API_METHODS(MlirIntegerSet, mlir::IntegerSet)
 
 #endif // MLIR_CAPI_INTEGERSET_H

mlir/core/include/mlir/CAPI/Interfaces.h

 //===- Interfaces.h - C API Utils for MLIR interfaces -----------*- 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 interface classes. This file should not be included from C++ code other
 // than C API implementation nor from C code.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_CAPI_INTERFACES_H
 #define MLIR_CAPI_INTERFACES_H
 
 #endif // MLIR_CAPI_INTERFACES_H

mlir/core/include/mlir/CAPI/Pass.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_CAPI_PASS_H
 #define MLIR_CAPI_PASS_H
 
 #include "mlir-c/Pass.h"
 
 #include "mlir/CAPI/Wrap.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 
 DEFINE_C_API_PTR_METHODS(MlirPass, mlir::Pass)
 DEFINE_C_API_PTR_METHODS(MlirPassManager, mlir::PassManager)
 DEFINE_C_API_PTR_METHODS(MlirOpPassManager, mlir::OpPassManager)
 
 #endif // MLIR_CAPI_PASS_H

mlir/core/include/mlir/CAPI/Registration.h

 //===- Registration.h - C API Registration implementation  ------*- 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_CAPI_REGISTRATION_H
 #define MLIR_CAPI_REGISTRATION_H
 
 #include "mlir-c/IR.h"
 #include "mlir-c/Registration.h"
 #include "mlir/CAPI/IR.h"
 #include "mlir/CAPI/Support.h"
 
 //===----------------------------------------------------------------------===//
 // Corrolary to MLIR_DECLARE_CAPI_DIALECT_REGISTRATION that defines an impl.
 // Takes the same name passed to the above and the fully qualified class name
 // of the dialect class.
 //===----------------------------------------------------------------------===//
 
 /// Hooks for dynamic discovery of dialects.
 typedef void (*MlirDialectRegistryInsertDialectHook)(
     MlirDialectRegistry registry);
 typedef MlirDialect (*MlirContextLoadDialectHook)(MlirContext context);
 typedef MlirStringRef (*MlirDialectGetNamespaceHook)();
 
 /// Structure of dialect registration hooks.
 struct MlirDialectRegistrationHooks {
   MlirDialectRegistryInsertDialectHook insertHook;
   MlirContextLoadDialectHook loadHook;
   MlirDialectGetNamespaceHook getNamespaceHook;
 };
 typedef struct MlirDialectRegistrationHooks MlirDialectRegistrationHooks;
 
 #define MLIR_DEFINE_CAPI_DIALECT_REGISTRATION(Name, Namespace, ClassName)      \
   static void mlirDialectRegistryInsert##Name##Dialect(                        \
       MlirDialectRegistry registry) {                                          \
     unwrap(registry)->insert<ClassName>();                                     \
   }                                                                            \
   static MlirDialect mlirContextLoad##Name##Dialect(MlirContext context) {     \
     return wrap(unwrap(context)->getOrLoadDialect<ClassName>());               \
   }                                                                            \
   static MlirStringRef mlir##Name##DialectGetNamespace() {                     \
     return wrap(ClassName::getDialectNamespace());                             \
   }                                                                            \
   MlirDialectHandle mlirGetDialectHandle__##Namespace##__() {                  \
     static MlirDialectRegistrationHooks hooks = {                              \
         mlirDialectRegistryInsert##Name##Dialect,                              \
         mlirContextLoad##Name##Dialect, mlir##Name##DialectGetNamespace};      \
     return MlirDialectHandle{&hooks};                                          \
   }
 
 #endif // MLIR_CAPI_REGISTRATION_H

mlir/core/include/mlir/CAPI/Support.h

 //===- Support.h - C API Helpers Implementation -----------------*- 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 definitions for converting MLIR C++ objects into helper
 // 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_SUPPORT_H
 #define MLIR_CAPI_SUPPORT_H
 
 #include "mlir-c/Support.h"
 #include "mlir/Support/LogicalResult.h"
 #include "llvm/ADT/StringRef.h"
 
 /// Converts a StringRef into its MLIR C API equivalent.
 inline MlirStringRef wrap(llvm::StringRef ref) {
   return mlirStringRefCreate(ref.data(), ref.size());
 }
 
 /// Creates a StringRef out of its MLIR C API equivalent.
 inline llvm::StringRef unwrap(MlirStringRef ref) {
   return llvm::StringRef(ref.data, ref.length);
 }
 
 inline MlirLogicalResult wrap(mlir::LogicalResult res) {
   if (mlir::succeeded(res))
     return mlirLogicalResultSuccess();
   return mlirLogicalResultFailure();
 }
 
 inline mlir::LogicalResult unwrap(MlirLogicalResult res) {
   return mlir::success(mlirLogicalResultIsSuccess(res));
 }
 
 #endif // MLIR_CAPI_SUPPORT_H

mlir/core/include/mlir/CAPI/Utils.h

 //===- Utils.h - C API General 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 defines general utilities for C API. This file should not be
 // included from C++ code other than C API implementation nor from C code.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_CAPI_UTILS_H
 #define MLIR_CAPI_UTILS_H
 
 #include <utility>
 
 #include "mlir-c/Support.h"
 #include "llvm/Support/raw_ostream.h"
 
 //===----------------------------------------------------------------------===//
 // Printing helper.
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
 namespace detail {
 /// 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:
   CallbackOstream(std::function<void(MlirStringRef, void *)> callback,
                   void *opaqueData)
       : raw_ostream(/*unbuffered=*/true), callback(std::move(callback)),
         opaqueData(opaqueData), pos(0u) {}
 
   void write_impl(const char *ptr, size_t size) override {
     MlirStringRef string = mlirStringRefCreate(ptr, size);
     callback(string, opaqueData);
     pos += size;
   }
 
   uint64_t current_pos() const override { return pos; }
 
 private:
   std::function<void(MlirStringRef, void *)> callback;
   void *opaqueData;
   uint64_t pos;
 };
 } // namespace detail
 } // namespace mlir
 
 #endif // MLIR_CAPI_UTILS_H

mlir/core/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/core/lib/CAPI/CMakeLists.txt

+add_subdirectory(Debug)
+add_subdirectory(Interfaces)
+add_subdirectory(IR)
+add_subdirectory(Registration)

mlir/core/lib/CAPI/Debug/CMakeLists.txt

 add_mlir_upstream_c_api_library(MLIRCAPIDebug
   Debug.cpp
 
   LINK_LIBS PUBLIC
   MLIRSupport
 )

mlir/core/lib/CAPI/Debug/Debug.cpp

 //===- Debug.cpp - C Interface for MLIR/LLVM Debugging Functions ----------===//
 //
 // 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/Debug.h"
 #include "mlir-c/Support.h"
 
 #include "mlir/CAPI/Support.h"
 
 #include "llvm/Support/Debug.h"
 
 void mlirEnableGlobalDebug(bool enable) { llvm::DebugFlag = enable; }
 
 bool mlirIsGlobalDebugEnabled() { return llvm::DebugFlag; }

mlir/core/lib/CAPI/IR/AffineExpr.cpp

 //===- AffineExpr.cpp - C API for MLIR Affine Expressions -----------------===//
 //
 // 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/AffineExpr.h"
 #include "mlir-c/AffineMap.h"
 #include "mlir-c/IR.h"
 #include "mlir/CAPI/AffineExpr.h"
 #include "mlir/CAPI/AffineMap.h"
 #include "mlir/CAPI/IR.h"
 #include "mlir/CAPI/Utils.h"
 #include "mlir/IR/AffineExpr.h"
 
 using namespace mlir;
 
 MlirContext mlirAffineExprGetContext(MlirAffineExpr affineExpr) {
   return wrap(unwrap(affineExpr).getContext());
 }
 
 bool mlirAffineExprEqual(MlirAffineExpr lhs, MlirAffineExpr rhs) {
   return unwrap(lhs) == unwrap(rhs);
 }
 
 void mlirAffineExprPrint(MlirAffineExpr affineExpr, MlirStringCallback callback,
                          void *userData) {
   mlir::detail::CallbackOstream stream(callback, userData);
   unwrap(affineExpr).print(stream);
 }
 
 void mlirAffineExprDump(MlirAffineExpr affineExpr) {
   unwrap(affineExpr).dump();
 }
 
 bool mlirAffineExprIsSymbolicOrConstant(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).isSymbolicOrConstant();
 }
 
 bool mlirAffineExprIsPureAffine(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).isPureAffine();
 }
 
 int64_t mlirAffineExprGetLargestKnownDivisor(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).getLargestKnownDivisor();
 }
 
 bool mlirAffineExprIsMultipleOf(MlirAffineExpr affineExpr, int64_t factor) {
   return unwrap(affineExpr).isMultipleOf(factor);
 }
 
 bool mlirAffineExprIsFunctionOfDim(MlirAffineExpr affineExpr,
                                    intptr_t position) {
   return unwrap(affineExpr).isFunctionOfDim(position);
 }
 
 MlirAffineExpr mlirAffineExprCompose(MlirAffineExpr affineExpr,
                                      MlirAffineMap affineMap) {
   return wrap(unwrap(affineExpr).compose(unwrap(affineMap)));
 }
 
 //===----------------------------------------------------------------------===//
 // Affine Dimension Expression.
 //===----------------------------------------------------------------------===//
 
 bool mlirAffineExprIsADim(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).isa<AffineDimExpr>();
 }
 
 MlirAffineExpr mlirAffineDimExprGet(MlirContext ctx, intptr_t position) {
   return wrap(getAffineDimExpr(position, unwrap(ctx)));
 }
 
 intptr_t mlirAffineDimExprGetPosition(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).cast<AffineDimExpr>().getPosition();
 }
 
 //===----------------------------------------------------------------------===//
 // Affine Symbol Expression.
 //===----------------------------------------------------------------------===//
 
 bool mlirAffineExprIsASymbol(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).isa<AffineSymbolExpr>();
 }
 
 MlirAffineExpr mlirAffineSymbolExprGet(MlirContext ctx, intptr_t position) {
   return wrap(getAffineSymbolExpr(position, unwrap(ctx)));
 }
 
 intptr_t mlirAffineSymbolExprGetPosition(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).cast<AffineSymbolExpr>().getPosition();
 }
 
 //===----------------------------------------------------------------------===//
 // Affine Constant Expression.
 //===----------------------------------------------------------------------===//
 
 bool mlirAffineExprIsAConstant(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).isa<AffineConstantExpr>();
 }
 
 MlirAffineExpr mlirAffineConstantExprGet(MlirContext ctx, int64_t constant) {
   return wrap(getAffineConstantExpr(constant, unwrap(ctx)));
 }
 
 int64_t mlirAffineConstantExprGetValue(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).cast<AffineConstantExpr>().getValue();
 }
 
 //===----------------------------------------------------------------------===//
 // Affine Add Expression.
 //===----------------------------------------------------------------------===//
 
 bool mlirAffineExprIsAAdd(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).getKind() == mlir::AffineExprKind::Add;
 }
 
 MlirAffineExpr mlirAffineAddExprGet(MlirAffineExpr lhs, MlirAffineExpr rhs) {
   return wrap(getAffineBinaryOpExpr(mlir::AffineExprKind::Add, unwrap(lhs),
                                     unwrap(rhs)));
 }
 
 //===----------------------------------------------------------------------===//
 // Affine Mul Expression.
 //===----------------------------------------------------------------------===//
 
 bool mlirAffineExprIsAMul(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).getKind() == mlir::AffineExprKind::Mul;
 }
 
 MlirAffineExpr mlirAffineMulExprGet(MlirAffineExpr lhs, MlirAffineExpr rhs) {
   return wrap(getAffineBinaryOpExpr(mlir::AffineExprKind::Mul, unwrap(lhs),
                                     unwrap(rhs)));
 }
 
 //===----------------------------------------------------------------------===//
 // Affine Mod Expression.
 //===----------------------------------------------------------------------===//
 
 bool mlirAffineExprIsAMod(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).getKind() == mlir::AffineExprKind::Mod;
 }
 
 MlirAffineExpr mlirAffineModExprGet(MlirAffineExpr lhs, MlirAffineExpr rhs) {
   return wrap(getAffineBinaryOpExpr(mlir::AffineExprKind::Mod, unwrap(lhs),
                                     unwrap(rhs)));
 }
 
 //===----------------------------------------------------------------------===//
 // Affine FloorDiv Expression.
 //===----------------------------------------------------------------------===//
 
 bool mlirAffineExprIsAFloorDiv(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).getKind() == mlir::AffineExprKind::FloorDiv;
 }
 
 MlirAffineExpr mlirAffineFloorDivExprGet(MlirAffineExpr lhs,
                                          MlirAffineExpr rhs) {
   return wrap(getAffineBinaryOpExpr(mlir::AffineExprKind::FloorDiv, unwrap(lhs),
                                     unwrap(rhs)));
 }
 
 //===----------------------------------------------------------------------===//
 // Affine CeilDiv Expression.
 //===----------------------------------------------------------------------===//
 
 bool mlirAffineExprIsACeilDiv(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).getKind() == mlir::AffineExprKind::CeilDiv;
 }
 
 MlirAffineExpr mlirAffineCeilDivExprGet(MlirAffineExpr lhs,
                                         MlirAffineExpr rhs) {
   return wrap(getAffineBinaryOpExpr(mlir::AffineExprKind::CeilDiv, unwrap(lhs),
                                     unwrap(rhs)));
 }
 
 //===----------------------------------------------------------------------===//
 // Affine Binary Operation Expression.
 //===----------------------------------------------------------------------===//
 
 bool mlirAffineExprIsABinary(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).isa<AffineBinaryOpExpr>();
 }
 
 MlirAffineExpr mlirAffineBinaryOpExprGetLHS(MlirAffineExpr affineExpr) {
   return wrap(unwrap(affineExpr).cast<AffineBinaryOpExpr>().getLHS());
 }
 
 MlirAffineExpr mlirAffineBinaryOpExprGetRHS(MlirAffineExpr affineExpr) {
   return wrap(unwrap(affineExpr).cast<AffineBinaryOpExpr>().getRHS());
 }

mlir/core/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/AffineExpr.h"
 #include "mlir/CAPI/AffineMap.h"
 #include "mlir/CAPI/IR.h"
 #include "mlir/CAPI/Utils.h"
 #include "mlir/IR/AffineMap.h"
 
 // TODO: expose the C API related to `AffineExpr` and mutable affine map.
 
 using namespace mlir;
 
 MlirContext mlirAffineMapGetContext(MlirAffineMap affineMap) {
   return wrap(unwrap(affineMap).getContext());
 }
 
 bool mlirAffineMapEqual(MlirAffineMap a1, MlirAffineMap a2) {
   return unwrap(a1) == unwrap(a2);
 }
 
 void mlirAffineMapPrint(MlirAffineMap affineMap, MlirStringCallback callback,
                         void *userData) {
   mlir::detail::CallbackOstream stream(callback, userData);
   unwrap(affineMap).print(stream);
 }
 
 void mlirAffineMapDump(MlirAffineMap affineMap) { unwrap(affineMap).dump(); }
 
 MlirAffineMap mlirAffineMapEmptyGet(MlirContext ctx) {
   return wrap(AffineMap::get(unwrap(ctx)));
 }
 
 MlirAffineMap mlirAffineMapZeroResultGet(MlirContext ctx, intptr_t dimCount,
                                          intptr_t symbolCount) {
   return wrap(AffineMap::get(dimCount, symbolCount, unwrap(ctx)));
 }
 
 MlirAffineMap mlirAffineMapGet(MlirContext ctx, intptr_t dimCount,
                                intptr_t symbolCount, intptr_t nAffineExprs,
                                MlirAffineExpr *affineExprs) {
   SmallVector<AffineExpr, 4> exprs;
   ArrayRef<AffineExpr> exprList = unwrapList(nAffineExprs, affineExprs, exprs);
   return wrap(AffineMap::get(dimCount, symbolCount, exprList, unwrap(ctx)));
 }
 
 MlirAffineMap mlirAffineMapConstantGet(MlirContext ctx, int64_t val) {
   return wrap(AffineMap::getConstantMap(val, unwrap(ctx)));
 }
 
 MlirAffineMap mlirAffineMapMultiDimIdentityGet(MlirContext ctx,
                                                intptr_t numDims) {
   return wrap(AffineMap::getMultiDimIdentityMap(numDims, unwrap(ctx)));
 }
 
 MlirAffineMap mlirAffineMapMinorIdentityGet(MlirContext ctx, intptr_t dims,
                                             intptr_t results) {
   return wrap(AffineMap::getMinorIdentityMap(dims, results, unwrap(ctx)));
 }
 
 MlirAffineMap mlirAffineMapPermutationGet(MlirContext ctx, intptr_t size,
                                           unsigned *permutation) {
   return wrap(AffineMap::getPermutationMap(
       llvm::makeArrayRef(permutation, static_cast<size_t>(size)), unwrap(ctx)));
 }
 
 bool mlirAffineMapIsIdentity(MlirAffineMap affineMap) {
   return unwrap(affineMap).isIdentity();
 }
 
 bool mlirAffineMapIsMinorIdentity(MlirAffineMap affineMap) {
   return unwrap(affineMap).isMinorIdentity();
 }
 
 bool mlirAffineMapIsEmpty(MlirAffineMap affineMap) {
   return unwrap(affineMap).isEmpty();
 }
 
 bool mlirAffineMapIsSingleConstant(MlirAffineMap affineMap) {
   return unwrap(affineMap).isSingleConstant();
 }
 
 int64_t mlirAffineMapGetSingleConstantResult(MlirAffineMap affineMap) {
   return unwrap(affineMap).getSingleConstantResult();
 }
 
 intptr_t mlirAffineMapGetNumDims(MlirAffineMap affineMap) {
   return unwrap(affineMap).getNumDims();
 }
 
 intptr_t mlirAffineMapGetNumSymbols(MlirAffineMap affineMap) {
   return unwrap(affineMap).getNumSymbols();
 }
 
 intptr_t mlirAffineMapGetNumResults(MlirAffineMap affineMap) {
   return unwrap(affineMap).getNumResults();
 }
 
 MlirAffineExpr mlirAffineMapGetResult(MlirAffineMap affineMap, intptr_t pos) {
   return wrap(unwrap(affineMap).getResult(static_cast<unsigned>(pos)));
 }
 
 intptr_t mlirAffineMapGetNumInputs(MlirAffineMap affineMap) {
   return unwrap(affineMap).getNumInputs();
 }
 
 bool mlirAffineMapIsProjectedPermutation(MlirAffineMap affineMap) {
   return unwrap(affineMap).isProjectedPermutation();
 }
 
 bool mlirAffineMapIsPermutation(MlirAffineMap affineMap) {
   return unwrap(affineMap).isPermutation();
 }
 
 MlirAffineMap mlirAffineMapGetSubMap(MlirAffineMap affineMap, intptr_t size,
                                      intptr_t *resultPos) {
   SmallVector<unsigned, 8> pos;
   pos.reserve(size);
   for (intptr_t i = 0; i < size; ++i)
     pos.push_back(static_cast<unsigned>(resultPos[i]));
   return wrap(unwrap(affineMap).getSubMap(pos));
 }
 
 MlirAffineMap mlirAffineMapGetMajorSubMap(MlirAffineMap affineMap,
                                           intptr_t numResults) {
   return wrap(unwrap(affineMap).getMajorSubMap(numResults));
 }
 
 MlirAffineMap mlirAffineMapGetMinorSubMap(MlirAffineMap affineMap,
                                           intptr_t numResults) {
   return wrap(unwrap(affineMap).getMinorSubMap(numResults));
 }
 
 MlirAffineMap mlirAffineMapReplace(MlirAffineMap affineMap,
                                    MlirAffineExpr expression,
                                    MlirAffineExpr replacement,
                                    intptr_t numResultDims,
                                    intptr_t numResultSyms) {
   return wrap(unwrap(affineMap).replace(unwrap(expression), unwrap(replacement),
                                         numResultDims, numResultSyms));
 }
 
 void mlirAffineMapCompressUnusedSymbols(
     MlirAffineMap *affineMaps, intptr_t size, void *result,
     void (*populateResult)(void *res, intptr_t idx, MlirAffineMap m)) {
   SmallVector<AffineMap> maps;
   for (intptr_t idx = 0; idx < size; ++idx)
     maps.push_back(unwrap(affineMaps[idx]));
   intptr_t idx = 0;
   for (auto m : mlir::compressUnusedSymbols(maps))
     populateResult(result, idx++, wrap(m));
 }

mlir/core/lib/CAPI/IR/BuiltinAttributes.cpp

 //===- BuiltinAttributes.cpp - C Interface to MLIR Builtin Attributes -----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir-c/BuiltinAttributes.h"
 #include "mlir/CAPI/AffineMap.h"
 #include "mlir/CAPI/IR.h"
 #include "mlir/CAPI/Support.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BuiltinTypes.h"
 
 using namespace mlir;
 
 MlirAttribute mlirAttributeGetNull() { return {nullptr}; }
 
 //===----------------------------------------------------------------------===//
 // Affine map attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAAffineMap(MlirAttribute attr) {
   return unwrap(attr).isa<AffineMapAttr>();
 }
 
 MlirAttribute mlirAffineMapAttrGet(MlirAffineMap map) {
   return wrap(AffineMapAttr::get(unwrap(map)));
 }
 
 MlirAffineMap mlirAffineMapAttrGetValue(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<AffineMapAttr>().getValue());
 }
 
 //===----------------------------------------------------------------------===//
 // Array attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAArray(MlirAttribute attr) {
   return unwrap(attr).isa<ArrayAttr>();
 }
 
 MlirAttribute mlirArrayAttrGet(MlirContext ctx, intptr_t numElements,
                                MlirAttribute const *elements) {
   SmallVector<Attribute, 8> attrs;
   return wrap(
       ArrayAttr::get(unwrap(ctx), unwrapList(static_cast<size_t>(numElements),
                                              elements, attrs)));
 }
 
 intptr_t mlirArrayAttrGetNumElements(MlirAttribute attr) {
   return static_cast<intptr_t>(unwrap(attr).cast<ArrayAttr>().size());
 }
 
 MlirAttribute mlirArrayAttrGetElement(MlirAttribute attr, intptr_t pos) {
   return wrap(unwrap(attr).cast<ArrayAttr>().getValue()[pos]);
 }
 
 //===----------------------------------------------------------------------===//
 // Dictionary attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsADictionary(MlirAttribute attr) {
   return unwrap(attr).isa<DictionaryAttr>();
 }
 
 MlirAttribute mlirDictionaryAttrGet(MlirContext ctx, intptr_t numElements,
                                     MlirNamedAttribute const *elements) {
   SmallVector<NamedAttribute, 8> attributes;
   attributes.reserve(numElements);
   for (intptr_t i = 0; i < numElements; ++i)
     attributes.emplace_back(unwrap(elements[i].name),
                             unwrap(elements[i].attribute));
   return wrap(DictionaryAttr::get(unwrap(ctx), attributes));
 }
 
 intptr_t mlirDictionaryAttrGetNumElements(MlirAttribute attr) {
   return static_cast<intptr_t>(unwrap(attr).cast<DictionaryAttr>().size());
 }
 
 MlirNamedAttribute mlirDictionaryAttrGetElement(MlirAttribute attr,
                                                 intptr_t pos) {
   NamedAttribute attribute =
       unwrap(attr).cast<DictionaryAttr>().getValue()[pos];
   return {wrap(attribute.getName()), wrap(attribute.getValue())};
 }
 
 MlirAttribute mlirDictionaryAttrGetElementByName(MlirAttribute attr,
                                                  MlirStringRef name) {
   return wrap(unwrap(attr).cast<DictionaryAttr>().get(unwrap(name)));
 }
 
 //===----------------------------------------------------------------------===//
 // Floating point attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAFloat(MlirAttribute attr) {
   return unwrap(attr).isa<FloatAttr>();
 }
 
 MlirAttribute mlirFloatAttrDoubleGet(MlirContext ctx, MlirType type,
                                      double value) {
   return wrap(FloatAttr::get(unwrap(type), value));
 }
 
 MlirAttribute mlirFloatAttrDoubleGetChecked(MlirLocation loc, MlirType type,
                                             double value) {
   return wrap(FloatAttr::getChecked(unwrap(loc), unwrap(type), value));
 }
 
 double mlirFloatAttrGetValueDouble(MlirAttribute attr) {
   return unwrap(attr).cast<FloatAttr>().getValueAsDouble();
 }
 
 //===----------------------------------------------------------------------===//
 // Integer attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAInteger(MlirAttribute attr) {
   return unwrap(attr).isa<IntegerAttr>();
 }
 
 MlirAttribute mlirIntegerAttrGet(MlirType type, int64_t value) {
   return wrap(IntegerAttr::get(unwrap(type), value));
 }
 
 int64_t mlirIntegerAttrGetValueInt(MlirAttribute attr) {
   return unwrap(attr).cast<IntegerAttr>().getInt();
 }
 
 int64_t mlirIntegerAttrGetValueSInt(MlirAttribute attr) {
   return unwrap(attr).cast<IntegerAttr>().getSInt();
 }
 
 uint64_t mlirIntegerAttrGetValueUInt(MlirAttribute attr) {
   return unwrap(attr).cast<IntegerAttr>().getUInt();
 }
 
 //===----------------------------------------------------------------------===//
 // Bool attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsABool(MlirAttribute attr) {
   return unwrap(attr).isa<BoolAttr>();
 }
 
 MlirAttribute mlirBoolAttrGet(MlirContext ctx, int value) {
   return wrap(BoolAttr::get(unwrap(ctx), value));
 }
 
 bool mlirBoolAttrGetValue(MlirAttribute attr) {
   return unwrap(attr).cast<BoolAttr>().getValue();
 }
 
 //===----------------------------------------------------------------------===//
 // Integer set attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAIntegerSet(MlirAttribute attr) {
   return unwrap(attr).isa<IntegerSetAttr>();
 }
 
 //===----------------------------------------------------------------------===//
 // Opaque attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAOpaque(MlirAttribute attr) {
   return unwrap(attr).isa<OpaqueAttr>();
 }
 
 MlirAttribute mlirOpaqueAttrGet(MlirContext ctx, MlirStringRef dialectNamespace,
                                 intptr_t dataLength, const char *data,
                                 MlirType type) {
   return wrap(
       OpaqueAttr::get(StringAttr::get(unwrap(ctx), unwrap(dialectNamespace)),
                       StringRef(data, dataLength), unwrap(type)));
 }
 
 MlirStringRef mlirOpaqueAttrGetDialectNamespace(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<OpaqueAttr>().getDialectNamespace().strref());
 }
 
 MlirStringRef mlirOpaqueAttrGetData(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<OpaqueAttr>().getAttrData());
 }
 
 //===----------------------------------------------------------------------===//
 // String attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAString(MlirAttribute attr) {
   return unwrap(attr).isa<StringAttr>();
 }
 
 MlirAttribute mlirStringAttrGet(MlirContext ctx, MlirStringRef str) {
   return wrap((Attribute)StringAttr::get(unwrap(ctx), unwrap(str)));
 }
 
 MlirAttribute mlirStringAttrTypedGet(MlirType type, MlirStringRef str) {
   return wrap((Attribute)StringAttr::get(unwrap(str), unwrap(type)));
 }
 
 MlirStringRef mlirStringAttrGetValue(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<StringAttr>().getValue());
 }
 
 //===----------------------------------------------------------------------===//
 // SymbolRef attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsASymbolRef(MlirAttribute attr) {
   return unwrap(attr).isa<SymbolRefAttr>();
 }
 
 MlirAttribute mlirSymbolRefAttrGet(MlirContext ctx, MlirStringRef symbol,
                                    intptr_t numReferences,
                                    MlirAttribute const *references) {
   SmallVector<FlatSymbolRefAttr, 4> refs;
   refs.reserve(numReferences);
   for (intptr_t i = 0; i < numReferences; ++i)
     refs.push_back(unwrap(references[i]).cast<FlatSymbolRefAttr>());
   auto symbolAttr = StringAttr::get(unwrap(ctx), unwrap(symbol));
   return wrap(SymbolRefAttr::get(symbolAttr, refs));
 }
 
 MlirStringRef mlirSymbolRefAttrGetRootReference(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<SymbolRefAttr>().getRootReference().getValue());
 }
 
 MlirStringRef mlirSymbolRefAttrGetLeafReference(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<SymbolRefAttr>().getLeafReference().getValue());
 }
 
 intptr_t mlirSymbolRefAttrGetNumNestedReferences(MlirAttribute attr) {
   return static_cast<intptr_t>(
       unwrap(attr).cast<SymbolRefAttr>().getNestedReferences().size());
 }
 
 MlirAttribute mlirSymbolRefAttrGetNestedReference(MlirAttribute attr,
                                                   intptr_t pos) {
   return wrap(unwrap(attr).cast<SymbolRefAttr>().getNestedReferences()[pos]);
 }
 
 //===----------------------------------------------------------------------===//
 // Flat SymbolRef attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAFlatSymbolRef(MlirAttribute attr) {
   return unwrap(attr).isa<FlatSymbolRefAttr>();
 }
 
 MlirAttribute mlirFlatSymbolRefAttrGet(MlirContext ctx, MlirStringRef symbol) {
   return wrap(FlatSymbolRefAttr::get(unwrap(ctx), unwrap(symbol)));
 }
 
 MlirStringRef mlirFlatSymbolRefAttrGetValue(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<FlatSymbolRefAttr>().getValue());
 }
 
 //===----------------------------------------------------------------------===//
 // Type attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAType(MlirAttribute attr) {
   return unwrap(attr).isa<TypeAttr>();
 }
 
 MlirAttribute mlirTypeAttrGet(MlirType type) {
   return wrap(TypeAttr::get(unwrap(type)));
 }
 
 MlirType mlirTypeAttrGetValue(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<TypeAttr>().getValue());
 }
 
 //===----------------------------------------------------------------------===//
 // Unit attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAUnit(MlirAttribute attr) {
   return unwrap(attr).isa<UnitAttr>();
 }
 
 MlirAttribute mlirUnitAttrGet(MlirContext ctx) {
   return wrap(UnitAttr::get(unwrap(ctx)));
 }
 
 //===----------------------------------------------------------------------===//
 // Elements attributes.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAElements(MlirAttribute attr) {
   return unwrap(attr).isa<ElementsAttr>();
 }
 
 MlirAttribute mlirElementsAttrGetValue(MlirAttribute attr, intptr_t rank,
                                        uint64_t *idxs) {
   return wrap(unwrap(attr)
                   .cast<ElementsAttr>()
                   .getValues<Attribute>()[llvm::makeArrayRef(idxs, rank)]);
 }
 
 bool mlirElementsAttrIsValidIndex(MlirAttribute attr, intptr_t rank,
                                   uint64_t *idxs) {
   return unwrap(attr).cast<ElementsAttr>().isValidIndex(
       llvm::makeArrayRef(idxs, rank));
 }
 
 int64_t mlirElementsAttrGetNumElements(MlirAttribute attr) {
   return unwrap(attr).cast<ElementsAttr>().getNumElements();
 }
 
 //===----------------------------------------------------------------------===//
 // Dense elements attribute.
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // IsA support.
 
 bool mlirAttributeIsADenseElements(MlirAttribute attr) {
   return unwrap(attr).isa<DenseElementsAttr>();
 }
 bool mlirAttributeIsADenseIntElements(MlirAttribute attr) {
   return unwrap(attr).isa<DenseIntElementsAttr>();
 }
 bool mlirAttributeIsADenseFPElements(MlirAttribute attr) {
   return unwrap(attr).isa<DenseFPElementsAttr>();
 }
 
 //===----------------------------------------------------------------------===//
 // Constructors.
 
 MlirAttribute mlirDenseElementsAttrGet(MlirType shapedType,
                                        intptr_t numElements,
                                        MlirAttribute const *elements) {
   SmallVector<Attribute, 8> attributes;
   return wrap(
       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
                              unwrapList(numElements, elements, attributes)));
 }
 
 MlirAttribute mlirDenseElementsAttrRawBufferGet(MlirType shapedType,
                                                 size_t rawBufferSize,
                                                 const void *rawBuffer) {
   auto shapedTypeCpp = unwrap(shapedType).cast<ShapedType>();
   ArrayRef<char> rawBufferCpp(static_cast<const char *>(rawBuffer),
                               rawBufferSize);
   bool isSplat = false;
   if (!DenseElementsAttr::isValidRawBuffer(shapedTypeCpp, rawBufferCpp,
                                            isSplat)) {
     return mlirAttributeGetNull();
   }
   return wrap(DenseElementsAttr::getFromRawBuffer(shapedTypeCpp, rawBufferCpp,
                                                   isSplat));
 }
 
 MlirAttribute mlirDenseElementsAttrSplatGet(MlirType shapedType,
                                             MlirAttribute element) {
   return wrap(DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
                                      unwrap(element)));
 }
 MlirAttribute mlirDenseElementsAttrBoolSplatGet(MlirType shapedType,
                                                 bool element) {
   return wrap(
       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
 }
 MlirAttribute mlirDenseElementsAttrUInt8SplatGet(MlirType shapedType,
                                                  uint8_t element) {
   return wrap(
       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
 }
 MlirAttribute mlirDenseElementsAttrInt8SplatGet(MlirType shapedType,
                                                 int8_t element) {
   return wrap(
       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
 }
 MlirAttribute mlirDenseElementsAttrUInt32SplatGet(MlirType shapedType,
                                                   uint32_t element) {
   return wrap(
       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
 }
 MlirAttribute mlirDenseElementsAttrInt32SplatGet(MlirType shapedType,
                                                  int32_t element) {
   return wrap(
       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
 }
 MlirAttribute mlirDenseElementsAttrUInt64SplatGet(MlirType shapedType,
                                                   uint64_t element) {
   return wrap(
       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
 }
 MlirAttribute mlirDenseElementsAttrInt64SplatGet(MlirType shapedType,
                                                  int64_t element) {
   return wrap(
       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
 }
 MlirAttribute mlirDenseElementsAttrFloatSplatGet(MlirType shapedType,
                                                  float element) {
   return wrap(
       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
 }
 MlirAttribute mlirDenseElementsAttrDoubleSplatGet(MlirType shapedType,
                                                   double element) {
   return wrap(
       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
 }
 
 MlirAttribute mlirDenseElementsAttrBoolGet(MlirType shapedType,
                                            intptr_t numElements,
                                            const int *elements) {
   SmallVector<bool, 8> values(elements, elements + numElements);
   return wrap(
       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), values));
 }
 
 /// Creates a dense attribute with elements of the type deduced by templates.
 template <typename T>
 static MlirAttribute getDenseAttribute(MlirType shapedType,
                                        intptr_t numElements,
                                        const T *elements) {
   return wrap(
       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
                              llvm::makeArrayRef(elements, numElements)));
 }
 
 MlirAttribute mlirDenseElementsAttrUInt8Get(MlirType shapedType,
                                             intptr_t numElements,
                                             const uint8_t *elements) {
   return getDenseAttribute(shapedType, numElements, elements);
 }
 MlirAttribute mlirDenseElementsAttrInt8Get(MlirType shapedType,
                                            intptr_t numElements,
                                            const int8_t *elements) {
   return getDenseAttribute(shapedType, numElements, elements);
 }
 MlirAttribute mlirDenseElementsAttrUInt16Get(MlirType shapedType,
                                              intptr_t numElements,
                                              const uint16_t *elements) {
   return getDenseAttribute(shapedType, numElements, elements);
 }
 MlirAttribute mlirDenseElementsAttrInt16Get(MlirType shapedType,
                                             intptr_t numElements,
                                             const int16_t *elements) {
   return getDenseAttribute(shapedType, numElements, elements);
 }
 MlirAttribute mlirDenseElementsAttrUInt32Get(MlirType shapedType,
                                              intptr_t numElements,
                                              const uint32_t *elements) {
   return getDenseAttribute(shapedType, numElements, elements);
 }
 MlirAttribute mlirDenseElementsAttrInt32Get(MlirType shapedType,
                                             intptr_t numElements,
                                             const int32_t *elements) {
   return getDenseAttribute(shapedType, numElements, elements);
 }
 MlirAttribute mlirDenseElementsAttrUInt64Get(MlirType shapedType,
                                              intptr_t numElements,
                                              const uint64_t *elements) {
   return getDenseAttribute(shapedType, numElements, elements);
 }
 MlirAttribute mlirDenseElementsAttrInt64Get(MlirType shapedType,
                                             intptr_t numElements,
                                             const int64_t *elements) {
   return getDenseAttribute(shapedType, numElements, elements);
 }
 MlirAttribute mlirDenseElementsAttrFloatGet(MlirType shapedType,
                                             intptr_t numElements,
                                             const float *elements) {
   return getDenseAttribute(shapedType, numElements, elements);
 }
 MlirAttribute mlirDenseElementsAttrDoubleGet(MlirType shapedType,
                                              intptr_t numElements,
                                              const double *elements) {
   return getDenseAttribute(shapedType, numElements, elements);
 }
 
 MlirAttribute mlirDenseElementsAttrStringGet(MlirType shapedType,
                                              intptr_t numElements,
                                              MlirStringRef *strs) {
   SmallVector<StringRef, 8> values;
   values.reserve(numElements);
   for (intptr_t i = 0; i < numElements; ++i)
     values.push_back(unwrap(strs[i]));
 
   return wrap(
       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), values));
 }
 
 MlirAttribute mlirDenseElementsAttrReshapeGet(MlirAttribute attr,
                                               MlirType shapedType) {
   return wrap(unwrap(attr).cast<DenseElementsAttr>().reshape(
       unwrap(shapedType).cast<ShapedType>()));
 }
 
 //===----------------------------------------------------------------------===//
 // Splat accessors.
 
 bool mlirDenseElementsAttrIsSplat(MlirAttribute attr) {
   return unwrap(attr).cast<DenseElementsAttr>().isSplat();
 }
 
 MlirAttribute mlirDenseElementsAttrGetSplatValue(MlirAttribute attr) {
   return wrap(
       unwrap(attr).cast<DenseElementsAttr>().getSplatValue<Attribute>());
 }
 int mlirDenseElementsAttrGetBoolSplatValue(MlirAttribute attr) {
   return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<bool>();
 }
 int8_t mlirDenseElementsAttrGetInt8SplatValue(MlirAttribute attr) {
   return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<int8_t>();
 }
 uint8_t mlirDenseElementsAttrGetUInt8SplatValue(MlirAttribute attr) {
   return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<uint8_t>();
 }
 int32_t mlirDenseElementsAttrGetInt32SplatValue(MlirAttribute attr) {
   return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<int32_t>();
 }
 uint32_t mlirDenseElementsAttrGetUInt32SplatValue(MlirAttribute attr) {
   return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<uint32_t>();
 }
 int64_t mlirDenseElementsAttrGetInt64SplatValue(MlirAttribute attr) {
   return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<int64_t>();
 }
 uint64_t mlirDenseElementsAttrGetUInt64SplatValue(MlirAttribute attr) {
   return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<uint64_t>();
 }
 float mlirDenseElementsAttrGetFloatSplatValue(MlirAttribute attr) {
   return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<float>();
 }
 double mlirDenseElementsAttrGetDoubleSplatValue(MlirAttribute attr) {
   return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<double>();
 }
 MlirStringRef mlirDenseElementsAttrGetStringSplatValue(MlirAttribute attr) {
   return wrap(
       unwrap(attr).cast<DenseElementsAttr>().getSplatValue<StringRef>());
 }
 
 //===----------------------------------------------------------------------===//
 // Indexed accessors.
 
 bool mlirDenseElementsAttrGetBoolValue(MlirAttribute attr, intptr_t pos) {
   return unwrap(attr).cast<DenseElementsAttr>().getValues<bool>()[pos];
 }
 int8_t mlirDenseElementsAttrGetInt8Value(MlirAttribute attr, intptr_t pos) {
   return unwrap(attr).cast<DenseElementsAttr>().getValues<int8_t>()[pos];
 }
 uint8_t mlirDenseElementsAttrGetUInt8Value(MlirAttribute attr, intptr_t pos) {
   return unwrap(attr).cast<DenseElementsAttr>().getValues<uint8_t>()[pos];
 }
 int16_t mlirDenseElementsAttrGetInt16Value(MlirAttribute attr, intptr_t pos) {
   return unwrap(attr).cast<DenseElementsAttr>().getValues<int16_t>()[pos];
 }
 uint16_t mlirDenseElementsAttrGetUInt16Value(MlirAttribute attr, intptr_t pos) {
   return unwrap(attr).cast<DenseElementsAttr>().getValues<uint16_t>()[pos];
 }
 int32_t mlirDenseElementsAttrGetInt32Value(MlirAttribute attr, intptr_t pos) {
   return unwrap(attr).cast<DenseElementsAttr>().getValues<int32_t>()[pos];
 }
 uint32_t mlirDenseElementsAttrGetUInt32Value(MlirAttribute attr, intptr_t pos) {
   return unwrap(attr).cast<DenseElementsAttr>().getValues<uint32_t>()[pos];
 }
 int64_t mlirDenseElementsAttrGetInt64Value(MlirAttribute attr, intptr_t pos) {
   return unwrap(attr).cast<DenseElementsAttr>().getValues<int64_t>()[pos];
 }
 uint64_t mlirDenseElementsAttrGetUInt64Value(MlirAttribute attr, intptr_t pos) {
   return unwrap(attr).cast<DenseElementsAttr>().getValues<uint64_t>()[pos];
 }
 float mlirDenseElementsAttrGetFloatValue(MlirAttribute attr, intptr_t pos) {
   return unwrap(attr).cast<DenseElementsAttr>().getValues<float>()[pos];
 }
 double mlirDenseElementsAttrGetDoubleValue(MlirAttribute attr, intptr_t pos) {
   return unwrap(attr).cast<DenseElementsAttr>().getValues<double>()[pos];
 }
 MlirStringRef mlirDenseElementsAttrGetStringValue(MlirAttribute attr,
                                                   intptr_t pos) {
   return wrap(
       unwrap(attr).cast<DenseElementsAttr>().getValues<StringRef>()[pos]);
 }
 
 //===----------------------------------------------------------------------===//
 // Raw data accessors.
 
 const void *mlirDenseElementsAttrGetRawData(MlirAttribute attr) {
   return static_cast<const void *>(
       unwrap(attr).cast<DenseElementsAttr>().getRawData().data());
 }
 
 //===----------------------------------------------------------------------===//
 // Opaque elements attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAOpaqueElements(MlirAttribute attr) {
   return unwrap(attr).isa<OpaqueElementsAttr>();
 }
 
 //===----------------------------------------------------------------------===//
 // Sparse elements attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsASparseElements(MlirAttribute attr) {
   return unwrap(attr).isa<SparseElementsAttr>();
 }
 
 MlirAttribute mlirSparseElementsAttribute(MlirType shapedType,
                                           MlirAttribute denseIndices,
                                           MlirAttribute denseValues) {
   return wrap(
       SparseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
                               unwrap(denseIndices).cast<DenseElementsAttr>(),
                               unwrap(denseValues).cast<DenseElementsAttr>()));
 }
 
 MlirAttribute mlirSparseElementsAttrGetIndices(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<SparseElementsAttr>().getIndices());
 }
 
 MlirAttribute mlirSparseElementsAttrGetValues(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<SparseElementsAttr>().getValues());
 }

mlir/core/lib/CAPI/IR/BuiltinTypes.cpp

 //===- BuiltinTypes.cpp - C Interface to MLIR Builtin 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/BuiltinTypes.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/BuiltinTypes.h"
 #include "mlir/IR/Types.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // Integer types.
 //===----------------------------------------------------------------------===//
 
 bool mlirTypeIsAInteger(MlirType type) {
   return unwrap(type).isa<IntegerType>();
 }
 
 MlirType mlirIntegerTypeGet(MlirContext ctx, unsigned bitwidth) {
   return wrap(IntegerType::get(unwrap(ctx), bitwidth));
 }
 
 MlirType mlirIntegerTypeSignedGet(MlirContext ctx, unsigned bitwidth) {
   return wrap(IntegerType::get(unwrap(ctx), bitwidth, IntegerType::Signed));
 }
 
 MlirType mlirIntegerTypeUnsignedGet(MlirContext ctx, unsigned bitwidth) {
   return wrap(IntegerType::get(unwrap(ctx), bitwidth, IntegerType::Unsigned));
 }
 
 unsigned mlirIntegerTypeGetWidth(MlirType type) {
   return unwrap(type).cast<IntegerType>().getWidth();
 }
 
 bool mlirIntegerTypeIsSignless(MlirType type) {
   return unwrap(type).cast<IntegerType>().isSignless();
 }
 
 bool mlirIntegerTypeIsSigned(MlirType type) {
   return unwrap(type).cast<IntegerType>().isSigned();
 }
 
 bool mlirIntegerTypeIsUnsigned(MlirType type) {
   return unwrap(type).cast<IntegerType>().isUnsigned();
 }
 
 //===----------------------------------------------------------------------===//
 // Index type.
 //===----------------------------------------------------------------------===//
 
 bool mlirTypeIsAIndex(MlirType type) { return unwrap(type).isa<IndexType>(); }
 
 MlirType mlirIndexTypeGet(MlirContext ctx) {
   return wrap(IndexType::get(unwrap(ctx)));
 }
 
 //===----------------------------------------------------------------------===//
 // Floating-point types.
 //===----------------------------------------------------------------------===//
 
 bool mlirTypeIsABF16(MlirType type) { return unwrap(type).isBF16(); }
 
 MlirType mlirBF16TypeGet(MlirContext ctx) {
   return wrap(FloatType::getBF16(unwrap(ctx)));
 }
 
 bool mlirTypeIsAF16(MlirType type) { return unwrap(type).isF16(); }
 
 MlirType mlirF16TypeGet(MlirContext ctx) {
   return wrap(FloatType::getF16(unwrap(ctx)));
 }
 
 bool mlirTypeIsAF32(MlirType type) { return unwrap(type).isF32(); }
 
 MlirType mlirF32TypeGet(MlirContext ctx) {
   return wrap(FloatType::getF32(unwrap(ctx)));
 }
 
 bool mlirTypeIsAF64(MlirType type) { return unwrap(type).isF64(); }
 
 MlirType mlirF64TypeGet(MlirContext ctx) {
   return wrap(FloatType::getF64(unwrap(ctx)));
 }
 
 //===----------------------------------------------------------------------===//
 // None type.
 //===----------------------------------------------------------------------===//
 
 bool mlirTypeIsANone(MlirType type) { return unwrap(type).isa<NoneType>(); }
 
 MlirType mlirNoneTypeGet(MlirContext ctx) {
   return wrap(NoneType::get(unwrap(ctx)));
 }
 
 //===----------------------------------------------------------------------===//
 // Complex type.
 //===----------------------------------------------------------------------===//
 
 bool 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.
 //===----------------------------------------------------------------------===//
 
 bool mlirTypeIsAShaped(MlirType type) { return unwrap(type).isa<ShapedType>(); }
 
 MlirType mlirShapedTypeGetElementType(MlirType type) {
   return wrap(unwrap(type).cast<ShapedType>().getElementType());
 }
 
 bool mlirShapedTypeHasRank(MlirType type) {
   return unwrap(type).cast<ShapedType>().hasRank();
 }
 
 int64_t mlirShapedTypeGetRank(MlirType type) {
   return unwrap(type).cast<ShapedType>().getRank();
 }
 
 bool mlirShapedTypeHasStaticShape(MlirType type) {
   return unwrap(type).cast<ShapedType>().hasStaticShape();
 }
 
 bool 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));
 }
 
 bool mlirShapedTypeIsDynamicSize(int64_t size) {
   return ShapedType::isDynamic(size);
 }
 
 bool mlirShapedTypeIsDynamicStrideOrOffset(int64_t val) {
   return ShapedType::isDynamicStrideOrOffset(val);
 }
 
 //===----------------------------------------------------------------------===//
 // Vector type.
 //===----------------------------------------------------------------------===//
 
 bool mlirTypeIsAVector(MlirType type) { return unwrap(type).isa<VectorType>(); }
 
 MlirType mlirVectorTypeGet(intptr_t rank, const int64_t *shape,
                            MlirType elementType) {
   return wrap(
       VectorType::get(llvm::makeArrayRef(shape, static_cast<size_t>(rank)),
                       unwrap(elementType)));
 }
 
 MlirType mlirVectorTypeGetChecked(MlirLocation loc, intptr_t rank,
                                   const int64_t *shape, MlirType elementType) {
   return wrap(VectorType::getChecked(
       unwrap(loc), llvm::makeArrayRef(shape, static_cast<size_t>(rank)),
       unwrap(elementType)));
 }
 
 //===----------------------------------------------------------------------===//
 // Ranked / Unranked tensor type.
 //===----------------------------------------------------------------------===//
 
 bool mlirTypeIsATensor(MlirType type) { return unwrap(type).isa<TensorType>(); }
 
 bool mlirTypeIsARankedTensor(MlirType type) {
   return unwrap(type).isa<RankedTensorType>();
 }
 
 bool mlirTypeIsAUnrankedTensor(MlirType type) {
   return unwrap(type).isa<UnrankedTensorType>();
 }
 
 MlirType mlirRankedTensorTypeGet(intptr_t rank, const int64_t *shape,
                                  MlirType elementType, MlirAttribute encoding) {
   return wrap(RankedTensorType::get(
       llvm::makeArrayRef(shape, static_cast<size_t>(rank)), unwrap(elementType),
       unwrap(encoding)));
 }
 
 MlirType mlirRankedTensorTypeGetChecked(MlirLocation loc, intptr_t rank,
                                         const int64_t *shape,
                                         MlirType elementType,
                                         MlirAttribute encoding) {
   return wrap(RankedTensorType::getChecked(
       unwrap(loc), llvm::makeArrayRef(shape, static_cast<size_t>(rank)),
       unwrap(elementType), unwrap(encoding)));
 }
 
 MlirAttribute mlirRankedTensorTypeGetEncoding(MlirType type) {
   return wrap(unwrap(type).cast<RankedTensorType>().getEncoding());
 }
 
 MlirType mlirUnrankedTensorTypeGet(MlirType elementType) {
   return wrap(UnrankedTensorType::get(unwrap(elementType)));
 }
 
 MlirType mlirUnrankedTensorTypeGetChecked(MlirLocation loc,
                                           MlirType elementType) {
   return wrap(UnrankedTensorType::getChecked(unwrap(loc), unwrap(elementType)));
 }
 
 //===----------------------------------------------------------------------===//
 // Ranked / Unranked MemRef type.
 //===----------------------------------------------------------------------===//
 
 bool mlirTypeIsAMemRef(MlirType type) { return unwrap(type).isa<MemRefType>(); }
 
 MlirType mlirMemRefTypeGet(MlirType elementType, intptr_t rank,
                            const int64_t *shape, MlirAttribute layout,
                            MlirAttribute memorySpace) {
   return wrap(MemRefType::get(
       llvm::makeArrayRef(shape, static_cast<size_t>(rank)), unwrap(elementType),
       mlirAttributeIsNull(layout)
           ? MemRefLayoutAttrInterface()
           : unwrap(layout).cast<MemRefLayoutAttrInterface>(),
       unwrap(memorySpace)));
 }
 
 MlirType mlirMemRefTypeGetChecked(MlirLocation loc, MlirType elementType,
                                   intptr_t rank, const int64_t *shape,
                                   MlirAttribute layout,
                                   MlirAttribute memorySpace) {
   return wrap(MemRefType::getChecked(
       unwrap(loc), llvm::makeArrayRef(shape, static_cast<size_t>(rank)),
       unwrap(elementType),
       mlirAttributeIsNull(layout)
           ? MemRefLayoutAttrInterface()
           : unwrap(layout).cast<MemRefLayoutAttrInterface>(),
       unwrap(memorySpace)));
 }
 
 MlirType mlirMemRefTypeContiguousGet(MlirType elementType, intptr_t rank,
                                      const int64_t *shape,
                                      MlirAttribute memorySpace) {
   return wrap(MemRefType::get(
       llvm::makeArrayRef(shape, static_cast<size_t>(rank)), unwrap(elementType),
       MemRefLayoutAttrInterface(), unwrap(memorySpace)));
 }
 
 MlirType mlirMemRefTypeContiguousGetChecked(MlirLocation loc,
                                             MlirType elementType, intptr_t rank,
                                             const int64_t *shape,
                                             MlirAttribute memorySpace) {
   return wrap(MemRefType::getChecked(
       unwrap(loc), llvm::makeArrayRef(shape, static_cast<size_t>(rank)),
       unwrap(elementType), MemRefLayoutAttrInterface(), unwrap(memorySpace)));
 }
 
 MlirAttribute mlirMemRefTypeGetLayout(MlirType type) {
   return wrap(unwrap(type).cast<MemRefType>().getLayout());
 }
 
 MlirAffineMap mlirMemRefTypeGetAffineMap(MlirType type) {
   return wrap(unwrap(type).cast<MemRefType>().getLayout().getAffineMap());
 }
 
 MlirAttribute mlirMemRefTypeGetMemorySpace(MlirType type) {
   return wrap(unwrap(type).cast<MemRefType>().getMemorySpace());
 }
 
 bool mlirTypeIsAUnrankedMemRef(MlirType type) {
   return unwrap(type).isa<UnrankedMemRefType>();
 }
 
 MlirType mlirUnrankedMemRefTypeGet(MlirType elementType,
                                    MlirAttribute memorySpace) {
   return wrap(
       UnrankedMemRefType::get(unwrap(elementType), unwrap(memorySpace)));
 }
 
 MlirType mlirUnrankedMemRefTypeGetChecked(MlirLocation loc,
                                           MlirType elementType,
                                           MlirAttribute memorySpace) {
   return wrap(UnrankedMemRefType::getChecked(unwrap(loc), unwrap(elementType),
                                              unwrap(memorySpace)));
 }
 
 MlirAttribute mlirUnrankedMemrefGetMemorySpace(MlirType type) {
   return wrap(unwrap(type).cast<UnrankedMemRefType>().getMemorySpace());
 }
 
 //===----------------------------------------------------------------------===//
 // Tuple type.
 //===----------------------------------------------------------------------===//
 
 bool mlirTypeIsATuple(MlirType type) { return unwrap(type).isa<TupleType>(); }
 
 MlirType mlirTupleTypeGet(MlirContext ctx, intptr_t numElements,
                           MlirType const *elements) {
   SmallVector<Type, 4> types;
   ArrayRef<Type> typeRef = unwrapList(numElements, elements, types);
   return wrap(TupleType::get(unwrap(ctx), typeRef));
 }
 
 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)));
 }
 
 //===----------------------------------------------------------------------===//
 // Function type.
 //===----------------------------------------------------------------------===//
 
 bool mlirTypeIsAFunction(MlirType type) {
   return unwrap(type).isa<FunctionType>();
 }
 
 MlirType mlirFunctionTypeGet(MlirContext ctx, intptr_t numInputs,
                              MlirType const *inputs, intptr_t numResults,
                              MlirType const *results) {
   SmallVector<Type, 4> inputsList;
   SmallVector<Type, 4> resultsList;
   (void)unwrapList(numInputs, inputs, inputsList);
   (void)unwrapList(numResults, results, resultsList);
   return wrap(FunctionType::get(unwrap(ctx), inputsList, resultsList));
 }
 
 intptr_t mlirFunctionTypeGetNumInputs(MlirType type) {
   return unwrap(type).cast<FunctionType>().getNumInputs();
 }
 
 intptr_t mlirFunctionTypeGetNumResults(MlirType type) {
   return unwrap(type).cast<FunctionType>().getNumResults();
 }
 
 MlirType mlirFunctionTypeGetInput(MlirType type, intptr_t pos) {
   assert(pos >= 0 && "pos in array must be positive");
   return wrap(
       unwrap(type).cast<FunctionType>().getInput(static_cast<unsigned>(pos)));
 }
 
 MlirType mlirFunctionTypeGetResult(MlirType type, intptr_t pos) {
   assert(pos >= 0 && "pos in array must be positive");
   return wrap(
       unwrap(type).cast<FunctionType>().getResult(static_cast<unsigned>(pos)));
 }

mlir/core/lib/CAPI/IR/CMakeLists.txt

 # Main API shared library.
 add_mlir_upstream_c_api_library(MLIRCAPIIR
   AffineExpr.cpp
   AffineMap.cpp
   BuiltinAttributes.cpp
   BuiltinTypes.cpp
   Diagnostics.cpp
   DialectHandle.cpp
   IntegerSet.cpp
   IR.cpp
   Pass.cpp
   Support.cpp
 
   LINK_LIBS PUBLIC
   MLIRIR
   MLIRParser
   MLIRSupport
   MLIRPass
 )

mlir/core/lib/CAPI/IR/Diagnostics.cpp

 //===- Diagnostics.cpp - C Interface for MLIR Diagnostics -----------------===//
 //
 // 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/Diagnostics.h"
 #include "mlir/CAPI/Diagnostics.h"
 #include "mlir/CAPI/IR.h"
 #include "mlir/CAPI/Support.h"
 #include "mlir/CAPI/Utils.h"
 #include "mlir/IR/Diagnostics.h"
 
 using namespace mlir;
 
 void mlirDiagnosticPrint(MlirDiagnostic diagnostic, MlirStringCallback callback,
                          void *userData) {
   detail::CallbackOstream stream(callback, userData);
   unwrap(diagnostic).print(stream);
 }
 
 MlirLocation mlirDiagnosticGetLocation(MlirDiagnostic diagnostic) {
   return wrap(unwrap(diagnostic).getLocation());
 }
 
 MlirDiagnosticSeverity mlirDiagnosticGetSeverity(MlirDiagnostic diagnostic) {
   switch (unwrap(diagnostic).getSeverity()) {
   case mlir::DiagnosticSeverity::Error:
     return MlirDiagnosticError;
   case mlir::DiagnosticSeverity::Warning:
     return MlirDiagnosticWarning;
   case mlir::DiagnosticSeverity::Note:
     return MlirDiagnosticNote;
   case mlir::DiagnosticSeverity::Remark:
     return MlirDiagnosticRemark;
   }
   llvm_unreachable("unhandled diagnostic severity");
 }
 
 // Notes are stored in a vector, so note iterator range is a pair of
 // random access iterators, for which it is cheap to compute the size.
 intptr_t mlirDiagnosticGetNumNotes(MlirDiagnostic diagnostic) {
   return static_cast<intptr_t>(llvm::size(unwrap(diagnostic).getNotes()));
 }
 
 // Notes are stored in a vector, so the iterator is a random access iterator,
 // cheap to advance multiple steps at a time.
 MlirDiagnostic mlirDiagnosticGetNote(MlirDiagnostic diagnostic, intptr_t pos) {
   return wrap(*std::next(unwrap(diagnostic).getNotes().begin(), pos));
 }
 
 static void deleteUserDataNoop(void *userData) {}
 
 MlirDiagnosticHandlerID mlirContextAttachDiagnosticHandler(
     MlirContext context, MlirDiagnosticHandler handler, void *userData,
     void (*deleteUserData)(void *)) {
   assert(handler && "unexpected null diagnostic handler");
   if (deleteUserData == nullptr)
     deleteUserData = deleteUserDataNoop;
   std::shared_ptr<void> sharedUserData(userData, deleteUserData);
   DiagnosticEngine::HandlerID id =
       unwrap(context)->getDiagEngine().registerHandler(
           [handler, sharedUserData](Diagnostic &diagnostic) {
             return unwrap(handler(wrap(diagnostic), sharedUserData.get()));
           });
   return static_cast<MlirDiagnosticHandlerID>(id);
 }
 
 void mlirContextDetachDiagnosticHandler(MlirContext context,
                                         MlirDiagnosticHandlerID id) {
   unwrap(context)->getDiagEngine().eraseHandler(
       static_cast<DiagnosticEngine::HandlerID>(id));
 }
 
 void mlirEmitError(MlirLocation location, const char *message) {
   emitError(unwrap(location)) << message;
 }

mlir/core/lib/CAPI/IR/DialectHandle.cpp

 //===- DialectHandle.cpp - C Interface for MLIR Dialect Operations -------===//
 //
 // 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/CAPI/Registration.h"
 
 static inline const MlirDialectRegistrationHooks *
 unwrap(MlirDialectHandle handle) {
   return (const MlirDialectRegistrationHooks *)handle.ptr;
 }
 
 MlirStringRef mlirDialectHandleGetNamespace(MlirDialectHandle handle) {
   return unwrap(handle)->getNamespaceHook();
 }
 
 void mlirDialectHandleInsertDialect(MlirDialectHandle handle,
                                     MlirDialectRegistry registry) {
   unwrap(handle)->insertHook(registry);
 }
 
 void mlirDialectHandleRegisterDialect(MlirDialectHandle handle,
                                       MlirContext ctx) {
   mlir::DialectRegistry registry;
   mlirDialectHandleInsertDialect(handle, wrap(&registry));
   unwrap(ctx)->appendDialectRegistry(registry);
 }
 
 MlirDialect mlirDialectHandleLoadDialect(MlirDialectHandle handle,
                                          MlirContext ctx) {
   return unwrap(handle)->loadHook(ctx);
 }

mlir/core/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-c/Support.h"
 
 #include "mlir/CAPI/IR.h"
 #include "mlir/CAPI/Support.h"
 #include "mlir/CAPI/Utils.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/Types.h"
 #include "mlir/IR/Verifier.h"
 #include "mlir/Interfaces/InferTypeOpInterface.h"
 #include "mlir/Parser/Parser.h"
 
 #include "llvm/Support/Debug.h"
 #include <cstddef>
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // Context API.
 //===----------------------------------------------------------------------===//
 
 MlirContext mlirContextCreate() {
   auto *context = new MLIRContext;
   return wrap(context);
 }
 
 bool mlirContextEqual(MlirContext ctx1, MlirContext ctx2) {
   return unwrap(ctx1) == unwrap(ctx2);
 }
 
 void mlirContextDestroy(MlirContext context) { delete unwrap(context); }
 
 void mlirContextSetAllowUnregisteredDialects(MlirContext context, bool allow) {
   unwrap(context)->allowUnregisteredDialects(allow);
 }
 
 bool mlirContextGetAllowUnregisteredDialects(MlirContext context) {
   return unwrap(context)->allowsUnregisteredDialects();
 }
 intptr_t mlirContextGetNumRegisteredDialects(MlirContext context) {
   return static_cast<intptr_t>(unwrap(context)->getAvailableDialects().size());
 }
 
 void mlirContextAppendDialectRegistry(MlirContext ctx,
                                       MlirDialectRegistry registry) {
   unwrap(ctx)->appendDialectRegistry(*unwrap(registry));
 }
 
 // TODO: expose a cheaper way than constructing + sorting a vector only to take
 // its size.
 intptr_t mlirContextGetNumLoadedDialects(MlirContext context) {
   return static_cast<intptr_t>(unwrap(context)->getLoadedDialects().size());
 }
 
 MlirDialect mlirContextGetOrLoadDialect(MlirContext context,
                                         MlirStringRef name) {
   return wrap(unwrap(context)->getOrLoadDialect(unwrap(name)));
 }
 
 bool mlirContextIsRegisteredOperation(MlirContext context, MlirStringRef name) {
   return unwrap(context)->isOperationRegistered(unwrap(name));
 }
 
 void mlirContextEnableMultithreading(MlirContext context, bool enable) {
   return unwrap(context)->enableMultithreading(enable);
 }
 
 //===----------------------------------------------------------------------===//
 // Dialect API.
 //===----------------------------------------------------------------------===//
 
 MlirContext mlirDialectGetContext(MlirDialect dialect) {
   return wrap(unwrap(dialect)->getContext());
 }
 
 bool mlirDialectEqual(MlirDialect dialect1, MlirDialect dialect2) {
   return unwrap(dialect1) == unwrap(dialect2);
 }
 
 MlirStringRef mlirDialectGetNamespace(MlirDialect dialect) {
   return wrap(unwrap(dialect)->getNamespace());
 }
 
 //===----------------------------------------------------------------------===//
 // DialectRegistry API.
 //===----------------------------------------------------------------------===//
 
 MlirDialectRegistry mlirDialectRegistryCreate() {
   return wrap(new DialectRegistry());
 }
 
 void mlirDialectRegistryDestroy(MlirDialectRegistry registry) {
   delete unwrap(registry);
 }
 
 //===----------------------------------------------------------------------===//
 // Printing flags API.
 //===----------------------------------------------------------------------===//
 
 MlirOpPrintingFlags mlirOpPrintingFlagsCreate() {
   return wrap(new OpPrintingFlags());
 }
 
 void mlirOpPrintingFlagsDestroy(MlirOpPrintingFlags flags) {
   delete unwrap(flags);
 }
 
 void mlirOpPrintingFlagsElideLargeElementsAttrs(MlirOpPrintingFlags flags,
                                                 intptr_t largeElementLimit) {
   unwrap(flags)->elideLargeElementsAttrs(largeElementLimit);
 }
 
 void mlirOpPrintingFlagsEnableDebugInfo(MlirOpPrintingFlags flags,
                                         bool prettyForm) {
   unwrap(flags)->enableDebugInfo(/*prettyForm=*/prettyForm);
 }
 
 void mlirOpPrintingFlagsPrintGenericOpForm(MlirOpPrintingFlags flags) {
   unwrap(flags)->printGenericOpForm();
 }
 
 void mlirOpPrintingFlagsUseLocalScope(MlirOpPrintingFlags flags) {
   unwrap(flags)->useLocalScope();
 }
 
 //===----------------------------------------------------------------------===//
 // Location API.
 //===----------------------------------------------------------------------===//
 
 MlirLocation mlirLocationFileLineColGet(MlirContext context,
                                         MlirStringRef filename, unsigned line,
                                         unsigned col) {
   return wrap(Location(
       FileLineColLoc::get(unwrap(context), unwrap(filename), line, col)));
 }
 
 MlirLocation mlirLocationCallSiteGet(MlirLocation callee, MlirLocation caller) {
   return wrap(Location(CallSiteLoc::get(unwrap(callee), unwrap(caller))));
 }
 
 MlirLocation mlirLocationFusedGet(MlirContext ctx, intptr_t nLocations,
                                   MlirLocation const *locations,
                                   MlirAttribute metadata) {
   SmallVector<Location, 4> locs;
   ArrayRef<Location> unwrappedLocs = unwrapList(nLocations, locations, locs);
   return wrap(FusedLoc::get(unwrappedLocs, unwrap(metadata), unwrap(ctx)));
 }
 
 MlirLocation mlirLocationNameGet(MlirContext context, MlirStringRef name,
                                  MlirLocation childLoc) {
   if (mlirLocationIsNull(childLoc))
     return wrap(
         Location(NameLoc::get(StringAttr::get(unwrap(context), unwrap(name)))));
   return wrap(Location(NameLoc::get(
       StringAttr::get(unwrap(context), unwrap(name)), unwrap(childLoc))));
 }
 
 MlirLocation mlirLocationUnknownGet(MlirContext context) {
   return wrap(Location(UnknownLoc::get(unwrap(context))));
 }
 
 bool mlirLocationEqual(MlirLocation l1, MlirLocation l2) {
   return unwrap(l1) == unwrap(l2);
 }
 
 MlirContext mlirLocationGetContext(MlirLocation location) {
   return wrap(unwrap(location).getContext());
 }
 
 void mlirLocationPrint(MlirLocation location, MlirStringCallback callback,
                        void *userData) {
   detail::CallbackOstream stream(callback, userData);
   unwrap(location).print(stream);
 }
 
 //===----------------------------------------------------------------------===//
 // Module API.
 //===----------------------------------------------------------------------===//
 
 MlirModule mlirModuleCreateEmpty(MlirLocation location) {
   return wrap(ModuleOp::create(unwrap(location)));
 }
 
 MlirModule mlirModuleCreateParse(MlirContext context, MlirStringRef module) {
   OwningOpRef<ModuleOp> owning =
       parseSourceString<ModuleOp>(unwrap(module), unwrap(context));
   if (!owning)
     return MlirModule{nullptr};
   return MlirModule{owning.release().getOperation()};
 }
 
 MlirContext mlirModuleGetContext(MlirModule module) {
   return wrap(unwrap(module).getContext());
 }
 
 MlirBlock mlirModuleGetBody(MlirModule module) {
   return wrap(unwrap(module).getBody());
 }
 
 void mlirModuleDestroy(MlirModule module) {
   // Transfer ownership to an OwningOpRef<ModuleOp> so that its destructor is
   // called.
   OwningOpRef<ModuleOp>(unwrap(module));
 }
 
 MlirOperation mlirModuleGetOperation(MlirModule module) {
   return wrap(unwrap(module).getOperation());
 }
 
 MlirModule mlirModuleFromOperation(MlirOperation op) {
   return wrap(dyn_cast<ModuleOp>(unwrap(op)));
 }
 
 //===----------------------------------------------------------------------===//
 // Operation state API.
 //===----------------------------------------------------------------------===//
 
 MlirOperationState mlirOperationStateGet(MlirStringRef name, MlirLocation loc) {
   MlirOperationState state;
   state.name = name;
   state.location = loc;
   state.nResults = 0;
   state.results = nullptr;
   state.nOperands = 0;
   state.operands = nullptr;
   state.nRegions = 0;
   state.regions = nullptr;
   state.nSuccessors = 0;
   state.successors = nullptr;
   state.nAttributes = 0;
   state.attributes = nullptr;
   state.enableResultTypeInference = false;
   return state;
 }
 
 #define APPEND_ELEMS(type, sizeName, elemName)                                 \
   state->elemName =                                                            \
       (type *)realloc(state->elemName, (state->sizeName + n) * sizeof(type));  \
   memcpy(state->elemName + state->sizeName, elemName, n * sizeof(type));       \
   state->sizeName += n;
 
 void mlirOperationStateAddResults(MlirOperationState *state, intptr_t n,
                                   MlirType const *results) {
   APPEND_ELEMS(MlirType, nResults, results);
 }
 
 void mlirOperationStateAddOperands(MlirOperationState *state, intptr_t n,
                                    MlirValue const *operands) {
   APPEND_ELEMS(MlirValue, nOperands, operands);
 }
 void mlirOperationStateAddOwnedRegions(MlirOperationState *state, intptr_t n,
                                        MlirRegion const *regions) {
   APPEND_ELEMS(MlirRegion, nRegions, regions);
 }
 void mlirOperationStateAddSuccessors(MlirOperationState *state, intptr_t n,
                                      MlirBlock const *successors) {
   APPEND_ELEMS(MlirBlock, nSuccessors, successors);
 }
 void mlirOperationStateAddAttributes(MlirOperationState *state, intptr_t n,
                                      MlirNamedAttribute const *attributes) {
   APPEND_ELEMS(MlirNamedAttribute, nAttributes, attributes);
 }
 
 void mlirOperationStateEnableResultTypeInference(MlirOperationState *state) {
   state->enableResultTypeInference = true;
 }
 
 //===----------------------------------------------------------------------===//
 // Operation API.
 //===----------------------------------------------------------------------===//
 
 static LogicalResult inferOperationTypes(OperationState &state) {
   MLIRContext *context = state.getContext();
   Optional<RegisteredOperationName> info = state.name.getRegisteredInfo();
   if (!info) {
     emitError(state.location)
         << "type inference was requested for the operation " << state.name
         << ", but the operation was not registered. Ensure that the dialect "
            "containing the operation is linked into MLIR and registered with "
            "the context";
     return failure();
   }
 
   // Fallback to inference via an op interface.
   auto *inferInterface = info->getInterface<InferTypeOpInterface>();
   if (!inferInterface) {
     emitError(state.location)
         << "type inference was requested for the operation " << state.name
         << ", but the operation does not support type inference. Result "
            "types must be specified explicitly.";
     return failure();
   }
 
   if (succeeded(inferInterface->inferReturnTypes(
           context, state.location, state.operands,
           state.attributes.getDictionary(context), state.regions, state.types)))
     return success();
 
   // Diagnostic emitted by interface.
   return failure();
 }
 
 MlirOperation mlirOperationCreate(MlirOperationState *state) {
   assert(state);
   OperationState cppState(unwrap(state->location), unwrap(state->name));
   SmallVector<Type, 4> resultStorage;
   SmallVector<Value, 8> operandStorage;
   SmallVector<Block *, 2> successorStorage;
   cppState.addTypes(unwrapList(state->nResults, state->results, resultStorage));
   cppState.addOperands(
       unwrapList(state->nOperands, state->operands, operandStorage));
   cppState.addSuccessors(
       unwrapList(state->nSuccessors, state->successors, successorStorage));
 
   cppState.attributes.reserve(state->nAttributes);
   for (intptr_t i = 0; i < state->nAttributes; ++i)
     cppState.addAttribute(unwrap(state->attributes[i].name),
                           unwrap(state->attributes[i].attribute));
 
   for (intptr_t i = 0; i < state->nRegions; ++i)
     cppState.addRegion(std::unique_ptr<Region>(unwrap(state->regions[i])));
 
   free(state->results);
   free(state->operands);
   free(state->successors);
   free(state->regions);
   free(state->attributes);
 
   // Infer result types.
   if (state->enableResultTypeInference) {
     assert(cppState.types.empty() &&
            "result type inference enabled and result types provided");
     if (failed(inferOperationTypes(cppState)))
       return {nullptr};
   }
 
   MlirOperation result = wrap(Operation::create(cppState));
   return result;
 }
 
 MlirOperation mlirOperationClone(MlirOperation op) {
   return wrap(unwrap(op)->clone());
 }
 
 void mlirOperationDestroy(MlirOperation op) { unwrap(op)->erase(); }
 
 void mlirOperationRemoveFromParent(MlirOperation op) { unwrap(op)->remove(); }
 
 bool mlirOperationEqual(MlirOperation op, MlirOperation other) {
   return unwrap(op) == unwrap(other);
 }
 
 MlirContext mlirOperationGetContext(MlirOperation op) {
   return wrap(unwrap(op)->getContext());
 }
 
 MlirLocation mlirOperationGetLocation(MlirOperation op) {
   return wrap(unwrap(op)->getLoc());
 }
 
 MlirTypeID mlirOperationGetTypeID(MlirOperation op) {
   if (auto info = unwrap(op)->getRegisteredInfo())
     return wrap(info->getTypeID());
   return {nullptr};
 }
 
 MlirIdentifier mlirOperationGetName(MlirOperation op) {
   return wrap(unwrap(op)->getName().getIdentifier());
 }
 
 MlirBlock mlirOperationGetBlock(MlirOperation op) {
   return wrap(unwrap(op)->getBlock());
 }
 
 MlirOperation mlirOperationGetParentOperation(MlirOperation op) {
   return wrap(unwrap(op)->getParentOp());
 }
 
 intptr_t mlirOperationGetNumRegions(MlirOperation op) {
   return static_cast<intptr_t>(unwrap(op)->getNumRegions());
 }
 
 MlirRegion mlirOperationGetRegion(MlirOperation op, intptr_t pos) {
   return wrap(&unwrap(op)->getRegion(static_cast<unsigned>(pos)));
 }
 
 MlirRegion mlirOperationGetFirstRegion(MlirOperation op) {
   Operation *cppOp = unwrap(op);
   if (cppOp->getNumRegions() == 0)
     return wrap(static_cast<Region *>(nullptr));
   return wrap(&cppOp->getRegion(0));
 }
 
 MlirRegion mlirRegionGetNextInOperation(MlirRegion region) {
   Region *cppRegion = unwrap(region);
   Operation *parent = cppRegion->getParentOp();
   intptr_t next = cppRegion->getRegionNumber() + 1;
   if (parent->getNumRegions() > next)
     return wrap(&parent->getRegion(next));
   return wrap(static_cast<Region *>(nullptr));
 }
 
 MlirOperation mlirOperationGetNextInBlock(MlirOperation op) {
   return wrap(unwrap(op)->getNextNode());
 }
 
 intptr_t mlirOperationGetNumOperands(MlirOperation op) {
   return static_cast<intptr_t>(unwrap(op)->getNumOperands());
 }
 
 MlirValue mlirOperationGetOperand(MlirOperation op, intptr_t pos) {
   return wrap(unwrap(op)->getOperand(static_cast<unsigned>(pos)));
 }
 
 void mlirOperationSetOperand(MlirOperation op, intptr_t pos,
                              MlirValue newValue) {
   unwrap(op)->setOperand(static_cast<unsigned>(pos), unwrap(newValue));
 }
 
 intptr_t mlirOperationGetNumResults(MlirOperation op) {
   return static_cast<intptr_t>(unwrap(op)->getNumResults());
 }
 
 MlirValue mlirOperationGetResult(MlirOperation op, intptr_t pos) {
   return wrap(unwrap(op)->getResult(static_cast<unsigned>(pos)));
 }
 
 intptr_t mlirOperationGetNumSuccessors(MlirOperation op) {
   return static_cast<intptr_t>(unwrap(op)->getNumSuccessors());
 }
 
 MlirBlock mlirOperationGetSuccessor(MlirOperation op, intptr_t pos) {
   return wrap(unwrap(op)->getSuccessor(static_cast<unsigned>(pos)));
 }
 
 intptr_t mlirOperationGetNumAttributes(MlirOperation op) {
   return static_cast<intptr_t>(unwrap(op)->getAttrs().size());
 }
 
 MlirNamedAttribute mlirOperationGetAttribute(MlirOperation op, intptr_t pos) {
   NamedAttribute attr = unwrap(op)->getAttrs()[pos];
   return MlirNamedAttribute{wrap(attr.getName()), wrap(attr.getValue())};
 }
 
 MlirAttribute mlirOperationGetAttributeByName(MlirOperation op,
                                               MlirStringRef name) {
   return wrap(unwrap(op)->getAttr(unwrap(name)));
 }
 
 void mlirOperationSetAttributeByName(MlirOperation op, MlirStringRef name,
                                      MlirAttribute attr) {
   unwrap(op)->setAttr(unwrap(name), unwrap(attr));
 }
 
 bool mlirOperationRemoveAttributeByName(MlirOperation op, MlirStringRef name) {
   return !!unwrap(op)->removeAttr(unwrap(name));
 }
 
 void mlirOperationPrint(MlirOperation op, MlirStringCallback callback,
                         void *userData) {
   detail::CallbackOstream stream(callback, userData);
   unwrap(op)->print(stream);
 }
 
 void mlirOperationPrintWithFlags(MlirOperation op, MlirOpPrintingFlags flags,
                                  MlirStringCallback callback, void *userData) {
   detail::CallbackOstream stream(callback, userData);
   unwrap(op)->print(stream, *unwrap(flags));
 }
 
 void mlirOperationDump(MlirOperation op) { return unwrap(op)->dump(); }
 
 bool mlirOperationVerify(MlirOperation op) {
   return succeeded(verify(unwrap(op)));
 }
 
 void mlirOperationMoveAfter(MlirOperation op, MlirOperation other) {
   return unwrap(op)->moveAfter(unwrap(other));
 }
 
 void mlirOperationMoveBefore(MlirOperation op, MlirOperation other) {
   return unwrap(op)->moveBefore(unwrap(other));
 }
 
 //===----------------------------------------------------------------------===//
 // Region API.
 //===----------------------------------------------------------------------===//
 
 MlirRegion mlirRegionCreate() { return wrap(new Region); }
 
 bool mlirRegionEqual(MlirRegion region, MlirRegion other) {
   return unwrap(region) == unwrap(other);
 }
 
 MlirBlock mlirRegionGetFirstBlock(MlirRegion region) {
   Region *cppRegion = unwrap(region);
   if (cppRegion->empty())
     return wrap(static_cast<Block *>(nullptr));
   return wrap(&cppRegion->front());
 }
 
 void mlirRegionAppendOwnedBlock(MlirRegion region, MlirBlock block) {
   unwrap(region)->push_back(unwrap(block));
 }
 
 void mlirRegionInsertOwnedBlock(MlirRegion region, intptr_t pos,
                                 MlirBlock block) {
   auto &blockList = unwrap(region)->getBlocks();
   blockList.insert(std::next(blockList.begin(), pos), unwrap(block));
 }
 
 void mlirRegionInsertOwnedBlockAfter(MlirRegion region, MlirBlock reference,
                                      MlirBlock block) {
   Region *cppRegion = unwrap(region);
   if (mlirBlockIsNull(reference)) {
     cppRegion->getBlocks().insert(cppRegion->begin(), unwrap(block));
     return;
   }
 
   assert(unwrap(reference)->getParent() == unwrap(region) &&
          "expected reference block to belong to the region");
   cppRegion->getBlocks().insertAfter(Region::iterator(unwrap(reference)),
                                      unwrap(block));
 }
 
 void mlirRegionInsertOwnedBlockBefore(MlirRegion region, MlirBlock reference,
                                       MlirBlock block) {
   if (mlirBlockIsNull(reference))
     return mlirRegionAppendOwnedBlock(region, block);
 
   assert(unwrap(reference)->getParent() == unwrap(region) &&
          "expected reference block to belong to the region");
   unwrap(region)->getBlocks().insert(Region::iterator(unwrap(reference)),
                                      unwrap(block));
 }
 
 void mlirRegionDestroy(MlirRegion region) {
   delete static_cast<Region *>(region.ptr);
 }
 
 //===----------------------------------------------------------------------===//
 // Block API.
 //===----------------------------------------------------------------------===//
 
 MlirBlock mlirBlockCreate(intptr_t nArgs, MlirType const *args,
                           MlirLocation const *locs) {
   Block *b = new Block;
   for (intptr_t i = 0; i < nArgs; ++i)
     b->addArgument(unwrap(args[i]), unwrap(locs[i]));
   return wrap(b);
 }
 
 bool mlirBlockEqual(MlirBlock block, MlirBlock other) {
   return unwrap(block) == unwrap(other);
 }
 
 MlirOperation mlirBlockGetParentOperation(MlirBlock block) {
   return wrap(unwrap(block)->getParentOp());
 }
 
 MlirRegion mlirBlockGetParentRegion(MlirBlock block) {
   return wrap(unwrap(block)->getParent());
 }
 
 MlirBlock mlirBlockGetNextInRegion(MlirBlock block) {
   return wrap(unwrap(block)->getNextNode());
 }
 
 MlirOperation mlirBlockGetFirstOperation(MlirBlock block) {
   Block *cppBlock = unwrap(block);
   if (cppBlock->empty())
     return wrap(static_cast<Operation *>(nullptr));
   return wrap(&cppBlock->front());
 }
 
 MlirOperation mlirBlockGetTerminator(MlirBlock block) {
   Block *cppBlock = unwrap(block);
   if (cppBlock->empty())
     return wrap(static_cast<Operation *>(nullptr));
   Operation &back = cppBlock->back();
   if (!back.hasTrait<OpTrait::IsTerminator>())
     return wrap(static_cast<Operation *>(nullptr));
   return wrap(&back);
 }
 
 void mlirBlockAppendOwnedOperation(MlirBlock block, MlirOperation operation) {
   unwrap(block)->push_back(unwrap(operation));
 }
 
 void mlirBlockInsertOwnedOperation(MlirBlock block, intptr_t pos,
                                    MlirOperation operation) {
   auto &opList = unwrap(block)->getOperations();
   opList.insert(std::next(opList.begin(), pos), unwrap(operation));
 }
 
 void mlirBlockInsertOwnedOperationAfter(MlirBlock block,
                                         MlirOperation reference,
                                         MlirOperation operation) {
   Block *cppBlock = unwrap(block);
   if (mlirOperationIsNull(reference)) {
     cppBlock->getOperations().insert(cppBlock->begin(), unwrap(operation));
     return;
   }
 
   assert(unwrap(reference)->getBlock() == unwrap(block) &&
          "expected reference operation to belong to the block");
   cppBlock->getOperations().insertAfter(Block::iterator(unwrap(reference)),
                                         unwrap(operation));
 }
 
 void mlirBlockInsertOwnedOperationBefore(MlirBlock block,
                                          MlirOperation reference,
                                          MlirOperation operation) {
   if (mlirOperationIsNull(reference))
     return mlirBlockAppendOwnedOperation(block, operation);
 
   assert(unwrap(reference)->getBlock() == unwrap(block) &&
          "expected reference operation to belong to the block");
   unwrap(block)->getOperations().insert(Block::iterator(unwrap(reference)),
                                         unwrap(operation));
 }
 
 void mlirBlockDestroy(MlirBlock block) { delete unwrap(block); }
 
 intptr_t mlirBlockGetNumArguments(MlirBlock block) {
   return static_cast<intptr_t>(unwrap(block)->getNumArguments());
 }
 
 MlirValue mlirBlockAddArgument(MlirBlock block, MlirType type,
                                MlirLocation loc) {
   return wrap(unwrap(block)->addArgument(unwrap(type), unwrap(loc)));
 }
 
 MlirValue mlirBlockGetArgument(MlirBlock block, intptr_t pos) {
   return wrap(unwrap(block)->getArgument(static_cast<unsigned>(pos)));
 }
 
 void mlirBlockPrint(MlirBlock block, MlirStringCallback callback,
                     void *userData) {
   detail::CallbackOstream stream(callback, userData);
   unwrap(block)->print(stream);
 }
 
 //===----------------------------------------------------------------------===//
 // Value API.
 //===----------------------------------------------------------------------===//
 
 bool mlirValueEqual(MlirValue value1, MlirValue value2) {
   return unwrap(value1) == unwrap(value2);
 }
 
 bool mlirValueIsABlockArgument(MlirValue value) {
   return unwrap(value).isa<BlockArgument>();
 }
 
 bool mlirValueIsAOpResult(MlirValue value) {
   return unwrap(value).isa<OpResult>();
 }
 
 MlirBlock mlirBlockArgumentGetOwner(MlirValue value) {
   return wrap(unwrap(value).cast<BlockArgument>().getOwner());
 }
 
 intptr_t mlirBlockArgumentGetArgNumber(MlirValue value) {
   return static_cast<intptr_t>(
       unwrap(value).cast<BlockArgument>().getArgNumber());
 }
 
 void mlirBlockArgumentSetType(MlirValue value, MlirType type) {
   unwrap(value).cast<BlockArgument>().setType(unwrap(type));
 }
 
 MlirOperation mlirOpResultGetOwner(MlirValue value) {
   return wrap(unwrap(value).cast<OpResult>().getOwner());
 }
 
 intptr_t mlirOpResultGetResultNumber(MlirValue value) {
   return static_cast<intptr_t>(
       unwrap(value).cast<OpResult>().getResultNumber());
 }
 
 MlirType mlirValueGetType(MlirValue value) {
   return wrap(unwrap(value).getType());
 }
 
 void mlirValueDump(MlirValue value) { unwrap(value).dump(); }
 
 void mlirValuePrint(MlirValue value, MlirStringCallback callback,
                     void *userData) {
   detail::CallbackOstream stream(callback, userData);
   unwrap(value).print(stream);
 }
 
 //===----------------------------------------------------------------------===//
 // Type API.
 //===----------------------------------------------------------------------===//
 
 MlirType mlirTypeParseGet(MlirContext context, MlirStringRef type) {
   return wrap(mlir::parseType(unwrap(type), unwrap(context)));
 }
 
 MlirContext mlirTypeGetContext(MlirType type) {
   return wrap(unwrap(type).getContext());
 }
 
 MlirTypeID mlirTypeGetTypeID(MlirType type) {
   return wrap(unwrap(type).getTypeID());
 }
 
 bool mlirTypeEqual(MlirType t1, MlirType t2) {
   return unwrap(t1) == unwrap(t2);
 }
 
 void mlirTypePrint(MlirType type, MlirStringCallback callback, void *userData) {
   detail::CallbackOstream stream(callback, userData);
   unwrap(type).print(stream);
 }
 
 void mlirTypeDump(MlirType type) { unwrap(type).dump(); }
 
 //===----------------------------------------------------------------------===//
 // Attribute API.
 //===----------------------------------------------------------------------===//
 
 MlirAttribute mlirAttributeParseGet(MlirContext context, MlirStringRef attr) {
   return wrap(mlir::parseAttribute(unwrap(attr), unwrap(context)));
 }
 
 MlirContext mlirAttributeGetContext(MlirAttribute attribute) {
   return wrap(unwrap(attribute).getContext());
 }
 
 MlirType mlirAttributeGetType(MlirAttribute attribute) {
   return wrap(unwrap(attribute).getType());
 }
 
 MlirTypeID mlirAttributeGetTypeID(MlirAttribute attr) {
   return wrap(unwrap(attr).getTypeID());
 }
 
 bool mlirAttributeEqual(MlirAttribute a1, MlirAttribute a2) {
   return unwrap(a1) == unwrap(a2);
 }
 
 void mlirAttributePrint(MlirAttribute attr, MlirStringCallback callback,
                         void *userData) {
   detail::CallbackOstream stream(callback, userData);
   unwrap(attr).print(stream);
 }
 
 void mlirAttributeDump(MlirAttribute attr) { unwrap(attr).dump(); }
 
 MlirNamedAttribute mlirNamedAttributeGet(MlirIdentifier name,
                                          MlirAttribute attr) {
   return MlirNamedAttribute{name, attr};
 }
 
 //===----------------------------------------------------------------------===//
 // Identifier API.
 //===----------------------------------------------------------------------===//
 
 MlirIdentifier mlirIdentifierGet(MlirContext context, MlirStringRef str) {
   return wrap(StringAttr::get(unwrap(context), unwrap(str)));
 }
 
 MlirContext mlirIdentifierGetContext(MlirIdentifier ident) {
   return wrap(unwrap(ident).getContext());
 }
 
 bool mlirIdentifierEqual(MlirIdentifier ident, MlirIdentifier other) {
   return unwrap(ident) == unwrap(other);
 }
 
 MlirStringRef mlirIdentifierStr(MlirIdentifier ident) {
   return wrap(unwrap(ident).strref());
 }
 
 //===----------------------------------------------------------------------===//
 // TypeID API.
 //===----------------------------------------------------------------------===//
 
 bool mlirTypeIDEqual(MlirTypeID typeID1, MlirTypeID typeID2) {
   return unwrap(typeID1) == unwrap(typeID2);
 }
 
 size_t mlirTypeIDHashValue(MlirTypeID typeID) {
   return hash_value(unwrap(typeID));
 }
 
 //===----------------------------------------------------------------------===//
 // Symbol and SymbolTable API.
 //===----------------------------------------------------------------------===//
 
 MlirStringRef mlirSymbolTableGetSymbolAttributeName() {
   return wrap(SymbolTable::getSymbolAttrName());
 }
 
 MlirStringRef mlirSymbolTableGetVisibilityAttributeName() {
   return wrap(SymbolTable::getVisibilityAttrName());
 }
 
 MlirSymbolTable mlirSymbolTableCreate(MlirOperation operation) {
   if (!unwrap(operation)->hasTrait<OpTrait::SymbolTable>())
     return wrap(static_cast<SymbolTable *>(nullptr));
   return wrap(new SymbolTable(unwrap(operation)));
 }
 
 void mlirSymbolTableDestroy(MlirSymbolTable symbolTable) {
   delete unwrap(symbolTable);
 }
 
 MlirOperation mlirSymbolTableLookup(MlirSymbolTable symbolTable,
                                     MlirStringRef name) {
   return wrap(unwrap(symbolTable)->lookup(StringRef(name.data, name.length)));
 }
 
 MlirAttribute mlirSymbolTableInsert(MlirSymbolTable symbolTable,
                                     MlirOperation operation) {
   return wrap((Attribute)unwrap(symbolTable)->insert(unwrap(operation)));
 }
 
 void mlirSymbolTableErase(MlirSymbolTable symbolTable,
                           MlirOperation operation) {
   unwrap(symbolTable)->erase(unwrap(operation));
 }
 
 MlirLogicalResult mlirSymbolTableReplaceAllSymbolUses(MlirStringRef oldSymbol,
                                                       MlirStringRef newSymbol,
                                                       MlirOperation from) {
   auto *cppFrom = unwrap(from);
   auto *context = cppFrom->getContext();
   auto oldSymbolAttr = StringAttr::get(context, unwrap(oldSymbol));
   auto newSymbolAttr = StringAttr::get(context, unwrap(newSymbol));
   return wrap(SymbolTable::replaceAllSymbolUses(oldSymbolAttr, newSymbolAttr,
                                                 unwrap(from)));
 }
 
 void mlirSymbolTableWalkSymbolTables(MlirOperation from, bool allSymUsesVisible,
                                      void (*callback)(MlirOperation, bool,
                                                       void *userData),
                                      void *userData) {
   SymbolTable::walkSymbolTables(unwrap(from), allSymUsesVisible,
                                 [&](Operation *foundOpCpp, bool isVisible) {
                                   callback(wrap(foundOpCpp), isVisible,
                                            userData);
                                 });
 }

mlir/core/lib/CAPI/IR/IntegerSet.cpp

 //===- IntegerSet.cpp - C API for MLIR Integer Sets -----------------------===//
 //
 // 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/IntegerSet.h"
 #include "mlir-c/AffineExpr.h"
 #include "mlir/CAPI/AffineExpr.h"
 #include "mlir/CAPI/IR.h"
 #include "mlir/CAPI/IntegerSet.h"
 #include "mlir/CAPI/Utils.h"
 #include "mlir/IR/IntegerSet.h"
 
 using namespace mlir;
 
 MlirContext mlirIntegerSetGetContext(MlirIntegerSet set) {
   return wrap(unwrap(set).getContext());
 }
 
 bool mlirIntegerSetEqual(MlirIntegerSet s1, MlirIntegerSet s2) {
   return unwrap(s1) == unwrap(s2);
 }
 
 void mlirIntegerSetPrint(MlirIntegerSet set, MlirStringCallback callback,
                          void *userData) {
   mlir::detail::CallbackOstream stream(callback, userData);
   unwrap(set).print(stream);
 }
 
 void mlirIntegerSetDump(MlirIntegerSet set) { unwrap(set).dump(); }
 
 MlirIntegerSet mlirIntegerSetEmptyGet(MlirContext context, intptr_t numDims,
                                       intptr_t numSymbols) {
   return wrap(IntegerSet::getEmptySet(static_cast<unsigned>(numDims),
                                       static_cast<unsigned>(numSymbols),
                                       unwrap(context)));
 }
 
 MlirIntegerSet mlirIntegerSetGet(MlirContext context, intptr_t numDims,
                                  intptr_t numSymbols, intptr_t numConstraints,
                                  const MlirAffineExpr *constraints,
                                  const bool *eqFlags) {
   SmallVector<AffineExpr> mlirConstraints;
   (void)unwrapList(static_cast<size_t>(numConstraints), constraints,
                    mlirConstraints);
   return wrap(IntegerSet::get(
       static_cast<unsigned>(numDims), static_cast<unsigned>(numSymbols),
       mlirConstraints,
       llvm::makeArrayRef(eqFlags, static_cast<size_t>(numConstraints))));
 }
 
 MlirIntegerSet
 mlirIntegerSetReplaceGet(MlirIntegerSet set,
                          const MlirAffineExpr *dimReplacements,
                          const MlirAffineExpr *symbolReplacements,
                          intptr_t numResultDims, intptr_t numResultSymbols) {
   SmallVector<AffineExpr> mlirDims, mlirSymbols;
   (void)unwrapList(unwrap(set).getNumDims(), dimReplacements, mlirDims);
   (void)unwrapList(unwrap(set).getNumSymbols(), symbolReplacements,
                    mlirSymbols);
   return wrap(unwrap(set).replaceDimsAndSymbols(
       mlirDims, mlirSymbols, static_cast<unsigned>(numResultDims),
       static_cast<unsigned>(numResultSymbols)));
 }
 
 bool mlirIntegerSetIsCanonicalEmpty(MlirIntegerSet set) {
   return unwrap(set).isEmptyIntegerSet();
 }
 
 intptr_t mlirIntegerSetGetNumDims(MlirIntegerSet set) {
   return static_cast<intptr_t>(unwrap(set).getNumDims());
 }
 
 intptr_t mlirIntegerSetGetNumSymbols(MlirIntegerSet set) {
   return static_cast<intptr_t>(unwrap(set).getNumSymbols());
 }
 
 intptr_t mlirIntegerSetGetNumInputs(MlirIntegerSet set) {
   return static_cast<intptr_t>(unwrap(set).getNumInputs());
 }
 
 intptr_t mlirIntegerSetGetNumConstraints(MlirIntegerSet set) {
   return static_cast<intptr_t>(unwrap(set).getNumConstraints());
 }
 
 intptr_t mlirIntegerSetGetNumEqualities(MlirIntegerSet set) {
   return static_cast<intptr_t>(unwrap(set).getNumEqualities());
 }
 
 intptr_t mlirIntegerSetGetNumInequalities(MlirIntegerSet set) {
   return static_cast<intptr_t>(unwrap(set).getNumInequalities());
 }
 
 MlirAffineExpr mlirIntegerSetGetConstraint(MlirIntegerSet set, intptr_t pos) {
   return wrap(unwrap(set).getConstraint(static_cast<unsigned>(pos)));
 }
 
 bool mlirIntegerSetIsConstraintEq(MlirIntegerSet set, intptr_t pos) {
   return unwrap(set).isEq(pos);
 }

mlir/core/lib/CAPI/IR/Pass.cpp

 //===- Pass.cpp - C Interface for General Pass Management 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/Pass.h"
 
 #include "mlir/CAPI/IR.h"
 #include "mlir/CAPI/Pass.h"
 #include "mlir/CAPI/Support.h"
 #include "mlir/CAPI/Utils.h"
 #include "mlir/Pass/PassManager.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // PassManager/OpPassManager APIs.
 //===----------------------------------------------------------------------===//
 
 MlirPassManager mlirPassManagerCreate(MlirContext ctx) {
   return wrap(new PassManager(unwrap(ctx)));
 }
 
 void mlirPassManagerDestroy(MlirPassManager passManager) {
   delete unwrap(passManager);
 }
 
 MlirOpPassManager
 mlirPassManagerGetAsOpPassManager(MlirPassManager passManager) {
   return wrap(static_cast<OpPassManager *>(unwrap(passManager)));
 }
 
 MlirLogicalResult mlirPassManagerRun(MlirPassManager passManager,
                                      MlirModule module) {
   return wrap(unwrap(passManager)->run(unwrap(module)));
 }
 
 void mlirPassManagerEnableIRPrinting(MlirPassManager passManager) {
   return unwrap(passManager)->enableIRPrinting();
 }
 
 void mlirPassManagerEnableVerifier(MlirPassManager passManager, bool enable) {
   unwrap(passManager)->enableVerifier(enable);
 }
 
 MlirOpPassManager mlirPassManagerGetNestedUnder(MlirPassManager passManager,
                                                 MlirStringRef operationName) {
   return wrap(&unwrap(passManager)->nest(unwrap(operationName)));
 }
 
 MlirOpPassManager mlirOpPassManagerGetNestedUnder(MlirOpPassManager passManager,
                                                   MlirStringRef operationName) {
   return wrap(&unwrap(passManager)->nest(unwrap(operationName)));
 }
 
 void mlirPassManagerAddOwnedPass(MlirPassManager passManager, MlirPass pass) {
   unwrap(passManager)->addPass(std::unique_ptr<Pass>(unwrap(pass)));
 }
 
 void mlirOpPassManagerAddOwnedPass(MlirOpPassManager passManager,
                                    MlirPass pass) {
   unwrap(passManager)->addPass(std::unique_ptr<Pass>(unwrap(pass)));
 }
 
 void mlirPrintPassPipeline(MlirOpPassManager passManager,
                            MlirStringCallback callback, void *userData) {
   detail::CallbackOstream stream(callback, userData);
   unwrap(passManager)->printAsTextualPipeline(stream);
 }
 
 MlirLogicalResult mlirParsePassPipeline(MlirOpPassManager passManager,
                                         MlirStringRef pipeline) {
   // TODO: errors are sent to std::errs() at the moment, we should pass in a
   // stream and redirect to a diagnostic.
   return wrap(mlir::parsePassPipeline(unwrap(pipeline), *unwrap(passManager)));
 }

mlir/core/lib/CAPI/IR/Support.cpp

 //===- Support.cpp - Helpers for C interface to MLIR API ------------------===//
 //
 // 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/Support.h"
 #include "llvm/ADT/StringRef.h"
 
 #include <cstring>
 
 MlirStringRef mlirStringRefCreateFromCString(const char *str) {
   return mlirStringRefCreate(str, strlen(str));
 }
 
 bool mlirStringRefEqual(MlirStringRef string, MlirStringRef other) {
   return llvm::StringRef(string.data, string.length) ==
          llvm::StringRef(other.data, other.length);
 }

mlir/core/lib/CAPI/Interfaces/CMakeLists.txt

 add_mlir_upstream_c_api_library(MLIRCAPIInterfaces
   Interfaces.cpp
 
   LINK_LIBS PUBLIC
   MLIRInferTypeOpInterface)

mlir/core/lib/CAPI/Interfaces/Interfaces.cpp

 //===- Interfaces.cpp - C Interface for MLIR Interfaces -------------------===//
 //
 // 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/Interfaces.h"
 
 #include "mlir/CAPI/IR.h"
 #include "mlir/CAPI/Wrap.h"
 #include "mlir/Interfaces/InferTypeOpInterface.h"
 #include "llvm/ADT/ScopeExit.h"
 
 using namespace mlir;
 
 bool mlirOperationImplementsInterface(MlirOperation operation,
                                       MlirTypeID interfaceTypeID) {
   Optional<RegisteredOperationName> info =
       unwrap(operation)->getRegisteredInfo();
   return info && info->hasInterface(unwrap(interfaceTypeID));
 }
 
 bool mlirOperationImplementsInterfaceStatic(MlirStringRef operationName,
                                             MlirContext context,
                                             MlirTypeID interfaceTypeID) {
   Optional<RegisteredOperationName> info = RegisteredOperationName::lookup(
       StringRef(operationName.data, operationName.length), unwrap(context));
   return info && info->hasInterface(unwrap(interfaceTypeID));
 }
 
 MlirTypeID mlirInferTypeOpInterfaceTypeID() {
   return wrap(InferTypeOpInterface::getInterfaceID());
 }
 
 MlirLogicalResult mlirInferTypeOpInterfaceInferReturnTypes(
     MlirStringRef opName, MlirContext context, MlirLocation location,
     intptr_t nOperands, MlirValue *operands, MlirAttribute attributes,
     intptr_t nRegions, MlirRegion *regions, MlirTypesCallback callback,
     void *userData) {
   StringRef name(opName.data, opName.length);
   Optional<RegisteredOperationName> info =
       RegisteredOperationName::lookup(name, unwrap(context));
   if (!info)
     return mlirLogicalResultFailure();
 
   llvm::Optional<Location> maybeLocation = llvm::None;
   if (!mlirLocationIsNull(location))
     maybeLocation = unwrap(location);
   SmallVector<Value> unwrappedOperands;
   (void)unwrapList(nOperands, operands, unwrappedOperands);
   DictionaryAttr attributeDict;
   if (!mlirAttributeIsNull(attributes))
     attributeDict = unwrap(attributes).cast<DictionaryAttr>();
 
   // Create a vector of unique pointers to regions and make sure they are not
   // deleted when exiting the scope. This is a hack caused by C++ API expecting
   // an list of unique pointers to regions (without ownership transfer
   // semantics) and C API making ownership transfer explicit.
   SmallVector<std::unique_ptr<Region>> unwrappedRegions;
   unwrappedRegions.reserve(nRegions);
   for (intptr_t i = 0; i < nRegions; ++i)
     unwrappedRegions.emplace_back(unwrap(*(regions + i)));
   auto cleaner = llvm::make_scope_exit([&]() {
     for (auto &region : unwrappedRegions)
       region.release();
   });
 
   SmallVector<Type> inferredTypes;
   if (failed(info->getInterface<InferTypeOpInterface>()->inferReturnTypes(
           unwrap(context), maybeLocation, unwrappedOperands, attributeDict,
           unwrappedRegions, inferredTypes)))
     return mlirLogicalResultFailure();
 
   SmallVector<MlirType> wrappedInferredTypes;
   wrappedInferredTypes.reserve(inferredTypes.size());
   for (Type t : inferredTypes)
     wrappedInferredTypes.push_back(wrap(t));
   callback(wrappedInferredTypes.size(), wrappedInferredTypes.data(), userData);
   return mlirLogicalResultSuccess();
 }

mlir/core/lib/CAPI/Registration/CMakeLists.txt

+add_mlir_upstream_c_api_library(MLIRCAPIRegistration
+  Registration.cpp
+
+  LINK_LIBS PUBLIC
+  MLIRCAPIIR
+  MLIRLLVMToLLVMIRTranslation
+  MLIRAllDialects
+  MLIRAllConversions
+  MLIRAllTranslations
+  )

mlir/core/lib/CAPI/Registration/Registration.cpp

 //===- Registration.cpp - C Interface for MLIR Registration ---------------===//
 //
 // 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/Registration.h"
 
 #include "mlir/CAPI/IR.h"
 #include "mlir/InitAllDialects.h"
 #include "mlir/InitAllPasses.h"
 #include "mlir/Target/LLVMIR/Dialect/LLVMIR/LLVMToLLVMIRTranslation.h"
 
 void mlirRegisterAllDialects(MlirContext context) {
   mlir::registerAllDialects(*unwrap(context));
   // TODO: we may not want to eagerly load here.
   unwrap(context)->loadAllAvailableDialects();
 }
 
 void mlirRegisterAllLLVMTranslations(MlirContext context) {
   mlir::registerLLVMDialectTranslation(*unwrap(context));
 }
 
 void mlirRegisterAllPasses() { mlir::registerAllPasses(); }

mlir/core/lib/CMakeLists.txt

+add_subdirectory(CAPI)
 add_subdirectory(Interfaces)
 add_subdirectory(IR)

mlir/lib/CAPI/CMakeLists.txt

-# For upstream, we accumulate all libraries into the MLIR_CAPI_LIBRARIES
-# property via a custom wrapper function. This is then used to create an
-# aggregate below.
-set_property(GLOBAL APPEND PROPERTY MLIR_CAPI_LIBRARIES)
-function(add_mlir_upstream_c_api_library name)
-  add_mlir_public_c_api_library(${name} ${ARGN})
-  set_property(GLOBAL APPEND PROPERTY MLIR_CAPI_LIBRARIES ${name})
-endfunction()
 
-add_subdirectory(Debug)
 add_subdirectory(Dialect)
 add_subdirectory(Conversion)
-add_subdirectory(Interfaces)
-add_subdirectory(IR)
-add_subdirectory(Registration)
 add_subdirectory(Transforms)
 
 # Only enable the ExecutionEngine if the native target is configured in.
 if(TARGET ${LLVM_NATIVE_ARCH})
   add_subdirectory(ExecutionEngine)
 endif()
 
 # Build the optional CAPI dylib.

mlir/lib/CAPI/Registration/CMakeLists.txt

-# Dialect registration.
-get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
-get_property(translation_libs GLOBAL PROPERTY MLIR_TRANSLATION_LIBS)
-get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS)
-add_mlir_upstream_c_api_library(MLIRCAPIRegistration
-  Registration.cpp
-
-  LINK_LIBS PUBLIC
-  MLIRCAPIIR
-  MLIRLLVMToLLVMIRTranslation
-  ${dialect_libs}
-  ${translation_libs}
-  ${conversion_libs}
-)

mlir/lib/CMakeLists.txt

 # Enable errors for any global constructors.
 add_flag_if_supported("-Werror=global-constructors" WERROR_GLOBAL_CONSTRUCTOR)
 
 add_subdirectory(Analysis)
 add_subdirectory(Conversion)
 add_subdirectory(Dialect)
 add_subdirectory(Parser)
 add_subdirectory(Pass)
 add_subdirectory(Reducer)
 add_subdirectory(Rewrite)
 add_subdirectory(Support)
 add_subdirectory(TableGen)
 add_subdirectory(Target)
 add_subdirectory(Tools)
 add_subdirectory(Transforms)
 
+get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
+add_mlir_library(MLIRAllDialects empty.cpp)
+target_link_libraries(MLIRAllDialects INTERFACE ${dialect_libs})
+
+get_property(translation_libs GLOBAL PROPERTY MLIR_TRANSLATION_LIBS)
+add_mlir_library(MLIRAllTranslations empty.cpp)
+target_link_libraries(MLIRAllDialects INTERFACE ${translation_libs})
+
+get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS)
+add_mlir_library(MLIRAllConversions empty.cpp)
+target_link_libraries(MLIRAllDialects INTERFACE ${conversion_libs})
+
+
 # Only enable the ExecutionEngine if the native target is configured in.
 if(TARGET ${LLVM_NATIVE_ARCH})
   add_subdirectory(ExecutionEngine)
 endif()