1//===- AffineMap.cpp - C API for MLIR Affine Maps -------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "mlir-c/AffineMap.h"
10#include "mlir-c/IR.h"
11#include "mlir/CAPI/AffineExpr.h"
12#include "mlir/CAPI/AffineMap.h"
13#include "mlir/CAPI/IR.h"
14#include "mlir/CAPI/Utils.h"
15#include "mlir/IR/AffineMap.h"
16
17// TODO: expose the C API related to `AffineExpr` and mutable affine map.
18
19using namespace mlir;
20
21MlirContext mlirAffineMapGetContext(MlirAffineMap affineMap) {
22 return wrap(cpp: unwrap(c: affineMap).getContext());
23}
24
25bool mlirAffineMapEqual(MlirAffineMap a1, MlirAffineMap a2) {
26 return unwrap(c: a1) == unwrap(c: a2);
27}
28
29void mlirAffineMapPrint(MlirAffineMap affineMap, MlirStringCallback callback,
30 void *userData) {
31 mlir::detail::CallbackOstream stream(callback, userData);
32 unwrap(c: affineMap).print(os&: stream);
33}
34
35void mlirAffineMapDump(MlirAffineMap affineMap) {
36 unwrap(c: affineMap).print(os&: llvm::errs());
37 llvm::errs() << "\n";
38}
39
40MlirAffineMap mlirAffineMapEmptyGet(MlirContext ctx) {
41 return wrap(cpp: AffineMap::get(context: unwrap(c: ctx)));
42}
43
44MlirAffineMap mlirAffineMapZeroResultGet(MlirContext ctx, intptr_t dimCount,
45 intptr_t symbolCount) {
46 return wrap(cpp: AffineMap::get(dimCount, symbolCount, context: unwrap(c: ctx)));
47}
48
49MlirAffineMap mlirAffineMapGet(MlirContext ctx, intptr_t dimCount,
50 intptr_t symbolCount, intptr_t nAffineExprs,
51 MlirAffineExpr *affineExprs) {
52 SmallVector<AffineExpr, 4> exprs;
53 ArrayRef<AffineExpr> exprList = unwrapList(size: nAffineExprs, first: affineExprs, storage&: exprs);
54 return wrap(cpp: AffineMap::get(dimCount, symbolCount, results: exprList, context: unwrap(c: ctx)));
55}
56
57MlirAffineMap mlirAffineMapConstantGet(MlirContext ctx, int64_t val) {
58 return wrap(cpp: AffineMap::getConstantMap(val, context: unwrap(c: ctx)));
59}
60
61MlirAffineMap mlirAffineMapMultiDimIdentityGet(MlirContext ctx,
62 intptr_t numDims) {
63 return wrap(cpp: AffineMap::getMultiDimIdentityMap(numDims, context: unwrap(c: ctx)));
64}
65
66MlirAffineMap mlirAffineMapMinorIdentityGet(MlirContext ctx, intptr_t dims,
67 intptr_t results) {
68 return wrap(cpp: AffineMap::getMinorIdentityMap(dims, results, context: unwrap(c: ctx)));
69}
70
71MlirAffineMap mlirAffineMapPermutationGet(MlirContext ctx, intptr_t size,
72 unsigned *permutation) {
73 return wrap(cpp: AffineMap::getPermutationMap(
74 permutation: llvm::ArrayRef(permutation, static_cast<size_t>(size)), context: unwrap(c: ctx)));
75}
76
77bool mlirAffineMapIsIdentity(MlirAffineMap affineMap) {
78 return unwrap(c: affineMap).isIdentity();
79}
80
81bool mlirAffineMapIsMinorIdentity(MlirAffineMap affineMap) {
82 return unwrap(c: affineMap).isMinorIdentity();
83}
84
85bool mlirAffineMapIsEmpty(MlirAffineMap affineMap) {
86 return unwrap(c: affineMap).isEmpty();
87}
88
89bool mlirAffineMapIsSingleConstant(MlirAffineMap affineMap) {
90 return unwrap(c: affineMap).isSingleConstant();
91}
92
93int64_t mlirAffineMapGetSingleConstantResult(MlirAffineMap affineMap) {
94 return unwrap(c: affineMap).getSingleConstantResult();
95}
96
97intptr_t mlirAffineMapGetNumDims(MlirAffineMap affineMap) {
98 return unwrap(c: affineMap).getNumDims();
99}
100
101intptr_t mlirAffineMapGetNumSymbols(MlirAffineMap affineMap) {
102 return unwrap(c: affineMap).getNumSymbols();
103}
104
105intptr_t mlirAffineMapGetNumResults(MlirAffineMap affineMap) {
106 return unwrap(c: affineMap).getNumResults();
107}
108
109MlirAffineExpr mlirAffineMapGetResult(MlirAffineMap affineMap, intptr_t pos) {
110 return wrap(cpp: unwrap(c: affineMap).getResult(idx: static_cast<unsigned>(pos)));
111}
112
113intptr_t mlirAffineMapGetNumInputs(MlirAffineMap affineMap) {
114 return unwrap(c: affineMap).getNumInputs();
115}
116
117bool mlirAffineMapIsProjectedPermutation(MlirAffineMap affineMap) {
118 return unwrap(c: affineMap).isProjectedPermutation();
119}
120
121bool mlirAffineMapIsPermutation(MlirAffineMap affineMap) {
122 return unwrap(c: affineMap).isPermutation();
123}
124
125MlirAffineMap mlirAffineMapGetSubMap(MlirAffineMap affineMap, intptr_t size,
126 intptr_t *resultPos) {
127 SmallVector<unsigned, 8> pos;
128 pos.reserve(N: size);
129 for (intptr_t i = 0; i < size; ++i)
130 pos.push_back(Elt: static_cast<unsigned>(resultPos[i]));
131 return wrap(cpp: unwrap(c: affineMap).getSubMap(resultPos: pos));
132}
133
134MlirAffineMap mlirAffineMapGetMajorSubMap(MlirAffineMap affineMap,
135 intptr_t numResults) {
136 return wrap(cpp: unwrap(c: affineMap).getMajorSubMap(numResults));
137}
138
139MlirAffineMap mlirAffineMapGetMinorSubMap(MlirAffineMap affineMap,
140 intptr_t numResults) {
141 return wrap(cpp: unwrap(c: affineMap).getMinorSubMap(numResults));
142}
143
144MlirAffineMap mlirAffineMapReplace(MlirAffineMap affineMap,
145 MlirAffineExpr expression,
146 MlirAffineExpr replacement,
147 intptr_t numResultDims,
148 intptr_t numResultSyms) {
149 return wrap(cpp: unwrap(c: affineMap).replace(expr: unwrap(c: expression), replacement: unwrap(c: replacement),
150 numResultDims, numResultSyms));
151}
152
153void mlirAffineMapCompressUnusedSymbols(
154 MlirAffineMap *affineMaps, intptr_t size, void *result,
155 void (*populateResult)(void *res, intptr_t idx, MlirAffineMap m)) {
156 SmallVector<AffineMap> maps;
157 for (intptr_t idx = 0; idx < size; ++idx)
158 maps.push_back(Elt: unwrap(c: affineMaps[idx]));
159 intptr_t idx = 0;
160 for (auto m : mlir::compressUnusedSymbols(maps))
161 populateResult(result, idx++, wrap(cpp: m));
162}
163