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(cpp: unwrap(c: affineExpr).getContext()); |
22 | } |
23 | |
24 | bool mlirAffineExprEqual(MlirAffineExpr lhs, MlirAffineExpr rhs) { |
25 | return unwrap(c: lhs) == unwrap(c: rhs); |
26 | } |
27 | |
28 | void mlirAffineExprPrint(MlirAffineExpr affineExpr, MlirStringCallback callback, |
29 | void *userData) { |
30 | mlir::detail::CallbackOstream stream(callback, userData); |
31 | unwrap(c: affineExpr).print(os&: stream); |
32 | } |
33 | |
34 | void mlirAffineExprDump(MlirAffineExpr affineExpr) { |
35 | unwrap(c: affineExpr).dump(); |
36 | } |
37 | |
38 | bool mlirAffineExprIsSymbolicOrConstant(MlirAffineExpr affineExpr) { |
39 | return unwrap(c: affineExpr).isSymbolicOrConstant(); |
40 | } |
41 | |
42 | bool mlirAffineExprIsPureAffine(MlirAffineExpr affineExpr) { |
43 | return unwrap(c: affineExpr).isPureAffine(); |
44 | } |
45 | |
46 | int64_t mlirAffineExprGetLargestKnownDivisor(MlirAffineExpr affineExpr) { |
47 | return unwrap(c: affineExpr).getLargestKnownDivisor(); |
48 | } |
49 | |
50 | bool mlirAffineExprIsMultipleOf(MlirAffineExpr affineExpr, int64_t factor) { |
51 | return unwrap(c: affineExpr).isMultipleOf(factor); |
52 | } |
53 | |
54 | bool mlirAffineExprIsFunctionOfDim(MlirAffineExpr affineExpr, |
55 | intptr_t position) { |
56 | return unwrap(c: affineExpr).isFunctionOfDim(position); |
57 | } |
58 | |
59 | MlirAffineExpr 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 | |
68 | bool mlirAffineExprIsADim(MlirAffineExpr affineExpr) { |
69 | return isa<AffineDimExpr>(Val: unwrap(c: affineExpr)); |
70 | } |
71 | |
72 | MlirAffineExpr mlirAffineDimExprGet(MlirContext ctx, intptr_t position) { |
73 | return wrap(cpp: getAffineDimExpr(position, context: unwrap(c: ctx))); |
74 | } |
75 | |
76 | intptr_t mlirAffineDimExprGetPosition(MlirAffineExpr affineExpr) { |
77 | return cast<AffineDimExpr>(Val: unwrap(c: affineExpr)).getPosition(); |
78 | } |
79 | |
80 | //===----------------------------------------------------------------------===// |
81 | // Affine Symbol Expression. |
82 | //===----------------------------------------------------------------------===// |
83 | |
84 | bool mlirAffineExprIsASymbol(MlirAffineExpr affineExpr) { |
85 | return isa<AffineSymbolExpr>(Val: unwrap(c: affineExpr)); |
86 | } |
87 | |
88 | MlirAffineExpr mlirAffineSymbolExprGet(MlirContext ctx, intptr_t position) { |
89 | return wrap(cpp: getAffineSymbolExpr(position, context: unwrap(c: ctx))); |
90 | } |
91 | |
92 | intptr_t mlirAffineSymbolExprGetPosition(MlirAffineExpr affineExpr) { |
93 | return cast<AffineSymbolExpr>(Val: unwrap(c: affineExpr)).getPosition(); |
94 | } |
95 | |
96 | //===----------------------------------------------------------------------===// |
97 | // Affine Constant Expression. |
98 | //===----------------------------------------------------------------------===// |
99 | |
100 | bool mlirAffineExprIsAConstant(MlirAffineExpr affineExpr) { |
101 | return isa<AffineConstantExpr>(Val: unwrap(c: affineExpr)); |
102 | } |
103 | |
104 | MlirAffineExpr mlirAffineConstantExprGet(MlirContext ctx, int64_t constant) { |
105 | return wrap(cpp: getAffineConstantExpr(constant, context: unwrap(c: ctx))); |
106 | } |
107 | |
108 | int64_t mlirAffineConstantExprGetValue(MlirAffineExpr affineExpr) { |
109 | return cast<AffineConstantExpr>(Val: unwrap(c: affineExpr)).getValue(); |
110 | } |
111 | |
112 | //===----------------------------------------------------------------------===// |
113 | // Affine Add Expression. |
114 | //===----------------------------------------------------------------------===// |
115 | |
116 | bool mlirAffineExprIsAAdd(MlirAffineExpr affineExpr) { |
117 | return unwrap(c: affineExpr).getKind() == mlir::AffineExprKind::Add; |
118 | } |
119 | |
120 | MlirAffineExpr 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 | |
129 | bool mlirAffineExprIsAMul(MlirAffineExpr affineExpr) { |
130 | return unwrap(c: affineExpr).getKind() == mlir::AffineExprKind::Mul; |
131 | } |
132 | |
133 | MlirAffineExpr 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 | |
142 | bool mlirAffineExprIsAMod(MlirAffineExpr affineExpr) { |
143 | return unwrap(c: affineExpr).getKind() == mlir::AffineExprKind::Mod; |
144 | } |
145 | |
146 | MlirAffineExpr 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 | |
155 | bool mlirAffineExprIsAFloorDiv(MlirAffineExpr affineExpr) { |
156 | return unwrap(c: affineExpr).getKind() == mlir::AffineExprKind::FloorDiv; |
157 | } |
158 | |
159 | MlirAffineExpr 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 | |
169 | bool mlirAffineExprIsACeilDiv(MlirAffineExpr affineExpr) { |
170 | return unwrap(c: affineExpr).getKind() == mlir::AffineExprKind::CeilDiv; |
171 | } |
172 | |
173 | MlirAffineExpr 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 | |
183 | bool mlirAffineExprIsABinary(MlirAffineExpr affineExpr) { |
184 | return isa<AffineBinaryOpExpr>(Val: unwrap(c: affineExpr)); |
185 | } |
186 | |
187 | MlirAffineExpr mlirAffineBinaryOpExprGetLHS(MlirAffineExpr affineExpr) { |
188 | return wrap(cpp: cast<AffineBinaryOpExpr>(Val: unwrap(c: affineExpr)).getLHS()); |
189 | } |
190 | |
191 | MlirAffineExpr mlirAffineBinaryOpExprGetRHS(MlirAffineExpr affineExpr) { |
192 | return wrap(cpp: cast<AffineBinaryOpExpr>(Val: unwrap(c: affineExpr)).getRHS()); |
193 | } |
194 | |