20 #include "llvm/ADT/APSInt.h"
21 #include "llvm/ADT/Sequence.h"
22 #include "llvm/ADT/TypeSwitch.h"
23 #include "llvm/Support/Debug.h"
24 #include "llvm/Support/Endian.h"
27 #define DEBUG_TYPE "builtinattributes"
36 #define GET_ATTRDEF_CLASSES
37 #include "mlir/IR/BuiltinAttributes.cpp.inc"
43 void BuiltinDialect::registerAttributes() {
45 #define GET_ATTRDEF_LIST
46 #include "mlir/IR/BuiltinAttributes.cpp.inc"
48 addAttributes<DistinctAttr>();
59 template <
bool inPlace>
63 switch (value.size()) {
72 storage.assign({value[0]});
75 bool isSorted = value[0] < value[1];
78 std::swap(storage[0], storage[1]);
79 }
else if (isSorted) {
80 storage.assign({value[0], value[1]});
82 storage.assign({value[1], value[0]});
88 storage.assign(value.begin(), value.end());
90 bool isSorted = llvm::is_sorted(value);
93 llvm::array_pod_sort(storage.begin(), storage.end());
101 static std::optional<NamedAttribute>
103 const std::optional<NamedAttribute> none{std::nullopt};
104 if (value.size() < 2)
107 if (value.size() == 2)
108 return value[0].getName() == value[1].getName() ? value[0] : none;
110 const auto *it = std::adjacent_find(value.begin(), value.end(),
112 return l.getName() == r.getName();
114 return it != value.end() ? *it : none;
121 "DictionaryAttr element names must be unique");
128 "DictionaryAttr element names must be unique");
132 std::optional<NamedAttribute>
143 return DictionaryAttr::getEmpty(context);
147 if (dictionaryAttrSort</*inPlace=*/false>(value, storage))
150 "DictionaryAttr element names must be unique");
155 DictionaryAttr DictionaryAttr::getWithSorted(
MLIRContext *context,
158 return DictionaryAttr::getEmpty(context);
160 assert(llvm::is_sorted(
162 "expected attribute values to be sorted");
164 "DictionaryAttr element names must be unique");
171 return it.second ? it.first->getValue() :
Attribute();
175 return it.second ? it.first->getValue() :
Attribute();
179 std::optional<NamedAttribute> DictionaryAttr::getNamed(StringRef name)
const {
181 return it.second ? *it.first : std::optional<NamedAttribute>();
183 std::optional<NamedAttribute> DictionaryAttr::getNamed(StringAttr name)
const {
185 return it.second ? *it.first : std::optional<NamedAttribute>();
196 DictionaryAttr::iterator DictionaryAttr::begin()
const {
197 return getValue().begin();
199 DictionaryAttr::iterator DictionaryAttr::end()
const {
200 return getValue().end();
202 size_t DictionaryAttr::size()
const {
return getValue().size(); }
204 DictionaryAttr DictionaryAttr::getEmptyUnchecked(
MLIRContext *context) {
214 auto printIntOrQuestion = [&](int64_t value) {
215 if (ShapedType::isDynamic(value))
222 llvm::interleaveComma(getStrides(), os, printIntOrQuestion);
225 if (getOffset() != 0) {
227 printIntOrQuestion(getOffset());
234 bool StridedLayoutAttr::hasStaticLayout()
const {
235 return !ShapedType::isDynamic(getOffset()) &&
236 !ShapedType::isDynamicShape(getStrides());
240 AffineMap StridedLayoutAttr::getAffineMap()
const {
252 LogicalResult StridedLayoutAttr::verifyLayout(
255 if (shape.size() != getStrides().size())
256 return emitError() <<
"expected the number of strides to match the rank";
265 StringAttr StringAttr::getEmptyStringAttrUnchecked(
MLIRContext *context) {
272 if (twine.isTriviallyEmpty())
284 StringRef StringAttr::getValue()
const {
return getImpl()->value; }
288 Dialect *StringAttr::getReferencedDialect()
const {
289 return getImpl()->referencedDialect;
296 double FloatAttr::getValueAsDouble()
const {
297 return getValueAsDouble(getValue());
299 double FloatAttr::getValueAsDouble(APFloat value) {
300 if (&value.getSemantics() != &APFloat::IEEEdouble()) {
301 bool losesInfo =
false;
302 value.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
305 return value.convertToDouble();
309 Type type, APFloat value) {
311 if (!llvm::isa<FloatType>(type))
312 return emitError() <<
"expected floating point type";
315 if (&llvm::cast<FloatType>(type).getFloatSemantics() !=
316 &value.getSemantics()) {
318 <<
"FloatAttr type doesn't match the type implied by its value";
333 return llvm::cast<FlatSymbolRefAttr>(
get(ctx, value, {}));
337 return llvm::cast<FlatSymbolRefAttr>(
get(value, {}));
343 assert(symName &&
"value does not have a valid symbol name");
347 StringAttr SymbolRefAttr::getLeafReference()
const {
349 return nestedRefs.empty() ? getRootReference() : nestedRefs.back().getAttr();
356 int64_t IntegerAttr::getInt()
const {
358 "must be signless integer");
359 return getValue().getSExtValue();
362 int64_t IntegerAttr::getSInt()
const {
363 assert(
getType().isSignedInteger() &&
"must be signed integer");
364 return getValue().getSExtValue();
367 uint64_t IntegerAttr::getUInt()
const {
368 assert(
getType().isUnsignedInteger() &&
"must be unsigned integer");
369 return getValue().getZExtValue();
374 APSInt IntegerAttr::getAPSInt()
const {
375 assert(!
getType().isSignlessInteger() &&
376 "Signless integers don't carry a sign for APSInt");
377 return APSInt(getValue(),
getType().isUnsignedInteger());
381 Type type, APInt value) {
382 if (IntegerType integerType = llvm::dyn_cast<IntegerType>(type)) {
383 if (integerType.getWidth() != value.getBitWidth())
384 return emitError() <<
"integer type bit width (" << integerType.getWidth()
385 <<
") doesn't match value bit width ("
386 << value.getBitWidth() <<
")";
389 if (llvm::isa<IndexType>(type)) {
390 if (value.getBitWidth() != IndexType::kInternalStorageBitWidth)
392 <<
"value bit width (" << value.getBitWidth()
393 <<
") doesn't match index type internal storage bit width ("
394 << IndexType::kInternalStorageBitWidth <<
")";
397 return emitError() <<
"expected integer or index type";
400 BoolAttr IntegerAttr::getBoolAttrUnchecked(IntegerType type,
bool value) {
401 auto attr =
Base::get(type.getContext(), type, APInt(1, value));
402 return llvm::cast<BoolAttr>(attr);
410 auto *storage =
reinterpret_cast<IntegerAttrStorage *
>(
impl);
411 return storage->value.getBoolValue();
415 IntegerAttr intAttr = llvm::dyn_cast<IntegerAttr>(attr);
416 return intAttr && intAttr.getType().isSignlessInteger(1);
424 StringAttr dialect, StringRef attrData,
427 return emitError() <<
"invalid dialect namespace '" << dialect <<
"'";
434 <<
"#" << dialect <<
"<\"" << attrData <<
"\"> : " << type
435 <<
" attribute created with unregistered dialect. If this is "
436 "intended, please call allowUnregisteredDialects() on the "
437 "MLIRContext, or use -allow-unregistered-dialect with "
438 "the MLIR opt tool used";
454 return origWidth == 1 ? origWidth : llvm::alignTo<8>(origWidth);
461 static void setBit(
char *rawData,
size_t bitPos,
bool value) {
463 rawData[bitPos / CHAR_BIT] |= (1 << (bitPos % CHAR_BIT));
465 rawData[bitPos / CHAR_BIT] &= ~(1 << (bitPos % CHAR_BIT));
469 static bool getBit(
const char *rawData,
size_t bitPos) {
470 return (rawData[bitPos / CHAR_BIT] & (1 << (bitPos % CHAR_BIT))) != 0;
477 assert(llvm::endianness::native == llvm::endianness::big);
478 assert(value.getNumWords() * APInt::APINT_WORD_SIZE >= numBytes);
483 size_t numFilledWords = (value.getNumWords() - 1) * APInt::APINT_WORD_SIZE;
484 std::copy_n(
reinterpret_cast<const char *
>(value.getRawData()),
485 numFilledWords, result);
489 size_t lastWordPos = numFilledWords;
491 DenseIntOrFPElementsAttr::convertEndianOfCharForBEmachine(
492 reinterpret_cast<const char *
>(value.getRawData()) + lastWordPos,
493 valueLE.begin(), APInt::APINT_BITS_PER_WORD, 1);
497 DenseIntOrFPElementsAttr::convertEndianOfCharForBEmachine(
498 valueLE.begin(), result + lastWordPos,
499 (numBytes - lastWordPos) * CHAR_BIT, 1);
506 assert(llvm::endianness::native == llvm::endianness::big);
507 assert(result.getNumWords() * APInt::APINT_WORD_SIZE >= numBytes);
514 size_t numFilledWords = (result.getNumWords() - 1) * APInt::APINT_WORD_SIZE;
516 inArray, numFilledWords,
517 const_cast<char *
>(
reinterpret_cast<const char *
>(result.getRawData())));
522 size_t lastWordPos = numFilledWords;
524 DenseIntOrFPElementsAttr::convertEndianOfCharForBEmachine(
525 inArray + lastWordPos, inArrayLE.begin(),
526 (numBytes - lastWordPos) * CHAR_BIT, 1);
530 DenseIntOrFPElementsAttr::convertEndianOfCharForBEmachine(
532 const_cast<char *
>(
reinterpret_cast<const char *
>(result.getRawData())) +
534 APInt::APINT_BITS_PER_WORD, 1);
538 static void writeBits(
char *rawData,
size_t bitPos, APInt value) {
539 size_t bitWidth = value.getBitWidth();
543 return setBit(rawData, bitPos, value.isOne());
546 assert((bitPos % CHAR_BIT) == 0 &&
"expected bitPos to be 8-bit aligned");
547 if (llvm::endianness::native == llvm::endianness::big) {
554 rawData + (bitPos / CHAR_BIT));
556 std::copy_n(
reinterpret_cast<const char *
>(value.getRawData()),
558 rawData + (bitPos / CHAR_BIT));
564 static APInt
readBits(
const char *rawData,
size_t bitPos,
size_t bitWidth) {
567 return APInt(1,
getBit(rawData, bitPos) ? 1 : 0);
570 assert((bitPos % CHAR_BIT) == 0 &&
"expected bitPos to be 8-bit aligned");
571 APInt result(bitWidth, 0);
572 if (llvm::endianness::native == llvm::endianness::big) {
581 std::copy_n(rawData + (bitPos / CHAR_BIT),
584 reinterpret_cast<const char *
>(result.getRawData())));
591 template <
typename Values>
593 return (values.size() == 1) ||
594 (type.getNumElements() ==
static_cast<int64_t
>(values.size()));
604 DenseElementsAttr::AttributeElementIterator::AttributeElementIterator(
606 :
llvm::indexed_accessor_iterator<AttributeElementIterator, const void *,
608 attr.getAsOpaquePointer(), index) {}
612 Type eltTy = owner.getElementType();
613 if (llvm::dyn_cast<IntegerType>(eltTy))
615 if (llvm::isa<IndexType>(eltTy))
617 if (
auto floatEltTy = llvm::dyn_cast<FloatType>(eltTy)) {
622 if (
auto complexTy = llvm::dyn_cast<ComplexType>(eltTy)) {
623 auto complexEltTy = complexTy.getElementType();
625 if (llvm::isa<IntegerType>(complexEltTy)) {
626 auto value = *complexIntIt;
634 llvm::cast<FloatType>(complexEltTy).getFloatSemantics(), complexIntIt);
635 auto value = *complexFloatIt;
641 if (llvm::isa<DenseStringElementsAttr>(owner)) {
643 return StringAttr::get(owner.isSplat() ? vals.front() : vals[index], eltTy);
645 llvm_unreachable(
"unexpected element type");
651 DenseElementsAttr::BoolElementIterator::BoolElementIterator(
657 return getBit(getData(), getDataIndex());
663 DenseElementsAttr::IntElementIterator::IntElementIterator(
678 DenseElementsAttr::ComplexIntElementIterator::ComplexIntElementIterator(
681 std::complex<APInt>, std::complex<APInt>,
682 std::complex<APInt>>(
684 auto complexType = llvm::cast<ComplexType>(attr.
getElementType());
691 size_t offset = getDataIndex() * storageWidth * 2;
692 return {
readBits(getData(), offset, bitWidth),
693 readBits(getData(), offset + storageWidth, bitWidth)};
704 return emitError() <<
"expected integer or floating point element type";
705 int64_t dataSize = rawData.size();
706 int64_t elementSize =
708 if (
size * elementSize != dataSize) {
709 return emitError() <<
"expected data size (" <<
size <<
" elements, "
711 <<
" bytes each) does not match: " << dataSize
720 template <
size_t width,
721 IntegerType::SignednessSemantics signedness = IntegerType::Signless>
722 struct DenseArrayAttrIntUtil {
723 static bool checkElementType(
Type eltType) {
724 auto type = llvm::dyn_cast<IntegerType>(eltType);
725 if (!type || type.getWidth() != width)
727 return type.getSignedness() == signedness;
734 template <
typename T>
735 static void printElement(raw_ostream &os, T value) {
739 template <
typename T>
740 static ParseResult parseElement(
AsmParser &parser, T &value) {
744 template <
typename T>
745 struct DenseArrayAttrUtil;
750 struct DenseArrayAttrUtil<bool> :
public DenseArrayAttrIntUtil<1> {
751 static void printElement(raw_ostream &os,
bool value) {
752 os << (value ?
"true" :
"false");
759 struct DenseArrayAttrUtil<int8_t> :
public DenseArrayAttrIntUtil<8> {
760 static void printElement(raw_ostream &os, int8_t value) {
761 os << static_cast<int>(value);
765 struct DenseArrayAttrUtil<int16_t> :
public DenseArrayAttrIntUtil<16> {};
767 struct DenseArrayAttrUtil<int32_t> :
public DenseArrayAttrIntUtil<32> {};
769 struct DenseArrayAttrUtil<int64_t> :
public DenseArrayAttrIntUtil<64> {};
773 struct DenseArrayAttrUtil<float> {
774 static bool checkElementType(
Type eltType) {
return eltType.
isF32(); }
776 static void printElement(raw_ostream &os,
float value) { os << value; }
779 static ParseResult parseElement(
AsmParser &parser,
float &value) {
790 struct DenseArrayAttrUtil<double> {
791 static bool checkElementType(
Type eltType) {
return eltType.
isF64(); }
793 static void printElement(raw_ostream &os,
float value) { os << value; }
794 static ParseResult parseElement(
AsmParser &parser,
double &value) {
800 template <
typename T>
805 template <
typename T>
807 llvm::interleaveComma(asArrayRef(), os, [&](T value) {
808 DenseArrayAttrUtil<T>::printElement(os, value);
812 template <
typename T>
815 printWithoutBraces(os);
820 template <
typename T>
826 if (DenseArrayAttrUtil<T>::parseElement(parser, value))
828 data.push_back(value);
836 template <
typename T>
843 Attribute result = parseWithoutBraces(parser, odsType);
850 template <
typename T>
853 assert((raw.size() %
sizeof(T)) == 0);
854 return ArrayRef<T>(
reinterpret_cast<const T *
>(raw.data()),
855 raw.size() /
sizeof(T));
859 template <
typename T>
863 auto rawArray =
ArrayRef<char>(
reinterpret_cast<const char *
>(content.data()),
864 content.size() *
sizeof(T));
865 return llvm::cast<DenseArrayAttrImpl<T>>(
866 Base::get(context, elementType, content.size(), rawArray));
869 template <
typename T>
871 if (
auto denseArray = llvm::dyn_cast<DenseArrayAttr>(attr))
872 return DenseArrayAttrUtil<T>::checkElementType(denseArray.getElementType());
895 return llvm::isa<DenseIntOrFPElementsAttr, DenseStringElementsAttr>(attr);
902 Type eltType = type.getElementType();
905 if (
auto complexType = llvm::dyn_cast<ComplexType>(eltType)) {
906 if (complexType.getElementType().isIntOrIndex()) {
908 complexValues.reserve(values.size());
910 assert(llvm::isa<ArrayAttr>(attr) &&
"expected ArrayAttr for complex");
911 auto arrayAttr = llvm::cast<ArrayAttr>(attr);
912 assert(arrayAttr.size() == 2 &&
"expected 2 element for complex");
913 auto attr0 = arrayAttr[0];
914 auto attr1 = arrayAttr[1];
915 complexValues.push_back(
916 std::complex<APInt>(llvm::cast<IntegerAttr>(attr0).getValue(),
917 llvm::cast<IntegerAttr>(attr1).getValue()));
923 complexValues.reserve(values.size());
925 assert(llvm::isa<ArrayAttr>(attr) &&
"expected ArrayAttr for complex");
926 auto arrayAttr = llvm::cast<ArrayAttr>(attr);
927 assert(arrayAttr.size() == 2 &&
"expected 2 element for complex");
928 auto attr0 = arrayAttr[0];
929 auto attr1 = arrayAttr[1];
930 complexValues.push_back(
931 std::complex<APFloat>(llvm::cast<FloatAttr>(attr0).getValue(),
932 llvm::cast<FloatAttr>(attr1).getValue()));
941 stringValues.reserve(values.size());
943 assert(llvm::isa<StringAttr>(attr) &&
944 "expected string value for non integer/index/float element");
945 stringValues.push_back(llvm::cast<StringAttr>(attr).getValue());
947 return get(type, stringValues);
958 for (
unsigned i = 0, e = values.size(); i < e; ++i) {
959 if (
auto floatAttr = llvm::dyn_cast<FloatAttr>(values[i])) {
960 assert(floatAttr.getType() == eltType &&
961 "expected float attribute type to equal element type");
962 intVal = floatAttr.getValue().bitcastToAPInt();
964 auto intAttr = llvm::cast<IntegerAttr>(values[i]);
965 assert(intAttr.getType() == eltType &&
966 "expected integer attribute type to equal element type");
967 intVal = intAttr.getValue();
970 assert(intVal.getBitWidth() == bitWidth &&
971 "expected value to have same bitwidth as element type");
972 writeBits(data.data(), i * storageBitWidth, intVal);
976 if (values.size() == 1 && eltType.
isInteger(1))
977 data[0] = data[0] ? -1 : 0;
979 return DenseIntOrFPElementsAttr::getRaw(type, data);
985 assert(type.getElementType().isInteger(1));
989 if (!values.empty()) {
991 bool firstValue = values[0];
992 for (
int i = 0, e = values.size(); i != e; ++i) {
993 isSplat &= values[i] == firstValue;
994 setBit(buff.data(), i, values[i]);
1000 buff[0] = values[0] ? -1 : 0;
1004 return DenseIntOrFPElementsAttr::getRaw(type, buff);
1009 assert(!type.getElementType().isIntOrFloat());
1018 assert(type.getElementType().isIntOrIndex());
1021 return DenseIntOrFPElementsAttr::getRaw(type, storageBitWidth, values);
1024 ArrayRef<std::complex<APInt>> values) {
1025 ComplexType complex = llvm::cast<ComplexType>(type.getElementType());
1026 assert(llvm::isa<IntegerType>(complex.getElementType()));
1029 ArrayRef<APInt> intVals(
reinterpret_cast<const APInt *
>(values.data()),
1031 return DenseIntOrFPElementsAttr::getRaw(type, storageBitWidth, intVals);
1039 assert(llvm::isa<FloatType>(type.getElementType()));
1042 return DenseIntOrFPElementsAttr::getRaw(type, storageBitWidth, values);
1046 ArrayRef<std::complex<APFloat>> values) {
1047 ComplexType complex = llvm::cast<ComplexType>(type.getElementType());
1048 assert(llvm::isa<FloatType>(complex.getElementType()));
1053 return DenseIntOrFPElementsAttr::getRaw(type, storageBitWidth, apVals);
1061 return DenseIntOrFPElementsAttr::getRaw(type, rawBuffer);
1067 bool &detectedSplat) {
1069 size_t rawBufferWidth = rawBuffer.size() * CHAR_BIT;
1070 int64_t numElements = type.getNumElements();
1073 detectedSplat = numElements == 1;
1076 if (storageWidth == 1) {
1079 if (rawBuffer.size() == 1) {
1080 auto rawByte =
static_cast<uint8_t
>(rawBuffer[0]);
1081 if (rawByte == 0 || rawByte == 0xff) {
1082 detectedSplat =
true;
1088 return rawBufferWidth == llvm::alignTo<8>(numElements);
1093 if (rawBufferWidth == storageWidth) {
1094 detectedSplat =
true;
1099 return rawBufferWidth == storageWidth * numElements;
1109 auto dataSize =
static_cast<size_t>(dataEltSize * CHAR_BIT);
1110 if (denseEltBitWidth != dataSize) {
1111 LLVM_DEBUG(llvm::dbgs() <<
"expected dense element bit width "
1112 << denseEltBitWidth <<
" to match data size "
1113 << dataSize <<
" for type " << type <<
"\n");
1119 bool valid = llvm::isa<FloatType>(type);
1121 LLVM_DEBUG(llvm::dbgs()
1122 <<
"expected float type when isInt is false, but found "
1129 auto intType = llvm::dyn_cast<IntegerType>(type);
1131 LLVM_DEBUG(llvm::dbgs()
1132 <<
"expected integer type when isInt is true, but found " << type
1138 if (intType.isSignless())
1141 bool valid = intType.isSigned() == isSigned;
1143 LLVM_DEBUG(llvm::dbgs() <<
"expected signedness " << isSigned
1144 <<
" to match type " << type <<
"\n");
1151 int64_t dataEltSize,
1152 bool isInt,
bool isSigned) {
1153 return DenseIntOrFPElementsAttr::getRawComplex(type, data, dataEltSize, isInt,
1158 int64_t dataEltSize,
1161 return DenseIntOrFPElementsAttr::getRawIntOrFloat(type, data, dataEltSize,
1166 bool isSigned)
const {
1170 bool isSigned)
const {
1173 dataEltSize / 2, isInt, isSigned);
1184 return llvm::isa<IntegerType>(llvm::cast<ComplexType>(type).
getElementType());
1201 const auto &elementSemantics = eltTy.getFloatSemantics();
1212 auto eltTy = llvm::dyn_cast<FloatType>(complexTy.getElementType());
1215 const auto &semantics = eltTy.getFloatSemantics();
1217 getType(), {semantics, {*
this, 0}},
1234 ShapedType curType =
getType();
1235 if (curType == newType)
1238 assert(newType.getElementType() == curType.getElementType() &&
1239 "expected the same element type");
1240 assert(newType.getNumElements() == curType.getNumElements() &&
1241 "expected the same number of elements");
1242 return DenseIntOrFPElementsAttr::getRaw(newType,
getRawData());
1246 assert(
isSplat() &&
"expected a splat type");
1248 ShapedType curType =
getType();
1249 if (curType == newType)
1252 assert(newType.getElementType() == curType.getElementType() &&
1253 "expected the same element type");
1254 return DenseIntOrFPElementsAttr::getRaw(newType,
getRawData());
1262 ShapedType curType =
getType();
1263 Type curElType = curType.getElementType();
1264 if (curElType == newElType)
1269 "expected element types with the same bitwidth");
1270 return DenseIntOrFPElementsAttr::getRaw(curType.clone(newElType),
1277 return llvm::cast<DenseIntElementsAttr>(*this).
mapValues(newElementType,
1283 return llvm::cast<DenseFPElementsAttr>(*this).
mapValues(newElementType,
1292 return getType().getElementType();
1296 return getType().getNumElements();
1304 template <
typename APRangeT>
1306 APRangeT &&values) {
1307 size_t numValues = llvm::size(values);
1310 for (
auto it = values.begin(), e = values.end(); it != e;
1311 ++it, offset += storageWidth) {
1312 assert((*it).getBitWidth() <= storageWidth);
1317 if (numValues == 1 && (*values.begin()).getBitWidth() == 1)
1318 data[0] = data[0] ? -1 : 0;
1325 size_t storageWidth,
1327 std::vector<char> data;
1328 auto unwrapFloat = [](
const APFloat &val) {
return val.bitcastToAPInt(); };
1330 return DenseIntOrFPElementsAttr::getRaw(type, data);
1337 size_t storageWidth,
1339 std::vector<char> data;
1341 return DenseIntOrFPElementsAttr::getRaw(type, data);
1346 assert(type.hasStaticShape() &&
"type must have static shape");
1359 int64_t dataEltSize,
1363 llvm::cast<ComplexType>(type.getElementType()).getElementType(),
1364 dataEltSize / 2, isInt, isSigned) &&
1365 "Try re-running with -debug-only=builtinattributes");
1367 int64_t numElements = data.size() / dataEltSize;
1369 assert(numElements == 1 || numElements == type.getNumElements());
1370 return getRaw(type, data);
1377 DenseIntOrFPElementsAttr::getRawIntOrFloat(ShapedType type,
ArrayRef<char> data,
1378 int64_t dataEltSize,
bool isInt,
1382 "Try re-running with -debug-only=builtinattributes");
1384 int64_t numElements = data.size() / dataEltSize;
1385 assert(numElements == 1 || numElements == type.getNumElements());
1387 return getRaw(type, data);
1390 void DenseIntOrFPElementsAttr::convertEndianOfCharForBEmachine(
1391 const char *inRawData,
char *outRawData,
size_t elementBitWidth,
1392 size_t numElements) {
1393 using llvm::support::ulittle16_t;
1394 using llvm::support::ulittle32_t;
1395 using llvm::support::ulittle64_t;
1397 assert(llvm::endianness::native == llvm::endianness::big);
1401 switch (elementBitWidth) {
1403 const ulittle16_t *inRawDataPos =
1404 reinterpret_cast<const ulittle16_t *
>(inRawData);
1405 uint16_t *outDataPos =
reinterpret_cast<uint16_t *
>(outRawData);
1406 std::copy_n(inRawDataPos, numElements, outDataPos);
1410 const ulittle32_t *inRawDataPos =
1411 reinterpret_cast<const ulittle32_t *
>(inRawData);
1412 uint32_t *outDataPos =
reinterpret_cast<uint32_t *
>(outRawData);
1413 std::copy_n(inRawDataPos, numElements, outDataPos);
1417 const ulittle64_t *inRawDataPos =
1418 reinterpret_cast<const ulittle64_t *
>(inRawData);
1419 uint64_t *outDataPos =
reinterpret_cast<uint64_t *
>(outRawData);
1420 std::copy_n(inRawDataPos, numElements, outDataPos);
1424 size_t nBytes = elementBitWidth / CHAR_BIT;
1425 for (
size_t i = 0; i < nBytes; i++)
1426 std::copy_n(inRawData + (nBytes - 1 - i), 1, outRawData + i);
1432 void DenseIntOrFPElementsAttr::convertEndianOfArrayRefForBEmachine(
1435 size_t numElements = type.getNumElements();
1436 Type elementType = type.getElementType();
1437 if (ComplexType complexTy = llvm::dyn_cast<ComplexType>(elementType)) {
1438 elementType = complexTy.getElementType();
1439 numElements = numElements * 2;
1442 assert(numElements * elementBitWidth == inRawData.size() * CHAR_BIT &&
1443 inRawData.size() <= outRawData.size());
1444 if (elementBitWidth <= CHAR_BIT)
1445 std::memcpy(outRawData.begin(), inRawData.begin(), inRawData.size());
1447 convertEndianOfCharForBEmachine(inRawData.begin(), outRawData.begin(),
1448 elementBitWidth, numElements);
1455 template <
typename Fn,
typename Attr>
1457 Type newElementType,
1462 ShapedType newArrayType = inType.cloneWith(inType.getShape(), newElementType);
1464 size_t numRawElements = attr.isSplat() ? 1 : newArrayType.getNumElements();
1468 auto processElt = [&](decltype(*attr.begin()) value,
size_t index) {
1469 auto newInt = mapping(value);
1470 assert(newInt.getBitWidth() == bitWidth);
1471 writeBits(data.data(), index * storageBitWidth, newInt);
1475 if (attr.isSplat()) {
1476 if (bitWidth == 1) {
1478 data[0] = mapping(*attr.begin()).isZero() ? 0 : -1;
1480 processElt(*attr.begin(), 0);
1482 return newArrayType;
1486 uint64_t elementIdx = 0;
1487 for (
auto value : attr)
1488 processElt(value, elementIdx++);
1489 return newArrayType;
1498 return getRaw(newArrayType, elementData);
1503 if (
auto denseAttr = llvm::dyn_cast<DenseElementsAttr>(attr))
1504 return llvm::isa<FloatType>(denseAttr.getType().getElementType());
1517 return getRaw(newArrayType, elementData);
1522 if (
auto denseAttr = llvm::dyn_cast<DenseElementsAttr>(attr))
1523 return denseAttr.getType().getElementType().isIntOrIndex();
1534 return Base::get(type.getContext(), type, handle);
1544 return get(type, manager.insert(blobName, std::move(blob)));
1553 template <
typename T>
1554 struct DenseResourceAttrUtil;
1555 template <
size_t w
idth,
bool isSigned>
1556 struct DenseResourceElementsAttrIntUtil {
1557 static bool checkElementType(
Type eltType) {
1558 IntegerType type = llvm::dyn_cast<IntegerType>(eltType);
1559 if (!type || type.getWidth() != width)
1561 return isSigned ? !type.isUnsigned() : !type.isSigned();
1565 struct DenseResourceAttrUtil<bool> {
1566 static bool checkElementType(
Type eltType) {
1571 struct DenseResourceAttrUtil<int8_t>
1572 :
public DenseResourceElementsAttrIntUtil<8, true> {};
1574 struct DenseResourceAttrUtil<uint8_t>
1575 :
public DenseResourceElementsAttrIntUtil<8, false> {};
1577 struct DenseResourceAttrUtil<int16_t>
1578 :
public DenseResourceElementsAttrIntUtil<16, true> {};
1580 struct DenseResourceAttrUtil<uint16_t>
1581 :
public DenseResourceElementsAttrIntUtil<16, false> {};
1583 struct DenseResourceAttrUtil<int32_t>
1584 :
public DenseResourceElementsAttrIntUtil<32, true> {};
1586 struct DenseResourceAttrUtil<uint32_t>
1587 :
public DenseResourceElementsAttrIntUtil<32, false> {};
1589 struct DenseResourceAttrUtil<int64_t>
1590 :
public DenseResourceElementsAttrIntUtil<64, true> {};
1592 struct DenseResourceAttrUtil<uint64_t>
1593 :
public DenseResourceElementsAttrIntUtil<64, false> {};
1595 struct DenseResourceAttrUtil<float> {
1596 static bool checkElementType(
Type eltType) {
return eltType.
isF32(); }
1599 struct DenseResourceAttrUtil<double> {
1600 static bool checkElementType(
Type eltType) {
return eltType.
isF64(); }
1604 template <
typename T>
1610 "alignment mismatch between expected alignment and blob alignment");
1611 assert(((blob.
getData().size() %
sizeof(T)) == 0) &&
1612 "size mismatch between expected element width and blob size");
1613 assert(DenseResourceAttrUtil<T>::checkElementType(type.getElementType()) &&
1614 "invalid shape element type for provided type `T`");
1615 return llvm::cast<DenseResourceElementsAttrBase<T>>(
1619 template <
typename T>
1620 std::optional<ArrayRef<T>>
1623 return blob->template getDataAs<T>();
1624 return std::nullopt;
1627 template <
typename T>
1629 auto resourceAttr = llvm::dyn_cast<DenseResourceElementsAttr>(attr);
1630 return resourceAttr && DenseResourceAttrUtil<T>::checkElementType(
1631 resourceAttr.getElementType());
1656 APFloat SparseElementsAttr::getZeroAPFloat()
const {
1658 return APFloat(eltType.getFloatSemantics());
1662 APInt SparseElementsAttr::getZeroAPInt()
const {
1668 Attribute SparseElementsAttr::getZeroAttr()
const {
1672 if (llvm::isa<FloatType>(eltType))
1676 if (
auto complexTy = llvm::dyn_cast<ComplexType>(eltType)) {
1677 auto eltType = complexTy.getElementType();
1679 if (llvm::isa<FloatType>(eltType))
1688 if (llvm::isa<DenseStringElementsAttr>(
getValues()))
1697 std::vector<ptrdiff_t> SparseElementsAttr::getFlattenedSparseIndices()
const {
1698 std::vector<ptrdiff_t> flatSparseIndices;
1703 auto sparseIndexValues = sparseIndices.getValues<uint64_t>();
1704 if (sparseIndices.isSplat()) {
1706 *sparseIndexValues.begin());
1707 flatSparseIndices.push_back(getFlattenedIndex(indices));
1708 return flatSparseIndices;
1712 auto numSparseIndices = sparseIndices.getType().getDimSize(0);
1713 size_t rank =
getType().getRank();
1714 for (
size_t i = 0, e = numSparseIndices; i != e; ++i)
1715 flatSparseIndices.push_back(getFlattenedIndex(
1716 {&*std::next(sparseIndexValues.begin(), i * rank), rank}));
1717 return flatSparseIndices;
1724 ShapedType valuesType = values.
getType();
1725 if (valuesType.getRank() != 1)
1726 return emitError() <<
"expected 1-d tensor for sparse element values";
1729 ShapedType indicesType = sparseIndices.getType();
1730 auto emitShapeError = [&]() {
1731 return emitError() <<
"expected shape ([" << type.getShape()
1732 <<
"]); inferred shape of indices literal (["
1733 << indicesType.getShape()
1734 <<
"]); inferred shape of values literal (["
1735 << valuesType.getShape() <<
"])";
1738 size_t rank = type.getRank(), indicesRank = indicesType.getRank();
1739 if (indicesRank == 2) {
1740 if (indicesType.getDimSize(1) !=
static_cast<int64_t
>(rank))
1741 return emitShapeError();
1742 }
else if (indicesRank != 1 || rank != 1) {
1743 return emitShapeError();
1746 int64_t numSparseIndices = indicesType.getDimSize(0);
1747 if (numSparseIndices != valuesType.getDimSize(0))
1748 return emitShapeError();
1753 <<
"sparse index #" << indexNum
1754 <<
" is not contained within the value shape, with index=[" << index
1755 <<
"], and type=" << type;
1759 auto sparseIndexValues = sparseIndices.getValues<uint64_t>();
1760 if (sparseIndices.isSplat()) {
1762 if (!ElementsAttr::isValidIndex(type, indices))
1763 return emitIndexError(0, indices);
1768 for (
size_t i = 0, e = numSparseIndices; i != e; ++i) {
1771 if (!ElementsAttr::isValidIndex(type, index))
1772 return emitIndexError(i, index);
1787 return getImpl()->referencedAttr;
1798 unsigned nSymbols = 0;
1802 if (!ShapedType::isDynamic(offset)) {
1813 auto dim = en.index();
1814 auto stride = en.value();
1818 if (!ShapedType::isDynamic(stride))
1823 expr = expr + d * mult;
static Value getZero(OpBuilder &b, Location loc, Type elementType)
Get zero value for an element type.
static void writeAPIntsToBuffer(size_t storageWidth, std::vector< char > &data, APRangeT &&values)
Utility method to write a range of APInt values to a buffer.
static bool isValidIntOrFloat(Type type, int64_t dataEltSize, bool isInt, bool isSigned)
Check the information for a C++ data type, check if this type is valid for the current attribute.
static void copyAPIntToArrayForBEmachine(APInt value, size_t numBytes, char *result)
Copy actual numBytes data from value (APInt) to char array(result) for BE format.
static ShapedType mappingHelper(Fn mapping, Attr &attr, ShapedType inType, Type newElementType, llvm::SmallVectorImpl< char > &data)
static void setBit(char *rawData, size_t bitPos, bool value)
Set a bit to a specific value.
static void writeBits(char *rawData, size_t bitPos, APInt value)
Writes value to the bit position bitPos in array rawData.
static bool dictionaryAttrSort(ArrayRef< NamedAttribute > value, SmallVectorImpl< NamedAttribute > &storage)
Helper function that does either an in place sort or sorts from source array into destination.
static size_t getDenseElementStorageWidth(size_t origWidth)
Get the bitwidth of a dense element type within the buffer.
static void copyArrayToAPIntForBEmachine(const char *inArray, size_t numBytes, APInt &result)
Copy numBytes data from inArray(char array) to result(APINT) for BE format.
static bool getBit(const char *rawData, size_t bitPos)
Return the value of the specified bit.
static bool isComplexOfIntType(Type type)
Return if the given complex type has an integer element type.
static std::optional< NamedAttribute > findDuplicateElement(ArrayRef< NamedAttribute > value)
Returns an entry with a duplicate name from the given sorted array of named attributes.
static bool hasSameElementsOrSplat(ShapedType type, const Values &values)
Returns true if 'values' corresponds to a splat, i.e.
static APInt readBits(const char *rawData, size_t bitPos, size_t bitWidth)
Reads the next bitWidth bits from the bit position bitPos in array rawData.
static MLIRContext * getContext(OpFoldResult val)
static bool contains(SMRange range, SMLoc loc)
Returns true if the given range contains the given source location.
static DimensionSize operator*(DimensionSize lhs, DimensionSize rhs)
static void print(spirv::VerCapExtAttr triple, DialectAsmPrinter &printer)
static Type getElementType(Type type, ArrayRef< int32_t > indices, function_ref< InFlightDiagnostic(StringRef)> emitErrorFn)
Walks the given type hierarchy with the given indices, potentially down to component granularity,...
Base type for affine expression.
A multi-dimensional affine map Affine map's are immutable like Type's, and they are uniqued.
static AffineMap get(MLIRContext *context)
Returns a zero result affine map with no dimensions or symbols: () -> ().
This base class exposes generic asm parser hooks, usable across the various derived parsers.
virtual ParseResult parseCommaSeparatedList(Delimiter delimiter, function_ref< ParseResult()> parseElementFn, StringRef contextMessage=StringRef())=0
Parse a list of comma-separated items with an optional delimiter.
MLIRContext * getContext() const
virtual ParseResult parseLSquare()=0
Parse a [ token.
virtual ParseResult parseRSquare()=0
Parse a ] token.
ParseResult parseInteger(IntT &result)
Parse an integer value from the stream.
virtual ParseResult parseOptionalRSquare()=0
Parse a ] token if present.
virtual ParseResult parseFloat(double &result)=0
Parse a floating point value from the stream.
This base class exposes generic asm printer hooks, usable across the various derived printers.
virtual raw_ostream & getStream() const
Return the raw output stream used by this printer.
This class represents a processed binary blob of data.
size_t getDataAlignment() const
Return the alignment of the underlying data.
ArrayRef< char > getData() const
Return the raw underlying data of this blob.
Attributes are known-constant values of operations.
void print(raw_ostream &os, bool elideType=false) const
Print the attribute.
MLIRContext * getContext() const
Return the context this attribute belongs to.
ImplType * getImpl() const
Return the internal Attribute implementation.
static Attribute getFromOpaquePointer(const void *ptr)
Construct an attribute from the opaque pointer representation.
Special case of IntegerAttr to represent boolean integers, i.e., signless i1 integers.
static bool classof(Attribute attr)
Methods for support type inquiry through isa, cast, and dyn_cast.
bool getValue() const
Return the boolean value of this attribute.
A utility iterator that allows walking over the internal bool values.
bool operator*() const
Accesses the bool value at this iterator position.
Iterator for walking over complex APFloat values.
A utility iterator that allows walking over the internal raw complex APInt values.
std::complex< APInt > operator*() const
Accesses the raw std::complex<APInt> value at this iterator position.
Iterator for walking over APFloat values.
A utility iterator that allows walking over the internal raw APInt values.
APInt operator*() const
Accesses the raw APInt value at this iterator position.
An attribute that represents a reference to a dense vector or tensor object.
ArrayRef< StringRef > getRawStringData() const
Return the raw StringRef data held by this attribute.
IntElementIterator raw_int_begin() const
Iterators to various elements that require out-of-line definition.
static DenseElementsAttr getRawIntOrFloat(ShapedType type, ArrayRef< char > data, int64_t dataEltSize, bool isInt, bool isSigned)
Overload of the raw 'get' method that asserts that the given type is of integer or floating-point typ...
static DenseElementsAttr getRawComplex(ShapedType type, ArrayRef< char > data, int64_t dataEltSize, bool isInt, bool isSigned)
Overload of the raw 'get' method that asserts that the given type is of complex type.
static bool classof(Attribute attr)
Method for support type inquiry through isa, cast and dyn_cast.
bool isValidComplex(int64_t dataEltSize, bool isInt, bool isSigned) const
auto getValues() const
Return the held element values as a range of the given type.
DenseElementsAttr resizeSplat(ShapedType newType)
Return a new DenseElementsAttr that has the same data as the current attribute, but with a different ...
int64_t getNumElements() const
Returns the number of elements held by this attribute.
static DenseElementsAttr getFromRawBuffer(ShapedType type, ArrayRef< char > rawBuffer)
Construct a dense elements attribute from a raw buffer representing the data for this attribute.
int64_t size() const
Returns the number of elements held by this attribute.
bool isSplat() const
Returns true if this attribute corresponds to a splat, i.e.
ArrayRef< char > getRawData() const
Return the raw storage data held by this attribute.
DenseElementsAttr mapValues(Type newElementType, function_ref< APInt(const APInt &)> mapping) const
Generates a new DenseElementsAttr by mapping each int value to a new underlying APInt.
Type getElementType() const
Return the element type of this DenseElementsAttr.
FailureOr< iterator_range_impl< ComplexFloatElementIterator > > tryGetComplexFloatValues() const
IntElementIterator raw_int_end() const
static DenseElementsAttr get(ShapedType type, ArrayRef< Attribute > values)
Constructs a dense elements attribute from an array of element values.
ShapedType getType() const
Return the type of this ElementsAttr, guaranteed to be a vector or tensor with static shape.
FailureOr< iterator_range_impl< FloatElementIterator > > tryGetFloatValues() const
static bool isValidRawBuffer(ShapedType type, ArrayRef< char > rawBuffer, bool &detectedSplat)
Returns true if the given buffer is a valid raw buffer for the given type.
DenseElementsAttr bitcast(Type newElType)
Return a new DenseElementsAttr that has the same data as the current attribute, but has bitcast eleme...
bool isValidIntOrFloat(int64_t dataEltSize, bool isInt, bool isSigned) const
DenseElementsAttr reshape(ShapedType newType)
Return a new DenseElementsAttr that has the same data as the current attribute, but has been reshaped...
FailureOr< iterator_range_impl< ComplexIntElementIterator > > tryGetComplexIntValues() const
static bool classof(Attribute attr)
Method for supporting type inquiry through isa, cast and dyn_cast.
DenseElementsAttr mapValues(Type newElementType, function_ref< APInt(const APFloat &)> mapping) const
Generates a new DenseElementsAttr by mapping each value attribute, and constructing the DenseElements...
An attribute that represents a reference to a dense integer vector or tensor object.
static bool classof(Attribute attr)
Method for supporting type inquiry through isa, cast and dyn_cast.
DenseElementsAttr mapValues(Type newElementType, function_ref< APInt(const APInt &)> mapping) const
Generates a new DenseElementsAttr by mapping each value attribute, and constructing the DenseElements...
Dialects are groups of MLIR operations, types and attributes, as well as behavior associated with the...
static bool isValidNamespace(StringRef str)
Utility function that returns if the given string is a valid dialect namespace.
An attribute that associates a referenced attribute with a unique identifier.
static DistinctAttr create(Attribute referencedAttr)
Creates a distinct attribute that associates a referenced attribute with a unique identifier.
Attribute getReferencedAttr() const
Returns the referenced attribute.
A symbol reference with a reference path containing a single element.
This class represents a diagnostic that is inflight and set to be reported.
MLIRContext is the top-level object for a collection of MLIR operations.
Dialect * getLoadedDialect(StringRef name)
Get a registered IR dialect with the given namespace.
bool allowsUnregisteredDialects()
Return true if we allow to create operation for unregistered dialects.
NamedAttribute represents a combination of a name and an Attribute value.
Operation is the basic unit of execution within MLIR.
AttrClass getAttrOfType(StringAttr name)
static StringRef getSymbolAttrName()
Return the name of the attribute used for symbol names.
Instances of the Type class are uniqued, have an immutable identifier and an optional mutable compone...
MLIRContext * getContext() const
Return the MLIRContext in which this type was uniqued.
bool isSignlessInteger() const
Return true if this is a signless integer type (with the specified width).
bool isIntOrIndexOrFloat() const
Return true if this is an integer (of any signedness), index, or float type.
bool isInteger() const
Return true if this is an integer type (with the specified width).
unsigned getIntOrFloatBitWidth() const
Return the bit width of an integer or a float type, assert failure on other types.
Base class for DenseArrayAttr that is instantiated and specialized for each supported element type be...
Impl iterator for indexed DenseElementsAttr iterators that records a data pointer and data index that...
Base class for DenseResourceElementsAttr that is instantiated and specialized for each supported elem...
This class provides iterator utilities for an ElementsAttr range.
The OpAsmOpInterface, see OpAsmInterface.td for more details.
constexpr void enumerate(std::tuple< Tys... > &tuple, CallbackT &&callback)
size_t getDenseElementBitWidth(Type eltType)
Return the bit width which DenseElementsAttr should use for this type.
llvm::TypeSize divideCeil(llvm::TypeSize numerator, uint64_t denominator)
Divides the known min value of the numerator by the denominator and rounds the result up to the next ...
std::pair< IteratorT, bool > findAttrSorted(IteratorT first, IteratorT last, StringRef name)
Using llvm::lower_bound requires an extra string comparison to check whether the returned iterator po...
Operation::operand_range getIndices(Operation *op)
Get the indices that the given load/store operation is operating on.
QueryRef parse(llvm::StringRef line, const QuerySession &qs)
Include the generated interface declarations.
Type getType(OpFoldResult ofr)
Returns the int type of the integer in ofr.
InFlightDiagnostic emitError(Location loc)
Utility method to emit an error message using this location.
AffineMap makeStridedLinearLayoutMap(ArrayRef< int64_t > strides, int64_t offset, MLIRContext *context)
Given a list of strides (in which ShapedType::kDynamic represents a dynamic value),...
AffineExpr getAffineConstantExpr(int64_t constant, MLIRContext *context)
auto get(MLIRContext *context, Ts &&...params)
Helper method that injects context only if needed, this helps unify some of the attribute constructio...
AffineExpr getAffineDimExpr(unsigned position, MLIRContext *context)
These free functions allow clients of the API to not use classes in detail.
LogicalResult verify(Operation *op, bool verifyRecursively=true)
Perform (potentially expensive) checks of invariants, used to detect compiler bugs,...
AffineExpr getAffineSymbolExpr(unsigned position, MLIRContext *context)
This class defines a dialect specific handle to a resource blob.
static ManagerInterface & getManagerInterface(MLIRContext *ctx)
Get the interface for the dialect that owns handles of this type.
An attribute representing a reference to a dense vector or tensor object.
An attribute representing a reference to a dense vector or tensor object.
static const char kSplatTrue
The values used to denote a boolean splat value.
static const char kSplatFalse
An attribute representing a reference to a dense vector or tensor object containing strings.