1 | //===-- mlir-c/AffineMap.h - C API for MLIR Affine maps -----------*- 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_AFFINEMAP_H |
11 | #define MLIR_C_AFFINEMAP_H |
12 | |
13 | #include "mlir-c/AffineExpr.h" |
14 | #include "mlir-c/IR.h" |
15 | |
16 | #ifdef __cplusplus |
17 | extern "C" { |
18 | #endif |
19 | |
20 | //===----------------------------------------------------------------------===// |
21 | // Opaque type declarations. |
22 | // |
23 | // Types are exposed to C bindings as structs containing opaque pointers. They |
24 | // are not supposed to be inspected from C. This allows the underlying |
25 | // representation to change without affecting the API users. The use of structs |
26 | // instead of typedefs enables some type safety as structs are not implicitly |
27 | // convertible to each other. |
28 | // |
29 | // Instances of these types may or may not own the underlying object. The |
30 | // ownership semantics is defined by how an instance of the type was obtained. |
31 | //===----------------------------------------------------------------------===// |
32 | |
33 | #define DEFINE_C_API_STRUCT(name, storage) \ |
34 | struct name { \ |
35 | storage *ptr; \ |
36 | }; \ |
37 | typedef struct name name |
38 | |
39 | DEFINE_C_API_STRUCT(MlirAffineMap, const void); |
40 | |
41 | #undef DEFINE_C_API_STRUCT |
42 | |
43 | /// Gets the context that the given affine map was created with |
44 | MLIR_CAPI_EXPORTED MlirContext mlirAffineMapGetContext(MlirAffineMap affineMap); |
45 | |
46 | /// Checks whether an affine map is null. |
47 | static inline bool mlirAffineMapIsNull(MlirAffineMap affineMap) { |
48 | return !affineMap.ptr; |
49 | } |
50 | |
51 | /// Checks if two affine maps are equal. |
52 | MLIR_CAPI_EXPORTED bool mlirAffineMapEqual(MlirAffineMap a1, MlirAffineMap a2); |
53 | |
54 | /// Prints an affine map by sending chunks of the string representation and |
55 | /// forwarding `userData to `callback`. Note that the callback may be called |
56 | /// several times with consecutive chunks of the string. |
57 | MLIR_CAPI_EXPORTED void mlirAffineMapPrint(MlirAffineMap affineMap, |
58 | MlirStringCallback callback, |
59 | void *userData); |
60 | |
61 | /// Prints the affine map to the standard error stream. |
62 | MLIR_CAPI_EXPORTED void mlirAffineMapDump(MlirAffineMap affineMap); |
63 | |
64 | /// Creates a zero result affine map with no dimensions or symbols in the |
65 | /// context. The affine map is owned by the context. |
66 | MLIR_CAPI_EXPORTED MlirAffineMap mlirAffineMapEmptyGet(MlirContext ctx); |
67 | |
68 | /// Creates a zero result affine map of the given dimensions and symbols in the |
69 | /// context. The affine map is owned by the context. |
70 | MLIR_CAPI_EXPORTED MlirAffineMap mlirAffineMapZeroResultGet( |
71 | MlirContext ctx, intptr_t dimCount, intptr_t symbolCount); |
72 | |
73 | /// Creates an affine map with results defined by the given list of affine |
74 | /// expressions. The map resulting map also has the requested number of input |
75 | /// dimensions and symbols, regardless of them being used in the results. |
76 | |
77 | MLIR_CAPI_EXPORTED MlirAffineMap mlirAffineMapGet(MlirContext ctx, |
78 | intptr_t dimCount, |
79 | intptr_t symbolCount, |
80 | intptr_t nAffineExprs, |
81 | MlirAffineExpr *affineExprs); |
82 | |
83 | /// Creates a single constant result affine map in the context. The affine map |
84 | /// is owned by the context. |
85 | MLIR_CAPI_EXPORTED MlirAffineMap mlirAffineMapConstantGet(MlirContext ctx, |
86 | int64_t val); |
87 | |
88 | /// Creates an affine map with 'numDims' identity in the context. The affine map |
89 | /// is owned by the context. |
90 | MLIR_CAPI_EXPORTED MlirAffineMap |
91 | mlirAffineMapMultiDimIdentityGet(MlirContext ctx, intptr_t numDims); |
92 | |
93 | /// Creates an identity affine map on the most minor dimensions in the context. |
94 | /// The affine map is owned by the context. The function asserts that the number |
95 | /// of dimensions is greater or equal to the number of results. |
96 | MLIR_CAPI_EXPORTED MlirAffineMap |
97 | mlirAffineMapMinorIdentityGet(MlirContext ctx, intptr_t dims, intptr_t results); |
98 | |
99 | /// Creates an affine map with a permutation expression and its size in the |
100 | /// context. The permutation expression is a non-empty vector of integers. |
101 | /// The elements of the permutation vector must be continuous from 0 and cannot |
102 | /// be repeated (i.e. `[1,2,0]` is a valid permutation. `[2,0]` or `[1,1,2]` is |
103 | /// an invalid permutation.) The affine map is owned by the context. |
104 | MLIR_CAPI_EXPORTED MlirAffineMap mlirAffineMapPermutationGet( |
105 | MlirContext ctx, intptr_t size, unsigned *permutation); |
106 | |
107 | /// Checks whether the given affine map is an identity affine map. The function |
108 | /// asserts that the number of dimensions is greater or equal to the number of |
109 | /// results. |
110 | MLIR_CAPI_EXPORTED bool mlirAffineMapIsIdentity(MlirAffineMap affineMap); |
111 | |
112 | /// Checks whether the given affine map is a minor identity affine map. |
113 | MLIR_CAPI_EXPORTED bool mlirAffineMapIsMinorIdentity(MlirAffineMap affineMap); |
114 | |
115 | /// Checks whether the given affine map is an empty affine map. |
116 | MLIR_CAPI_EXPORTED bool mlirAffineMapIsEmpty(MlirAffineMap affineMap); |
117 | |
118 | /// Checks whether the given affine map is a single result constant affine |
119 | /// map. |
120 | MLIR_CAPI_EXPORTED bool mlirAffineMapIsSingleConstant(MlirAffineMap affineMap); |
121 | |
122 | /// Returns the constant result of the given affine map. The function asserts |
123 | /// that the map has a single constant result. |
124 | MLIR_CAPI_EXPORTED int64_t |
125 | mlirAffineMapGetSingleConstantResult(MlirAffineMap affineMap); |
126 | |
127 | /// Returns the number of dimensions of the given affine map. |
128 | MLIR_CAPI_EXPORTED intptr_t mlirAffineMapGetNumDims(MlirAffineMap affineMap); |
129 | |
130 | /// Returns the number of symbols of the given affine map. |
131 | MLIR_CAPI_EXPORTED intptr_t mlirAffineMapGetNumSymbols(MlirAffineMap affineMap); |
132 | |
133 | /// Returns the number of results of the given affine map. |
134 | MLIR_CAPI_EXPORTED intptr_t mlirAffineMapGetNumResults(MlirAffineMap affineMap); |
135 | |
136 | /// Returns the result at the given position. |
137 | MLIR_CAPI_EXPORTED MlirAffineExpr |
138 | mlirAffineMapGetResult(MlirAffineMap affineMap, intptr_t pos); |
139 | |
140 | /// Returns the number of inputs (dimensions + symbols) of the given affine |
141 | /// map. |
142 | MLIR_CAPI_EXPORTED intptr_t mlirAffineMapGetNumInputs(MlirAffineMap affineMap); |
143 | |
144 | /// Checks whether the given affine map represents a subset of a symbol-less |
145 | /// permutation map. |
146 | MLIR_CAPI_EXPORTED bool |
147 | mlirAffineMapIsProjectedPermutation(MlirAffineMap affineMap); |
148 | |
149 | /// Checks whether the given affine map represents a symbol-less permutation |
150 | /// map. |
151 | MLIR_CAPI_EXPORTED bool mlirAffineMapIsPermutation(MlirAffineMap affineMap); |
152 | |
153 | /// Returns the affine map consisting of the `resultPos` subset. |
154 | MLIR_CAPI_EXPORTED MlirAffineMap mlirAffineMapGetSubMap(MlirAffineMap affineMap, |
155 | intptr_t size, |
156 | intptr_t *resultPos); |
157 | |
158 | /// Returns the affine map consisting of the most major `numResults` results. |
159 | /// Returns the null AffineMap if the `numResults` is equal to zero. |
160 | /// Returns the `affineMap` if `numResults` is greater or equals to number of |
161 | /// results of the given affine map. |
162 | MLIR_CAPI_EXPORTED MlirAffineMap |
163 | mlirAffineMapGetMajorSubMap(MlirAffineMap affineMap, intptr_t numResults); |
164 | |
165 | /// Returns the affine map consisting of the most minor `numResults` results. |
166 | /// Returns the null AffineMap if the `numResults` is equal to zero. |
167 | /// Returns the `affineMap` if `numResults` is greater or equals to number of |
168 | /// results of the given affine map. |
169 | MLIR_CAPI_EXPORTED MlirAffineMap |
170 | mlirAffineMapGetMinorSubMap(MlirAffineMap affineMap, intptr_t numResults); |
171 | |
172 | /// Apply AffineExpr::replace(`map`) to each of the results and return a new |
173 | /// new AffineMap with the new results and the specified number of dims and |
174 | /// symbols. |
175 | MLIR_CAPI_EXPORTED MlirAffineMap mlirAffineMapReplace( |
176 | MlirAffineMap affineMap, MlirAffineExpr expression, |
177 | MlirAffineExpr replacement, intptr_t numResultDims, intptr_t numResultSyms); |
178 | |
179 | /// Returns the simplified affine map resulting from dropping the symbols that |
180 | /// do not appear in any of the individual maps in `affineMaps`. |
181 | /// Asserts that all maps in `affineMaps` are normalized to the same number of |
182 | /// dims and symbols. |
183 | /// Takes a callback `populateResult` to fill the `res` container with value |
184 | /// `m` at entry `idx`. This allows returning without worrying about ownership |
185 | /// considerations. |
186 | MLIR_CAPI_EXPORTED void mlirAffineMapCompressUnusedSymbols( |
187 | MlirAffineMap *affineMaps, intptr_t size, void *result, |
188 | void (*populateResult)(void *res, intptr_t idx, MlirAffineMap m)); |
189 | |
190 | #ifdef __cplusplus |
191 | } |
192 | #endif |
193 | |
194 | #endif // MLIR_C_AFFINEMAP_H |
195 | |