diff --git a/llvm/include/llvm/IR/Attributes.h b/llvm/include/llvm/IR/Attributes.h --- a/llvm/include/llvm/IR/Attributes.h +++ b/llvm/include/llvm/IR/Attributes.h @@ -559,7 +559,7 @@ 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)); } @@ -616,7 +616,7 @@ //===--------------------------------------------------------------------===// /// 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. @@ -629,41 +629,41 @@ 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; @@ -672,7 +672,7 @@ 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 @@ -681,29 +681,29 @@ 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. diff --git a/llvm/include/llvm/IR/Function.h b/llvm/include/llvm/IR/Function.h --- a/llvm/include/llvm/IR/Function.h +++ b/llvm/include/llvm/IR/Function.h @@ -442,7 +442,7 @@ /// 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. @@ -462,12 +462,12 @@ /// 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. diff --git a/llvm/include/llvm/IR/InstrTypes.h b/llvm/include/llvm/IR/InstrTypes.h --- a/llvm/include/llvm/IR/InstrTypes.h +++ b/llvm/include/llvm/IR/InstrTypes.h @@ -1585,12 +1585,12 @@ /// 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 diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp --- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp +++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp @@ -836,7 +836,7 @@ 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})); } diff --git a/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp b/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp --- a/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp +++ b/llvm/lib/Bitcode/Writer/ValueEnumerator.cpp @@ -1037,7 +1037,7 @@ // 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}; diff --git a/llvm/lib/CodeGen/GlobalISel/CallLowering.cpp b/llvm/lib/CodeGen/GlobalISel/CallLowering.cpp --- a/llvm/lib/CodeGen/GlobalISel/CallLowering.cpp +++ b/llvm/lib/CodeGen/GlobalISel/CallLowering.cpp @@ -73,7 +73,7 @@ const AttributeList &Attrs, unsigned OpIdx) const { addFlagsUsingAttrFn(Flags, [&Attrs, &OpIdx](Attribute::AttrKind Attr) { - return Attrs.hasAttribute(OpIdx, Attr); + return Attrs.hasAttributeImpl(OpIdx, Attr); }); } @@ -167,7 +167,7 @@ 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 diff --git a/llvm/lib/IR/Attributes.cpp b/llvm/lib/IR/Attributes.cpp --- a/llvm/lib/IR/Attributes.cpp +++ b/llvm/lib/IR/Attributes.cpp @@ -1202,7 +1202,7 @@ 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); } @@ -1211,8 +1211,9 @@ 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 NewAttrs(Attrs.begin(), Attrs.end()); NewAttrs.push_back(Attribute::get(C, Kind)); @@ -1255,13 +1256,13 @@ #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)); } @@ -1288,7 +1289,8 @@ 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 AttrSets(this->begin(), this->end()); @@ -1301,7 +1303,8 @@ 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 AttrSets(this->begin(), this->end()); @@ -1315,7 +1318,7 @@ 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) @@ -1373,28 +1376,28 @@ //===----------------------------------------------------------------------===// 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, - Attribute::AttrKind Kind) const { - return getAttributes(Index).hasAttribute(Kind); +bool AttributeList::hasAttributeImpl(unsigned Index, + Attribute::AttrKind Kind) const { + 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 { @@ -1402,7 +1405,7 @@ } bool AttributeList::hasFnAttr(StringRef Kind) const { - return hasAttribute(AttributeList::FunctionIndex, Kind); + return hasAttributeImpl(AttributeList::FunctionIndex, Kind); } bool AttributeList::hasAttrSomewhere(Attribute::AttrKind Attr, @@ -1410,78 +1413,79 @@ return pImpl && pImpl->hasAttrSomewhere(Attr, Index); } -Attribute AttributeList::getAttribute(unsigned Index, - Attribute::AttrKind Kind) const { - return getAttributes(Index).getAttribute(Kind); +Attribute AttributeList::getAttributeImpl(unsigned Index, + Attribute::AttrKind Kind) const { + 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> AttributeList::getAllocSizeArgs(unsigned Index) const { - return getAttributes(Index).getAllocSizeArgs(); + return getAttributesImpl(Index).getAllocSizeArgs(); } std::pair 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 {}; @@ -1516,7 +1520,7 @@ 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) { @@ -1545,7 +1549,7 @@ // 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); } @@ -1628,7 +1632,7 @@ } AttrBuilder &AttrBuilder::removeAttributes(AttributeList A, uint64_t Index) { - remove(A.getAttributes(Index)); + remove(A.getAttributesImpl(Index)); return *this; } @@ -1840,7 +1844,7 @@ } 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()) { diff --git a/llvm/lib/IR/Core.cpp b/llvm/lib/IR/Core.cpp --- a/llvm/lib/IR/Core.cpp +++ b/llvm/lib/IR/Core.cpp @@ -2464,13 +2464,13 @@ } unsigned LLVMGetAttributeCountAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx) { - auto AS = unwrap(F)->getAttributes().getAttributes(Idx); + auto AS = unwrap(F)->getAttributes().getAttributesImpl(Idx); return AS.getNumAttributes(); } void LLVMGetAttributesAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, LLVMAttributeRef *Attrs) { - auto AS = unwrap(F)->getAttributes().getAttributes(Idx); + auto AS = unwrap(F)->getAttributes().getAttributesImpl(Idx); for (auto A : AS) *Attrs++ = wrap(A); } @@ -2873,14 +2873,14 @@ unsigned LLVMGetCallSiteAttributeCount(LLVMValueRef C, LLVMAttributeIndex Idx) { auto *Call = unwrap(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(C); - auto AS = Call->getAttributes().getAttributes(Idx); + auto AS = Call->getAttributes().getAttributesImpl(Idx); for (auto A : AS) *Attrs++ = wrap(A); } diff --git a/llvm/lib/Linker/IRMover.cpp b/llvm/lib/Linker/IRMover.cpp --- a/llvm/lib/Linker/IRMover.cpp +++ b/llvm/lib/Linker/IRMover.cpp @@ -651,8 +651,8 @@ 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; } diff --git a/llvm/lib/Transforms/IPO/Attributor.cpp b/llvm/lib/Transforms/IPO/Attributor.cpp --- a/llvm/lib/Transforms/IPO/Attributor.cpp +++ b/llvm/lib/Transforms/IPO/Attributor.cpp @@ -382,27 +382,27 @@ 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); @@ -658,9 +658,9 @@ 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; } diff --git a/llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp b/llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp --- a/llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp +++ b/llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp @@ -2662,7 +2662,7 @@ 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()) diff --git a/llvm/lib/Transforms/Utils/FunctionComparator.cpp b/llvm/lib/Transforms/Utils/FunctionComparator.cpp --- a/llvm/lib/Transforms/Utils/FunctionComparator.cpp +++ b/llvm/lib/Transforms/Utils/FunctionComparator.cpp @@ -111,8 +111,8 @@ 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) { diff --git a/llvm/lib/Transforms/Utils/ValueMapper.cpp b/llvm/lib/Transforms/Utils/ValueMapper.cpp --- a/llvm/lib/Transforms/Utils/ValueMapper.cpp +++ b/llvm/lib/Transforms/Utils/ValueMapper.cpp @@ -947,7 +947,7 @@ 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; diff --git a/llvm/tools/llvm-reduce/deltas/ReduceAttributes.cpp b/llvm/tools/llvm-reduce/deltas/ReduceAttributes.cpp --- a/llvm/tools/llvm-reduce/deltas/ReduceAttributes.cpp +++ b/llvm/tools/llvm-reduce/deltas/ReduceAttributes.cpp @@ -88,7 +88,7 @@ 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));