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