1 //===-- mlir-c/AffineExpr.h - C API for MLIR Affine Expressions ---*- C -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM
4 // Exceptions.
5 // See https://llvm.org/LICENSE.txt for license information.
6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //
8 //===----------------------------------------------------------------------===//
9
10 #ifndef MLIR_C_AFFINEEXPR_H
11 #define MLIR_C_AFFINEEXPR_H
12
13 #include "mlir-c/IR.h"
14
15 #ifdef __cplusplus
16 extern "C" {
17 #endif
18
19 //===----------------------------------------------------------------------===//
20 // Opaque type declarations.
21 //
22 // Types are exposed to C bindings as structs containing opaque pointers. They
23 // are not supposed to be inspected from C. This allows the underlying
24 // representation to change without affecting the API users. The use of structs
25 // instead of typedefs enables some type safety as structs are not implicitly
26 // convertible to each other.
27 //
28 // Instances of these types may or may not own the underlying object. The
29 // ownership semantics is defined by how an instance of the type was obtained.
30 //===----------------------------------------------------------------------===//
31
32 #define DEFINE_C_API_STRUCT(name, storage) \
33 struct name { \
34 storage *ptr; \
35 }; \
36 typedef struct name name
37
38 DEFINE_C_API_STRUCT(MlirAffineExpr, const void);
39
40 #undef DEFINE_C_API_STRUCT
41
42 struct MlirAffineMap;
43
44 /// Gets the context that owns the affine expression.
45 MLIR_CAPI_EXPORTED MlirContext
46 mlirAffineExprGetContext(MlirAffineExpr affineExpr);
47
48 /// Returns `true` if the two affine expressions are equal.
49 MLIR_CAPI_EXPORTED bool mlirAffineExprEqual(MlirAffineExpr lhs,
50 MlirAffineExpr rhs);
51
52 /// Returns `true` if the given affine expression is a null expression. Note
53 /// constant zero is not a null expression.
mlirAffineExprIsNull(MlirAffineExpr affineExpr)54 inline static bool mlirAffineExprIsNull(MlirAffineExpr affineExpr) {
55 return affineExpr.ptr == NULL;
56 }
57
58 /// Prints an affine expression by sending chunks of the string representation
59 /// and forwarding `userData to `callback`. Note that the callback may be called
60 /// several times with consecutive chunks of the string.
61 MLIR_CAPI_EXPORTED void mlirAffineExprPrint(MlirAffineExpr affineExpr,
62 MlirStringCallback callback,
63 void *userData);
64
65 /// Prints the affine expression to the standard error stream.
66 MLIR_CAPI_EXPORTED void mlirAffineExprDump(MlirAffineExpr affineExpr);
67
68 /// Checks whether the given affine expression is made out of only symbols and
69 /// constants.
70 MLIR_CAPI_EXPORTED bool
71 mlirAffineExprIsSymbolicOrConstant(MlirAffineExpr affineExpr);
72
73 /// Checks whether the given affine expression is a pure affine expression, i.e.
74 /// mul, floordiv, ceildic, and mod is only allowed w.r.t constants.
75 MLIR_CAPI_EXPORTED bool mlirAffineExprIsPureAffine(MlirAffineExpr affineExpr);
76
77 /// Returns the greatest known integral divisor of this affine expression. The
78 /// result is always positive.
79 MLIR_CAPI_EXPORTED int64_t
80 mlirAffineExprGetLargestKnownDivisor(MlirAffineExpr affineExpr);
81
82 /// Checks whether the given affine expression is a multiple of 'factor'.
83 MLIR_CAPI_EXPORTED bool mlirAffineExprIsMultipleOf(MlirAffineExpr affineExpr,
84 int64_t factor);
85
86 /// Checks whether the given affine expression involves AffineDimExpr
87 /// 'position'.
88 MLIR_CAPI_EXPORTED bool mlirAffineExprIsFunctionOfDim(MlirAffineExpr affineExpr,
89 intptr_t position);
90
91 /// Composes the given map with the given expression.
92 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineExprCompose(
93 MlirAffineExpr affineExpr, struct MlirAffineMap affineMap);
94
95 //===----------------------------------------------------------------------===//
96 // Affine Dimension Expression.
97 //===----------------------------------------------------------------------===//
98
99 /// Checks whether the given affine expression is a dimension expression.
100 MLIR_CAPI_EXPORTED bool mlirAffineExprIsADim(MlirAffineExpr affineExpr);
101
102 /// Creates an affine dimension expression with 'position' in the context.
103 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineDimExprGet(MlirContext ctx,
104 intptr_t position);
105
106 /// Returns the position of the given affine dimension expression.
107 MLIR_CAPI_EXPORTED intptr_t
108 mlirAffineDimExprGetPosition(MlirAffineExpr affineExpr);
109
110 //===----------------------------------------------------------------------===//
111 // Affine Symbol Expression.
112 //===----------------------------------------------------------------------===//
113
114 /// Checks whether the given affine expression is a symbol expression.
115 MLIR_CAPI_EXPORTED bool mlirAffineExprIsASymbol(MlirAffineExpr affineExpr);
116
117 /// Creates an affine symbol expression with 'position' in the context.
118 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineSymbolExprGet(MlirContext ctx,
119 intptr_t position);
120
121 /// Returns the position of the given affine symbol expression.
122 MLIR_CAPI_EXPORTED intptr_t
123 mlirAffineSymbolExprGetPosition(MlirAffineExpr affineExpr);
124
125 //===----------------------------------------------------------------------===//
126 // Affine Constant Expression.
127 //===----------------------------------------------------------------------===//
128
129 /// Checks whether the given affine expression is a constant expression.
130 MLIR_CAPI_EXPORTED bool mlirAffineExprIsAConstant(MlirAffineExpr affineExpr);
131
132 /// Creates an affine constant expression with 'constant' in the context.
133 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineConstantExprGet(MlirContext ctx,
134 int64_t constant);
135
136 /// Returns the value of the given affine constant expression.
137 MLIR_CAPI_EXPORTED int64_t
138 mlirAffineConstantExprGetValue(MlirAffineExpr affineExpr);
139
140 //===----------------------------------------------------------------------===//
141 // Affine Add Expression.
142 //===----------------------------------------------------------------------===//
143
144 /// Checks whether the given affine expression is an add expression.
145 MLIR_CAPI_EXPORTED bool mlirAffineExprIsAAdd(MlirAffineExpr affineExpr);
146
147 /// Creates an affine add expression with 'lhs' and 'rhs'.
148 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineAddExprGet(MlirAffineExpr lhs,
149 MlirAffineExpr rhs);
150
151 //===----------------------------------------------------------------------===//
152 // Affine Mul Expression.
153 //===----------------------------------------------------------------------===//
154
155 /// Checks whether the given affine expression is an mul expression.
156 MLIR_CAPI_EXPORTED bool mlirAffineExprIsAMul(MlirAffineExpr affineExpr);
157
158 /// Creates an affine mul expression with 'lhs' and 'rhs'.
159 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineMulExprGet(MlirAffineExpr lhs,
160 MlirAffineExpr rhs);
161
162 //===----------------------------------------------------------------------===//
163 // Affine Mod Expression.
164 //===----------------------------------------------------------------------===//
165
166 /// Checks whether the given affine expression is an mod expression.
167 MLIR_CAPI_EXPORTED bool mlirAffineExprIsAMod(MlirAffineExpr affineExpr);
168
169 /// Creates an affine mod expression with 'lhs' and 'rhs'.
170 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineModExprGet(MlirAffineExpr lhs,
171 MlirAffineExpr rhs);
172
173 //===----------------------------------------------------------------------===//
174 // Affine FloorDiv Expression.
175 //===----------------------------------------------------------------------===//
176
177 /// Checks whether the given affine expression is an floordiv expression.
178 MLIR_CAPI_EXPORTED bool mlirAffineExprIsAFloorDiv(MlirAffineExpr affineExpr);
179
180 /// Creates an affine floordiv expression with 'lhs' and 'rhs'.
181 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineFloorDivExprGet(MlirAffineExpr lhs,
182 MlirAffineExpr rhs);
183
184 //===----------------------------------------------------------------------===//
185 // Affine CeilDiv Expression.
186 //===----------------------------------------------------------------------===//
187
188 /// Checks whether the given affine expression is an ceildiv expression.
189 MLIR_CAPI_EXPORTED bool mlirAffineExprIsACeilDiv(MlirAffineExpr affineExpr);
190
191 /// Creates an affine ceildiv expression with 'lhs' and 'rhs'.
192 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineCeilDivExprGet(MlirAffineExpr lhs,
193 MlirAffineExpr rhs);
194
195 //===----------------------------------------------------------------------===//
196 // Affine Binary Operation Expression.
197 //===----------------------------------------------------------------------===//
198
199 /// Checks whether the given affine expression is binary.
200 MLIR_CAPI_EXPORTED bool mlirAffineExprIsABinary(MlirAffineExpr affineExpr);
201
202 /// Returns the left hand side affine expression of the given affine binary
203 /// operation expression.
204 MLIR_CAPI_EXPORTED MlirAffineExpr
205 mlirAffineBinaryOpExprGetLHS(MlirAffineExpr affineExpr);
206
207 /// Returns the right hand side affine expression of the given affine binary
208 /// operation expression.
209 MLIR_CAPI_EXPORTED MlirAffineExpr
210 mlirAffineBinaryOpExprGetRHS(MlirAffineExpr affineExpr);
211
212 #ifdef __cplusplus
213 }
214 #endif
215
216 #endif // MLIR_C_AFFINEEXPR_H
217