[NFC] Rename AttributeList::has/getAttribute() -> has/getAttributeImpl()

[aeubanks]

Summary

AttributeList::get/hasAttribute() are confusing because they use indexes
where (unsigned)-1 represents the function, 0 represents the return
value, and 1+ represents parameters. I've been bitten by this multiple
times, assuming that the index only corresponds to parameters.

Adding Impl at the end of the name encourages users to use the less
confusing {get,has}{Fn,Ret,Param}Attribute().

Some places require a larger cleanup, so keep those using
get/hasAttribute() for now. Also, the C API uses these so we can't
really get rid of them/make them private.

This doesn't touch the methods that modify attributes. I'll clean those
up in the future.

[rnk]

There's a related change here: https://reviews.llvm.org/D105485

Honestly, I like this approach better. Adding a strongly-typed integer wrapper is a pretty heavyweight solution for a problem that seems solvable with better named methods.

As a practical matter, consider splitting this up to reduce churn in case anything gets reverted. Most of the getAttribute -> getParamAttr calls can be migrated ahead of time as NFC commits to improve readability. The most risk-averse version of this change is to leave behind the getAttribute entry points as aliases to getAttributeImpl, and then remove them in a final commit.

[aeubanks]

rebase past cleanups

[aeubanks]

one more place

llvm/include/llvm/IR/Attributes.h

