1//===- BuiltinTypes.cpp - C Interface to MLIR Builtin Types ---------------===//
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/BuiltinTypes.h"
10#include "mlir-c/AffineMap.h"
11#include "mlir-c/IR.h"
12#include "mlir-c/Support.h"
13#include "mlir/CAPI/AffineMap.h"
14#include "mlir/CAPI/IR.h"
15#include "mlir/CAPI/Support.h"
16#include "mlir/IR/AffineMap.h"
17#include "mlir/IR/BuiltinTypes.h"
18#include "mlir/IR/Types.h"
19
20#include <algorithm>
21
22using namespace mlir;
23
24//===----------------------------------------------------------------------===//
25// Integer types.
26//===----------------------------------------------------------------------===//
27
28MlirTypeID mlirIntegerTypeGetTypeID() { return wrap(cpp: IntegerType::getTypeID()); }
29
30bool mlirTypeIsAInteger(MlirType type) {
31 return llvm::isa<IntegerType>(Val: unwrap(c: type));
32}
33
34MlirType mlirIntegerTypeGet(MlirContext ctx, unsigned bitwidth) {
35 return wrap(cpp: IntegerType::get(context: unwrap(c: ctx), width: bitwidth));
36}
37
38MlirStringRef mlirIntegerTypeGetName(void) { return wrap(ref: IntegerType::name); }
39
40MlirType mlirIntegerTypeSignedGet(MlirContext ctx, unsigned bitwidth) {
41 return wrap(cpp: IntegerType::get(context: unwrap(c: ctx), width: bitwidth, signedness: IntegerType::Signed));
42}
43
44MlirType mlirIntegerTypeUnsignedGet(MlirContext ctx, unsigned bitwidth) {
45 return wrap(cpp: IntegerType::get(context: unwrap(c: ctx), width: bitwidth, signedness: IntegerType::Unsigned));
46}
47
48unsigned mlirIntegerTypeGetWidth(MlirType type) {
49 return llvm::cast<IntegerType>(Val: unwrap(c: type)).getWidth();
50}
51
52bool mlirIntegerTypeIsSignless(MlirType type) {
53 return llvm::cast<IntegerType>(Val: unwrap(c: type)).isSignless();
54}
55
56bool mlirIntegerTypeIsSigned(MlirType type) {
57 return llvm::cast<IntegerType>(Val: unwrap(c: type)).isSigned();
58}
59
60bool mlirIntegerTypeIsUnsigned(MlirType type) {
61 return llvm::cast<IntegerType>(Val: unwrap(c: type)).isUnsigned();
62}
63
64//===----------------------------------------------------------------------===//
65// Index type.
66//===----------------------------------------------------------------------===//
67
68MlirTypeID mlirIndexTypeGetTypeID() { return wrap(cpp: IndexType::getTypeID()); }
69
70bool mlirTypeIsAIndex(MlirType type) {
71 return llvm::isa<IndexType>(Val: unwrap(c: type));
72}
73
74MlirType mlirIndexTypeGet(MlirContext ctx) {
75 return wrap(cpp: IndexType::get(context: unwrap(c: ctx)));
76}
77
78MlirStringRef mlirIndexTypeGetName(void) { return wrap(ref: IndexType::name); }
79
80//===----------------------------------------------------------------------===//
81// Floating-point types.
82//===----------------------------------------------------------------------===//
83
84bool mlirTypeIsAFloat(MlirType type) {
85 return llvm::isa<FloatType>(Val: unwrap(c: type));
86}
87
88unsigned mlirFloatTypeGetWidth(MlirType type) {
89 return llvm::cast<FloatType>(Val: unwrap(c: type)).getWidth();
90}
91
92MlirTypeID mlirFloat4E2M1FNTypeGetTypeID() {
93 return wrap(cpp: Float4E2M1FNType::getTypeID());
94}
95
96bool mlirTypeIsAFloat4E2M1FN(MlirType type) {
97 return llvm::isa<Float4E2M1FNType>(Val: unwrap(c: type));
98}
99
100MlirType mlirFloat4E2M1FNTypeGet(MlirContext ctx) {
101 return wrap(cpp: Float4E2M1FNType::get(ctx: unwrap(c: ctx)));
102}
103
104MlirStringRef mlirFloat4E2M1FNTypeGetName(void) {
105 return wrap(ref: Float4E2M1FNType::name);
106}
107
108MlirTypeID mlirFloat6E2M3FNTypeGetTypeID() {
109 return wrap(cpp: Float6E2M3FNType::getTypeID());
110}
111
112bool mlirTypeIsAFloat6E2M3FN(MlirType type) {
113 return llvm::isa<Float6E2M3FNType>(Val: unwrap(c: type));
114}
115
116MlirType mlirFloat6E2M3FNTypeGet(MlirContext ctx) {
117 return wrap(cpp: Float6E2M3FNType::get(ctx: unwrap(c: ctx)));
118}
119
120MlirStringRef mlirFloat6E2M3FNTypeGetName(void) {
121 return wrap(ref: Float6E2M3FNType::name);
122}
123
124MlirTypeID mlirFloat6E3M2FNTypeGetTypeID() {
125 return wrap(cpp: Float6E3M2FNType::getTypeID());
126}
127
128bool mlirTypeIsAFloat6E3M2FN(MlirType type) {
129 return llvm::isa<Float6E3M2FNType>(Val: unwrap(c: type));
130}
131
132MlirType mlirFloat6E3M2FNTypeGet(MlirContext ctx) {
133 return wrap(cpp: Float6E3M2FNType::get(ctx: unwrap(c: ctx)));
134}
135
136MlirStringRef mlirFloat6E3M2FNTypeGetName(void) {
137 return wrap(ref: Float6E3M2FNType::name);
138}
139
140MlirTypeID mlirFloat8E5M2TypeGetTypeID() {
141 return wrap(cpp: Float8E5M2Type::getTypeID());
142}
143
144bool mlirTypeIsAFloat8E5M2(MlirType type) {
145 return llvm::isa<Float8E5M2Type>(Val: unwrap(c: type));
146}
147
148MlirType mlirFloat8E5M2TypeGet(MlirContext ctx) {
149 return wrap(cpp: Float8E5M2Type::get(ctx: unwrap(c: ctx)));
150}
151
152MlirStringRef mlirFloat8E5M2TypeGetName(void) {
153 return wrap(ref: Float8E5M2Type::name);
154}
155
156MlirTypeID mlirFloat8E4M3TypeGetTypeID() {
157 return wrap(cpp: Float8E4M3Type::getTypeID());
158}
159
160bool mlirTypeIsAFloat8E4M3(MlirType type) {
161 return llvm::isa<Float8E4M3Type>(Val: unwrap(c: type));
162}
163
164MlirType mlirFloat8E4M3TypeGet(MlirContext ctx) {
165 return wrap(cpp: Float8E4M3Type::get(ctx: unwrap(c: ctx)));
166}
167
168MlirStringRef mlirFloat8E4M3TypeGetName(void) {
169 return wrap(ref: Float8E4M3Type::name);
170}
171
172MlirTypeID mlirFloat8E4M3FNTypeGetTypeID() {
173 return wrap(cpp: Float8E4M3FNType::getTypeID());
174}
175
176bool mlirTypeIsAFloat8E4M3FN(MlirType type) {
177 return llvm::isa<Float8E4M3FNType>(Val: unwrap(c: type));
178}
179
180MlirType mlirFloat8E4M3FNTypeGet(MlirContext ctx) {
181 return wrap(cpp: Float8E4M3FNType::get(ctx: unwrap(c: ctx)));
182}
183
184MlirStringRef mlirFloat8E4M3FNTypeGetName(void) {
185 return wrap(ref: Float8E4M3FNType::name);
186}
187
188MlirTypeID mlirFloat8E5M2FNUZTypeGetTypeID() {
189 return wrap(cpp: Float8E5M2FNUZType::getTypeID());
190}
191
192bool mlirTypeIsAFloat8E5M2FNUZ(MlirType type) {
193 return llvm::isa<Float8E5M2FNUZType>(Val: unwrap(c: type));
194}
195
196MlirType mlirFloat8E5M2FNUZTypeGet(MlirContext ctx) {
197 return wrap(cpp: Float8E5M2FNUZType::get(ctx: unwrap(c: ctx)));
198}
199
200MlirStringRef mlirFloat8E5M2FNUZTypeGetName(void) {
201 return wrap(ref: Float8E5M2FNUZType::name);
202}
203
204MlirTypeID mlirFloat8E4M3FNUZTypeGetTypeID() {
205 return wrap(cpp: Float8E4M3FNUZType::getTypeID());
206}
207
208bool mlirTypeIsAFloat8E4M3FNUZ(MlirType type) {
209 return llvm::isa<Float8E4M3FNUZType>(Val: unwrap(c: type));
210}
211
212MlirType mlirFloat8E4M3FNUZTypeGet(MlirContext ctx) {
213 return wrap(cpp: Float8E4M3FNUZType::get(ctx: unwrap(c: ctx)));
214}
215
216MlirStringRef mlirFloat8E4M3FNUZTypeGetName(void) {
217 return wrap(ref: Float8E4M3FNUZType::name);
218}
219
220MlirTypeID mlirFloat8E4M3B11FNUZTypeGetTypeID() {
221 return wrap(cpp: Float8E4M3B11FNUZType::getTypeID());
222}
223
224bool mlirTypeIsAFloat8E4M3B11FNUZ(MlirType type) {
225 return llvm::isa<Float8E4M3B11FNUZType>(Val: unwrap(c: type));
226}
227
228MlirType mlirFloat8E4M3B11FNUZTypeGet(MlirContext ctx) {
229 return wrap(cpp: Float8E4M3B11FNUZType::get(ctx: unwrap(c: ctx)));
230}
231
232MlirStringRef mlirFloat8E4M3B11FNUZTypeGetName(void) {
233 return wrap(ref: Float8E4M3B11FNUZType::name);
234}
235
236MlirTypeID mlirFloat8E3M4TypeGetTypeID() {
237 return wrap(cpp: Float8E3M4Type::getTypeID());
238}
239
240bool mlirTypeIsAFloat8E3M4(MlirType type) {
241 return llvm::isa<Float8E3M4Type>(Val: unwrap(c: type));
242}
243
244MlirType mlirFloat8E3M4TypeGet(MlirContext ctx) {
245 return wrap(cpp: Float8E3M4Type::get(ctx: unwrap(c: ctx)));
246}
247
248MlirStringRef mlirFloat8E3M4TypeGetName(void) {
249 return wrap(ref: Float8E3M4Type::name);
250}
251
252MlirTypeID mlirFloat8E8M0FNUTypeGetTypeID() {
253 return wrap(cpp: Float8E8M0FNUType::getTypeID());
254}
255
256bool mlirTypeIsAFloat8E8M0FNU(MlirType type) {
257 return llvm::isa<Float8E8M0FNUType>(Val: unwrap(c: type));
258}
259
260MlirType mlirFloat8E8M0FNUTypeGet(MlirContext ctx) {
261 return wrap(cpp: Float8E8M0FNUType::get(ctx: unwrap(c: ctx)));
262}
263
264MlirStringRef mlirFloat8E8M0FNUTypeGetName(void) {
265 return wrap(ref: Float8E8M0FNUType::name);
266}
267
268MlirTypeID mlirFloat8E5M3FNUTypeGetTypeID() {
269 return wrap(cpp: Float8E5M3FNUType::getTypeID());
270}
271
272bool mlirTypeIsAFloat8E5M3FNU(MlirType type) {
273 return llvm::isa<Float8E5M3FNUType>(Val: unwrap(c: type));
274}
275
276MlirType mlirFloat8E5M3FNUTypeGet(MlirContext ctx) {
277 return wrap(cpp: Float8E5M3FNUType::get(ctx: unwrap(c: ctx)));
278}
279
280MlirStringRef mlirFloat8E5M3FNUTypeGetName(void) {
281 return wrap(ref: Float8E5M3FNUType::name);
282}
283
284MlirTypeID mlirBFloat16TypeGetTypeID() {
285 return wrap(cpp: BFloat16Type::getTypeID());
286}
287
288bool mlirTypeIsABF16(MlirType type) {
289 return llvm::isa<BFloat16Type>(Val: unwrap(c: type));
290}
291
292MlirType mlirBF16TypeGet(MlirContext ctx) {
293 return wrap(cpp: BFloat16Type::get(context: unwrap(c: ctx)));
294}
295
296MlirStringRef mlirBF16TypeGetName(void) { return wrap(ref: BFloat16Type::name); }
297
298MlirTypeID mlirFloat16TypeGetTypeID() { return wrap(cpp: Float16Type::getTypeID()); }
299
300bool mlirTypeIsAF16(MlirType type) {
301 return llvm::isa<Float16Type>(Val: unwrap(c: type));
302}
303
304MlirType mlirF16TypeGet(MlirContext ctx) {
305 return wrap(cpp: Float16Type::get(context: unwrap(c: ctx)));
306}
307
308MlirStringRef mlirF16TypeGetName(void) { return wrap(ref: Float16Type::name); }
309
310MlirTypeID mlirFloatTF32TypeGetTypeID() {
311 return wrap(cpp: FloatTF32Type::getTypeID());
312}
313
314bool mlirTypeIsATF32(MlirType type) {
315 return llvm::isa<FloatTF32Type>(Val: unwrap(c: type));
316}
317
318MlirType mlirTF32TypeGet(MlirContext ctx) {
319 return wrap(cpp: FloatTF32Type::get(context: unwrap(c: ctx)));
320}
321
322MlirStringRef mlirTF32TypeGetName(void) { return wrap(ref: FloatTF32Type::name); }
323
324MlirTypeID mlirFloat32TypeGetTypeID() { return wrap(cpp: Float32Type::getTypeID()); }
325
326bool mlirTypeIsAF32(MlirType type) {
327 return llvm::isa<Float32Type>(Val: unwrap(c: type));
328}
329
330MlirType mlirF32TypeGet(MlirContext ctx) {
331 return wrap(cpp: Float32Type::get(context: unwrap(c: ctx)));
332}
333
334MlirStringRef mlirF32TypeGetName(void) { return wrap(ref: Float32Type::name); }
335
336MlirTypeID mlirFloat64TypeGetTypeID() { return wrap(cpp: Float64Type::getTypeID()); }
337
338bool mlirTypeIsAF64(MlirType type) {
339 return llvm::isa<Float64Type>(Val: unwrap(c: type));
340}
341
342MlirType mlirF64TypeGet(MlirContext ctx) {
343 return wrap(cpp: Float64Type::get(context: unwrap(c: ctx)));
344}
345
346MlirStringRef mlirF64TypeGetName(void) { return wrap(ref: Float64Type::name); }
347
348//===----------------------------------------------------------------------===//
349// None type.
350//===----------------------------------------------------------------------===//
351
352MlirTypeID mlirNoneTypeGetTypeID() { return wrap(cpp: NoneType::getTypeID()); }
353
354bool mlirTypeIsANone(MlirType type) {
355 return llvm::isa<NoneType>(Val: unwrap(c: type));
356}
357
358MlirType mlirNoneTypeGet(MlirContext ctx) {
359 return wrap(cpp: NoneType::get(context: unwrap(c: ctx)));
360}
361
362MlirStringRef mlirNoneTypeGetName(void) { return wrap(ref: NoneType::name); }
363
364//===----------------------------------------------------------------------===//
365// Complex type.
366//===----------------------------------------------------------------------===//
367
368MlirTypeID mlirComplexTypeGetTypeID() { return wrap(cpp: ComplexType::getTypeID()); }
369
370bool mlirTypeIsAComplex(MlirType type) {
371 return llvm::isa<ComplexType>(Val: unwrap(c: type));
372}
373
374MlirType mlirComplexTypeGet(MlirType elementType) {
375 return wrap(cpp: ComplexType::get(elementType: unwrap(c: elementType)));
376}
377
378MlirStringRef mlirComplexTypeGetName(void) { return wrap(ref: ComplexType::name); }
379
380MlirType mlirComplexTypeGetElementType(MlirType type) {
381 return wrap(cpp: llvm::cast<ComplexType>(Val: unwrap(c: type)).getElementType());
382}
383
384//===----------------------------------------------------------------------===//
385// Shaped type.
386//===----------------------------------------------------------------------===//
387
388bool mlirTypeIsAShaped(MlirType type) {
389 return llvm::isa<ShapedType>(Val: unwrap(c: type));
390}
391
392MlirType mlirShapedTypeGetElementType(MlirType type) {
393 return wrap(cpp: llvm::cast<ShapedType>(Val: unwrap(c: type)).getElementType());
394}
395
396bool mlirShapedTypeHasRank(MlirType type) {
397 return llvm::cast<ShapedType>(Val: unwrap(c: type)).hasRank();
398}
399
400int64_t mlirShapedTypeGetRank(MlirType type) {
401 return llvm::cast<ShapedType>(Val: unwrap(c: type)).getRank();
402}
403
404bool mlirShapedTypeHasStaticShape(MlirType type) {
405 return llvm::cast<ShapedType>(Val: unwrap(c: type)).hasStaticShape();
406}
407
408bool mlirShapedTypeIsDynamicDim(MlirType type, intptr_t dim) {
409 return llvm::cast<ShapedType>(Val: unwrap(c: type))
410 .isDynamicDim(idx: static_cast<unsigned>(dim));
411}
412
413bool mlirShapedTypeIsStaticDim(MlirType type, intptr_t dim) {
414 return llvm::cast<ShapedType>(Val: unwrap(c: type))
415 .isStaticDim(idx: static_cast<unsigned>(dim));
416}
417
418int64_t mlirShapedTypeGetDimSize(MlirType type, intptr_t dim) {
419 return llvm::cast<ShapedType>(Val: unwrap(c: type))
420 .getDimSize(idx: static_cast<unsigned>(dim));
421}
422
423int64_t mlirShapedTypeGetDynamicSize() { return ShapedType::kDynamic; }
424
425bool mlirShapedTypeIsDynamicSize(int64_t size) {
426 return ShapedType::isDynamic(dValue: size);
427}
428
429bool mlirShapedTypeIsStaticSize(int64_t size) {
430 return ShapedType::isStatic(dValue: size);
431}
432
433bool mlirShapedTypeIsDynamicStrideOrOffset(int64_t val) {
434 return ShapedType::isDynamic(dValue: val);
435}
436
437bool mlirShapedTypeIsStaticStrideOrOffset(int64_t val) {
438 return ShapedType::isStatic(dValue: val);
439}
440
441int64_t mlirShapedTypeGetDynamicStrideOrOffset() {
442 return ShapedType::kDynamic;
443}
444
445//===----------------------------------------------------------------------===//
446// Vector type.
447//===----------------------------------------------------------------------===//
448
449MlirTypeID mlirVectorTypeGetTypeID() { return wrap(cpp: VectorType::getTypeID()); }
450
451bool mlirTypeIsAVector(MlirType type) {
452 return llvm::isa<VectorType>(Val: unwrap(c: type));
453}
454
455MlirType mlirVectorTypeGet(intptr_t rank, const int64_t *shape,
456 MlirType elementType) {
457 return wrap(cpp: VectorType::get(shape: llvm::ArrayRef(shape, static_cast<size_t>(rank)),
458 elementType: unwrap(c: elementType)));
459}
460
461MlirStringRef mlirVectorTypeGetName(void) { return wrap(ref: VectorType::name); }
462
463MlirType mlirVectorTypeGetChecked(MlirLocation loc, intptr_t rank,
464 const int64_t *shape, MlirType elementType) {
465 return wrap(cpp: VectorType::getChecked(
466 loc: unwrap(c: loc), args: llvm::ArrayRef(shape, static_cast<size_t>(rank)),
467 args: unwrap(c: elementType)));
468}
469
470MlirType mlirVectorTypeGetScalable(intptr_t rank, const int64_t *shape,
471 const bool *scalable, MlirType elementType) {
472 return wrap(cpp: VectorType::get(
473 shape: llvm::ArrayRef(shape, static_cast<size_t>(rank)), elementType: unwrap(c: elementType),
474 scalableDims: llvm::ArrayRef(scalable, static_cast<size_t>(rank))));
475}
476
477MlirType mlirVectorTypeGetScalableChecked(MlirLocation loc, intptr_t rank,
478 const int64_t *shape,
479 const bool *scalable,
480 MlirType elementType) {
481 return wrap(cpp: VectorType::getChecked(
482 loc: unwrap(c: loc), args: llvm::ArrayRef(shape, static_cast<size_t>(rank)),
483 args: unwrap(c: elementType),
484 args: llvm::ArrayRef(scalable, static_cast<size_t>(rank))));
485}
486
487bool mlirVectorTypeIsScalable(MlirType type) {
488 return cast<VectorType>(Val: unwrap(c: type)).isScalable();
489}
490
491bool mlirVectorTypeIsDimScalable(MlirType type, intptr_t dim) {
492 return cast<VectorType>(Val: unwrap(c: type)).getScalableDims()[dim];
493}
494
495//===----------------------------------------------------------------------===//
496// Ranked / Unranked tensor type.
497//===----------------------------------------------------------------------===//
498
499bool mlirTypeIsATensor(MlirType type) {
500 return llvm::isa<TensorType>(Val: unwrap(c: type));
501}
502
503MlirTypeID mlirRankedTensorTypeGetTypeID() {
504 return wrap(cpp: RankedTensorType::getTypeID());
505}
506
507bool mlirTypeIsARankedTensor(MlirType type) {
508 return llvm::isa<RankedTensorType>(Val: unwrap(c: type));
509}
510
511MlirTypeID mlirUnrankedTensorTypeGetTypeID() {
512 return wrap(cpp: UnrankedTensorType::getTypeID());
513}
514
515bool mlirTypeIsAUnrankedTensor(MlirType type) {
516 return llvm::isa<UnrankedTensorType>(Val: unwrap(c: type));
517}
518
519MlirType mlirRankedTensorTypeGet(intptr_t rank, const int64_t *shape,
520 MlirType elementType, MlirAttribute encoding) {
521 return wrap(
522 cpp: RankedTensorType::get(shape: llvm::ArrayRef(shape, static_cast<size_t>(rank)),
523 elementType: unwrap(c: elementType), encoding: unwrap(c: encoding)));
524}
525
526MlirStringRef mlirRankedTensorTypeGetName(void) {
527 return wrap(ref: RankedTensorType::name);
528}
529
530MlirType mlirRankedTensorTypeGetChecked(MlirLocation loc, intptr_t rank,
531 const int64_t *shape,
532 MlirType elementType,
533 MlirAttribute encoding) {
534 return wrap(cpp: RankedTensorType::getChecked(
535 loc: unwrap(c: loc), args: llvm::ArrayRef(shape, static_cast<size_t>(rank)),
536 args: unwrap(c: elementType), args: unwrap(c: encoding)));
537}
538
539MlirAttribute mlirRankedTensorTypeGetEncoding(MlirType type) {
540 return wrap(cpp: llvm::cast<RankedTensorType>(Val: unwrap(c: type)).getEncoding());
541}
542
543MlirType mlirUnrankedTensorTypeGet(MlirType elementType) {
544 return wrap(cpp: UnrankedTensorType::get(elementType: unwrap(c: elementType)));
545}
546
547MlirStringRef mlirUnrankedTensorTypeGetName(void) {
548 return wrap(ref: UnrankedTensorType::name);
549}
550
551MlirType mlirUnrankedTensorTypeGetChecked(MlirLocation loc,
552 MlirType elementType) {
553 return wrap(cpp: UnrankedTensorType::getChecked(loc: unwrap(c: loc), args: unwrap(c: elementType)));
554}
555
556//===----------------------------------------------------------------------===//
557// Ranked / Unranked MemRef type.
558//===----------------------------------------------------------------------===//
559
560MlirTypeID mlirMemRefTypeGetTypeID() { return wrap(cpp: MemRefType::getTypeID()); }
561
562bool mlirTypeIsAMemRef(MlirType type) {
563 return llvm::isa<MemRefType>(Val: unwrap(c: type));
564}
565
566MlirType mlirMemRefTypeGet(MlirType elementType, intptr_t rank,
567 const int64_t *shape, MlirAttribute layout,
568 MlirAttribute memorySpace) {
569 return wrap(cpp: MemRefType::get(
570 shape: llvm::ArrayRef(shape, static_cast<size_t>(rank)), elementType: unwrap(c: elementType),
571 layout: mlirAttributeIsNull(attr: layout)
572 ? MemRefLayoutAttrInterface()
573 : llvm::cast<MemRefLayoutAttrInterface>(Val: unwrap(c: layout)),
574 memorySpace: unwrap(c: memorySpace)));
575}
576
577MlirStringRef mlirMemRefTypeGetName(void) { return wrap(ref: MemRefType::name); }
578
579MlirType mlirMemRefTypeGetChecked(MlirLocation loc, MlirType elementType,
580 intptr_t rank, const int64_t *shape,
581 MlirAttribute layout,
582 MlirAttribute memorySpace) {
583 return wrap(cpp: MemRefType::getChecked(
584 loc: unwrap(c: loc), args: llvm::ArrayRef(shape, static_cast<size_t>(rank)),
585 args: unwrap(c: elementType),
586 args: mlirAttributeIsNull(attr: layout)
587 ? MemRefLayoutAttrInterface()
588 : llvm::cast<MemRefLayoutAttrInterface>(Val: unwrap(c: layout)),
589 args: unwrap(c: memorySpace)));
590}
591
592MlirType mlirMemRefTypeContiguousGet(MlirType elementType, intptr_t rank,
593 const int64_t *shape,
594 MlirAttribute memorySpace) {
595 return wrap(cpp: MemRefType::get(shape: llvm::ArrayRef(shape, static_cast<size_t>(rank)),
596 elementType: unwrap(c: elementType), layout: MemRefLayoutAttrInterface(),
597 memorySpace: unwrap(c: memorySpace)));
598}
599
600MlirType mlirMemRefTypeContiguousGetChecked(MlirLocation loc,
601 MlirType elementType, intptr_t rank,
602 const int64_t *shape,
603 MlirAttribute memorySpace) {
604 return wrap(cpp: MemRefType::getChecked(
605 loc: unwrap(c: loc), args: llvm::ArrayRef(shape, static_cast<size_t>(rank)),
606 args: unwrap(c: elementType), args: MemRefLayoutAttrInterface(), args: unwrap(c: memorySpace)));
607}
608
609MlirAttribute mlirMemRefTypeGetLayout(MlirType type) {
610 return wrap(cpp: llvm::cast<MemRefType>(Val: unwrap(c: type)).getLayout());
611}
612
613MlirAffineMap mlirMemRefTypeGetAffineMap(MlirType type) {
614 return wrap(cpp: llvm::cast<MemRefType>(Val: unwrap(c: type)).getLayout().getAffineMap());
615}
616
617MlirAttribute mlirMemRefTypeGetMemorySpace(MlirType type) {
618 return wrap(cpp: llvm::cast<MemRefType>(Val: unwrap(c: type)).getMemorySpace());
619}
620
621MlirLogicalResult mlirMemRefTypeGetStridesAndOffset(MlirType type,
622 int64_t *strides,
623 int64_t *offset) {
624 MemRefType memrefType = llvm::cast<MemRefType>(Val: unwrap(c: type));
625 SmallVector<int64_t> strides_;
626 if (failed(Result: memrefType.getStridesAndOffset(strides&: strides_, offset&: *offset)))
627 return mlirLogicalResultFailure();
628
629 (void)llvm::copy(Range&: strides_, Out: strides);
630 return mlirLogicalResultSuccess();
631}
632
633MlirTypeID mlirUnrankedMemRefTypeGetTypeID() {
634 return wrap(cpp: UnrankedMemRefType::getTypeID());
635}
636
637bool mlirTypeIsAUnrankedMemRef(MlirType type) {
638 return llvm::isa<UnrankedMemRefType>(Val: unwrap(c: type));
639}
640
641MlirType mlirUnrankedMemRefTypeGet(MlirType elementType,
642 MlirAttribute memorySpace) {
643 return wrap(
644 cpp: UnrankedMemRefType::get(elementType: unwrap(c: elementType), memorySpace: unwrap(c: memorySpace)));
645}
646
647MlirStringRef mlirUnrankedMemRefTypeGetName(void) {
648 return wrap(ref: UnrankedMemRefType::name);
649}
650
651MlirType mlirUnrankedMemRefTypeGetChecked(MlirLocation loc,
652 MlirType elementType,
653 MlirAttribute memorySpace) {
654 return wrap(cpp: UnrankedMemRefType::getChecked(loc: unwrap(c: loc), args: unwrap(c: elementType),
655 args: unwrap(c: memorySpace)));
656}
657
658MlirAttribute mlirUnrankedMemrefGetMemorySpace(MlirType type) {
659 return wrap(cpp: llvm::cast<UnrankedMemRefType>(Val: unwrap(c: type)).getMemorySpace());
660}
661
662//===----------------------------------------------------------------------===//
663// Tuple type.
664//===----------------------------------------------------------------------===//
665
666MlirTypeID mlirTupleTypeGetTypeID() { return wrap(cpp: TupleType::getTypeID()); }
667
668bool mlirTypeIsATuple(MlirType type) {
669 return llvm::isa<TupleType>(Val: unwrap(c: type));
670}
671
672MlirType mlirTupleTypeGet(MlirContext ctx, intptr_t numElements,
673 MlirType const *elements) {
674 SmallVector<Type, 4> types;
675 ArrayRef<Type> typeRef = unwrapList(size: numElements, first: elements, storage&: types);
676 return wrap(cpp: TupleType::get(context: unwrap(c: ctx), elementTypes: typeRef));
677}
678
679MlirStringRef mlirTupleTypeGetName(void) { return wrap(ref: TupleType::name); }
680
681intptr_t mlirTupleTypeGetNumTypes(MlirType type) {
682 return llvm::cast<TupleType>(Val: unwrap(c: type)).size();
683}
684
685MlirType mlirTupleTypeGetType(MlirType type, intptr_t pos) {
686 return wrap(
687 cpp: llvm::cast<TupleType>(Val: unwrap(c: type)).getType(index: static_cast<size_t>(pos)));
688}
689
690//===----------------------------------------------------------------------===//
691// Function type.
692//===----------------------------------------------------------------------===//
693
694MlirTypeID mlirFunctionTypeGetTypeID() {
695 return wrap(cpp: FunctionType::getTypeID());
696}
697
698bool mlirTypeIsAFunction(MlirType type) {
699 return llvm::isa<FunctionType>(Val: unwrap(c: type));
700}
701
702MlirType mlirFunctionTypeGet(MlirContext ctx, intptr_t numInputs,
703 MlirType const *inputs, intptr_t numResults,
704 MlirType const *results) {
705 SmallVector<Type, 4> inputsList;
706 SmallVector<Type, 4> resultsList;
707 (void)unwrapList(size: numInputs, first: inputs, storage&: inputsList);
708 (void)unwrapList(size: numResults, first: results, storage&: resultsList);
709 return wrap(cpp: FunctionType::get(context: unwrap(c: ctx), inputs: inputsList, results: resultsList));
710}
711
712MlirStringRef mlirFunctionTypeGetName(void) { return wrap(ref: FunctionType::name); }
713
714intptr_t mlirFunctionTypeGetNumInputs(MlirType type) {
715 return llvm::cast<FunctionType>(Val: unwrap(c: type)).getNumInputs();
716}
717
718intptr_t mlirFunctionTypeGetNumResults(MlirType type) {
719 return llvm::cast<FunctionType>(Val: unwrap(c: type)).getNumResults();
720}
721
722MlirType mlirFunctionTypeGetInput(MlirType type, intptr_t pos) {
723 assert(pos >= 0 && "pos in array must be positive");
724 return wrap(cpp: llvm::cast<FunctionType>(Val: unwrap(c: type))
725 .getInput(i: static_cast<unsigned>(pos)));
726}
727
728MlirType mlirFunctionTypeGetResult(MlirType type, intptr_t pos) {
729 assert(pos >= 0 && "pos in array must be positive");
730 return wrap(cpp: llvm::cast<FunctionType>(Val: unwrap(c: type))
731 .getResult(i: static_cast<unsigned>(pos)));
732}
733
734//===----------------------------------------------------------------------===//
735// Opaque type.
736//===----------------------------------------------------------------------===//
737
738MlirTypeID mlirOpaqueTypeGetTypeID() { return wrap(cpp: OpaqueType::getTypeID()); }
739
740bool mlirTypeIsAOpaque(MlirType type) {
741 return llvm::isa<OpaqueType>(Val: unwrap(c: type));
742}
743
744MlirType mlirOpaqueTypeGet(MlirContext ctx, MlirStringRef dialectNamespace,
745 MlirStringRef typeData) {
746 return wrap(
747 cpp: OpaqueType::get(dialectNamespace: StringAttr::get(context: unwrap(c: ctx), bytes: unwrap(ref: dialectNamespace)),
748 typeData: unwrap(ref: typeData)));
749}
750
751MlirStringRef mlirOpaqueTypeGetName(void) { return wrap(ref: OpaqueType::name); }
752
753MlirStringRef mlirOpaqueTypeGetDialectNamespace(MlirType type) {
754 return wrap(
755 ref: llvm::cast<OpaqueType>(Val: unwrap(c: type)).getDialectNamespace().strref());
756}
757
758MlirStringRef mlirOpaqueTypeGetData(MlirType type) {
759 return wrap(ref: llvm::cast<OpaqueType>(Val: unwrap(c: type)).getTypeData());
760}
761