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
64//===----------------------------------------------------------------------===//
65// Affine Dimension Expression.
66//===----------------------------------------------------------------------===//
67
68bool mlirAffineExprIsADim(MlirAffineExpr affineExpr) {
69 return isa<AffineDimExpr>(Val: unwrap(c: affineExpr));
70}
71
72MlirAffineExpr mlirAffineDimExprGet(MlirContext ctx, intptr_t position) {
73 return wrap(cpp: getAffineDimExpr(position, context: unwrap(c: ctx)));
74}
75
76intptr_t mlirAffineDimExprGetPosition(MlirAffineExpr affineExpr) {
77 return cast<AffineDimExpr>(Val: unwrap(c: affineExpr)).getPosition();
78}
79
80//===----------------------------------------------------------------------===//
81// Affine Symbol Expression.
82//===----------------------------------------------------------------------===//
83
84bool mlirAffineExprIsASymbol(MlirAffineExpr affineExpr) {
85 return isa<AffineSymbolExpr>(Val: unwrap(c: affineExpr));
86}
87
88MlirAffineExpr mlirAffineSymbolExprGet(MlirContext ctx, intptr_t position) {
89 return wrap(cpp: getAffineSymbolExpr(position, context: unwrap(c: ctx)));
90}
91
92intptr_t mlirAffineSymbolExprGetPosition(MlirAffineExpr affineExpr) {
93 return cast<AffineSymbolExpr>(Val: unwrap(c: affineExpr)).getPosition();
94}
95
96//===----------------------------------------------------------------------===//
97// Affine Constant Expression.
98//===----------------------------------------------------------------------===//
99
100bool mlirAffineExprIsAConstant(MlirAffineExpr affineExpr) {
101 return isa<AffineConstantExpr>(Val: unwrap(c: affineExpr));
102}
103
104MlirAffineExpr mlirAffineConstantExprGet(MlirContext ctx, int64_t constant) {
105 return wrap(cpp: getAffineConstantExpr(constant, context: unwrap(c: ctx)));
106}
107
108int64_t mlirAffineConstantExprGetValue(MlirAffineExpr affineExpr) {
109 return cast<AffineConstantExpr>(Val: unwrap(c: affineExpr)).getValue();
110}
111
112//===----------------------------------------------------------------------===//
113// Affine Add Expression.
114//===----------------------------------------------------------------------===//
115
116bool mlirAffineExprIsAAdd(MlirAffineExpr affineExpr) {
117 return unwrap(c: affineExpr).getKind() == mlir::AffineExprKind::Add;
118}
119
120MlirAffineExpr mlirAffineAddExprGet(MlirAffineExpr lhs, MlirAffineExpr rhs) {
121 return wrap(cpp: getAffineBinaryOpExpr(kind: mlir::AffineExprKind::Add, lhs: unwrap(c: lhs),
122 rhs: unwrap(c: rhs)));
123}
124
125//===----------------------------------------------------------------------===//
126// Affine Mul Expression.
127//===----------------------------------------------------------------------===//
128
129bool mlirAffineExprIsAMul(MlirAffineExpr affineExpr) {
130 return unwrap(c: affineExpr).getKind() == mlir::AffineExprKind::Mul;
131}
132
133MlirAffineExpr mlirAffineMulExprGet(MlirAffineExpr lhs, MlirAffineExpr rhs) {
134 return wrap(cpp: getAffineBinaryOpExpr(kind: mlir::AffineExprKind::Mul, lhs: unwrap(c: lhs),
135 rhs: unwrap(c: rhs)));
136}
137
138//===----------------------------------------------------------------------===//
139// Affine Mod Expression.
140//===----------------------------------------------------------------------===//
141
142bool mlirAffineExprIsAMod(MlirAffineExpr affineExpr) {
143 return unwrap(c: affineExpr).getKind() == mlir::AffineExprKind::Mod;
144}
145
146MlirAffineExpr mlirAffineModExprGet(MlirAffineExpr lhs, MlirAffineExpr rhs) {
147 return wrap(cpp: getAffineBinaryOpExpr(kind: mlir::AffineExprKind::Mod, lhs: unwrap(c: lhs),
148 rhs: unwrap(c: rhs)));
149}
150
151//===----------------------------------------------------------------------===//
152// Affine FloorDiv Expression.
153//===----------------------------------------------------------------------===//
154
155bool mlirAffineExprIsAFloorDiv(MlirAffineExpr affineExpr) {
156 return unwrap(c: affineExpr).getKind() == mlir::AffineExprKind::FloorDiv;
157}
158
159MlirAffineExpr mlirAffineFloorDivExprGet(MlirAffineExpr lhs,
160 MlirAffineExpr rhs) {
161 return wrap(cpp: getAffineBinaryOpExpr(kind: mlir::AffineExprKind::FloorDiv, lhs: unwrap(c: lhs),
162 rhs: unwrap(c: rhs)));
163}
164
165//===----------------------------------------------------------------------===//
166// Affine CeilDiv Expression.
167//===----------------------------------------------------------------------===//
168
169bool mlirAffineExprIsACeilDiv(MlirAffineExpr affineExpr) {
170 return unwrap(c: affineExpr).getKind() == mlir::AffineExprKind::CeilDiv;
171}
172
173MlirAffineExpr mlirAffineCeilDivExprGet(MlirAffineExpr lhs,
174 MlirAffineExpr rhs) {
175 return wrap(cpp: getAffineBinaryOpExpr(kind: mlir::AffineExprKind::CeilDiv, lhs: unwrap(c: lhs),
176 rhs: unwrap(c: rhs)));
177}
178
179//===----------------------------------------------------------------------===//
180// Affine Binary Operation Expression.
181//===----------------------------------------------------------------------===//
182
183bool mlirAffineExprIsABinary(MlirAffineExpr affineExpr) {
184 return isa<AffineBinaryOpExpr>(Val: unwrap(c: affineExpr));
185}
186
187MlirAffineExpr mlirAffineBinaryOpExprGetLHS(MlirAffineExpr affineExpr) {
188 return wrap(cpp: cast<AffineBinaryOpExpr>(Val: unwrap(c: affineExpr)).getLHS());
189}
190
191MlirAffineExpr mlirAffineBinaryOpExprGetRHS(MlirAffineExpr affineExpr) {
192 return wrap(cpp: cast<AffineBinaryOpExpr>(Val: unwrap(c: affineExpr)).getRHS());
193}
194

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