public:
   }
 
   /// Replace the type contained by attribute \p AttrKind at index \p ArgNo wih
   /// \p ReplacementTy, preserving all other attributes.
   LLVM_NODISCARD AttributeList replaceAttributeType(LLVMContext &C,
                                                     unsigned ArgNo,
                                                     Attribute::AttrKind Kind,
                                                     Type *ReplacementTy) const {
-    Attribute Attr = getAttribute(ArgNo, Kind);
+    Attribute Attr = getAttributeImpl(ArgNo, Kind);
     auto Attrs = removeAttribute(C, ArgNo, Kind);
     return Attrs.addAttribute(C, ArgNo, Attr.getWithNewType(C, ReplacementTy));
   }
 
   /// \brief Add the dereferenceable attribute to the attribute set at the given
   /// index. Returns a new list because attribute lists are immutable.
   LLVM_NODISCARD AttributeList addDereferenceableAttr(LLVMContext &C,
                                                       unsigned Index,
LLVM_NODISCARD AttributeList addVScaleRangeAttr(LLVMContext &C,
                                                   unsigned MinValue,
                                                   unsigned MaxValue);
 
   //===--------------------------------------------------------------------===//
   // AttributeList Accessors
   //===--------------------------------------------------------------------===//
 
   /// The attributes for the specified index are returned.
-  AttributeSet getAttributes(unsigned Index) const;
+  AttributeSet getAttributesImpl(unsigned Index) const;
 
   /// The attributes for the argument or parameter at the given index are
   /// returned.
   AttributeSet getParamAttrs(unsigned ArgNo) const;
 
   /// The attributes for the ret value are returned.
   AttributeSet getRetAttrs() const;
 
   /// The function attributes are returned.
   AttributeSet getFnAttrs() const;
 
   /// Return true if the attribute exists at the given index.
-  bool hasAttribute(unsigned Index, Attribute::AttrKind Kind) const;
+  bool hasAttributeImpl(unsigned Index, Attribute::AttrKind Kind) const;
 
   /// Return true if the attribute exists at the given index.
-  bool hasAttribute(unsigned Index, StringRef Kind) const;
+  bool hasAttributeImpl(unsigned Index, StringRef Kind) const;
 
   /// Return true if attribute exists at the given index.
-  bool hasAttributes(unsigned Index) const;
+  bool hasAttributesImpl(unsigned Index) const;
 
   /// Return true if the attribute exists for the given argument
   bool hasParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const {
-    return hasAttribute(ArgNo + FirstArgIndex, Kind);
+    return hasAttributeImpl(ArgNo + FirstArgIndex, Kind);
   }
 
   /// Return true if the attribute exists for the given argument
   bool hasParamAttr(unsigned ArgNo, StringRef Kind) const {
-    return hasAttribute(ArgNo + FirstArgIndex, Kind);
+    return hasAttributeImpl(ArgNo + FirstArgIndex, Kind);
   }
 
   /// Return true if attributes exists for the given argument
   bool hasParamAttrs(unsigned ArgNo) const {
-    return hasAttributes(ArgNo + FirstArgIndex);
+    return hasAttributesImpl(ArgNo + FirstArgIndex);
   }
 
   /// Return true if the attribute exists for the return value.
   bool hasRetAttr(Attribute::AttrKind Kind) const {
-    return hasAttribute(ReturnIndex, Kind);
+    return hasAttributeImpl(ReturnIndex, Kind);
   }
 
   /// Return true if the attribute exists for the return value.
   bool hasRetAttr(StringRef Kind) const {
-    return hasAttribute(ReturnIndex, Kind);
+    return hasAttributeImpl(ReturnIndex, Kind);
   }
 
   /// Return true if attributes exist for the return value.
-  bool hasRetAttrs() const { return hasAttributes(ReturnIndex); }
+  bool hasRetAttrs() const { return hasAttributesImpl(ReturnIndex); }
 
   /// Return true if the attribute exists for the function.
   bool hasFnAttr(Attribute::AttrKind Kind) const;
 
   /// Return true if the attribute exists for the function.
   bool hasFnAttr(StringRef Kind) const;
 
   /// Return true the attributes exist for the function.
-  bool hasFnAttrs() const { return hasAttributes(FunctionIndex); }
+  bool hasFnAttrs() const { return hasAttributesImpl(FunctionIndex); }
 
   /// Return true if the specified attribute is set for at least one
   /// parameter or for the return value. If Index is not nullptr, the index
   /// of a parameter with the specified attribute is provided.
   bool hasAttrSomewhere(Attribute::AttrKind Kind,
                         unsigned *Index = nullptr) const;
 
   /// Return the attribute object that exists at the given index.
-  Attribute getAttribute(unsigned Index, Attribute::AttrKind Kind) const;
+  Attribute getAttributeImpl(unsigned Index, Attribute::AttrKind Kind) const;
 
   /// Return the attribute object that exists at the given index.
-  Attribute getAttribute(unsigned Index, StringRef Kind) const;
+  Attribute getAttributeImpl(unsigned Index, StringRef Kind) const;
 
   /// Return the attribute object that exists at the arg index.
   Attribute getParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const {
-    return getAttribute(ArgNo + FirstArgIndex, Kind);
+    return getAttributeImpl(ArgNo + FirstArgIndex, Kind);
   }
 
   /// Return the attribute object that exists at the given index.
   Attribute getParamAttr(unsigned ArgNo, StringRef Kind) const {
-    return getAttribute(ArgNo + FirstArgIndex, Kind);
+    return getAttributeImpl(ArgNo + FirstArgIndex, Kind);
   }
 
   /// Return the attribute object that exists for the function.
   Attribute getFnAttr(Attribute::AttrKind Kind) const {
-    return getAttribute(FunctionIndex, Kind);
+    return getAttributeImpl(FunctionIndex, Kind);
   }
 
   /// Return the attribute object that exists for the function.
   Attribute getFnAttr(StringRef Kind) const {
-    return getAttribute(FunctionIndex, Kind);
+    return getAttributeImpl(FunctionIndex, Kind);
   }
 
   /// Return the alignment of the return value.
   MaybeAlign getRetAlignment() const;
 
   /// Return the alignment for the specified function parameter.
   MaybeAlign getParamAlignment(unsigned ArgNo) const;
 

llvm/include/llvm/IR/Function.h

public:
   void removeParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs);
 
   /// removes noundef and other attributes that imply undefined behavior if a
   /// `undef` or `poison` value is passed from the list of attributes.
   void removeParamUndefImplyingAttrs(unsigned ArgNo);
 
   /// check if an attributes is in the list of attributes.
   bool hasAttribute(unsigned i, Attribute::AttrKind Kind) const {
-    return getAttributes().hasAttribute(i, Kind);
+    return getAttributes().hasAttributeImpl(i, Kind);
   }
 
   /// check if an attributes is in the list of attributes.
   bool hasParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const {
     return getAttributes().hasParamAttr(ArgNo, Kind);
   }
 
   /// gets the specified attribute from the list of attributes.
   Attribute getParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const {
     return getAttributes().getParamAttr(ArgNo, Kind);
   }
 
   /// check if an attribute is in the list of attributes for the return value.
   bool hasRetAttribute(Attribute::AttrKind Kind) const {
     return getAttributes().hasRetAttr(Kind);
   }
 
   /// gets the attribute from the list of attributes.
   Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const {
-    return AttributeSets.getAttribute(i, Kind);
+    return AttributeSets.getAttributeImpl(i, Kind);
   }
 
   /// gets the attribute from the list of attributes.
   Attribute getAttribute(unsigned i, StringRef Kind) const {
-    return AttributeSets.getAttribute(i, Kind);
+    return AttributeSets.getAttributeImpl(i, Kind);
   }
 
   /// adds the dereferenceable attribute to the list of attributes.
   void addDereferenceableAttr(unsigned i, uint64_t Bytes);
 
   /// adds the dereferenceable attribute to the list of attributes for
   /// the given arg.
   void addDereferenceableParamAttr(unsigned ArgNo, uint64_t Bytes);

llvm/include/llvm/IR/InstrTypes.h

