1 //===- BuiltinAttributes.cpp - C Interface to MLIR Builtin Attributes -----===//
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/BuiltinAttributes.h"
10 #include "mlir/CAPI/AffineMap.h"
11 #include "mlir/CAPI/IR.h"
12 #include "mlir/CAPI/Support.h"
13 #include "mlir/IR/Attributes.h"
14 #include "mlir/IR/BuiltinTypes.h"
15 
16 using namespace mlir;
17 
18 MlirAttribute mlirAttributeGetNull() { return {nullptr}; }
19 
20 //===----------------------------------------------------------------------===//
21 // Affine map attribute.
22 //===----------------------------------------------------------------------===//
23 
24 bool mlirAttributeIsAAffineMap(MlirAttribute attr) {
25   return unwrap(attr).isa<AffineMapAttr>();
26 }
27 
28 MlirAttribute mlirAffineMapAttrGet(MlirAffineMap map) {
29   return wrap(AffineMapAttr::get(unwrap(map)));
30 }
31 
32 MlirAffineMap mlirAffineMapAttrGetValue(MlirAttribute attr) {
33   return wrap(unwrap(attr).cast<AffineMapAttr>().getValue());
34 }
35 
36 //===----------------------------------------------------------------------===//
37 // Array attribute.
38 //===----------------------------------------------------------------------===//
39 
40 bool mlirAttributeIsAArray(MlirAttribute attr) {
41   return unwrap(attr).isa<ArrayAttr>();
42 }
43 
44 MlirAttribute mlirArrayAttrGet(MlirContext ctx, intptr_t numElements,
45                                MlirAttribute const *elements) {
46   SmallVector<Attribute, 8> attrs;
47   return wrap(
48       ArrayAttr::get(unwrap(ctx), unwrapList(static_cast<size_t>(numElements),
49                                              elements, attrs)));
50 }
51 
52 intptr_t mlirArrayAttrGetNumElements(MlirAttribute attr) {
53   return static_cast<intptr_t>(unwrap(attr).cast<ArrayAttr>().size());
54 }
55 
56 MlirAttribute mlirArrayAttrGetElement(MlirAttribute attr, intptr_t pos) {
57   return wrap(unwrap(attr).cast<ArrayAttr>().getValue()[pos]);
58 }
59 
60 //===----------------------------------------------------------------------===//
61 // Dictionary attribute.
62 //===----------------------------------------------------------------------===//
63 
64 bool mlirAttributeIsADictionary(MlirAttribute attr) {
65   return unwrap(attr).isa<DictionaryAttr>();
66 }
67 
68 MlirAttribute mlirDictionaryAttrGet(MlirContext ctx, intptr_t numElements,
69                                     MlirNamedAttribute const *elements) {
70   SmallVector<NamedAttribute, 8> attributes;
71   attributes.reserve(numElements);
72   for (intptr_t i = 0; i < numElements; ++i)
73     attributes.emplace_back(unwrap(elements[i].name),
74                             unwrap(elements[i].attribute));
75   return wrap(DictionaryAttr::get(unwrap(ctx), attributes));
76 }
77 
78 intptr_t mlirDictionaryAttrGetNumElements(MlirAttribute attr) {
79   return static_cast<intptr_t>(unwrap(attr).cast<DictionaryAttr>().size());
80 }
81 
82 MlirNamedAttribute mlirDictionaryAttrGetElement(MlirAttribute attr,
83                                                 intptr_t pos) {
84   NamedAttribute attribute =
85       unwrap(attr).cast<DictionaryAttr>().getValue()[pos];
86   return {wrap(attribute.getName()), wrap(attribute.getValue())};
87 }
88 
89 MlirAttribute mlirDictionaryAttrGetElementByName(MlirAttribute attr,
90                                                  MlirStringRef name) {
91   return wrap(unwrap(attr).cast<DictionaryAttr>().get(unwrap(name)));
92 }
93 
94 //===----------------------------------------------------------------------===//
95 // Floating point attribute.
96 //===----------------------------------------------------------------------===//
97 
98 bool mlirAttributeIsAFloat(MlirAttribute attr) {
99   return unwrap(attr).isa<FloatAttr>();
100 }
101 
102 MlirAttribute mlirFloatAttrDoubleGet(MlirContext ctx, MlirType type,
103                                      double value) {
104   return wrap(FloatAttr::get(unwrap(type), value));
105 }
106 
107 MlirAttribute mlirFloatAttrDoubleGetChecked(MlirLocation loc, MlirType type,
108                                             double value) {
109   return wrap(FloatAttr::getChecked(unwrap(loc), unwrap(type), value));
110 }
111 
112 double mlirFloatAttrGetValueDouble(MlirAttribute attr) {
113   return unwrap(attr).cast<FloatAttr>().getValueAsDouble();
114 }
115 
116 //===----------------------------------------------------------------------===//
117 // Integer attribute.
118 //===----------------------------------------------------------------------===//
119 
120 bool mlirAttributeIsAInteger(MlirAttribute attr) {
121   return unwrap(attr).isa<IntegerAttr>();
122 }
123 
124 MlirAttribute mlirIntegerAttrGet(MlirType type, int64_t value) {
125   return wrap(IntegerAttr::get(unwrap(type), value));
126 }
127 
128 int64_t mlirIntegerAttrGetValueInt(MlirAttribute attr) {
129   return unwrap(attr).cast<IntegerAttr>().getInt();
130 }
131 
132 //===----------------------------------------------------------------------===//
133 // Bool attribute.
134 //===----------------------------------------------------------------------===//
135 
136 bool mlirAttributeIsABool(MlirAttribute attr) {
137   return unwrap(attr).isa<BoolAttr>();
138 }
139 
140 MlirAttribute mlirBoolAttrGet(MlirContext ctx, int value) {
141   return wrap(BoolAttr::get(unwrap(ctx), value));
142 }
143 
144 bool mlirBoolAttrGetValue(MlirAttribute attr) {
145   return unwrap(attr).cast<BoolAttr>().getValue();
146 }
147 
148 //===----------------------------------------------------------------------===//
149 // Integer set attribute.
150 //===----------------------------------------------------------------------===//
151 
152 bool mlirAttributeIsAIntegerSet(MlirAttribute attr) {
153   return unwrap(attr).isa<IntegerSetAttr>();
154 }
155 
156 //===----------------------------------------------------------------------===//
157 // Opaque attribute.
158 //===----------------------------------------------------------------------===//
159 
160 bool mlirAttributeIsAOpaque(MlirAttribute attr) {
161   return unwrap(attr).isa<OpaqueAttr>();
162 }
163 
164 MlirAttribute mlirOpaqueAttrGet(MlirContext ctx, MlirStringRef dialectNamespace,
165                                 intptr_t dataLength, const char *data,
166                                 MlirType type) {
167   return wrap(
168       OpaqueAttr::get(StringAttr::get(unwrap(ctx), unwrap(dialectNamespace)),
169                       StringRef(data, dataLength), unwrap(type)));
170 }
171 
172 MlirStringRef mlirOpaqueAttrGetDialectNamespace(MlirAttribute attr) {
173   return wrap(unwrap(attr).cast<OpaqueAttr>().getDialectNamespace().strref());
174 }
175 
176 MlirStringRef mlirOpaqueAttrGetData(MlirAttribute attr) {
177   return wrap(unwrap(attr).cast<OpaqueAttr>().getAttrData());
178 }
179 
180 //===----------------------------------------------------------------------===//
181 // String attribute.
182 //===----------------------------------------------------------------------===//
183 
184 bool mlirAttributeIsAString(MlirAttribute attr) {
185   return unwrap(attr).isa<StringAttr>();
186 }
187 
188 MlirAttribute mlirStringAttrGet(MlirContext ctx, MlirStringRef str) {
189   return wrap((Attribute)StringAttr::get(unwrap(ctx), unwrap(str)));
190 }
191 
192 MlirAttribute mlirStringAttrTypedGet(MlirType type, MlirStringRef str) {
193   return wrap((Attribute)StringAttr::get(unwrap(str), unwrap(type)));
194 }
195 
196 MlirStringRef mlirStringAttrGetValue(MlirAttribute attr) {
197   return wrap(unwrap(attr).cast<StringAttr>().getValue());
198 }
199 
200 //===----------------------------------------------------------------------===//
201 // SymbolRef attribute.
202 //===----------------------------------------------------------------------===//
203 
204 bool mlirAttributeIsASymbolRef(MlirAttribute attr) {
205   return unwrap(attr).isa<SymbolRefAttr>();
206 }
207 
208 MlirAttribute mlirSymbolRefAttrGet(MlirContext ctx, MlirStringRef symbol,
209                                    intptr_t numReferences,
210                                    MlirAttribute const *references) {
211   SmallVector<FlatSymbolRefAttr, 4> refs;
212   refs.reserve(numReferences);
213   for (intptr_t i = 0; i < numReferences; ++i)
214     refs.push_back(unwrap(references[i]).cast<FlatSymbolRefAttr>());
215   auto symbolAttr = StringAttr::get(unwrap(ctx), unwrap(symbol));
216   return wrap(SymbolRefAttr::get(symbolAttr, refs));
217 }
218 
219 MlirStringRef mlirSymbolRefAttrGetRootReference(MlirAttribute attr) {
220   return wrap(unwrap(attr).cast<SymbolRefAttr>().getRootReference().getValue());
221 }
222 
223 MlirStringRef mlirSymbolRefAttrGetLeafReference(MlirAttribute attr) {
224   return wrap(unwrap(attr).cast<SymbolRefAttr>().getLeafReference().getValue());
225 }
226 
227 intptr_t mlirSymbolRefAttrGetNumNestedReferences(MlirAttribute attr) {
228   return static_cast<intptr_t>(
229       unwrap(attr).cast<SymbolRefAttr>().getNestedReferences().size());
230 }
231 
232 MlirAttribute mlirSymbolRefAttrGetNestedReference(MlirAttribute attr,
233                                                   intptr_t pos) {
234   return wrap(unwrap(attr).cast<SymbolRefAttr>().getNestedReferences()[pos]);
235 }
236 
237 //===----------------------------------------------------------------------===//
238 // Flat SymbolRef attribute.
239 //===----------------------------------------------------------------------===//
240 
241 bool mlirAttributeIsAFlatSymbolRef(MlirAttribute attr) {
242   return unwrap(attr).isa<FlatSymbolRefAttr>();
243 }
244 
245 MlirAttribute mlirFlatSymbolRefAttrGet(MlirContext ctx, MlirStringRef symbol) {
246   return wrap(FlatSymbolRefAttr::get(unwrap(ctx), unwrap(symbol)));
247 }
248 
249 MlirStringRef mlirFlatSymbolRefAttrGetValue(MlirAttribute attr) {
250   return wrap(unwrap(attr).cast<FlatSymbolRefAttr>().getValue());
251 }
252 
253 //===----------------------------------------------------------------------===//
254 // Type attribute.
255 //===----------------------------------------------------------------------===//
256 
257 bool mlirAttributeIsAType(MlirAttribute attr) {
258   return unwrap(attr).isa<TypeAttr>();
259 }
260 
261 MlirAttribute mlirTypeAttrGet(MlirType type) {
262   return wrap(TypeAttr::get(unwrap(type)));
263 }
264 
265 MlirType mlirTypeAttrGetValue(MlirAttribute attr) {
266   return wrap(unwrap(attr).cast<TypeAttr>().getValue());
267 }
268 
269 //===----------------------------------------------------------------------===//
270 // Unit attribute.
271 //===----------------------------------------------------------------------===//
272 
273 bool mlirAttributeIsAUnit(MlirAttribute attr) {
274   return unwrap(attr).isa<UnitAttr>();
275 }
276 
277 MlirAttribute mlirUnitAttrGet(MlirContext ctx) {
278   return wrap(UnitAttr::get(unwrap(ctx)));
279 }
280 
281 //===----------------------------------------------------------------------===//
282 // Elements attributes.
283 //===----------------------------------------------------------------------===//
284 
285 bool mlirAttributeIsAElements(MlirAttribute attr) {
286   return unwrap(attr).isa<ElementsAttr>();
287 }
288 
289 MlirAttribute mlirElementsAttrGetValue(MlirAttribute attr, intptr_t rank,
290                                        uint64_t *idxs) {
291   return wrap(unwrap(attr)
292                   .cast<ElementsAttr>()
293                   .getValues<Attribute>()[llvm::makeArrayRef(idxs, rank)]);
294 }
295 
296 bool mlirElementsAttrIsValidIndex(MlirAttribute attr, intptr_t rank,
297                                   uint64_t *idxs) {
298   return unwrap(attr).cast<ElementsAttr>().isValidIndex(
299       llvm::makeArrayRef(idxs, rank));
300 }
301 
302 int64_t mlirElementsAttrGetNumElements(MlirAttribute attr) {
303   return unwrap(attr).cast<ElementsAttr>().getNumElements();
304 }
305 
306 //===----------------------------------------------------------------------===//
307 // Dense elements attribute.
308 //===----------------------------------------------------------------------===//
309 
310 //===----------------------------------------------------------------------===//
311 // IsA support.
312 
313 bool mlirAttributeIsADenseElements(MlirAttribute attr) {
314   return unwrap(attr).isa<DenseElementsAttr>();
315 }
316 bool mlirAttributeIsADenseIntElements(MlirAttribute attr) {
317   return unwrap(attr).isa<DenseIntElementsAttr>();
318 }
319 bool mlirAttributeIsADenseFPElements(MlirAttribute attr) {
320   return unwrap(attr).isa<DenseFPElementsAttr>();
321 }
322 
323 //===----------------------------------------------------------------------===//
324 // Constructors.
325 
326 MlirAttribute mlirDenseElementsAttrGet(MlirType shapedType,
327                                        intptr_t numElements,
328                                        MlirAttribute const *elements) {
329   SmallVector<Attribute, 8> attributes;
330   return wrap(
331       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
332                              unwrapList(numElements, elements, attributes)));
333 }
334 
335 MlirAttribute mlirDenseElementsAttrRawBufferGet(MlirType shapedType,
336                                                 size_t rawBufferSize,
337                                                 const void *rawBuffer) {
338   auto shapedTypeCpp = unwrap(shapedType).cast<ShapedType>();
339   ArrayRef<char> rawBufferCpp(static_cast<const char *>(rawBuffer),
340                               rawBufferSize);
341   bool isSplat = false;
342   if (!DenseElementsAttr::isValidRawBuffer(shapedTypeCpp, rawBufferCpp,
343                                            isSplat)) {
344     return mlirAttributeGetNull();
345   }
346   return wrap(DenseElementsAttr::getFromRawBuffer(shapedTypeCpp, rawBufferCpp,
347                                                   isSplat));
348 }
349 
350 MlirAttribute mlirDenseElementsAttrSplatGet(MlirType shapedType,
351                                             MlirAttribute element) {
352   return wrap(DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
353                                      unwrap(element)));
354 }
355 MlirAttribute mlirDenseElementsAttrBoolSplatGet(MlirType shapedType,
356                                                 bool element) {
357   return wrap(
358       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
359 }
360 MlirAttribute mlirDenseElementsAttrUInt8SplatGet(MlirType shapedType,
361                                                  uint8_t element) {
362   return wrap(
363       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
364 }
365 MlirAttribute mlirDenseElementsAttrInt8SplatGet(MlirType shapedType,
366                                                 int8_t element) {
367   return wrap(
368       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
369 }
370 MlirAttribute mlirDenseElementsAttrUInt32SplatGet(MlirType shapedType,
371                                                   uint32_t element) {
372   return wrap(
373       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
374 }
375 MlirAttribute mlirDenseElementsAttrInt32SplatGet(MlirType shapedType,
376                                                  int32_t element) {
377   return wrap(
378       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
379 }
380 MlirAttribute mlirDenseElementsAttrUInt64SplatGet(MlirType shapedType,
381                                                   uint64_t element) {
382   return wrap(
383       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
384 }
385 MlirAttribute mlirDenseElementsAttrInt64SplatGet(MlirType shapedType,
386                                                  int64_t element) {
387   return wrap(
388       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
389 }
390 MlirAttribute mlirDenseElementsAttrFloatSplatGet(MlirType shapedType,
391                                                  float element) {
392   return wrap(
393       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
394 }
395 MlirAttribute mlirDenseElementsAttrDoubleSplatGet(MlirType shapedType,
396                                                   double element) {
397   return wrap(
398       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
399 }
400 
401 MlirAttribute mlirDenseElementsAttrBoolGet(MlirType shapedType,
402                                            intptr_t numElements,
403                                            const int *elements) {
404   SmallVector<bool, 8> values(elements, elements + numElements);
405   return wrap(
406       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), values));
407 }
408 
409 /// Creates a dense attribute with elements of the type deduced by templates.
410 template <typename T>
411 static MlirAttribute getDenseAttribute(MlirType shapedType,
412                                        intptr_t numElements,
413                                        const T *elements) {
414   return wrap(
415       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
416                              llvm::makeArrayRef(elements, numElements)));
417 }
418 
419 MlirAttribute mlirDenseElementsAttrUInt8Get(MlirType shapedType,
420                                             intptr_t numElements,
421                                             const uint8_t *elements) {
422   return getDenseAttribute(shapedType, numElements, elements);
423 }
424 MlirAttribute mlirDenseElementsAttrInt8Get(MlirType shapedType,
425                                            intptr_t numElements,
426                                            const int8_t *elements) {
427   return getDenseAttribute(shapedType, numElements, elements);
428 }
429 MlirAttribute mlirDenseElementsAttrUInt32Get(MlirType shapedType,
430                                              intptr_t numElements,
431                                              const uint32_t *elements) {
432   return getDenseAttribute(shapedType, numElements, elements);
433 }
434 MlirAttribute mlirDenseElementsAttrInt32Get(MlirType shapedType,
435                                             intptr_t numElements,
436                                             const int32_t *elements) {
437   return getDenseAttribute(shapedType, numElements, elements);
438 }
439 MlirAttribute mlirDenseElementsAttrUInt64Get(MlirType shapedType,
440                                              intptr_t numElements,
441                                              const uint64_t *elements) {
442   return getDenseAttribute(shapedType, numElements, elements);
443 }
444 MlirAttribute mlirDenseElementsAttrInt64Get(MlirType shapedType,
445                                             intptr_t numElements,
446                                             const int64_t *elements) {
447   return getDenseAttribute(shapedType, numElements, elements);
448 }
449 MlirAttribute mlirDenseElementsAttrFloatGet(MlirType shapedType,
450                                             intptr_t numElements,
451                                             const float *elements) {
452   return getDenseAttribute(shapedType, numElements, elements);
453 }
454 MlirAttribute mlirDenseElementsAttrDoubleGet(MlirType shapedType,
455                                              intptr_t numElements,
456                                              const double *elements) {
457   return getDenseAttribute(shapedType, numElements, elements);
458 }
459 
460 MlirAttribute mlirDenseElementsAttrStringGet(MlirType shapedType,
461                                              intptr_t numElements,
462                                              MlirStringRef *strs) {
463   SmallVector<StringRef, 8> values;
464   values.reserve(numElements);
465   for (intptr_t i = 0; i < numElements; ++i)
466     values.push_back(unwrap(strs[i]));
467 
468   return wrap(
469       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), values));
470 }
471 
472 MlirAttribute mlirDenseElementsAttrReshapeGet(MlirAttribute attr,
473                                               MlirType shapedType) {
474   return wrap(unwrap(attr).cast<DenseElementsAttr>().reshape(
475       unwrap(shapedType).cast<ShapedType>()));
476 }
477 
478 //===----------------------------------------------------------------------===//
479 // Splat accessors.
480 
481 bool mlirDenseElementsAttrIsSplat(MlirAttribute attr) {
482   return unwrap(attr).cast<DenseElementsAttr>().isSplat();
483 }
484 
485 MlirAttribute mlirDenseElementsAttrGetSplatValue(MlirAttribute attr) {
486   return wrap(
487       unwrap(attr).cast<DenseElementsAttr>().getSplatValue<Attribute>());
488 }
489 int mlirDenseElementsAttrGetBoolSplatValue(MlirAttribute attr) {
490   return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<bool>();
491 }
492 int8_t mlirDenseElementsAttrGetInt8SplatValue(MlirAttribute attr) {
493   return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<int8_t>();
494 }
495 uint8_t mlirDenseElementsAttrGetUInt8SplatValue(MlirAttribute attr) {
496   return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<uint8_t>();
497 }
498 int32_t mlirDenseElementsAttrGetInt32SplatValue(MlirAttribute attr) {
499   return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<int32_t>();
500 }
501 uint32_t mlirDenseElementsAttrGetUInt32SplatValue(MlirAttribute attr) {
502   return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<uint32_t>();
503 }
504 int64_t mlirDenseElementsAttrGetInt64SplatValue(MlirAttribute attr) {
505   return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<int64_t>();
506 }
507 uint64_t mlirDenseElementsAttrGetUInt64SplatValue(MlirAttribute attr) {
508   return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<uint64_t>();
509 }
510 float mlirDenseElementsAttrGetFloatSplatValue(MlirAttribute attr) {
511   return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<float>();
512 }
513 double mlirDenseElementsAttrGetDoubleSplatValue(MlirAttribute attr) {
514   return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<double>();
515 }
516 MlirStringRef mlirDenseElementsAttrGetStringSplatValue(MlirAttribute attr) {
517   return wrap(
518       unwrap(attr).cast<DenseElementsAttr>().getSplatValue<StringRef>());
519 }
520 
521 //===----------------------------------------------------------------------===//
522 // Indexed accessors.
523 
524 bool mlirDenseElementsAttrGetBoolValue(MlirAttribute attr, intptr_t pos) {
525   return unwrap(attr).cast<DenseElementsAttr>().getValues<bool>()[pos];
526 }
527 int8_t mlirDenseElementsAttrGetInt8Value(MlirAttribute attr, intptr_t pos) {
528   return unwrap(attr).cast<DenseElementsAttr>().getValues<int8_t>()[pos];
529 }
530 uint8_t mlirDenseElementsAttrGetUInt8Value(MlirAttribute attr, intptr_t pos) {
531   return unwrap(attr).cast<DenseElementsAttr>().getValues<uint8_t>()[pos];
532 }
533 int32_t mlirDenseElementsAttrGetInt32Value(MlirAttribute attr, intptr_t pos) {
534   return unwrap(attr).cast<DenseElementsAttr>().getValues<int32_t>()[pos];
535 }
536 uint32_t mlirDenseElementsAttrGetUInt32Value(MlirAttribute attr, intptr_t pos) {
537   return unwrap(attr).cast<DenseElementsAttr>().getValues<uint32_t>()[pos];
538 }
539 int64_t mlirDenseElementsAttrGetInt64Value(MlirAttribute attr, intptr_t pos) {
540   return unwrap(attr).cast<DenseElementsAttr>().getValues<int64_t>()[pos];
541 }
542 uint64_t mlirDenseElementsAttrGetUInt64Value(MlirAttribute attr, intptr_t pos) {
543   return unwrap(attr).cast<DenseElementsAttr>().getValues<uint64_t>()[pos];
544 }
545 float mlirDenseElementsAttrGetFloatValue(MlirAttribute attr, intptr_t pos) {
546   return unwrap(attr).cast<DenseElementsAttr>().getValues<float>()[pos];
547 }
548 double mlirDenseElementsAttrGetDoubleValue(MlirAttribute attr, intptr_t pos) {
549   return unwrap(attr).cast<DenseElementsAttr>().getValues<double>()[pos];
550 }
551 MlirStringRef mlirDenseElementsAttrGetStringValue(MlirAttribute attr,
552                                                   intptr_t pos) {
553   return wrap(
554       unwrap(attr).cast<DenseElementsAttr>().getValues<StringRef>()[pos]);
555 }
556 
557 //===----------------------------------------------------------------------===//
558 // Raw data accessors.
559 
560 const void *mlirDenseElementsAttrGetRawData(MlirAttribute attr) {
561   return static_cast<const void *>(
562       unwrap(attr).cast<DenseElementsAttr>().getRawData().data());
563 }
564 
565 //===----------------------------------------------------------------------===//
566 // Opaque elements attribute.
567 //===----------------------------------------------------------------------===//
568 
569 bool mlirAttributeIsAOpaqueElements(MlirAttribute attr) {
570   return unwrap(attr).isa<OpaqueElementsAttr>();
571 }
572 
573 //===----------------------------------------------------------------------===//
574 // Sparse elements attribute.
575 //===----------------------------------------------------------------------===//
576 
577 bool mlirAttributeIsASparseElements(MlirAttribute attr) {
578   return unwrap(attr).isa<SparseElementsAttr>();
579 }
580 
581 MlirAttribute mlirSparseElementsAttribute(MlirType shapedType,
582                                           MlirAttribute denseIndices,
583                                           MlirAttribute denseValues) {
584   return wrap(
585       SparseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
586                               unwrap(denseIndices).cast<DenseElementsAttr>(),
587                               unwrap(denseValues).cast<DenseElementsAttr>()));
588 }
589 
590 MlirAttribute mlirSparseElementsAttrGetIndices(MlirAttribute attr) {
591   return wrap(unwrap(attr).cast<SparseElementsAttr>().getIndices());
592 }
593 
594 MlirAttribute mlirSparseElementsAttrGetValues(MlirAttribute attr) {
595   return wrap(unwrap(attr).cast<SparseElementsAttr>().getValues());
596 }
597