[mlir] expose affine map to C API

[zhanghb97]

Summary

This patch provides C API for MLIR affine map.

• Implement C API for AffineMap class.
• Add Utils.h to include/mlir/CAPI/, and move the definition of the CallbackOstream to Utils.h to make sure mlirAffineMapPrint work correct.
• Add TODO for exposing the C API related to AffineExpr and mutable affine map.

[ftynse]

mlir/include/mlir-c/AffineMap.h

21

I'd call this mlirAffineMapEmptyGet.

25

This should be the default mlirAffineMapGet IMO.

26

We agreed to use intptr_t instead of unsigned for anything related to sizes. Dim/symbol count are sizes.

30

I would not not repeat Map in the name, mlirAffineMapConstantGet should be enough.

43

Please give more details on what should the arguments be.

mlir/include/mlir-c/IR.h

364–386

Why can all of this go to AffineMap.h ?

mlir/include/mlir/CAPI/IR.h

18 ↗

(On Diff #291586)

This inverts the layering IMO. AffineMap should depend on IR, not the inverse.

[zhanghb97]

• Modify name of mlirAffineMap***Get functions.
• Use intptr_t for parameters related to sizes.
• Add details for the comments of the mlirAffineMapPermutationMapGet.

mlir/include/mlir-c/IR.h

364–386

I noticed that the standard types/attributes place those API in the IR.h, so I followed the rule and I think that placing them in IR.h can maintain consistency with the standard type/attributes.
It's OK for me to place all of them to AffineMap.h, but what about the definition of these functions? The definition of the mlirAffineMapPrint must be placed in the IR.cpp because it needs the CallbackOstream that only available in the IR.cpp. Should we place the mlirAffineMapPrint in IR.cpp alone and place other functions in AffineMap.cpp?

mlir/include/mlir/CAPI/IR.h

18 ↗

(On Diff #291586)

Remove the #include, and add the #include "mlir/CAPI/AffineMap.h" to IR.cpp to make sure the functions can work correctly.

[ftynse]

mlir/include/mlir-c/AffineMap.h

71–81

These are still unsigned

93

This is still unsigned

mlir/include/mlir-c/IR.h

364–386

You are mistaking mlir::Attribute, which represents the core concept of an attribute, for _standard attrbutes_, which are specific subclasses of mlir::Attribute such as IntegerAttr or StringAttr. The former, being a core IR concept, is rightfully declared in IR.h. The latter are declared in StandardAttributes.h. IR.h should only contain core IR, i.e. things that are necessary to inspect any operation. Affine maps are not that.

No, the definition of mlirAffineMapPrint can be placed anywhere as long as CallbackOstream is placed in the detail namespace and factored out into a private header that implementations can include.

[zhanghb97]

• unsigned -> intptr_t
• Place all the affine map C API back to AffineMap.h/.cpp
• Add Utils.h and move CallbackOstream to Utils.h to make sure it is available to mlirAffineMapPrint.

mlir/include/mlir-c/AffineMap.h

71–81

Done - unsigned -> intptr_t

93

I think this should be a unsigned type. The resultPos is not a directly used size/index, it is used as the argument of the llvm::makeArrayRef, and the AffineMap::getSubMap(ArrayRef<unsigned> resultPos) method wants a ArrayRef<unsigned>. So if we use intptr_t here, we should convert the intptr_t * to unsigned * when we call the llvm::makeArrayRef to make the getSubMap work. I don't think the conversion is necessary.

mlir/include/mlir-c/IR.h

364–386

Done - Place the CallbackOstream to mlir/include/mlir/CAPI/Utils.h to make sure a correct layer.

[zhanghb97]

mlir/include/mlir-c/AffineMap.h

203

See the comment above for the reason I use unsigned here.

[ftynse]

mlir/include/mlir-c/AffineMap.h

93

Positions in a container should use the same type as the size of said container, don't you think? Yes, you'd need to materialize a new vector and convert elements one by one, we already do this in other places.

[zhanghb97]

mlir/include/mlir-c/AffineMap.h

93

The resultPos here is the container (not the position in the container), and the unsigned type here is the type of elements in the container (see the method AffineMap::getSubMap(ArrayRef<unsigned> resultPos)). The type of element has no relationship with the type of size, right?

For example:
The int64_t *shape in the mlirVectorTypeGet

MlirType mlirVectorTypeGet(intptr_t rank, int64_t *shape, MlirType elementType);

is similar with the unsigned *resultPos here:

MlirAffineMap mlirAffineMapGetSubMap(MlirAffineMap affineMap, intptr_t size,
                                     unsigned *resultPos);

The type of the shape or resultPos depends on the method:

VectorType::get(ArrayRef<int64_t> shape, Type elementType)

or

AffineMap::getSubMap(ArrayRef<unsigned> resultPos)

Is my understanding correct? Or I missed somthing important?

Apart from that, if we use intptr_t here, I think the conversion can be:

MlirAffineMap mlirAffineMapGetSubMap(MlirAffineMap affineMap, intptr_t size,
                                     intptr_t *resultPos) {
  return wrap(unwrap(affineMap).getSubMap(
      llvm::makeArrayRef((unsigned *)resultPos, static_cast<size_t>(size))));
}

why should we materialize a new vector?

[ftynse]

Is my understanding correct? Or I missed somthing important?

You are missing the fact that positions of you pass into the call are merely indices of a vector. AffineMap is slightly more than just a vector of AffineExpr. AffineMap::getNumResults returns the size of that vector. If that size has intptr_t type, so should the indices. Type difference also makes user code full of casts that can be avoided.

Apart from that, if we use intptr_t here, I think the conversion can be:

 MlirAffineMap mlirAffineMapGetSubMap(MlirAffineMap affineMap, intptr_t size,
                                     intptr_t *resultPos) {
  return wrap(unwrap(affineMap).getSubMap(
      llvm::makeArrayRef((unsigned *)resultPos, static_cast<size_t>(size))));
}

why should we materialize a new vector?

Because you cannot just cast intptr_t * to unsigned * and expect to access the same data. The pointed-to types may or may not have the same bitwidth. And such casts may be forbidden under strict aliasing.

[zhanghb97]

• Use intptr_t * for the `resultPos parameter in mlirAffineMapGetSubMap function.
• Use a vector to cast the element of resultPos from intptr_t to unsigned.

[ftynse]

Thanks for iterating!

[zhanghb97]

Hi @ftynse - After pushing this patch, I received en email said that:

The Buildbot has detected a new failure on builder mlir-windows while building llvm.
Full details are available at:
http://lab.llvm.org:8011/builders/mlir-windows/builds/7787

I don't know why I received this, what can I do for it?

[stellaraccident]

I don't think that is related to you: that run was for a batch of changes
and the error is in a section of the tree in no way related to your change.
I think you're clear.

[bondhugula]

mlir/test/CAPI/ir.c

591

Document the return value?

819–828

Should all the trailing ones be CHECK-NEXT?

[ftynse]

mlir/test/CAPI/ir.c

819–828

No. This would add an unnecessary constraint (no lines printed in between) that is irrelevant to what is being tested. Labels suffice to differentiate between different "blocks" of tests.

829

Don't forget to turn clang-format back on again.

[zhanghb97]

mlir/test/CAPI/ir.c

829

OK, I will fix this with the next patch about MutableAffineMap.

[ftynse]

mlir/test/CAPI/ir.c

829

I have already changed this.

[zhanghb97]

mlir/test/CAPI/ir.c

829

Thanks!

mlir/include/mlir-c/AffineMap.h

 #define MLIR_C_AFFINEMAP_H
 
 #include "mlir-c/IR.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-DEFINE_C_API_STRUCT(MlirAffineMap, const void);
+/** Creates a zero result affine map with no dimensions or symbols in the
+ * context. The affine map is owned by the context. */
+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. */
+MlirAffineMap mlirAffineMapGet(MlirContext ctx, intptr_t dimCount,
+                               intptr_t symbolCount);
+
+/** Creates a single constant result affine map in the context. The affine map
+ * is owned by the context. */
+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. */
+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. */
+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. */
+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. */
+int mlirAffineMapIsIdentity(MlirAffineMap affineMap);
+
+/** Checks whether the given affine map is a minor identity affine map. */
+int mlirAffineMapIsMinorIdentity(MlirAffineMap affineMap);
+
+/** Checks whether the given affine map is an empty affine map. */
+int mlirAffineMapIsEmpty(MlirAffineMap affineMap);
+
+/** Checks whether the given affine map is a single result constant affine
+ * map. */
+int mlirAffineMapIsSingleConstant(MlirAffineMap affineMap);
+
+/** Returns the constant result of the given affine map. The function asserts
+ * that the map has a single constant result. */
+int64_t mlirAffineMapGetSingleConstantResult(MlirAffineMap affineMap);
+
+/** Returns the number of dimensions of the given affine map. */
+unsigned mlirAffineMapGetNumDims(MlirAffineMap affineMap);
+
+/** Returns the number of symbols of the given affine map. */
+unsigned mlirAffineMapGetNumSymbols(MlirAffineMap affineMap);
+
+/** Returns the number of results of the given affine map. */
+unsigned mlirAffineMapGetNumResults(MlirAffineMap affineMap);
+
+/** Returns the number of inputs (dimensions + symbols) of the given affine
+ * map. */
+unsigned mlirAffineMapGetNumInputs(MlirAffineMap affineMap);
+
+/** Checks whether the given affine map represents a subset of a symbol-less
+ * permutation map. */
+int mlirAffineMapIsProjectedPermutation(MlirAffineMap affineMap);
+
+/** Checks whether the given affine map represents a symbol-less permutation
+ * map. */
+int mlirAffineMapIsPermutation(MlirAffineMap affineMap);
+
+/** Returns the affine map consisting of the `resultPos` subset. */
+MlirAffineMap mlirAffineMapGetSubMap(MlirAffineMap affineMap, intptr_t size,
+                                     unsigned *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. */
+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. */
+MlirAffineMap mlirAffineMapGetMinorSubMap(MlirAffineMap affineMap,
+                                          intptr_t numResults);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_AFFINEMAP_H

mlir/include/mlir-c/IR.h

 DEFINE_C_API_STRUCT(MlirBlock, void);
 DEFINE_C_API_STRUCT(MlirRegion, void);
 
 DEFINE_C_API_STRUCT(MlirValue, const void);
 DEFINE_C_API_STRUCT(MlirAttribute, const void);
 DEFINE_C_API_STRUCT(MlirType, const void);
 DEFINE_C_API_STRUCT(MlirLocation, const void);
 DEFINE_C_API_STRUCT(MlirModule, const void);
+DEFINE_C_API_STRUCT(MlirAffineMap, const void);
 
 /** Named MLIR attribute.
  *
  * A named attribute is essentially a (name, attribute) pair where the name is
  * a string.
  */
 struct MlirNamedAttribute {
   const char *name;
void mlirAttributePrint(MlirAttribute attr, MlirStringCallback callback,
                         void *userData);
 
 /** Prints the attrbute to the standard error stream. */
 void mlirAttributeDump(MlirAttribute attr);
 
 /** Associates an attribute with the name. Takes ownership of neither. */
 MlirNamedAttribute mlirNamedAttributeGet(const char *name, MlirAttribute attr);
 
+/*============================================================================*/
+/* Affine Map API.                                                            */
+/*============================================================================*/
+
+/** Gets the context that the given affine map was created with*/
+MlirContext mlirAffineMapGetContext(MlirAffineMap affineMap);
+
+/** Checks whether an affine map is null. */
+inline int mlirAffineMapIsNull(MlirAffineMap affineMap) {
+  return !affineMap.ptr;
+}
+
+/** Checks if two affine maps are equal. */
+int 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. */
+void mlirAffineMapPrint(MlirAffineMap affineMap, MlirStringCallback callback,
+                        void *userData);
+
+/** Prints the affine map to the standard error stream. */
+void mlirAffineMapDump(MlirAffineMap affineMap);
+
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_IR_H

mlir/lib/CAPI/IR/AffineMap.cpp

 //===- AffineMap.cpp - C API for MLIR Affine Maps -------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir-c/AffineMap.h"
 #include "mlir-c/IR.h"
 #include "mlir/CAPI/AffineMap.h"
+#include "mlir/CAPI/IR.h"
 #include "mlir/IR/AffineMap.h"
 
-// This is a placeholder for affine map bindings. The file is here to serve as a
-// compilation unit that includes the headers.
+// TODO: expose the C API related to `AffineExpr` and mutable affine map.
+
+using namespace mlir;
+
+MlirAffineMap mlirAffineMapEmptyGet(MlirContext ctx) {
+  return wrap(AffineMap::get(unwrap(ctx)));
+}
+
+MlirAffineMap mlirAffineMapGet(MlirContext ctx, intptr_t dimCount,
+                               intptr_t symbolCount) {
+  return wrap(AffineMap::get(dimCount, symbolCount, 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)));
+}
+
+int mlirAffineMapIsIdentity(MlirAffineMap affineMap) {
+  return unwrap(affineMap).isIdentity();
+}
+
+int mlirAffineMapIsMinorIdentity(MlirAffineMap affineMap) {
+  return unwrap(affineMap).isMinorIdentity();
+}
+
+int mlirAffineMapIsEmpty(MlirAffineMap affineMap) {
+  return unwrap(affineMap).isEmpty();
+}
+
+int mlirAffineMapIsSingleConstant(MlirAffineMap affineMap) {
+  return unwrap(affineMap).isSingleConstant();
+}
+
+int64_t mlirAffineMapGetSingleConstantResult(MlirAffineMap affineMap) {
+  return unwrap(affineMap).getSingleConstantResult();
+}
+
+unsigned mlirAffineMapGetNumDims(MlirAffineMap affineMap) {
+  return unwrap(affineMap).getNumDims();
+}
+
+unsigned mlirAffineMapGetNumSymbols(MlirAffineMap affineMap) {
+  return unwrap(affineMap).getNumSymbols();
+}
+
+unsigned mlirAffineMapGetNumResults(MlirAffineMap affineMap) {
+  return unwrap(affineMap).getNumResults();
+}
+
+unsigned mlirAffineMapGetNumInputs(MlirAffineMap affineMap) {
+  return unwrap(affineMap).getNumInputs();
+}
+
+int mlirAffineMapIsProjectedPermutation(MlirAffineMap affineMap) {
+  return unwrap(affineMap).isProjectedPermutation();
+}
+
+int mlirAffineMapIsPermutation(MlirAffineMap affineMap) {
+  return unwrap(affineMap).isPermutation();
+}
+
+MlirAffineMap mlirAffineMapGetSubMap(MlirAffineMap affineMap, intptr_t size,
+                                     unsigned *resultPos) {
+  return wrap(unwrap(affineMap).getSubMap(
+      llvm::makeArrayRef(resultPos, static_cast<size_t>(size))));
+}
+
+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));
+}

mlir/lib/CAPI/IR/IR.cpp

 //===- IR.cpp - C Interface for Core MLIR APIs ----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir-c/IR.h"
 
+#include "mlir/CAPI/AffineMap.h"
 #include "mlir/CAPI/IR.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Parser.h"
 #include "llvm/Support/raw_ostream.h"
void mlirAttributePrint(MlirAttribute attr, MlirStringCallback callback,
   stream.flush();
 }
 
 void mlirAttributeDump(MlirAttribute attr) { unwrap(attr).dump(); }
 
 MlirNamedAttribute mlirNamedAttributeGet(const char *name, MlirAttribute attr) {
   return MlirNamedAttribute{name, attr};
 }
+
+/*============================================================================*/
+/* Affine Map API.                                                            */
+/*============================================================================*/
+
+MlirContext mlirAffineMapGetContext(MlirAffineMap affineMap) {
+  return wrap(unwrap(affineMap).getContext());
+}
+
+int mlirAffineMapEqual(MlirAffineMap a1, MlirAffineMap a2) {
+  return unwrap(a1) == unwrap(a2);
+}
+
+void mlirAffineMapPrint(MlirAffineMap affineMap, MlirStringCallback callback,
+                        void *userData) {
+  CallbackOstream stream(callback, userData);
+  unwrap(affineMap).print(stream);
+  stream.flush();
+}
+
+void mlirAffineMapDump(MlirAffineMap affineMap) { unwrap(affineMap).dump(); }

mlir/test/CAPI/ir.c

 /*===- ir.c - Simple test of C APIs ---------------------------------------===*\
 |*                                                                            *|
 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
 |* Exceptions.                                                                *|
 |* See https://llvm.org/LICENSE.txt for license information.                  *|
 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 /* RUN: mlir-capi-ir-test 2>&1 | FileCheck %s
  */
 
 #include "mlir-c/IR.h"
 #include "mlir-c/Registration.h"
 #include "mlir-c/StandardAttributes.h"
 #include "mlir-c/StandardTypes.h"
+#include "mlir-c/AffineMap.h"
 
 #include <assert.h>
 #include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 void populateLoopBody(MlirContext ctx, MlirBlock loopBody,
int printStandardAttributes(MlirContext ctx) {
   MlirAttribute sparseAttr = mlirSparseElementsAttribute(
       mlirRankedTensorTypeGet(2, shape, mlirF32TypeGet(ctx)), indicesAttr,
       valuesAttr);
   mlirAttributeDump(sparseAttr);
 
   return 0;
 }
 
+int printAffineMap(MlirContext ctx) {
+  MlirAffineMap emptyAffineMap = mlirAffineMapEmptyGet(ctx);
+  MlirAffineMap affineMap = mlirAffineMapGet(ctx, 3, 2);
+  MlirAffineMap constAffineMap = mlirAffineMapConstantGet(ctx, 2);
+  MlirAffineMap multiDimIdentityAffineMap =
+      mlirAffineMapMultiDimIdentityGet(ctx, 3);
+  MlirAffineMap minorIdentityAffineMap =
+      mlirAffineMapMinorIdentityGet(ctx, 3, 2);
+  unsigned permutation[] = {1, 2, 0};
+  MlirAffineMap permutationAffineMap = mlirAffineMapPermutationGet(
+      ctx, sizeof(permutation) / sizeof(unsigned), permutation);
+
+  mlirAffineMapDump(emptyAffineMap);
+  mlirAffineMapDump(affineMap);
+  mlirAffineMapDump(constAffineMap);
+  mlirAffineMapDump(multiDimIdentityAffineMap);
+  mlirAffineMapDump(minorIdentityAffineMap);
+  mlirAffineMapDump(permutationAffineMap);
+
+  if (!mlirAffineMapIsIdentity(emptyAffineMap) ||
+      mlirAffineMapIsIdentity(affineMap) ||
+      mlirAffineMapIsIdentity(constAffineMap) ||
+      !mlirAffineMapIsIdentity(multiDimIdentityAffineMap) ||
+      mlirAffineMapIsIdentity(minorIdentityAffineMap) ||
+      mlirAffineMapIsIdentity(permutationAffineMap))
+    return 1;
+
+  if (!mlirAffineMapIsMinorIdentity(emptyAffineMap) ||
+      mlirAffineMapIsMinorIdentity(affineMap) ||
+      !mlirAffineMapIsMinorIdentity(multiDimIdentityAffineMap) ||
+      !mlirAffineMapIsMinorIdentity(minorIdentityAffineMap) ||
+      mlirAffineMapIsMinorIdentity(permutationAffineMap))
+    return 2;
+
+  if (!mlirAffineMapIsEmpty(emptyAffineMap) ||
+      mlirAffineMapIsEmpty(affineMap) ||
+      mlirAffineMapIsEmpty(constAffineMap) ||
+      mlirAffineMapIsEmpty(multiDimIdentityAffineMap) ||
+      mlirAffineMapIsEmpty(minorIdentityAffineMap) ||
+      mlirAffineMapIsEmpty(permutationAffineMap))
+    return 3;
+
+  if (mlirAffineMapIsSingleConstant(emptyAffineMap) ||
+      mlirAffineMapIsSingleConstant(affineMap) ||
+      !mlirAffineMapIsSingleConstant(constAffineMap) ||
+      mlirAffineMapIsSingleConstant(multiDimIdentityAffineMap) ||
+      mlirAffineMapIsSingleConstant(minorIdentityAffineMap) ||
+      mlirAffineMapIsSingleConstant(permutationAffineMap))
+    return 4;
+
+  if (mlirAffineMapGetSingleConstantResult(constAffineMap) != 2)
+    return 5;
+
+  if (mlirAffineMapGetNumDims(emptyAffineMap) != 0 ||
+      mlirAffineMapGetNumDims(affineMap) != 3 ||
+      mlirAffineMapGetNumDims(constAffineMap) != 0 ||
+      mlirAffineMapGetNumDims(multiDimIdentityAffineMap) != 3 ||
+      mlirAffineMapGetNumDims(minorIdentityAffineMap) != 3 ||
+      mlirAffineMapGetNumDims(permutationAffineMap) != 3)
+    return 6;
+
+  if (mlirAffineMapGetNumSymbols(emptyAffineMap) != 0 ||
+      mlirAffineMapGetNumSymbols(affineMap) != 2 ||
+      mlirAffineMapGetNumSymbols(constAffineMap) != 0 ||
+      mlirAffineMapGetNumSymbols(multiDimIdentityAffineMap) != 0 ||
+      mlirAffineMapGetNumSymbols(minorIdentityAffineMap) != 0 ||
+      mlirAffineMapGetNumSymbols(permutationAffineMap) != 0)
+    return 7;
+
+  if (mlirAffineMapGetNumResults(emptyAffineMap) != 0 ||
+      mlirAffineMapGetNumResults(affineMap) != 0 ||
+      mlirAffineMapGetNumResults(constAffineMap) != 1 ||
+      mlirAffineMapGetNumResults(multiDimIdentityAffineMap) != 3 ||
+      mlirAffineMapGetNumResults(minorIdentityAffineMap) != 2 ||
+      mlirAffineMapGetNumResults(permutationAffineMap) != 3)
+    return 8;
+
+  if (mlirAffineMapGetNumInputs(emptyAffineMap) != 0 ||
+      mlirAffineMapGetNumInputs(affineMap) != 5 ||
+      mlirAffineMapGetNumInputs(constAffineMap) != 0 ||
+      mlirAffineMapGetNumInputs(multiDimIdentityAffineMap) != 3 ||
+      mlirAffineMapGetNumInputs(minorIdentityAffineMap) != 3 ||
+      mlirAffineMapGetNumInputs(permutationAffineMap) != 3)
+    return 9;
+
+  if (!mlirAffineMapIsProjectedPermutation(emptyAffineMap) ||
+      !mlirAffineMapIsPermutation(emptyAffineMap) ||
+      mlirAffineMapIsProjectedPermutation(affineMap) ||
+      mlirAffineMapIsPermutation(affineMap) ||
+      mlirAffineMapIsProjectedPermutation(constAffineMap) ||
+      mlirAffineMapIsPermutation(constAffineMap) ||
+      !mlirAffineMapIsProjectedPermutation(multiDimIdentityAffineMap) ||
+      !mlirAffineMapIsPermutation(multiDimIdentityAffineMap) ||
+      !mlirAffineMapIsProjectedPermutation(minorIdentityAffineMap) ||
+      mlirAffineMapIsPermutation(minorIdentityAffineMap) ||
+      !mlirAffineMapIsProjectedPermutation(permutationAffineMap) ||
+      !mlirAffineMapIsPermutation(permutationAffineMap))
+    return 10;
+
+  unsigned sub[] = {1};
+
+  MlirAffineMap subMap = mlirAffineMapGetSubMap(
+      multiDimIdentityAffineMap, sizeof(sub) / sizeof(unsigned), sub);
+  MlirAffineMap majorSubMap = mlirAffineMapGetMajorSubMap(
+      multiDimIdentityAffineMap, 1);
+  MlirAffineMap minorSubMap = mlirAffineMapGetMinorSubMap(
+      multiDimIdentityAffineMap, 1);
+
+  mlirAffineMapDump(subMap);
+  mlirAffineMapDump(majorSubMap);
+  mlirAffineMapDump(minorSubMap);
+
+  return 0;
+}
+
 int main() {
   MlirContext ctx = mlirContextCreate();
   mlirRegisterAllDialects(ctx);
   MlirLocation location = mlirLocationUnknownGet(ctx);
 
   MlirModule moduleOp = makeAdd(ctx, location);
   MlirOperation module = mlirModuleGetOperation(moduleOp);
   mlirOperationDump(module);
int main() {
   // CHECK: 1.000000e+00 : f32
   // CHECK: 1.000000e+00 : f64
   // CHECK: sparse<[4, 7], [0.000000e+00, 1.000000e+00]> : tensor<1x2xf32>
   // clang-format on
   fprintf(stderr, "@attrs\n");
   errcode = printStandardAttributes(ctx);
   fprintf(stderr, "%d\n", errcode);
 
+  // clang-format off
+  // CHECK-LABEL: @affineMap
+  // CHECK: () -> ()
+  // CHECK: (d0, d1, d2)[s0, s1] -> ()
+  // CHECK: () -> (2)
+  // CHECK: (d0, d1, d2) -> (d0, d1, d2)
+  // CHECK: (d0, d1, d2) -> (d1, d2)
+  // CHECK: (d0, d1, d2) -> (d1, d2, d0)
+  // CHECK: (d0, d1, d2) -> (d1)
+  // CHECK: (d0, d1, d2) -> (d0)
+  // CHECK: (d0, d1, d2) -> (d2)
+  // CHECK: 0
+  fprintf(stderr, "@affineMap\n");
+  errcode = printAffineMap(ctx);
+  fprintf(stderr, "%d\n", errcode);
+
   mlirContextDestroy(ctx);
 
   return 0;
 }