public:
   /// Determine whether the return value has the given attribute.
   bool hasRetAttr(StringRef Kind) const { return hasRetAttrImpl(Kind); }
 
   /// Determine whether the argument or parameter has the given attribute.
   bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const;
 
   /// Get the attribute of a given kind at a position.
   Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const {
-    return getAttributes().getAttribute(i, Kind);
+    return getAttributes().getAttributeImpl(i, Kind);
   }
 
   /// Get the attribute of a given kind at a position.
   Attribute getAttribute(unsigned i, StringRef Kind) const {
-    return getAttributes().getAttribute(i, Kind);
+    return getAttributes().getAttributeImpl(i, Kind);
   }
 
   /// Get the attribute of a given kind from a given arg
   Attribute getParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const {
     assert(ArgNo < getNumArgOperands() && "Out of bounds");
     return getAttributes().getParamAttr(ArgNo, Kind);
   }
 

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

void ModuleBitcodeWriter::writeAttributeTable() {
   if (Attrs.empty()) return;
 
   Stream.EnterSubblock(bitc::PARAMATTR_BLOCK_ID, 3);
 
   SmallVector<uint64_t, 64> Record;
   for (unsigned i = 0, e = Attrs.size(); i != e; ++i) {
     AttributeList AL = Attrs[i];
     for (unsigned i = AL.index_begin(), e = AL.index_end(); i != e; ++i) {
-      AttributeSet AS = AL.getAttributes(i);
+      AttributeSet AS = AL.getAttributesImpl(i);
       if (AS.hasAttributes())
         Record.push_back(VE.getAttributeGroupID({i, AS}));
     }
 
     Stream.EmitRecord(bitc::PARAMATTR_CODE_ENTRY, Record);
     Record.clear();
   }
 

llvm/lib/Bitcode/Writer/ValueEnumerator.cpp

void ValueEnumerator::EnumerateAttributes(AttributeList PAL) {
   if (Entry == 0) {
     // Never saw this before, add it.
     AttributeLists.push_back(PAL);
     Entry = AttributeLists.size();
   }
 
   // Do lookups for all attribute groups.
   for (unsigned i = PAL.index_begin(), e = PAL.index_end(); i != e; ++i) {
-    AttributeSet AS = PAL.getAttributes(i);
+    AttributeSet AS = PAL.getAttributesImpl(i);
     if (!AS.hasAttributes())
       continue;
     IndexAndAttrSet Pair = {i, AS};
     unsigned &Entry = AttributeGroupMap[Pair];
     if (Entry == 0) {
       AttributeGroups.push_back(Pair);
       Entry = AttributeGroups.size();
 

llvm/lib/CodeGen/GlobalISel/CallLowering.cpp

ISD::ArgFlagsTy CallLowering::getAttributesForArgIdx(const CallBase &Call,
   });
   return Flags;
 }
 
 void CallLowering::addArgFlagsFromAttributes(ISD::ArgFlagsTy &Flags,
                                              const AttributeList &Attrs,
                                              unsigned OpIdx) const {
   addFlagsUsingAttrFn(Flags, [&Attrs, &OpIdx](Attribute::AttrKind Attr) {
-    return Attrs.hasAttribute(OpIdx, Attr);
+    return Attrs.hasAttributeImpl(OpIdx, Attr);
   });
 }
 
 bool CallLowering::lowerCall(MachineIRBuilder &MIRBuilder, const CallBase &CB,
                              ArrayRef<Register> ResRegs,
                              ArrayRef<ArrayRef<Register>> ArgRegs,
                              Register SwiftErrorVReg,
                              std::function<unsigned()> GetCalleeReg) const {
if (PtrTy) {
     Flags.setPointerAddrSpace(PtrTy->getPointerAddressSpace());
   }
 
   Align MemAlign = DL.getABITypeAlign(Arg.Ty);
   if (Flags.isByVal() || Flags.isInAlloca() || Flags.isPreallocated()) {
     assert(OpIdx >= AttributeList::FirstArgIndex);
     Type *ElementTy = PtrTy->getElementType();
 
-    auto Ty = Attrs.getAttribute(OpIdx, Attribute::ByVal).getValueAsType();
+    auto Ty = Attrs.getAttributeImpl(OpIdx, Attribute::ByVal).getValueAsType();
     Flags.setByValSize(DL.getTypeAllocSize(Ty ? Ty : ElementTy));
 
     // For ByVal, alignment should be passed from FE.  BE will guess if
     // this info is not there but there are cases it cannot get right.
     if (auto ParamAlign =
             FuncInfo.getParamStackAlign(OpIdx - AttributeList::FirstArgIndex))
       MemAlign = *ParamAlign;
     else if ((ParamAlign =

llvm/lib/IR/Attributes.cpp

AttributeList AttributeList::get(LLVMContext &C,
   // If every list was empty, there is no point in merging the lists.
   if (MaxSize == 0)
     return {};
 
   SmallVector<AttributeSet, 8> NewAttrSets(MaxSize);
   for (unsigned I = 0; I < MaxSize; ++I) {
     AttrBuilder CurBuilder;
     for (const auto &List : Attrs)
-      CurBuilder.merge(List.getAttributes(I - 1));
+      CurBuilder.merge(List.getAttributesImpl(I - 1));
     NewAttrSets[I] = AttributeSet::get(C, CurBuilder);
   }
 
   return getImpl(C, NewAttrSets);
 }
 
 AttributeList AttributeList::addAttribute(LLVMContext &C, unsigned Index,
                                           Attribute::AttrKind Kind) const {
-  if (hasAttribute(Index, Kind)) return *this;
-  AttributeSet Attrs = getAttributes(Index);
+  if (hasAttributeImpl(Index, Kind))
+    return *this;
+  AttributeSet Attrs = getAttributesImpl(Index);
   // TODO: Insert at correct position and avoid sort.
   SmallVector<Attribute, 8> NewAttrs(Attrs.begin(), Attrs.end());
   NewAttrs.push_back(Attribute::get(C, Kind));
   return setAttributes(C, Index, AttributeSet::get(C, NewAttrs));
 }
 
 AttributeList AttributeList::addAttribute(LLVMContext &C, unsigned Index,
                                           StringRef Kind,
if (!B.hasAttributes())
     return *this;
 
   if (!pImpl)
     return AttributeList::get(C, {{Index, AttributeSet::get(C, B)}});
 
 #ifndef NDEBUG
   // FIXME it is not obvious how this should work for alignment. For now, say
   // we can't change a known alignment.
-  const MaybeAlign OldAlign = getAttributes(Index).getAlignment();
+  const MaybeAlign OldAlign = getAttributesImpl(Index).getAlignment();
   const MaybeAlign NewAlign = B.getAlignment();
   assert((!OldAlign || !NewAlign || OldAlign == NewAlign) &&
          "Attempt to change alignment!");
 #endif
 
-  AttrBuilder Merged(getAttributes(Index));
+  AttrBuilder Merged(getAttributesImpl(Index));
   Merged.merge(B);
   return setAttributes(C, Index, AttributeSet::get(C, Merged));
 }
 
 AttributeList AttributeList::addParamAttribute(LLVMContext &C,
                                                ArrayRef<unsigned> ArgNos,
                                                Attribute A) const {
   assert(llvm::is_sorted(ArgNos));
for (unsigned ArgNo : ArgNos) {
     AttrSets[Index] = AttributeSet::get(C, B);
   }
 
   return getImpl(C, AttrSets);
 }
 
 AttributeList AttributeList::removeAttribute(LLVMContext &C, unsigned Index,
                                              Attribute::AttrKind Kind) const {
-  if (!hasAttribute(Index, Kind)) return *this;
+  if (!hasAttributeImpl(Index, Kind))
+    return *this;
 
   Index = attrIdxToArrayIdx(Index);
   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
   assert(Index < AttrSets.size());
 
   AttrSets[Index] = AttrSets[Index].removeAttribute(C, Kind);
 
   return getImpl(C, AttrSets);
 }
 
 AttributeList AttributeList::removeAttribute(LLVMContext &C, unsigned Index,
                                              StringRef Kind) const {
-  if (!hasAttribute(Index, Kind)) return *this;
+  if (!hasAttributeImpl(Index, Kind))
+    return *this;
 
   Index = attrIdxToArrayIdx(Index);
   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
   assert(Index < AttrSets.size());
 
   AttrSets[Index] = AttrSets[Index].removeAttribute(C, Kind);
 
   return getImpl(C, AttrSets);
 }
 
 AttributeList
 AttributeList::removeAttributes(LLVMContext &C, unsigned Index,
                                 const AttrBuilder &AttrsToRemove) const {
-  AttributeSet Attrs = getAttributes(Index);
+  AttributeSet Attrs = getAttributesImpl(Index);
   AttributeSet NewAttrs = Attrs.removeAttributes(C, AttrsToRemove);
   // If nothing was removed, return the original list.
   if (Attrs == NewAttrs)
     return *this;
   return setAttributes(C, Index, NewAttrs);
 }
 
 AttributeList AttributeList::removeAttributes(LLVMContext &C,
AttributeList AttributeList::addVScaleRangeAttr(LLVMContext &C, unsigned Index,
   return addAttributes(C, Index, B);
 }
 
 //===----------------------------------------------------------------------===//
 // AttributeList Accessor Methods
 //===----------------------------------------------------------------------===//
 
 AttributeSet AttributeList::getParamAttrs(unsigned ArgNo) const {
-  return getAttributes(ArgNo + FirstArgIndex);
+  return getAttributesImpl(ArgNo + FirstArgIndex);
 }
 
 AttributeSet AttributeList::getRetAttrs() const {
-  return getAttributes(ReturnIndex);
+  return getAttributesImpl(ReturnIndex);
 }
 
 AttributeSet AttributeList::getFnAttrs() const {
-  return getAttributes(FunctionIndex);
+  return getAttributesImpl(FunctionIndex);
 }
 
-bool AttributeList::hasAttribute(unsigned Index,
+bool AttributeList::hasAttributeImpl(unsigned Index,
                                      Attribute::AttrKind Kind) const {
-  return getAttributes(Index).hasAttribute(Kind);
+  return getAttributesImpl(Index).hasAttribute(Kind);
 }
 
-bool AttributeList::hasAttribute(unsigned Index, StringRef Kind) const {
-  return getAttributes(Index).hasAttribute(Kind);
+bool AttributeList::hasAttributeImpl(unsigned Index, StringRef Kind) const {
+  return getAttributesImpl(Index).hasAttribute(Kind);
 }
 
-bool AttributeList::hasAttributes(unsigned Index) const {
-  return getAttributes(Index).hasAttributes();
+bool AttributeList::hasAttributesImpl(unsigned Index) const {
+  return getAttributesImpl(Index).hasAttributes();
 }
 
 bool AttributeList::hasFnAttr(Attribute::AttrKind Kind) const {
   return pImpl && pImpl->hasFnAttribute(Kind);
 }
 
 bool AttributeList::hasFnAttr(StringRef Kind) const {
-  return hasAttribute(AttributeList::FunctionIndex, Kind);
+  return hasAttributeImpl(AttributeList::FunctionIndex, Kind);
 }
 
 bool AttributeList::hasAttrSomewhere(Attribute::AttrKind Attr,
                                      unsigned *Index) const {
   return pImpl && pImpl->hasAttrSomewhere(Attr, Index);
 }
 
-Attribute AttributeList::getAttribute(unsigned Index,
+Attribute AttributeList::getAttributeImpl(unsigned Index,
                                           Attribute::AttrKind Kind) const {
-  return getAttributes(Index).getAttribute(Kind);
+  return getAttributesImpl(Index).getAttribute(Kind);
 }
 
-Attribute AttributeList::getAttribute(unsigned Index, StringRef Kind) const {
-  return getAttributes(Index).getAttribute(Kind);
+Attribute AttributeList::getAttributeImpl(unsigned Index,
+                                          StringRef Kind) const {
+  return getAttributesImpl(Index).getAttribute(Kind);
 }
 
 MaybeAlign AttributeList::getRetAlignment() const {
-  return getAttributes(ReturnIndex).getAlignment();
+  return getAttributesImpl(ReturnIndex).getAlignment();
 }
 
 MaybeAlign AttributeList::getParamAlignment(unsigned ArgNo) const {
-  return getAttributes(ArgNo + FirstArgIndex).getAlignment();
+  return getAttributesImpl(ArgNo + FirstArgIndex).getAlignment();
 }
 
 MaybeAlign AttributeList::getParamStackAlignment(unsigned ArgNo) const {
-  return getAttributes(ArgNo + FirstArgIndex).getStackAlignment();
+  return getAttributesImpl(ArgNo + FirstArgIndex).getStackAlignment();
 }
 
 Type *AttributeList::getParamByValType(unsigned Index) const {
-  return getAttributes(Index+FirstArgIndex).getByValType();
+  return getAttributesImpl(Index + FirstArgIndex).getByValType();
 }
 
 Type *AttributeList::getParamStructRetType(unsigned Index) const {
-  return getAttributes(Index + FirstArgIndex).getStructRetType();
+  return getAttributesImpl(Index + FirstArgIndex).getStructRetType();
 }
 
 Type *AttributeList::getParamByRefType(unsigned Index) const {
-  return getAttributes(Index + FirstArgIndex).getByRefType();
+  return getAttributesImpl(Index + FirstArgIndex).getByRefType();
 }
 
 Type *AttributeList::getParamPreallocatedType(unsigned Index) const {
-  return getAttributes(Index + FirstArgIndex).getPreallocatedType();
+  return getAttributesImpl(Index + FirstArgIndex).getPreallocatedType();
 }
 
 Type *AttributeList::getParamInAllocaType(unsigned Index) const {
-  return getAttributes(Index + FirstArgIndex).getInAllocaType();
+  return getAttributesImpl(Index + FirstArgIndex).getInAllocaType();
 }
 
 Type *AttributeList::getParamElementType(unsigned Index) const {
-  return getAttributes(Index + FirstArgIndex).getElementType();
+  return getAttributesImpl(Index + FirstArgIndex).getElementType();
 }
 
 MaybeAlign AttributeList::getStackAlignment(unsigned Index) const {
-  return getAttributes(Index).getStackAlignment();
+  return getAttributesImpl(Index).getStackAlignment();
 }
 
 uint64_t AttributeList::getDereferenceableBytes(unsigned Index) const {
-  return getAttributes(Index).getDereferenceableBytes();
+  return getAttributesImpl(Index).getDereferenceableBytes();
 }
 
 uint64_t AttributeList::getDereferenceableOrNullBytes(unsigned Index) const {
-  return getAttributes(Index).getDereferenceableOrNullBytes();
+  return getAttributesImpl(Index).getDereferenceableOrNullBytes();
 }
 
 std::pair<unsigned, Optional<unsigned>>
 AttributeList::getAllocSizeArgs(unsigned Index) const {
-  return getAttributes(Index).getAllocSizeArgs();
+  return getAttributesImpl(Index).getAllocSizeArgs();
 }
 
 std::pair<unsigned, unsigned>
 AttributeList::getVScaleRangeArgs(unsigned Index) const {
-  return getAttributes(Index).getVScaleRangeArgs();
+  return getAttributesImpl(Index).getVScaleRangeArgs();
 }
 
 std::string AttributeList::getAsString(unsigned Index, bool InAttrGrp) const {
-  return getAttributes(Index).getAsString(InAttrGrp);
+  return getAttributesImpl(Index).getAsString(InAttrGrp);
 }
 
-AttributeSet AttributeList::getAttributes(unsigned Index) const {
+AttributeSet AttributeList::getAttributesImpl(unsigned Index) const {
   Index = attrIdxToArrayIdx(Index);
   if (!pImpl || Index >= getNumAttrSets())
     return {};
   return pImpl->begin()[Index];
 }
 
 bool AttributeList::hasParentContext(LLVMContext &C) const {
   assert(!isEmpty() && "an empty attribute list has no parent context");

 unsigned AttributeList::getNumAttrSets() const {
   return pImpl ? pImpl->NumAttrSets : 0;
 }
 
 void AttributeList::print(raw_ostream &O) const {
   O << "AttributeList[\n";
 
   for (unsigned i = index_begin(), e = index_end(); i != e; ++i) {
-    if (!getAttributes(i).hasAttributes())
+    if (!getAttributesImpl(i).hasAttributes())
       continue;
     O << "  { ";
     switch (i) {
     case AttrIndex::ReturnIndex:
       O << "return";
       break;
     case AttrIndex::FunctionIndex:
       O << "function";

 #endif
 
 //===----------------------------------------------------------------------===//
 // AttrBuilder Method Implementations
 //===----------------------------------------------------------------------===//
 
 // FIXME: Remove this ctor, use AttributeSet.
 AttrBuilder::AttrBuilder(AttributeList AL, unsigned Index) {
-  AttributeSet AS = AL.getAttributes(Index);
+  AttributeSet AS = AL.getAttributesImpl(Index);
   for (const auto &A : AS)
     addAttribute(A);
 }
 
 AttrBuilder::AttrBuilder(AttributeSet AS) {
   for (const auto &A : AS)
     addAttribute(A);
 }
else if (Val == Attribute::AllocSize)
     AllocSizeArgs = 0;
   else if (Val == Attribute::VScaleRange)
     VScaleRangeArgs = 0;
 
   return *this;
 }
 
 AttrBuilder &AttrBuilder::removeAttributes(AttributeList A, uint64_t Index) {
-  remove(A.getAttributes(Index));
+  remove(A.getAttributesImpl(Index));
   return *this;
 }
 
 AttrBuilder &AttrBuilder::removeAttribute(StringRef A) {
   auto I = TargetDepAttrs.find(A);
   if (I != TargetDepAttrs.end())
     TargetDepAttrs.erase(I);
   return *this;
bool AttrBuilder::contains(StringRef A) const {
   return TargetDepAttrs.find(A) != TargetDepAttrs.end();
 }
 
 bool AttrBuilder::hasAttributes() const {
   return !Attrs.none() || !TargetDepAttrs.empty();
 }
 
 bool AttrBuilder::hasAttributes(AttributeList AL, uint64_t Index) const {
-  AttributeSet AS = AL.getAttributes(Index);
+  AttributeSet AS = AL.getAttributesImpl(Index);
 
   for (const auto &Attr : AS) {
     if (Attr.isEnumAttribute() || Attr.isIntAttribute()) {
       if (contains(Attr.getKindAsEnum()))
         return true;
     } else {
       assert(Attr.isStringAttribute() && "Invalid attribute kind!");
       return contains(Attr.getKindAsString());

llvm/lib/IR/Core.cpp

 }
 
 void LLVMAddAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
                              LLVMAttributeRef A) {
   unwrap<Function>(F)->addAttribute(Idx, unwrap(A));
 }
 
 unsigned LLVMGetAttributeCountAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx) {
-  auto AS = unwrap<Function>(F)->getAttributes().getAttributes(Idx);
+  auto AS = unwrap<Function>(F)->getAttributes().getAttributesImpl(Idx);
   return AS.getNumAttributes();
 }
 
 void LLVMGetAttributesAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
                               LLVMAttributeRef *Attrs) {
-  auto AS = unwrap<Function>(F)->getAttributes().getAttributes(Idx);
+  auto AS = unwrap<Function>(F)->getAttributes().getAttributesImpl(Idx);
   for (auto A : AS)
     *Attrs++ = wrap(A);
 }
 
 LLVMAttributeRef LLVMGetEnumAttributeAtIndex(LLVMValueRef F,
                                              LLVMAttributeIndex Idx,
                                              unsigned KindID) {
   return wrap(unwrap<Function>(F)->getAttribute(Idx,

 void LLVMAddCallSiteAttribute(LLVMValueRef C, LLVMAttributeIndex Idx,
                               LLVMAttributeRef A) {
   unwrap<CallBase>(C)->addAttribute(Idx, unwrap(A));
 }
 
 unsigned LLVMGetCallSiteAttributeCount(LLVMValueRef C,
                                        LLVMAttributeIndex Idx) {
   auto *Call = unwrap<CallBase>(C);
-  auto AS = Call->getAttributes().getAttributes(Idx);
+  auto AS = Call->getAttributes().getAttributesImpl(Idx);
   return AS.getNumAttributes();
 }
 
 void LLVMGetCallSiteAttributes(LLVMValueRef C, LLVMAttributeIndex Idx,
                                LLVMAttributeRef *Attrs) {
   auto *Call = unwrap<CallBase>(C);
-  auto AS = Call->getAttributes().getAttributes(Idx);
+  auto AS = Call->getAttributes().getAttributesImpl(Idx);
   for (auto A : AS)
     *Attrs++ = wrap(A);
 }
 
 LLVMAttributeRef LLVMGetCallSiteEnumAttribute(LLVMValueRef C,
                                               LLVMAttributeIndex Idx,
                                               unsigned KindID) {
   return wrap(

llvm/lib/Linker/IRMover.cpp

GlobalVariable *IRLinker::copyGlobalVariableProto(const GlobalVariable *SGVar) {
   return NewDGV;
 }
 
 AttributeList IRLinker::mapAttributeTypes(LLVMContext &C, AttributeList Attrs) {
   for (unsigned i = 0; i < Attrs.getNumAttrSets(); ++i) {
     for (Attribute::AttrKind TypedAttr :
          {Attribute::ByVal, Attribute::StructRet, Attribute::ByRef,
           Attribute::InAlloca}) {
-      if (Attrs.hasAttribute(i, TypedAttr)) {
-        if (Type *Ty = Attrs.getAttribute(i, TypedAttr).getValueAsType()) {
+      if (Attrs.hasAttributeImpl(i, TypedAttr)) {
+        if (Type *Ty = Attrs.getAttributeImpl(i, TypedAttr).getValueAsType()) {
           Attrs = Attrs.replaceAttributeType(C, i, TypedAttr, TypeMap.get(Ty));
           break;
         }
       }
     }
   }
   return Attrs;
 }

llvm/lib/Transforms/IPO/Attributor.cpp

 /// attribute list \p Attrs. This is only the case if it was not already present
 /// in \p Attrs at the position describe by \p PK and \p AttrIdx.
 static bool addIfNotExistent(LLVMContext &Ctx, const Attribute &Attr,
                              AttributeList &Attrs, int AttrIdx,
                              bool ForceReplace = false) {
 
   if (Attr.isEnumAttribute()) {
     Attribute::AttrKind Kind = Attr.getKindAsEnum();
-    if (Attrs.hasAttribute(AttrIdx, Kind))
+    if (Attrs.hasAttributeImpl(AttrIdx, Kind))
       if (!ForceReplace &&
-          isEqualOrWorse(Attr, Attrs.getAttribute(AttrIdx, Kind)))
+          isEqualOrWorse(Attr, Attrs.getAttributeImpl(AttrIdx, Kind)))
         return false;
     Attrs = Attrs.addAttribute(Ctx, AttrIdx, Attr);
     return true;
   }
   if (Attr.isStringAttribute()) {
     StringRef Kind = Attr.getKindAsString();
-    if (Attrs.hasAttribute(AttrIdx, Kind))
+    if (Attrs.hasAttributeImpl(AttrIdx, Kind))
       if (!ForceReplace &&
-          isEqualOrWorse(Attr, Attrs.getAttribute(AttrIdx, Kind)))
+          isEqualOrWorse(Attr, Attrs.getAttributeImpl(AttrIdx, Kind)))
         return false;
     Attrs = Attrs.addAttribute(Ctx, AttrIdx, Attr);
     return true;
   }
   if (Attr.isIntAttribute()) {
     Attribute::AttrKind Kind = Attr.getKindAsEnum();
-    if (Attrs.hasAttribute(AttrIdx, Kind))
+    if (Attrs.hasAttributeImpl(AttrIdx, Kind))
       if (!ForceReplace &&
-          isEqualOrWorse(Attr, Attrs.getAttribute(AttrIdx, Kind)))
+          isEqualOrWorse(Attr, Attrs.getAttributeImpl(AttrIdx, Kind)))
         return false;
     Attrs = Attrs.removeAttribute(Ctx, AttrIdx, Kind);
     Attrs = Attrs.addAttribute(Ctx, AttrIdx, Attr);
     return true;
   }
 
   llvm_unreachable("Expected enum or string attribute!");
 }
if (getPositionKind() == IRP_INVALID || getPositionKind() == IRP_FLOAT)
     return false;
 
   AttributeList AttrList;
   if (const auto *CB = dyn_cast<CallBase>(&getAnchorValue()))
     AttrList = CB->getAttributes();
   else
     AttrList = getAssociatedFunction()->getAttributes();
 
-  bool HasAttr = AttrList.hasAttribute(getAttrIdx(), AK);
+  bool HasAttr = AttrList.hasAttributeImpl(getAttrIdx(), AK);
   if (HasAttr)
-    Attrs.push_back(AttrList.getAttribute(getAttrIdx(), AK));
+    Attrs.push_back(AttrList.getAttributeImpl(getAttrIdx(), AK));
   return HasAttr;
 }
 
 bool IRPosition::getAttrsFromAssumes(Attribute::AttrKind AK,
                                      SmallVectorImpl<Attribute> &Attrs,
                                      Attributor &A) const {
   assert(getPositionKind() != IRP_INVALID && "Did expect a valid position!");
   Value &AssociatedValue = getAssociatedValue();

llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

static void RemoveNonValidAttrAtIndex(LLVMContext &Ctx, AttrHolder &AH,
   AttrBuilder R;
   if (AH.getDereferenceableBytes(Index))
     R.addAttribute(Attribute::get(Ctx, Attribute::Dereferenceable,
                                   AH.getDereferenceableBytes(Index)));
   if (AH.getDereferenceableOrNullBytes(Index))
     R.addAttribute(Attribute::get(Ctx, Attribute::DereferenceableOrNull,
                                   AH.getDereferenceableOrNullBytes(Index)));
   for (auto Attr : ParamAttrsToStrip)
-    if (AH.getAttributes().hasAttribute(Index, Attr))
+    if (AH.getAttributes().hasAttributeImpl(Index, Attr))
       R.addAttribute(Attr);
 
   if (!R.empty())
     AH.setAttributes(AH.getAttributes().removeAttributes(Ctx, Index, R));
 }
 
 static void stripNonValidAttributesFromPrototype(Function &F) {
   LLVMContext &Ctx = F.getContext();

llvm/lib/Transforms/Utils/FunctionComparator.cpp

 }
 
 int FunctionComparator::cmpAttrs(const AttributeList L,
                                  const AttributeList R) const {
   if (int Res = cmpNumbers(L.getNumAttrSets(), R.getNumAttrSets()))
     return Res;
 
   for (unsigned i = L.index_begin(), e = L.index_end(); i != e; ++i) {
-    AttributeSet LAS = L.getAttributes(i);
-    AttributeSet RAS = R.getAttributes(i);
+    AttributeSet LAS = L.getAttributesImpl(i);
+    AttributeSet RAS = R.getAttributesImpl(i);
     AttributeSet::iterator LI = LAS.begin(), LE = LAS.end();
     AttributeSet::iterator RI = RAS.begin(), RE = RAS.end();
     for (; LI != LE && RI != RE; ++LI, ++RI) {
       Attribute LA = *LI;
       Attribute RA = *RI;
       if (LA.isTypeAttribute() && RA.isTypeAttribute()) {
         if (LA.getKindAsEnum() != RA.getKindAsEnum())
           return cmpNumbers(LA.getKindAsEnum(), RA.getKindAsEnum());

llvm/lib/Transforms/Utils/ValueMapper.cpp

CB->mutateFunctionType(FunctionType::get(
         TypeMapper->remapType(I->getType()), Tys, FTy->isVarArg()));
 
     LLVMContext &C = CB->getContext();
     AttributeList Attrs = CB->getAttributes();
     for (unsigned i = 0; i < Attrs.getNumAttrSets(); ++i) {
       for (Attribute::AttrKind TypedAttr :
              {Attribute::ByVal, Attribute::StructRet, Attribute::ByRef,
               Attribute::InAlloca}) {
-        if (Type *Ty = Attrs.getAttribute(i, TypedAttr).getValueAsType()) {
+        if (Type *Ty = Attrs.getAttributeImpl(i, TypedAttr).getValueAsType()) {
           Attrs = Attrs.replaceAttributeType(C, i, TypedAttr,
                                              TypeMapper->remapType(Ty));
           break;
         }
       }
     }
     CB->setAttributes(Attrs);
     return;

llvm/tools/llvm-reduce/deltas/ReduceAttributes.cpp

public:
   void visitAttributeList(const AttributeList &AL,
                           AttrPtrVecVecTy &AttributeSetsToPreserve) {
     assert(AttributeSetsToPreserve.empty() && "Should not be sharing vectors.");
     AttributeSetsToPreserve.reserve(AL.getNumAttrSets());
     for (unsigned SetIdx = AL.index_begin(), SetEndIdx = AL.index_end();
          SetIdx != SetEndIdx; ++SetIdx) {
       AttrPtrIdxVecVecTy AttributesToPreserve;
       AttributesToPreserve.first = SetIdx;
-      visitAttributeSet(AL.getAttributes(AttributesToPreserve.first),
+      visitAttributeSet(AL.getAttributesImpl(AttributesToPreserve.first),
                         AttributesToPreserve.second);
       if (!AttributesToPreserve.second.empty())
         AttributeSetsToPreserve.emplace_back(std::move(AttributesToPreserve));
     }
   }
 
   void visitAttributeSet(const AttributeSet &AS,
                          AttrPtrVecTy &AttrsToPreserve) {