1//===- AffineExpr.cpp - C API for MLIR Affine Expressions -----------------===//
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/AffineExpr.h"
10#include "mlir-c/AffineMap.h"
11#include "mlir-c/IR.h"
12#include "mlir/CAPI/AffineExpr.h"
13#include "mlir/CAPI/AffineMap.h"
14#include "mlir/CAPI/IR.h"
15#include "mlir/CAPI/Utils.h"
16#include "mlir/IR/AffineExpr.h"
17
18using namespace mlir;
19
20MlirContext mlirAffineExprGetContext(MlirAffineExpr affineExpr) {
21 return wrap(cpp: unwrap(c: affineExpr).getContext());
22}
23
24bool mlirAffineExprEqual(MlirAffineExpr lhs, MlirAffineExpr rhs) {
25 return unwrap(c: lhs) == unwrap(c: rhs);
26}
27
28void mlirAffineExprPrint(MlirAffineExpr affineExpr, MlirStringCallback callback,
29 void *userData) {
30 mlir::detail::CallbackOstream stream(callback, userData);
31 unwrap(c: affineExpr).print(os&: stream);
32}
33
34void mlirAffineExprDump(MlirAffineExpr affineExpr) {
35 unwrap(c: affineExpr).dump();
36}
37
38bool mlirAffineExprIsSymbolicOrConstant(MlirAffineExpr affineExpr) {
39 return unwrap(c: affineExpr).isSymbolicOrConstant();
40}
41
42bool mlirAffineExprIsPureAffine(MlirAffineExpr affineExpr) {
43 return unwrap(c: affineExpr).isPureAffine();
44}
45
46int64_t mlirAffineExprGetLargestKnownDivisor(MlirAffineExpr affineExpr) {
47 return unwrap(c: affineExpr).getLargestKnownDivisor();
48}
49
50bool mlirAffineExprIsMultipleOf(MlirAffineExpr affineExpr, int64_t factor) {
51 return unwrap(c: affineExpr).isMultipleOf(factor);
52}
53
54bool mlirAffineExprIsFunctionOfDim(MlirAffineExpr affineExpr,
55 intptr_t position) {
56 return unwrap(c: affineExpr).isFunctionOfDim(position);
57}
58
59MlirAffineExpr mlirAffineExprCompose(MlirAffineExpr affineExpr,
60 MlirAffineMap affineMap) {
61 return wrap(cpp: unwrap(c: affineExpr).compose(map: unwrap(c: affineMap)));
62}
63
64MlirAffineExpr mlirAffineExprShiftDims(MlirAffineExpr affineExpr,
65 uint32_t numDims, uint32_t shift,
66 uint32_t offset) {
67 return wrap(cpp: unwrap(c: affineExpr).shiftDims(numDims, shift, offset));
68}
69
70MlirAffineExpr mlirAffineExprShiftSymbols(MlirAffineExpr affineExpr,
71 uint32_t numSymbols, uint32_t shift,
72 uint32_t offset) {
73 return wrap(cpp: unwrap(c: affineExpr).shiftSymbols(numSymbols, shift, offset));
74}
75
76MlirAffineExpr mlirSimplifyAffineExpr(MlirAffineExpr expr, uint32_t numDims,
77 uint32_t numSymbols) {
78 return wrap(cpp: simplifyAffineExpr(expr: unwrap(c: expr), numDims, numSymbols));
79}
80
81//===----------------------------------------------------------------------===//
82// Affine Dimension Expression.
83//===----------------------------------------------------------------------===//
84
85bool mlirAffineExprIsADim(MlirAffineExpr affineExpr) {
86 return isa<AffineDimExpr>(Val: unwrap(c: affineExpr));
87}
88
89MlirAffineExpr mlirAffineDimExprGet(MlirContext ctx, intptr_t position) {
90 return wrap(cpp: getAffineDimExpr(position, context: unwrap(c: ctx)));
91}
92
93intptr_t mlirAffineDimExprGetPosition(MlirAffineExpr affineExpr) {
94 return cast<AffineDimExpr>(Val: unwrap(c: affineExpr)).getPosition();
95}
96
97//===----------------------------------------------------------------------===//
98// Affine Symbol Expression.
99//===----------------------------------------------------------------------===//
100
101bool mlirAffineExprIsASymbol(MlirAffineExpr affineExpr) {
102 return isa<AffineSymbolExpr>(Val: unwrap(c: affineExpr));
103}
104
105MlirAffineExpr mlirAffineSymbolExprGet(MlirContext ctx, intptr_t position) {
106 return wrap(cpp: getAffineSymbolExpr(position, context: unwrap(c: ctx)));
107}
108
109intptr_t mlirAffineSymbolExprGetPosition(MlirAffineExpr affineExpr) {
110 return cast<AffineSymbolExpr>(Val: unwrap(c: affineExpr)).getPosition();
111}
112
113//===----------------------------------------------------------------------===//
114// Affine Constant Expression.
115//===----------------------------------------------------------------------===//
116
117bool mlirAffineExprIsAConstant(MlirAffineExpr affineExpr) {
118 return isa<AffineConstantExpr>(Val: unwrap(c: affineExpr));
119}
120
121MlirAffineExpr mlirAffineConstantExprGet(MlirContext ctx, int64_t constant) {
122 return wrap(cpp: getAffineConstantExpr(constant, context: unwrap(c: ctx)));
123}
124
125int64_t mlirAffineConstantExprGetValue(MlirAffineExpr affineExpr) {
126 return cast<AffineConstantExpr>(Val: unwrap(c: affineExpr)).getValue();
127}
128
129//===----------------------------------------------------------------------===//
130// Affine Add Expression.
131//===----------------------------------------------------------------------===//
132
133bool mlirAffineExprIsAAdd(MlirAffineExpr affineExpr) {
134 return unwrap(c: affineExpr).getKind() == mlir::AffineExprKind::Add;
135}
136
137MlirAffineExpr mlirAffineAddExprGet(MlirAffineExpr lhs, MlirAffineExpr rhs) {
138 return wrap(cpp: getAffineBinaryOpExpr(kind: mlir::AffineExprKind::Add, lhs: unwrap(c: lhs),
139 rhs: unwrap(c: rhs)));
140}
141
142//===----------------------------------------------------------------------===//
143// Affine Mul Expression.
144//===----------------------------------------------------------------------===//
145
146bool mlirAffineExprIsAMul(MlirAffineExpr affineExpr) {
147 return unwrap(c: affineExpr).getKind() == mlir::AffineExprKind::Mul;
148}
149
150MlirAffineExpr mlirAffineMulExprGet(MlirAffineExpr lhs, MlirAffineExpr rhs) {
151 return wrap(cpp: getAffineBinaryOpExpr(kind: mlir::AffineExprKind::Mul, lhs: unwrap(c: lhs),
152 rhs: unwrap(c: rhs)));
153}
154
155//===----------------------------------------------------------------------===//
156// Affine Mod Expression.
157//===----------------------------------------------------------------------===//
158
159bool mlirAffineExprIsAMod(MlirAffineExpr affineExpr) {
160 return unwrap(c: affineExpr).getKind() == mlir::AffineExprKind::Mod;
161}
162
163MlirAffineExpr mlirAffineModExprGet(MlirAffineExpr lhs, MlirAffineExpr rhs) {
164 return wrap(cpp: getAffineBinaryOpExpr(kind: mlir::AffineExprKind::Mod, lhs: unwrap(c: lhs),
165 rhs: unwrap(c: rhs)));
166}
167
168//===----------------------------------------------------------------------===//
169// Affine FloorDiv Expression.
170//===----------------------------------------------------------------------===//
171
172bool mlirAffineExprIsAFloorDiv(MlirAffineExpr affineExpr) {
173 return unwrap(c: affineExpr).getKind() == mlir::AffineExprKind::FloorDiv;
174}
175
176MlirAffineExpr mlirAffineFloorDivExprGet(MlirAffineExpr lhs,
177 MlirAffineExpr rhs) {
178 return wrap(cpp: getAffineBinaryOpExpr(kind: mlir::AffineExprKind::FloorDiv, lhs: unwrap(c: lhs),
179 rhs: unwrap(c: rhs)));
180}
181
182//===----------------------------------------------------------------------===//
183// Affine CeilDiv Expression.
184//===----------------------------------------------------------------------===//
185
186bool mlirAffineExprIsACeilDiv(MlirAffineExpr affineExpr) {
187 return unwrap(c: affineExpr).getKind() == mlir::AffineExprKind::CeilDiv;
188}
189
190MlirAffineExpr mlirAffineCeilDivExprGet(MlirAffineExpr lhs,
191 MlirAffineExpr rhs) {
192 return wrap(cpp: getAffineBinaryOpExpr(kind: mlir::AffineExprKind::CeilDiv, lhs: unwrap(c: lhs),
193 rhs: unwrap(c: rhs)));
194}
195
196//===----------------------------------------------------------------------===//
197// Affine Binary Operation Expression.
198//===----------------------------------------------------------------------===//
199
200bool mlirAffineExprIsABinary(MlirAffineExpr affineExpr) {
201 return isa<AffineBinaryOpExpr>(Val: unwrap(c: affineExpr));
202}
203
204MlirAffineExpr mlirAffineBinaryOpExprGetLHS(MlirAffineExpr affineExpr) {
205 return wrap(cpp: cast<AffineBinaryOpExpr>(Val: unwrap(c: affineExpr)).getLHS());
206}
207
208MlirAffineExpr mlirAffineBinaryOpExprGetRHS(MlirAffineExpr affineExpr) {
209 return wrap(cpp: cast<AffineBinaryOpExpr>(Val: unwrap(c: affineExpr)).getRHS());
210}
211

source code of mlir/lib/CAPI/IR/AffineExpr.cpp