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