text: //===- BuiltinAttributes.cpp - MLIR Builtin Attribute Classes -------------===//
  //
  // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  // See https://llvm.org/LICENSE.txt for license information.
  // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  //
  //===----------------------------------------------------------------------===//
  
  #include "mlir/IR/BuiltinAttributes.h"
  #include "AttributeDetail.h"
  #include "mlir/IR/AffineMap.h"
  #include "mlir/IR/BuiltinDialect.h"
  #include "mlir/IR/Dialect.h"
  #include "mlir/IR/IntegerSet.h"
  #include "mlir/IR/Operation.h"
  #include "mlir/IR/SymbolTable.h"
  #include "mlir/IR/Types.h"
  #include "mlir/Interfaces/DecodeAttributesInterfaces.h"
  #include "llvm/ADT/APSInt.h"
  #include "llvm/ADT/Sequence.h"
  #include "llvm/Support/Endian.h"
  
  using namespace mlir;
  using namespace mlir::detail;
  
  //===----------------------------------------------------------------------===//
  /// Tablegen Attribute Definitions
  //===----------------------------------------------------------------------===//
  
  #define GET_ATTRDEF_CLASSES
  #include "mlir/IR/BuiltinAttributes.cpp.inc"
  
  //===----------------------------------------------------------------------===//
  // BuiltinDialect
  //===----------------------------------------------------------------------===//
  
  void BuiltinDialect::registerAttributes() {
    addAttributes<AffineMapAttr, ArrayAttr, DenseIntOrFPElementsAttr,
                  DenseStringElementsAttr, DictionaryAttr, FloatAttr,
                  SymbolRefAttr, IntegerAttr, IntegerSetAttr, OpaqueAttr,
                  OpaqueElementsAttr, SparseElementsAttr, StringAttr, TypeAttr,
                  UnitAttr>();
  }
  
  //===----------------------------------------------------------------------===//
  // ArrayAttr
  //===----------------------------------------------------------------------===//
  
  void ArrayAttr::walkImmediateSubElements(
      function_ref<void(Attribute)> walkAttrsFn,
      function_ref<void(Type)> walkTypesFn) const {
    for (Attribute attr : getValue())
      walkAttrsFn(attr);
  }
  
  SubElementAttrInterface ArrayAttr::replaceImmediateSubAttribute(
      ArrayRef<std::pair<size_t, Attribute>> replacements) const {
    std::vector<Attribute> vector = getValue().vec();
    for (auto &it : replacements) {
      vector[it.first] = it.second;
    }
    return get(getContext(), vector);
  }
  
  //===----------------------------------------------------------------------===//
  // DictionaryAttr
  //===----------------------------------------------------------------------===//
  
  /// Helper function that does either an in place sort or sorts from source array
  /// into destination. If inPlace then storage is both the source and the
  /// destination, else value is the source and storage destination. Returns
  /// whether source was sorted.
  template <bool inPlace>
  static bool dictionaryAttrSort(ArrayRef<NamedAttribute> value,
                                 SmallVectorImpl<NamedAttribute> &storage) {
    // Specialize for the common case.
    switch (value.size()) {
    case 0:
      // Zero already sorted.
      if (!inPlace)
        storage.clear();
      break;
    case 1:
      // One already sorted but may need to be copied.
      if (!inPlace)
        storage.assign({value[0]});
      break;
    case 2: {
      bool isSorted = value[0] < value[1];
      if (inPlace) {
        if (!isSorted)
          std::swap(storage[0], storage[1]);
      } else if (isSorted) {
        storage.assign({value[0], value[1]});
      } else {
        storage.assign({value[1], value[0]});
      }
      return !isSorted;
    }
    default:
      if (!inPlace)
        storage.assign(value.begin(), value.end());
      // Check to see they are sorted already.
      bool isSorted = llvm::is_sorted(value);
      // If not, do a general sort.
      if (!isSorted)
        llvm::array_pod_sort(storage.begin(), storage.end());
      return !isSorted;
    }
    return false;
  }
  
  /// Returns an entry with a duplicate name from the given sorted array of named
  /// attributes. Returns llvm::None if all elements have unique names.
  static Optional<NamedAttribute>
  findDuplicateElement(ArrayRef<NamedAttribute> value) {
    const Optional<NamedAttribute> none{llvm::None};
    if (value.size() < 2)
      return none;
  
    if (value.size() == 2)
      return value[0].first == value[1].first ? value[0] : none;
  
    auto it = std::adjacent_find(
        value.begin(), value.end(),
        [](NamedAttribute l, NamedAttribute r) { return l.first == r.first; });
    return it != value.end() ? *it : none;
  }
  
  bool DictionaryAttr::sort(ArrayRef<NamedAttribute> value,
                            SmallVectorImpl<NamedAttribute> &storage) {
    bool isSorted = dictionaryAttrSort</*inPlace=*/false>(value, storage);
    assert(!findDuplicateElement(storage) &&
           "DictionaryAttr element names must be unique");
    return isSorted;
  }
  
  bool DictionaryAttr::sortInPlace(SmallVectorImpl<NamedAttribute> &array) {
    bool isSorted = dictionaryAttrSort</*inPlace=*/true>(array, array);
    assert(!findDuplicateElement(array) &&
           "DictionaryAttr element names must be unique");
    return isSorted;
  }
  
  Optional<NamedAttribute>
  DictionaryAttr::findDuplicate(SmallVectorImpl<NamedAttribute> &array,
                                bool isSorted) {
    if (!isSorted)
      dictionaryAttrSort</*inPlace=*/true>(array, array);
    return findDuplicateElement(array);
  }
  
  DictionaryAttr DictionaryAttr::get(MLIRContext *context,
                                     ArrayRef<NamedAttribute> value) {
    if (value.empty())
      return DictionaryAttr::getEmpty(context);
    assert(llvm::all_of(value,
                        [](const NamedAttribute &attr) { return attr.second; }) &&
           "value cannot have null entries");
  
    // We need to sort the element list to canonicalize it.
    SmallVector<NamedAttribute, 8> storage;
    if (dictionaryAttrSort</*inPlace=*/false>(value, storage))
      value = storage;
    assert(!findDuplicateElement(value) &&
           "DictionaryAttr element names must be unique");
    return Base::get(context, value);
  }
  /// Construct a dictionary with an array of values that is known to already be
  /// sorted by name and uniqued.
  DictionaryAttr DictionaryAttr::getWithSorted(MLIRContext *context,
                                               ArrayRef<NamedAttribute> value) {
    if (value.empty())
      return DictionaryAttr::getEmpty(context);
    // Ensure that the attribute elements are unique and sorted.
    assert(llvm::is_sorted(value,
                           [](NamedAttribute l, NamedAttribute r) {
                             return l.first.strref() < r.first.strref();
                           }) &&
           "expected attribute values to be sorted");
    assert(!findDuplicateElement(value) &&
           "DictionaryAttr element names must be unique");
    return Base::get(context, value);
  }
  
  /// Return the specified attribute if present, null otherwise.
  Attribute DictionaryAttr::get(StringRef name) const {
    auto it = impl::findAttrSorted(begin(), end(), name);
    return it.second ? it.first->second : Attribute();
  }
  Attribute DictionaryAttr::get(StringAttr name) const {
    auto it = impl::findAttrSorted(begin(), end(), name);
    return it.second ? it.first->second : Attribute();
  }
  
  /// Return the specified named attribute if present, None otherwise.
  Optional<NamedAttribute> DictionaryAttr::getNamed(StringRef name) const {
    auto it = impl::findAttrSorted(begin(), end(), name);
    return it.second ? *it.first : Optional<NamedAttribute>();
  }
  Optional<NamedAttribute> DictionaryAttr::getNamed(StringAttr name) const {
    auto it = impl::findAttrSorted(begin(), end(), name);
    return it.second ? *it.first : Optional<NamedAttribute>();
  }
  
  /// Return whether the specified attribute is present.
  bool DictionaryAttr::contains(StringRef name) const {
    return impl::findAttrSorted(begin(), end(), name).second;
  }
  bool DictionaryAttr::contains(StringAttr name) const {
    return impl::findAttrSorted(begin(), end(), name).second;
  }
  
  DictionaryAttr::iterator DictionaryAttr::begin() const {
    return getValue().begin();
  }
  DictionaryAttr::iterator DictionaryAttr::end() const {
    return getValue().end();
  }
  size_t DictionaryAttr::size() const { return getValue().size(); }
  
  DictionaryAttr DictionaryAttr::getEmptyUnchecked(MLIRContext *context) {
    return Base::get(context, ArrayRef<NamedAttribute>());
  }
  
  void DictionaryAttr::walkImmediateSubElements(
      function_ref<void(Attribute)> walkAttrsFn,
      function_ref<void(Type)> walkTypesFn) const {
    for (Attribute attr : llvm::make_second_range(getValue()))
      walkAttrsFn(attr);
  }
  
  SubElementAttrInterface DictionaryAttr::replaceImmediateSubAttribute(
      ArrayRef<std::pair<size_t, Attribute>> replacements) const {
    std::vector<NamedAttribute> vec = getValue().vec();
    for (auto &it : replacements) {
      vec[it.first].second = it.second;
    }
    // The above only modifies the mapped value, but not the key, and therefore
    // not the order of the elements. It remains sorted
    return getWithSorted(getContext(), vec);
  }
  
  //===----------------------------------------------------------------------===//
  // StringAttr
  //===----------------------------------------------------------------------===//
  
  StringAttr StringAttr::getEmptyStringAttrUnchecked(MLIRContext *context) {
    return Base::get(context, "", NoneType::get(context));
  }
  
  /// Twine support for StringAttr.
  StringAttr StringAttr::get(MLIRContext *context, const Twine &twine) {
    // Fast-path empty twine.
    if (twine.isTriviallyEmpty())
      return get(context);
    SmallVector<char, 32> tempStr;
    return Base::get(context, twine.toStringRef(tempStr), NoneType::get(context));
  }
  
  /// Twine support for StringAttr.
  StringAttr StringAttr::get(const Twine &twine, Type type) {
    SmallVector<char, 32> tempStr;
    return Base::get(type.getContext(), twine.toStringRef(tempStr), type);
  }
  
  StringRef StringAttr::getValue() const { return getImpl()->value; }
  
  Dialect *StringAttr::getReferencedDialect() const {
    return getImpl()->referencedDialect;
  }
  
  //===----------------------------------------------------------------------===//
  // FloatAttr
  //===----------------------------------------------------------------------===//
  
  double FloatAttr::getValueAsDouble() const {
    return getValueAsDouble(getValue());
  }
  double FloatAttr::getValueAsDouble(APFloat value) {
    if (&value.getSemantics() != &APFloat::IEEEdouble()) {
      bool losesInfo = false;
      value.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
                    &losesInfo);
    }
    return value.convertToDouble();
  }
  
  LogicalResult FloatAttr::verify(function_ref<InFlightDiagnostic()> emitError,
                                  Type type, APFloat value) {
    // Verify that the type is correct.
    if (!type.isa<FloatType>())
      return emitError() << "expected floating point type";
  
    // Verify that the type semantics match that of the value.
    if (&type.cast<FloatType>().getFloatSemantics() != &value.getSemantics()) {
      return emitError()
             << "FloatAttr type doesn't match the type implied by its value";
    }
    return success();
  }
  
  //===----------------------------------------------------------------------===//
  // SymbolRefAttr
  //===----------------------------------------------------------------------===//
  
  SymbolRefAttr SymbolRefAttr::get(MLIRContext *ctx, StringRef value,
                                   ArrayRef<FlatSymbolRefAttr> nestedRefs) {
    return get(StringAttr::get(ctx, value), nestedRefs);
  }
  
  FlatSymbolRefAttr SymbolRefAttr::get(MLIRContext *ctx, StringRef value) {
    return get(ctx, value, {}).cast<FlatSymbolRefAttr>();
  }
  
  FlatSymbolRefAttr SymbolRefAttr::get(StringAttr value) {
    return get(value, {}).cast<FlatSymbolRefAttr>();
  }
  
  FlatSymbolRefAttr SymbolRefAttr::get(Operation *symbol) {
    auto symName =
        symbol->getAttrOfType<StringAttr>(SymbolTable::getSymbolAttrName());
    assert(symName && "value does not have a valid symbol name");
    return SymbolRefAttr::get(symName);
  }
  
  StringAttr SymbolRefAttr::getLeafReference() const {
    ArrayRef<FlatSymbolRefAttr> nestedRefs = getNestedReferences();
    return nestedRefs.empty() ? getRootReference() : nestedRefs.back().getAttr();
  }
  
  //===----------------------------------------------------------------------===//
  // IntegerAttr
  //===----------------------------------------------------------------------===//
  
  int64_t IntegerAttr::getInt() const {
    assert((getType().isIndex() || getType().isSignlessInteger()) &&
           "must be signless integer");
    return getValue().getSExtValue();
  }
  
  int64_t IntegerAttr::getSInt() const {
    assert(getType().isSignedInteger() && "must be signed integer");
    return getValue().getSExtValue();
  }
  
  uint64_t IntegerAttr::getUInt() const {
    assert(getType().isUnsignedInteger() && "must be unsigned integer");
    return getValue().getZExtValue();
  }
  
  /// Return the value as an APSInt which carries the signed from the type of
  /// the attribute.  This traps on signless integers types!
  APSInt IntegerAttr::getAPSInt() const {
    assert(!getType().isSignlessInteger() &&
           "Signless integers don't carry a sign for APSInt");
    return APSInt(getValue(), getType().isUnsignedInteger());
  }
  
  LogicalResult IntegerAttr::verify(function_ref<InFlightDiagnostic()> emitError,
                                    Type type, APInt value) {
    if (IntegerType integerType = type.dyn_cast<IntegerType>()) {
      if (integerType.getWidth() != value.getBitWidth())
        return emitError() << "integer type bit width (" << integerType.getWidth()
                           << ") doesn't match value bit width ("
                           << value.getBitWidth() << ")";
      return success();
    }
    if (type.isa<IndexType>())
      return success();
    return emitError() << "expected integer or index type";
  }
  
  BoolAttr IntegerAttr::getBoolAttrUnchecked(IntegerType type, bool value) {
    auto attr = Base::get(type.getContext(), type, APInt(/*numBits=*/1, value));
    return attr.cast<BoolAttr>();
  }
  
  //===----------------------------------------------------------------------===//
  // BoolAttr
  
  bool BoolAttr::getValue() const {
    auto *storage = reinterpret_cast<IntegerAttrStorage *>(impl);
    return storage->value.getBoolValue();
  }
  
  bool BoolAttr::classof(Attribute attr) {
    IntegerAttr intAttr = attr.dyn_cast<IntegerAttr>();
    return intAttr && intAttr.getType().isSignlessInteger(1);
  }
  
  //===----------------------------------------------------------------------===//
  // OpaqueAttr
  //===----------------------------------------------------------------------===//
  
  LogicalResult OpaqueAttr::verify(function_ref<InFlightDiagnostic()> emitError,
                                   StringAttr dialect, StringRef attrData,
                                   Type type) {
    if (!Dialect::isValidNamespace(dialect.strref()))
      return emitError() << "invalid dialect namespace '" << dialect << "'";
  
    // Check that the dialect is actually registered.
    MLIRContext *context = dialect.getContext();
    if (!context->allowsUnregisteredDialects() &&
        !context->getLoadedDialect(dialect.strref())) {
      return emitError()
             << "#" << dialect << "<\"" << attrData << "\"> : " << type
             << " attribute created with unregistered dialect. If this is "
                "intended, please call allowUnregisteredDialects() on the "
                "MLIRContext, or use -allow-unregistered-dialect with "
                "the MLIR opt tool used";
    }
  
    return success();
  }
  
  //===----------------------------------------------------------------------===//
  // DenseElementsAttr Utilities
  //===----------------------------------------------------------------------===//
  
  /// Get the bitwidth of a dense element type within the buffer.
  /// DenseElementsAttr requires bitwidths greater than 1 to be aligned by 8.
  static size_t getDenseElementStorageWidth(size_t origWidth) {
    return origWidth == 1 ? origWidth : llvm::alignTo<8>(origWidth);
  }
  static size_t getDenseElementStorageWidth(Type elementType) {
    return getDenseElementStorageWidth(getDenseElementBitWidth(elementType));
  }
  
  /// Set a bit to a specific value.
  static void setBit(char *rawData, size_t bitPos, bool value) {
    if (value)
      rawData[bitPos / CHAR_BIT] |= (1 << (bitPos % CHAR_BIT));
    else
      rawData[bitPos / CHAR_BIT] &= ~(1 << (bitPos % CHAR_BIT));
  }
  
  /// Return the value of the specified bit.
  static bool getBit(const char *rawData, size_t bitPos) {
    return (rawData[bitPos / CHAR_BIT] & (1 << (bitPos % CHAR_BIT))) != 0;
  }
  
  /// Copy actual `numBytes` data from `value` (APInt) to char array(`result`) for
  /// BE format.
  static void copyAPIntToArrayForBEmachine(APInt value, size_t numBytes,
                                           char *result) {
    assert(llvm::support::endian::system_endianness() == // NOLINT
           llvm::support::endianness::big);              // NOLINT
    assert(value.getNumWords() * APInt::APINT_WORD_SIZE >= numBytes);
  
    // Copy the words filled with data.
    // For example, when `value` has 2 words, the first word is filled with data.
    // `value` (10 bytes, BE):|abcdefgh|------ij| ==> `result` (BE):|abcdefgh|--|
    size_t numFilledWords = (value.getNumWords() - 1) * APInt::APINT_WORD_SIZE;
    std::copy_n(reinterpret_cast<const char *>(value.getRawData()),
                numFilledWords, result);
    // Convert last word of APInt to LE format and store it in char
    // array(`valueLE`).
    // ex. last word of `value` (BE): |------ij|  ==> `valueLE` (LE): |ji------|
    size_t lastWordPos = numFilledWords;
    SmallVector<char, 8> valueLE(APInt::APINT_WORD_SIZE);
    DenseIntOrFPElementsAttr::convertEndianOfCharForBEmachine(
        reinterpret_cast<const char *>(value.getRawData()) + lastWordPos,
        valueLE.begin(), APInt::APINT_BITS_PER_WORD, 1);
    // Extract actual APInt data from `valueLE`, convert endianness to BE format,
    // and store it in `result`.
    // ex. `valueLE` (LE): |ji------|  ==> `result` (BE): |abcdefgh|ij|
    DenseIntOrFPElementsAttr::convertEndianOfCharForBEmachine(
        valueLE.begin(), result + lastWordPos,
        (numBytes - lastWordPos) * CHAR_BIT, 1);
  }
  
  /// Copy `numBytes` data from `inArray`(char array) to `result`(APINT) for BE
  /// format.
  static void copyArrayToAPIntForBEmachine(const char *inArray, size_t numBytes,
                                           APInt &result) {
    assert(llvm::support::endian::system_endianness() == // NOLINT
           llvm::support::endianness::big);              // NOLINT
    assert(result.getNumWords() * APInt::APINT_WORD_SIZE >= numBytes);
  
    // Copy the data that fills the word of `result` from `inArray`.
    // For example, when `result` has 2 words, the first word will be filled with
    // data. So, the first 8 bytes are copied from `inArray` here.
    // `inArray` (10 bytes, BE): |abcdefgh|ij|
    //                     ==> `result` (2 words, BE): |abcdefgh|--------|
    size_t numFilledWords = (result.getNumWords() - 1) * APInt::APINT_WORD_SIZE;
    std::copy_n(
        inArray, numFilledWords,
        const_cast<char *>(reinterpret_cast<const char *>(result.getRawData())));
  
    // Convert array data which will be last word of `result` to LE format, and
    // store it in char array(`inArrayLE`).
    // ex. `inArray` (last two bytes, BE): |ij|  ==> `inArrayLE` (LE): |ji------|
    size_t lastWordPos = numFilledWords;
    SmallVector<char, 8> inArrayLE(APInt::APINT_WORD_SIZE);
    DenseIntOrFPElementsAttr::convertEndianOfCharForBEmachine(
        inArray + lastWordPos, inArrayLE.begin(),
        (numBytes - lastWordPos) * CHAR_BIT, 1);
  
    // Convert `inArrayLE` to BE format, and store it in last word of `result`.
    // ex. `inArrayLE` (LE): |ji------|  ==> `result` (BE): |abcdefgh|------ij|
    DenseIntOrFPElementsAttr::convertEndianOfCharForBEmachine(
        inArrayLE.begin(),
        const_cast<char *>(reinterpret_cast<const char *>(result.getRawData())) +
            lastWordPos,
        APInt::APINT_BITS_PER_WORD, 1);
  }
  
  /// Writes value to the bit position `bitPos` in array `rawData`.
  static void writeBits(char *rawData, size_t bitPos, APInt value) {
    size_t bitWidth = value.getBitWidth();
  
    // If the bitwidth is 1 we just toggle the specific bit.
    if (bitWidth == 1)
      return setBit(rawData, bitPos, value.isOneValue());
  
    // Otherwise, the bit position is guaranteed to be byte aligned.
    assert((bitPos % CHAR_BIT) == 0 && "expected bitPos to be 8-bit aligned");
    if (llvm::support::endian::system_endianness() ==
        llvm::support::endianness::big) {
      // Copy from `value` to `rawData + (bitPos / CHAR_BIT)`.
      // Copying the first `llvm::divideCeil(bitWidth, CHAR_BIT)` bytes doesn't
      // work correctly in BE format.
      // ex. `value` (2 words including 10 bytes)
      // ==> BE: |abcdefgh|------ij|,  LE: |hgfedcba|ji------|
      copyAPIntToArrayForBEmachine(value, llvm::divideCeil(bitWidth, CHAR_BIT),
                                   rawData + (bitPos / CHAR_BIT));
    } else {
      std::copy_n(reinterpret_cast<const char *>(value.getRawData()),
                  llvm::divideCeil(bitWidth, CHAR_BIT),
                  rawData + (bitPos / CHAR_BIT));
    }
  }
  
  /// Reads the next `bitWidth` bits from the bit position `bitPos` in array
  /// `rawData`.
  static APInt readBits(const char *rawData, size_t bitPos, size_t bitWidth) {
    // Handle a boolean bit position.
    if (bitWidth == 1)
      return APInt(1, getBit(rawData, bitPos) ? 1 : 0);
  
    // Otherwise, the bit position must be 8-bit aligned.
    assert((bitPos % CHAR_BIT) == 0 && "expected bitPos to be 8-bit aligned");
    APInt result(bitWidth, 0);
    if (llvm::support::endian::system_endianness() ==
        llvm::support::endianness::big) {
      // Copy from `rawData + (bitPos / CHAR_BIT)` to `result`.
      // Copying the first `llvm::divideCeil(bitWidth, CHAR_BIT)` bytes doesn't
      // work correctly in BE format.
      // ex. `result` (2 words including 10 bytes)
      // ==> BE: |abcdefgh|------ij|,  LE: |hgfedcba|ji------| This function
      copyArrayToAPIntForBEmachine(rawData + (bitPos / CHAR_BIT),
                                   llvm::divideCeil(bitWidth, CHAR_BIT), result);
    } else {
      std::copy_n(rawData + (bitPos / CHAR_BIT),
                  llvm::divideCeil(bitWidth, CHAR_BIT),
                  const_cast<char *>(
                      reinterpret_cast<const char *>(result.getRawData())));
    }
    return result;
  }
  
  /// Returns true if 'values' corresponds to a splat, i.e. one element, or has
  /// the same element count as 'type'.
  template <typename Values>
  static bool hasSameElementsOrSplat(ShapedType type, const Values &values) {
    return (values.size() == 1) ||
           (type.getNumElements() == static_cast<int64_t>(values.size()));
  }
  
  //===----------------------------------------------------------------------===//
  // DenseElementsAttr Iterators
  //===----------------------------------------------------------------------===//
  
  //===----------------------------------------------------------------------===//
  // AttributeElementIterator
  
  DenseElementsAttr::AttributeElementIterator::AttributeElementIterator(
      DenseElementsAttr attr, size_t index)
      : llvm::indexed_accessor_iterator<AttributeElementIterator, const void *,
                                        Attribute, Attribute, Attribute>(
            attr.getAsOpaquePointer(), index) {}
  
  Attribute DenseElementsAttr::AttributeElementIterator::operator*() const {
    auto owner = getFromOpaquePointer(base).cast<DenseElementsAttr>();
    Type eltTy = owner.getElementType();
    if (auto intEltTy = eltTy.dyn_cast<IntegerType>())
      return IntegerAttr::get(eltTy, *IntElementIterator(owner, index));
    if (eltTy.isa<IndexType>())
      return IntegerAttr::get(eltTy, *IntElementIterator(owner, index));
    if (auto floatEltTy = eltTy.dyn_cast<FloatType>()) {
      IntElementIterator intIt(owner, index);
      FloatElementIterator floatIt(floatEltTy.getFloatSemantics(), intIt);
      return FloatAttr::get(eltTy, *floatIt);
    }
    if (auto complexTy = eltTy.dyn_cast<ComplexType>()) {
      auto complexEltTy = complexTy.getElementType();
      ComplexIntElementIterator complexIntIt(owner, index);
      if (complexEltTy.isa<IntegerType>()) {
        auto value = *complexIntIt;
        auto real = IntegerAttr::get(complexEltTy, value.real());
        auto imag = IntegerAttr::get(complexEltTy, value.imag());
        return ArrayAttr::get(complexTy.getContext(),
                              ArrayRef<Attribute>{real, imag});
      }
  
      ComplexFloatElementIterator complexFloatIt(
          complexEltTy.cast<FloatType>().getFloatSemantics(), complexIntIt);
      auto value = *complexFloatIt;
      auto real = FloatAttr::get(complexEltTy, value.real());
      auto imag = FloatAttr::get(complexEltTy, value.imag());
      return ArrayAttr::get(complexTy.getContext(),
                            ArrayRef<Attribute>{real, imag});
    }
    if (owner.isa<DenseStringElementsAttr>()) {
      ArrayRef<StringRef> vals = owner.getRawStringData();
      return StringAttr::get(owner.isSplat() ? vals.front() : vals[index], eltTy);
    }
    llvm_unreachable("unexpected element type");
  }
  
  //===----------------------------------------------------------------------===//
  // BoolElementIterator
  
  DenseElementsAttr::BoolElementIterator::BoolElementIterator(
      DenseElementsAttr attr, size_t dataIndex)
      : DenseElementIndexedIteratorImpl<BoolElementIterator, bool, bool, bool>(
            attr.getRawData().data(), attr.isSplat(), dataIndex) {}
  
  bool DenseElementsAttr::BoolElementIterator::operator*() const {
    return getBit(getData(), getDataIndex());
  }
  
  //===----------------------------------------------------------------------===//
  // IntElementIterator
  
  DenseElementsAttr::IntElementIterator::IntElementIterator(
      DenseElementsAttr attr, size_t dataIndex)
      : DenseElementIndexedIteratorImpl<IntElementIterator, APInt, APInt, APInt>(
            attr.getRawData().data(), attr.isSplat(), dataIndex),
        bitWidth(getDenseElementBitWidth(attr.getElementType())) {}
  
  APInt DenseElementsAttr::IntElementIterator::operator*() const {
    return readBits(getData(),
                    getDataIndex() * getDenseElementStorageWidth(bitWidth),
                    bitWidth);
  }
  
  //===----------------------------------------------------------------------===//
  // ComplexIntElementIterator
  
  DenseElementsAttr::ComplexIntElementIterator::ComplexIntElementIterator(
      DenseElementsAttr attr, size_t dataIndex)
      : DenseElementIndexedIteratorImpl<ComplexIntElementIterator,
                                        std::complex<APInt>, std::complex<APInt>,
                                        std::complex<APInt>>(
            attr.getRawData().data(), attr.isSplat(), dataIndex) {
    auto complexType = attr.getElementType().cast<ComplexType>();
    bitWidth = getDenseElementBitWidth(complexType.getElementType());
  }
  
  std::complex<APInt>
  DenseElementsAttr::ComplexIntElementIterator::operator*() const {
    size_t storageWidth = getDenseElementStorageWidth(bitWidth);
    size_t offset = getDataIndex() * storageWidth * 2;
    return {readBits(getData(), offset, bitWidth),
            readBits(getData(), offset + storageWidth, bitWidth)};
  }
  
  //===----------------------------------------------------------------------===//
  // DenseElementsAttr
  //===----------------------------------------------------------------------===//
  
  /// Method for support type inquiry through isa, cast and dyn_cast.
  bool DenseElementsAttr::classof(Attribute attr) {
    return attr.isa<DenseIntOrFPElementsAttr, DenseStringElementsAttr>();
  }
  
  DenseElementsAttr DenseElementsAttr::get(ShapedType type,
                                           ArrayRef<Attribute> values) {
    assert(hasSameElementsOrSplat(type, values));
  
    // If the element type is not based on int/float/index, assume it is a string
    // type.
    auto eltType = type.getElementType();
    if (!type.getElementType().isIntOrIndexOrFloat()) {
      SmallVector<StringRef, 8> stringValues;
      stringValues.reserve(values.size());
      for (Attribute attr : values) {
        assert(attr.isa<StringAttr>() &&
               "expected string value for non integer/index/float element");
        stringValues.push_back(attr.cast<StringAttr>().getValue());
      }
      return get(type, stringValues);
    }
  
    // Otherwise, get the raw storage width to use for the allocation.
    size_t bitWidth = getDenseElementBitWidth(eltType);
    size_t storageBitWidth = getDenseElementStorageWidth(bitWidth);
  
    // Compress the attribute values into a character buffer.
    SmallVector<char, 8> data(llvm::divideCeil(storageBitWidth, CHAR_BIT) *
                              values.size());
    APInt intVal;
    for (unsigned i = 0, e = values.size(); i < e; ++i) {
      assert(eltType == values[i].getType() &&
             "expected attribute value to have element type");
      if (eltType.isa<FloatType>())
        intVal = values[i].cast<FloatAttr>().getValue().bitcastToAPInt();
      else if (eltType.isa<IntegerType, IndexType>())
        intVal = values[i].cast<IntegerAttr>().getValue();
      else
        llvm_unreachable("unexpected element type");
  
      assert(intVal.getBitWidth() == bitWidth &&
             "expected value to have same bitwidth as element type");
      writeBits(data.data(), i * storageBitWidth, intVal);
    }
    return DenseIntOrFPElementsAttr::getRaw(type, data,
                                            /*isSplat=*/(values.size() == 1));
  }
  
  DenseElementsAttr DenseElementsAttr::get(ShapedType type,
                                           ArrayRef<bool> values) {
    assert(hasSameElementsOrSplat(type, values));
    assert(type.getElementType().isInteger(1));
  
    std::vector<char> buff(llvm::divideCeil(values.size(), CHAR_BIT));
    for (int i = 0, e = values.size(); i != e; ++i)
      setBit(buff.data(), i, values[i]);
    return DenseIntOrFPElementsAttr::getRaw(type, buff,
                                            /*isSplat=*/(values.size() == 1));
  }
  
  DenseElementsAttr DenseElementsAttr::get(ShapedType type,
                                           ArrayRef<StringRef> values) {
    assert(!type.getElementType().isIntOrFloat());
    return DenseStringElementsAttr::get(type, values);
  }
  
  /// Constructs a dense integer elements attribute from an array of APInt
  /// values. Each APInt value is expected to have the same bitwidth as the
  /// element type of 'type'.
  DenseElementsAttr DenseElementsAttr::get(ShapedType type,
                                           ArrayRef<APInt> values) {
    assert(type.getElementType().isIntOrIndex());
    assert(hasSameElementsOrSplat(type, values));
    size_t storageBitWidth = getDenseElementStorageWidth(type.getElementType());
    return DenseIntOrFPElementsAttr::getRaw(type, storageBitWidth, values,
                                            /*isSplat=*/(values.size() == 1));
  }
  DenseElementsAttr DenseElementsAttr::get(ShapedType type,
                                           ArrayRef<std::complex<APInt>> values) {
    ComplexType complex = type.getElementType().cast<ComplexType>();
    assert(complex.getElementType().isa<IntegerType>());
    assert(hasSameElementsOrSplat(type, values));
    size_t storageBitWidth = getDenseElementStorageWidth(complex) / 2;
    ArrayRef<APInt> intVals(reinterpret_cast<const APInt *>(values.data()),
                            values.size() * 2);
    return DenseIntOrFPElementsAttr::getRaw(type, storageBitWidth, intVals,
                                            /*isSplat=*/(values.size() == 1));
  }
  
  // Constructs a dense float elements attribute from an array of APFloat
  // values. Each APFloat value is expected to have the same bitwidth as the
  // element type of 'type'.
  DenseElementsAttr DenseElementsAttr::get(ShapedType type,
                                           ArrayRef<APFloat> values) {
    assert(type.getElementType().isa<FloatType>());
    assert(hasSameElementsOrSplat(type, values));
    size_t storageBitWidth = getDenseElementStorageWidth(type.getElementType());
    return DenseIntOrFPElementsAttr::getRaw(type, storageBitWidth, values,
                                            /*isSplat=*/(values.size() == 1));
  }
  DenseElementsAttr
  DenseElementsAttr::get(ShapedType type,
                         ArrayRef<std::complex<APFloat>> values) {
    ComplexType complex = type.getElementType().cast<ComplexType>();
    assert(complex.getElementType().isa<FloatType>());
    assert(hasSameElementsOrSplat(type, values));
    ArrayRef<APFloat> apVals(reinterpret_cast<const APFloat *>(values.data()),
                             values.size() * 2);
    size_t storageBitWidth = getDenseElementStorageWidth(complex) / 2;
    return DenseIntOrFPElementsAttr::getRaw(type, storageBitWidth, apVals,
                                            /*isSplat=*/(values.size() == 1));
  }
  
  /// Construct a dense elements attribute from a raw buffer representing the
  /// data for this attribute. Users should generally not use this methods as
  /// the expected buffer format may not be a form the user expects.
  DenseElementsAttr DenseElementsAttr::getFromRawBuffer(ShapedType type,
                                                        ArrayRef<char> rawBuffer,
                                                        bool isSplatBuffer) {
    return DenseIntOrFPElementsAttr::getRaw(type, rawBuffer, isSplatBuffer);
  }
  
  /// Returns true if the given buffer is a valid raw buffer for the given type.
  bool DenseElementsAttr::isValidRawBuffer(ShapedType type,
                                           ArrayRef<char> rawBuffer,
                                           bool &detectedSplat) {
    size_t storageWidth = getDenseElementStorageWidth(type.getElementType());
    size_t rawBufferWidth = rawBuffer.size() * CHAR_BIT;
  
    // Storage width of 1 is special as it is packed by the bit.
    if (storageWidth == 1) {
      // Check for a splat, or a buffer equal to the number of elements which
      // consists of either all 0's or all 1's.
      detectedSplat = false;
      if (rawBuffer.size() == 1) {
        auto rawByte = static_cast<uint8_t>(rawBuffer[0]);
        if (rawByte == 0 || rawByte == 0xff) {
          detectedSplat = true;
          return true;
        }
      }
      return rawBufferWidth == llvm::alignTo<8>(type.getNumElements());
    }
    // All other types are 8-bit aligned.
    if ((detectedSplat = rawBufferWidth == storageWidth))
      return true;
    return rawBufferWidth == (storageWidth * type.getNumElements());
  }
  
  /// Check the information for a C++ data type, check if this type is valid for
  /// the current attribute. This method is used to verify specific type
  /// invariants that the templatized 'getValues' method cannot.
  static bool isValidIntOrFloat(Type type, int64_t dataEltSize, bool isInt,
                                bool isSigned) {
    // Make sure that the data element size is the same as the type element width.
    if (getDenseElementBitWidth(type) !=
        static_cast<size_t>(dataEltSize * CHAR_BIT))
      return false;
  
    // Check that the element type is either float or integer or index.
    if (!isInt)
      return type.isa<FloatType>();
    if (type.isIndex())
      return true;
  
    auto intType = type.dyn_cast<IntegerType>();
    if (!intType)
      return false;
  
    // Make sure signedness semantics is consistent.
    if (intType.isSignless())
      return true;
    return intType.isSigned() ? isSigned : !isSigned;
  }
  
  /// Defaults down the subclass implementation.
  DenseElementsAttr DenseElementsAttr::getRawComplex(ShapedType type,
                                                     ArrayRef<char> data,
                                                     int64_t dataEltSize,
                                                     bool isInt, bool isSigned) {
    return DenseIntOrFPElementsAttr::getRawComplex(type, data, dataEltSize, isInt,
                                                   isSigned);
  }
  DenseElementsAttr DenseElementsAttr::getRawIntOrFloat(ShapedType type,
                                                        ArrayRef<char> data,
                                                        int64_t dataEltSize,
                                                        bool isInt,
                                                        bool isSigned) {
    return DenseIntOrFPElementsAttr::getRawIntOrFloat(type, data, dataEltSize,
                                                      isInt, isSigned);
  }
  
  bool DenseElementsAttr::isValidIntOrFloat(int64_t dataEltSize, bool isInt,
                                            bool isSigned) const {
    return ::isValidIntOrFloat(getElementType(), dataEltSize, isInt, isSigned);
  }
  bool DenseElementsAttr::isValidComplex(int64_t dataEltSize, bool isInt,
                                         bool isSigned) const {
    return ::isValidIntOrFloat(
        getElementType().cast<ComplexType>().getElementType(), dataEltSize / 2,
        isInt, isSigned);
  }
  
  /// Returns true if this attribute corresponds to a splat, i.e. if all element
  /// values are the same.
  bool DenseElementsAttr::isSplat() const {
    return static_cast<DenseElementsAttributeStorage *>(impl)->isSplat;
  }
  
  /// Return if the given complex type has an integer element type.
  LLVM_ATTRIBUTE_UNUSED static bool isComplexOfIntType(Type type) {
    return type.cast<ComplexType>().getElementType().isa<IntegerType>();
  }
  
  auto DenseElementsAttr::getComplexIntValues() const
      -> iterator_range_impl<ComplexIntElementIterator> {
    assert(isComplexOfIntType(getElementType()) &&
           "expected complex integral type");
    return {getType(), ComplexIntElementIterator(*this, 0),
            ComplexIntElementIterator(*this, getNumElements())};
  }
  auto DenseElementsAttr::complex_value_begin() const
      -> ComplexIntElementIterator {
    assert(isComplexOfIntType(getElementType()) &&
           "expected complex integral type");
    return ComplexIntElementIterator(*this, 0);
  }
  auto DenseElementsAttr::complex_value_end() const -> ComplexIntElementIterator {
    assert(isComplexOfIntType(getElementType()) &&
           "expected complex integral type");
    return ComplexIntElementIterator(*this, getNumElements());
  }
  
  /// Return the held element values as a range of APFloat. The element type of
  /// this attribute must be of float type.
  auto DenseElementsAttr::getFloatValues() const
      -> iterator_range_impl<FloatElementIterator> {
    auto elementType = getElementType().cast<FloatType>();
    const auto &elementSemantics = elementType.getFloatSemantics();
    return {getType(), FloatElementIterator(elementSemantics, raw_int_begin()),
            FloatElementIterator(elementSemantics, raw_int_end())};
  }
  auto DenseElementsAttr::float_value_begin() const -> FloatElementIterator {
    auto elementType = getElementType().cast<FloatType>();
    return FloatElementIterator(elementType.getFloatSemantics(), raw_int_begin());
  }
  auto DenseElementsAttr::float_value_end() const -> FloatElementIterator {
    auto elementType = getElementType().cast<FloatType>();
    return FloatElementIterator(elementType.getFloatSemantics(), raw_int_end());
  }
  
  auto DenseElementsAttr::getComplexFloatValues() const
      -> iterator_range_impl<ComplexFloatElementIterator> {
    Type eltTy = getElementType().cast<ComplexType>().getElementType();
    assert(eltTy.isa<FloatType>() && "expected complex float type");
    const auto &semantics = eltTy.cast<FloatType>().getFloatSemantics();
    return {getType(),
            {semantics, {*this, 0}},
            {semantics, {*this, static_cast<size_t>(getNumElements())}}};
  }
  auto DenseElementsAttr::complex_float_value_begin() const
      -> ComplexFloatElementIterator {
    Type eltTy = getElementType().cast<ComplexType>().getElementType();
    assert(eltTy.isa<FloatType>() && "expected complex float type");
    return {eltTy.cast<FloatType>().getFloatSemantics(), {*this, 0}};
  }
  auto DenseElementsAttr::complex_float_value_end() const
      -> ComplexFloatElementIterator {
    Type eltTy = getElementType().cast<ComplexType>().getElementType();
    assert(eltTy.isa<FloatType>() && "expected complex float type");
    return {eltTy.cast<FloatType>().getFloatSemantics(),
            {*this, static_cast<size_t>(getNumElements())}};
  }
  
  /// Return the raw storage data held by this attribute.
  ArrayRef<char> DenseElementsAttr::getRawData() const {
    return static_cast<DenseIntOrFPElementsAttrStorage *>(impl)->data;
  }
  
  ArrayRef<StringRef> DenseElementsAttr::getRawStringData() const {
    return static_cast<DenseStringElementsAttrStorage *>(impl)->data;
  }
  
  /// Return a new DenseElementsAttr that has the same data as the current
  /// attribute, but has been reshaped to 'newType'. The new type must have the
  /// same total number of elements as well as element type.
  DenseElementsAttr DenseElementsAttr::reshape(ShapedType newType) {
    ShapedType curType = getType();
    if (curType == newType)
      return *this;
  
    assert(newType.getElementType() == curType.getElementType() &&
           "expected the same element type");
    assert(newType.getNumElements() == curType.getNumElements() &&
           "expected the same number of elements");
    return DenseIntOrFPElementsAttr::getRaw(newType, getRawData(), isSplat());
  }
  
  /// Return a new DenseElementsAttr that has the same data as the current
  /// attribute, but has bitcast elements such that it is now 'newType'. The new
  /// type must have the same shape and element types of the same bitwidth as the
  /// current type.
  DenseElementsAttr DenseElementsAttr::bitcast(Type newElType) {
    ShapedType curType = getType();
    Type curElType = curType.getElementType();
    if (curElType == newElType)
      return *this;
  
    assert(getDenseElementBitWidth(newElType) ==
               getDenseElementBitWidth(curElType) &&
           "expected element types with the same bitwidth");
    return DenseIntOrFPElementsAttr::getRaw(curType.clone(newElType),
                                            getRawData(), isSplat());
  }
  
  DenseElementsAttr
  DenseElementsAttr::mapValues(Type newElementType,
                               function_ref<APInt(const APInt &)> mapping) const {
    return cast<DenseIntElementsAttr>().mapValues(newElementType, mapping);
  }
  
  DenseElementsAttr DenseElementsAttr::mapValues(
      Type newElementType, function_ref<APInt(const APFloat &)> mapping) const {
    return cast<DenseFPElementsAttr>().mapValues(newElementType, mapping);
  }
  
  ShapedType DenseElementsAttr::getType() const {
    return Attribute::getType().cast<ShapedType>();
  }
  
  Type DenseElementsAttr::getElementType() const {
    return getType().getElementType();
  }
  
  int64_t DenseElementsAttr::getNumElements() const {
    return getType().getNumElements();
  }
  
  //===----------------------------------------------------------------------===//
  // DenseIntOrFPElementsAttr
  //===----------------------------------------------------------------------===//
  
  /// Utility method to write a range of APInt values to a buffer.
  template <typename APRangeT>
  static void writeAPIntsToBuffer(size_t storageWidth, std::vector<char> &data,
                                  APRangeT &&values) {
    data.resize(llvm::divideCeil(storageWidth, CHAR_BIT) * llvm::size(values));
    size_t offset = 0;
    for (auto it = values.begin(), e = values.end(); it != e;
         ++it, offset += storageWidth) {
      assert((*it).getBitWidth() <= storageWidth);
      writeBits(data.data(), offset, *it);
    }
  }
  
  /// Constructs a dense elements attribute from an array of raw APFloat values.
  /// Each APFloat value is expected to have the same bitwidth as the element
  /// type of 'type'. 'type' must be a vector or tensor with static shape.
  DenseElementsAttr DenseIntOrFPElementsAttr::getRaw(ShapedType type,
                                                     size_t storageWidth,
                                                     ArrayRef<APFloat> values,
                                                     bool isSplat) {
    std::vector<char> data;
    auto unwrapFloat = [](const APFloat &val) { return val.bitcastToAPInt(); };
    writeAPIntsToBuffer(storageWidth, data, llvm::map_range(values, unwrapFloat));
    return DenseIntOrFPElementsAttr::getRaw(type, data, isSplat);
  }
  
  /// Constructs a dense elements attribute from an array of raw APInt values.
  /// Each APInt value is expected to have the same bitwidth as the element type
  /// of 'type'.
  DenseElementsAttr DenseIntOrFPElementsAttr::getRaw(ShapedType type,
                                                     size_t storageWidth,
                                                     ArrayRef<APInt> values,
                                                     bool isSplat) {
    std::vector<char> data;
    writeAPIntsToBuffer(storageWidth, data, values);
    return DenseIntOrFPElementsAttr::getRaw(type, data, isSplat);
  }
  
  DenseElementsAttr DenseIntOrFPElementsAttr::getRaw(ShapedType type,
                                                     ArrayRef<char> data,
                                                     bool isSplat) {
    assert((type.isa<RankedTensorType, VectorType>()) &&
           "type must be ranked tensor or vector");
    assert(type.hasStaticShape() && "type must have static shape");
    return Base::get(type.getContext(), type, data, isSplat);
  }
  
  /// Overload of the raw 'get' method that asserts that the given type is of
  /// complex type. This method is used to verify type invariants that the
  /// templatized 'get' method cannot.
  DenseElementsAttr DenseIntOrFPElementsAttr::getRawComplex(ShapedType type,
                                                            ArrayRef<char> data,
                                                            int64_t dataEltSize,
                                                            bool isInt,
                                                            bool isSigned) {
    assert(::isValidIntOrFloat(
        type.getElementType().cast<ComplexType>().getElementType(),
        dataEltSize / 2, isInt, isSigned));
  
    int64_t numElements = data.size() / dataEltSize;
    assert(numElements == 1 || numElements == type.getNumElements());
    return getRaw(type, data, /*isSplat=*/numElements == 1);
  }
  
  /// Overload of the 'getRaw' method that asserts that the given type is of
  /// integer type. This method is used to verify type invariants that the
  /// templatized 'get' method cannot.
  DenseElementsAttr
  DenseIntOrFPElementsAttr::getRawIntOrFloat(ShapedType type, ArrayRef<char> data,
                                             int64_t dataEltSize, bool isInt,
                                             bool isSigned) {
    assert(
        ::isValidIntOrFloat(type.getElementType(), dataEltSize, isInt, isSigned));
  
    int64_t numElements = data.size() / dataEltSize;
    assert(numElements == 1 || numElements == type.getNumElements());
    return getRaw(type, data, /*isSplat=*/numElements == 1);
  }
  
  void DenseIntOrFPElementsAttr::convertEndianOfCharForBEmachine(
      const char *inRawData, char *outRawData, size_t elementBitWidth,
      size_t numElements) {
    using llvm::support::ulittle16_t;
    using llvm::support::ulittle32_t;
    using llvm::support::ulittle64_t;
  
    assert(llvm::support::endian::system_endianness() == // NOLINT
           llvm::support::endianness::big);              // NOLINT
    // NOLINT to avoid warning message about replacing by static_assert()
  
    // Following std::copy_n always converts endianness on BE machine.
    switch (elementBitWidth) {
    case 16: {
      const ulittle16_t *inRawDataPos =
          reinterpret_cast<const ulittle16_t *>(inRawData);
      uint16_t *outDataPos = reinterpret_cast<uint16_t *>(outRawData);
      std::copy_n(inRawDataPos, numElements, outDataPos);
      break;
    }
    case 32: {
      const ulittle32_t *inRawDataPos =
          reinterpret_cast<const ulittle32_t *>(inRawData);
      uint32_t *outDataPos = reinterpret_cast<uint32_t *>(outRawData);
      std::copy_n(inRawDataPos, numElements, outDataPos);
      break;
    }
    case 64: {
      const ulittle64_t *inRawDataPos =
          reinterpret_cast<const ulittle64_t *>(inRawData);
      uint64_t *outDataPos = reinterpret_cast<uint64_t *>(outRawData);
      std::copy_n(inRawDataPos, numElements, outDataPos);
      break;
    }
    default: {
      size_t nBytes = elementBitWidth / CHAR_BIT;
      for (size_t i = 0; i < nBytes; i++)
        std::copy_n(inRawData + (nBytes - 1 - i), 1, outRawData + i);
      break;
    }
    }
  }
  
  void DenseIntOrFPElementsAttr::convertEndianOfArrayRefForBEmachine(
      ArrayRef<char> inRawData, MutableArrayRef<char> outRawData,
      ShapedType type) {
    size_t numElements = type.getNumElements();
    Type elementType = type.getElementType();
    if (ComplexType complexTy = elementType.dyn_cast<ComplexType>()) {
      elementType = complexTy.getElementType();
      numElements = numElements * 2;
    }
    size_t elementBitWidth = getDenseElementStorageWidth(elementType);
    assert(numElements * elementBitWidth == inRawData.size() * CHAR_BIT &&
           inRawData.size() <= outRawData.size());
    convertEndianOfCharForBEmachine(inRawData.begin(), outRawData.begin(),
                                    elementBitWidth, numElements);
  }
  
  //===----------------------------------------------------------------------===//
  // DenseFPElementsAttr
  //===----------------------------------------------------------------------===//
  
  template <typename Fn, typename Attr>
  static ShapedType mappingHelper(Fn mapping, Attr &attr, ShapedType inType,
                                  Type newElementType,
                                  llvm::SmallVectorImpl<char> &data) {
    size_t bitWidth = getDenseElementBitWidth(newElementType);
    size_t storageBitWidth = getDenseElementStorageWidth(bitWidth);
  
    ShapedType newArrayType;
    if (inType.isa<RankedTensorType>())
      newArrayType = RankedTensorType::get(inType.getShape(), newElementType);
    else if (inType.isa<UnrankedTensorType>())
      newArrayType = RankedTensorType::get(inType.getShape(), newElementType);
    else if (inType.isa<VectorType>())
      newArrayType = VectorType::get(inType.getShape(), newElementType);
    else
      assert(newArrayType && "Unhandled tensor type");
  
    size_t numRawElements = attr.isSplat() ? 1 : newArrayType.getNumElements();
    data.resize(llvm::divideCeil(storageBitWidth, CHAR_BIT) * numRawElements);
  
    // Functor used to process a single element value of the attribute.
    auto processElt = [&](decltype(*attr.begin()) value, size_t index) {
      auto newInt = mapping(value);
      assert(newInt.getBitWidth() == bitWidth);
      writeBits(data.data(), index * storageBitWidth, newInt);
    };
  
    // Check for the splat case.
    if (attr.isSplat()) {
      processElt(*attr.begin(), /*index=*/0);
      return newArrayType;
    }
  
    // Otherwise, process all of the element values.
    uint64_t elementIdx = 0;
    for (auto value : attr)
      processElt(value, elementIdx++);
    return newArrayType;
  }
  
  DenseElementsAttr DenseFPElementsAttr::mapValues(
      Type newElementType, function_ref<APInt(const APFloat &)> mapping) const {
    llvm::SmallVector<char, 8> elementData;
    auto newArrayType =
        mappingHelper(mapping, *this, getType(), newElementType, elementData);
  
    return getRaw(newArrayType, elementData, isSplat());
  }
  
  /// Method for supporting type inquiry through isa, cast and dyn_cast.
  bool DenseFPElementsAttr::classof(Attribute attr) {
    return attr.isa<DenseElementsAttr>() &&
           attr.getType().cast<ShapedType>().getElementType().isa<FloatType>();
  }
  
  //===----------------------------------------------------------------------===//
  // DenseIntElementsAttr
  //===----------------------------------------------------------------------===//
  
  DenseElementsAttr DenseIntElementsAttr::mapValues(
      Type newElementType, function_ref<APInt(const APInt &)> mapping) const {
    llvm::SmallVector<char, 8> elementData;
    auto newArrayType =
        mappingHelper(mapping, *this, getType(), newElementType, elementData);
  
    return getRaw(newArrayType, elementData, isSplat());
  }
  
  /// Method for supporting type inquiry through isa, cast and dyn_cast.
  bool DenseIntElementsAttr::classof(Attribute attr) {
    return attr.isa<DenseElementsAttr>() &&
           attr.getType().cast<ShapedType>().getElementType().isIntOrIndex();
  }
  
  //===----------------------------------------------------------------------===//
  // OpaqueElementsAttr
  //===----------------------------------------------------------------------===//
  
  bool OpaqueElementsAttr::decode(ElementsAttr &result) {
    Dialect *dialect = getContext()->getLoadedDialect(getDialect());
    if (!dialect)
      return true;
    auto *interface =
        dialect->getRegisteredInterface<DialectDecodeAttributesInterface>();
    if (!interface)
      return true;
    return failed(interface->decode(*this, result));
  }
  
  LogicalResult
  OpaqueElementsAttr::verify(function_ref<InFlightDiagnostic()> emitError,
                             StringAttr dialect, StringRef value,
                             ShapedType type) {
    if (!Dialect::isValidNamespace(dialect.strref()))
      return emitError() << "invalid dialect namespace '" << dialect << "'";
    return success();
  }
  
  //===----------------------------------------------------------------------===//
  // SparseElementsAttr
  //===----------------------------------------------------------------------===//
  
  /// Get a zero APFloat for the given sparse attribute.
  APFloat SparseElementsAttr::getZeroAPFloat() const {
    auto eltType = getElementType().cast<FloatType>();
    return APFloat(eltType.getFloatSemantics());
  }
  
  /// Get a zero APInt for the given sparse attribute.
  APInt SparseElementsAttr::getZeroAPInt() const {
    auto eltType = getElementType().cast<IntegerType>();
    return APInt::getZero(eltType.getWidth());
  }
  
  /// Get a zero attribute for the given attribute type.
  Attribute SparseElementsAttr::getZeroAttr() const {
    auto eltType = getElementType();
  
    // Handle floating point elements.
    if (eltType.isa<FloatType>())
      return FloatAttr::get(eltType, 0);
  
    // Handle string type.
    if (getValues().isa<DenseStringElementsAttr>())
      return StringAttr::get("", eltType);
  
    // Otherwise, this is an integer.
    return IntegerAttr::get(eltType, 0);
  }
  
  /// Flatten, and return, all of the sparse indices in this attribute in
  /// row-major order.
  std::vector<ptrdiff_t> SparseElementsAttr::getFlattenedSparseIndices() const {
    std::vector<ptrdiff_t> flatSparseIndices;
  
    // The sparse indices are 64-bit integers, so we can reinterpret the raw data
    // as a 1-D index array.
    auto sparseIndices = getIndices();
    auto sparseIndexValues = sparseIndices.getValues<uint64_t>();
    if (sparseIndices.isSplat()) {
      SmallVector<uint64_t, 8> indices(getType().getRank(),
                                       *sparseIndexValues.begin());
      flatSparseIndices.push_back(getFlattenedIndex(indices));
      return flatSparseIndices;
    }
  
    // Otherwise, reinterpret each index as an ArrayRef when flattening.
    auto numSparseIndices = sparseIndices.getType().getDimSize(0);
    size_t rank = getType().getRank();
    for (size_t i = 0, e = numSparseIndices; i != e; ++i)
      flatSparseIndices.push_back(getFlattenedIndex(
          {&*std::next(sparseIndexValues.begin(), i * rank), rank}));
    return flatSparseIndices;
  }
  
  LogicalResult
  SparseElementsAttr::verify(function_ref<InFlightDiagnostic()> emitError,
                             ShapedType type, DenseIntElementsAttr sparseIndices,
                             DenseElementsAttr values) {
    ShapedType valuesType = values.getType();
    if (valuesType.getRank() != 1)
      return emitError() << "expected 1-d tensor for sparse element values";
  
    // Verify the indices and values shape.
    ShapedType indicesType = sparseIndices.getType();
    auto emitShapeError = [&]() {
      return emitError() << "expected shape ([" << type.getShape()
                         << "]); inferred shape of indices literal (["
                         << indicesType.getShape()
                         << "]); inferred shape of values literal (["
                         << valuesType.getShape() << "])";
    };
    // Verify indices shape.
    size_t rank = type.getRank(), indicesRank = indicesType.getRank();
    if (indicesRank == 2) {
      if (indicesType.getDimSize(1) != static_cast<int64_t>(rank))
        return emitShapeError();
    } else if (indicesRank != 1 || rank != 1) {
      return emitShapeError();
    }
    // Verify the values shape.
    int64_t numSparseIndices = indicesType.getDimSize(0);
    if (numSparseIndices != valuesType.getDimSize(0))
      return emitShapeError();
  
    // Verify that the sparse indices are within the value shape.
    auto emitIndexError = [&](unsigned indexNum, ArrayRef<uint64_t> index) {
      return emitError()
             << "sparse index #" << indexNum
             << " is not contained within the value shape, with index=[" << index
             << "], and type=" << type;
    };
  
    // Handle the case where the index values are a splat.
    auto sparseIndexValues = sparseIndices.getValues<uint64_t>();
    if (sparseIndices.isSplat()) {
      SmallVector<uint64_t> indices(rank, *sparseIndexValues.begin());
      if (!ElementsAttr::isValidIndex(type, indices))
        return emitIndexError(0, indices);
      return success();
    }
  
    // Otherwise, reinterpret each index as an ArrayRef.
    for (size_t i = 0, e = numSparseIndices; i != e; ++i) {
      ArrayRef<uint64_t> index(&*std::next(sparseIndexValues.begin(), i * rank),
                               rank);
      if (!ElementsAttr::isValidIndex(type, index))
        return emitIndexError(i, index);
    }
  
    return success();
  }
  
  //===----------------------------------------------------------------------===//
  // TypeAttr
  //===----------------------------------------------------------------------===//
  
  void TypeAttr::walkImmediateSubElements(
      function_ref<void(Attribute)> walkAttrsFn,
      function_ref<void(Type)> walkTypesFn) const {
    walkTypesFn(getValue());
  }
  