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