[IR] Use a proper type for AttributeList indexing

[gchatelet]

Summary

This is a follow up patch on https://reviews.llvm.org/D32811.
It avoids leaking information about the encoding of the index for
AttributeList.

[gchatelet]

The gist of the patch is the addition of a inner Index class inside AttributeList see llvm/include/llvm/IR/Attributes.h.
This patch should be NFC.

[gchatelet]

• revert unrelated change

[foad]

llvm/lib/Target/AMDGPU/AMDGPUCallLowering.cpp

641

This is just a drive-by comment, so feel free to ignore, but for client code like this it would be nicer if we could just write AttributeList::getArgIndex. (It already says Index in the function name so why do I have to qualify it with Index:: as well?)

[gchatelet]

• rename functions

[gchatelet]

llvm/lib/Target/AMDGPU/AMDGPUCallLowering.cpp

641

Yes good point, I'm still refining the API to make it easier to use. This is is great suggestion thx!

[gchatelet]

• Provide a simpler way to create Arg indices

[gchatelet]

• Rebase and Fix lint issues

[gchatelet]

• rebase to get rid of unrelated broken tests

[courbet]

Nice!

llvm/include/llvm/IR/Attributes.h

444

constexpr ?

llvm/lib/Transforms/Utils/AssumeBundleBuilder.cpp

212

This was broken, right ?

[gchatelet]

@cherry @anna @thanm since you worked on D53602. Do you have a sense of whether the failing test is legitimate?

Basically these lines :

call void bitcast (void (...)* @c to void (i32*)*)(i32* sret(i32) %y)
call void bitcast (void (i32, ...)* @d to void (i32, i32*)*)(i32 0, i32* sret(i32) %y)

Are considered illegal by the Verifier and trigger the following assert:

if (TargetFuncType->isVarArg()) {
  AttributeSet ArgAttrs = Attrs.getParamAttributes(5 + i);
  Assert(!ArgAttrs.hasAttribute(Attribute::StructRet),
         "Attribute 'sret' cannot be used for vararg call arguments!",
         Call);
}

Any help here would be highly appreciated!

llvm/include/llvm/IR/Attributes.h

444

As discussed offline, I wasn't able to do so because the definition of AttributeList::Index::Index() is not available before AttributeList class is finished parsing.
This then fires the following error expression must have a constant value -- constexpr function "llvm::AttributeList::Index::Index(unsigned int Value)" (declared at line 394) is not definedC/C++(28)

llvm/lib/Transforms/Utils/AssumeBundleBuilder.cpp

212

This was broken, right ?

Yes I believe so. It might 'happen to work' by chance.

[thanm]

I am confused as to why this test would be failing. The verifier fragment in question is for statepoints, and I don't see any statepoints in the test. When I run

./bin/opt -debug-pass-manager -instcombine -S < ../llvm-project/llvm/test/Transforms/InstCombine/call-cast-attrs.ll

I don't see anything related to statepoints or statepoint lowering.

[gchatelet]

In D105485#2864372, @thanm wrote:

I am confused as to why this test would be failing. The verifier fragment in question is for statepoints, and I don't see any statepoints in the test. When I run

./bin/opt -debug-pass-manager -instcombine -S < ../llvm-project/llvm/test/Transforms/InstCombine/call-cast-attrs.ll

I don't see anything related to statepoints or statepoint lowering.

I may have linked to the wrong line in Verifier.cpp. There are two asserts with the same message.

[thanm]

I may have linked to the wrong line in Verifier.cpp. There are two asserts with the same message.

Ah, ok, that makes a bit more sense. https://reviews.llvm.org/D53602 really only deals with the statepoint case, so I am not sure if I have any insights as to what might be doing wrong with this test.

[gchatelet]

In D105485#2864433, @thanm wrote:

I may have linked to the wrong line in Verifier.cpp. There are two asserts with the same message.

Ah, ok, that makes a bit more sense. https://reviews.llvm.org/D53602 really only deals with the statepoint case, so I am not sure if I have any insights as to what might be doing wrong with this test.

My bad then. Sorry for bothering.

[gchatelet]

In D105485#2864433, @thanm wrote:

I may have linked to the wrong line in Verifier.cpp. There are two asserts with the same message.

Ah, ok, that makes a bit more sense. https://reviews.llvm.org/D53602 really only deals with the statepoint case, so I am not sure if I have any insights as to what might be doing wrong with this test.

@thanm upon closer look the second error message also comes from D53602.
See https://reviews.llvm.org/D53602#change-oHfYVs0pQmdt

https://github.com/llvm/llvm-project/blob/ba913b8da57dcdcda0572ec3a6b8d4e367f22803/llvm/lib/IR/Verifier.cpp#L3267-L3272

// Statepoint intrinsic is vararg but the wrapped function may be not.
// Allow sret here and check the wrapped function in verifyStatepoint.
if (!Call.getCalledFunction() ||
    Call.getCalledFunction()->getIntrinsicID() !=
        Intrinsic::experimental_gc_statepoint)
  Assert(!ArgAttrs.hasAttribute(Attribute::StructRet),
         "Attribute 'sret' cannot be used for vararg call arguments!",
         Call);

So it's definitely one of these two (there are no other such error messages in the codebase)

[gchatelet]

Replying here to my for future self. There's currently a hole in the type system which lets AttributeIndex be created from an unsigned, this leaves a whole lot of indexing logic deal with the unsafe type, starting with llvm/utils/TableGen/IntrinsicEmitter.cpp.
So there is actually much more work to introduce a proper type.

I'm putting this patch on hold for now.

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

2681

The mistake is here it should be SRetIdx.rawValue() > FT->getNumParams() but this leaks the abstraction.

llvm/include/llvm/CodeGen/GlobalISel/CallLowering.h

protected:
   /// parameter of \p Call.
   ISD::ArgFlagsTy getAttributesForArgIdx(const CallBase &Call,
                                          unsigned ArgIdx) const;
 
   /// Adds flags to \p Flags based off of the attributes in \p Attrs.
   /// \p OpIdx is the index in \p Attrs to add flags from.
   void addArgFlagsFromAttributes(ISD::ArgFlagsTy &Flags,
                                  const AttributeList &Attrs,
-                                 unsigned OpIdx) const;
+                                 AttributeList::Index OpIdx) const;
 
   template <typename FuncInfoTy>
-  void setArgFlags(ArgInfo &Arg, unsigned OpIdx, const DataLayout &DL,
-                   const FuncInfoTy &FuncInfo) const;
+  void setArgFlags(ArgInfo &Arg, AttributeList::Index OpIdx,
+                   const DataLayout &DL, const FuncInfoTy &FuncInfo) const;
 
   /// Break \p OrigArgInfo into one or more pieces the calling convention can
   /// process, returned in \p SplitArgs. For example, this should break structs
   /// down into individual fields.
   void splitToValueTypes(const ArgInfo &OrigArgInfo,
                          SmallVectorImpl<ArgInfo> &SplitArgs,
                          const DataLayout &DL, CallingConv::ID CallConv) const;
 

llvm/include/llvm/IR/Attributes.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_ATTRIBUTES_H
 #define LLVM_IR_ATTRIBUTES_H
 
 #include "llvm-c/Types.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/Alignment.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 #include <bitset>

 /// This class holds the attributes for a function, its return value, and
 /// its parameters. You access the attributes for each of them via an index into
 /// the AttributeList object. The function attributes are at index
 /// `AttributeList::FunctionIndex', the return value is at index
 /// `AttributeList::ReturnIndex', and the attributes for the parameters start at
 /// index `AttributeList::FirstArgIndex'.
 class AttributeList {
 public:
-  enum AttrIndex : unsigned {
-    ReturnIndex = 0U,
-    FunctionIndex = ~0U,
-    FirstArgIndex = 1,
+  //===--------------------------------------------------------------------===//
+  /// \class
+  /// This class act as an indexing type for the AttributeList.
+  class Index {
+  public:
+    Index() = default;
+    Index(unsigned Value) : Value(Value) {}
+
+    bool operator<(Index Other) const { return Value < Other.Value; }
+    bool operator==(Index Other) const { return Value == Other.Value; }
+    bool operator!=(Index Other) const { return Value != Other.Value; }
+
+    Index &operator++() {
+      ++Value;
+      return *this;
+    }
+
+    /// Whether this index refers to an Argument.
+    bool isArg() const {
+      return Value != ReturnIndex && Value != FunctionIndex;
+    }
+
+    /// When this index refers to an Argument, the position of the argument in
+    /// the function arguments list.
+    unsigned toArgNo() const {
+      assert(isArg() && "Not an argument");
+      return Value - FirstArgIndex;
+    }
+
+    /// The internal encoded representation of this Index.
+    /// Use with caution as it's an implementation detail.
+    unsigned raw_value() const { return Value; }
+
+  private:
+    static constexpr unsigned FirstArgIndex = 1;
+    static constexpr unsigned ReturnIndex = 0;
+    static constexpr unsigned FunctionIndex = ~0;
+
+    unsigned Value = 0;
+
+    /// Creates an Index representing the ArgNo argument in the function
+    /// arguments list.
+    static Index fromArgNo(unsigned ArgNo) { return {ArgNo + FirstArgIndex}; }
+
+    /// Map from AttributeList index to the internal array index. Adding one
+    /// happens to work, because -1 wraps around to 0.
+    unsigned ArrayIndex() const { return Value + 1; }
+    static Index FromArrayIndex(unsigned Value) { return {Value - 1}; }
+
+    friend class AttributeList;
+    friend class AttributeListImpl;
   };
 
+  /// Creates an Index representing the ArgNo argument in the function arguments
+  /// list.
+  static Index getArgIndex(unsigned ArgNo) { return Index::fromArgNo(ArgNo); }
+  static const Index ReturnIndex;
+  static const Index FunctionIndex;
+
 private:
   friend class AttrBuilder;
   friend class AttributeListImpl;
   friend class AttributeSet;
   friend class AttributeSetNode;
   template <typename Ty> friend struct DenseMapInfo;
 
   /// The attributes that we are managing. This can be null to represent
   /// the empty attributes list.
   AttributeListImpl *pImpl = nullptr;
 
 public:
   /// Create an AttributeList with the specified parameters in it.
   static AttributeList get(LLVMContext &C,
-                           ArrayRef<std::pair<unsigned, Attribute>> Attrs);
+                           ArrayRef<std::pair<Index, Attribute>> Attrs);
   static AttributeList get(LLVMContext &C,
-                           ArrayRef<std::pair<unsigned, AttributeSet>> Attrs);
+                           ArrayRef<std::pair<Index, AttributeSet>> Attrs);
 
   /// Create an AttributeList from attribute sets for a function, its
   /// return value, and all of its arguments.
   static AttributeList get(LLVMContext &C, AttributeSet FnAttrs,
                            AttributeSet RetAttrs,
                            ArrayRef<AttributeSet> ArgAttrs);
 
 private:
   explicit AttributeList(AttributeListImpl *LI) : pImpl(LI) {}
 
   static AttributeList getImpl(LLVMContext &C, ArrayRef<AttributeSet> AttrSets);
 
-  AttributeList setAttributes(LLVMContext &C, unsigned Index,
+  AttributeList setAttributes(LLVMContext &C, Index Index,
                               AttributeSet Attrs) const;
 
 public:
   AttributeList() = default;
 
   //===--------------------------------------------------------------------===//
   // AttributeList Construction and Mutation
   //===--------------------------------------------------------------------===//
 
   /// Return an AttributeList with the specified parameters in it.
   static AttributeList get(LLVMContext &C, ArrayRef<AttributeList> Attrs);
-  static AttributeList get(LLVMContext &C, unsigned Index,
+  static AttributeList get(LLVMContext &C, Index Index,
                            ArrayRef<Attribute::AttrKind> Kinds);
-  static AttributeList get(LLVMContext &C, unsigned Index,
+  static AttributeList get(LLVMContext &C, Index Index,
                            ArrayRef<Attribute::AttrKind> Kinds,
                            ArrayRef<uint64_t> Values);
-  static AttributeList get(LLVMContext &C, unsigned Index,
+  static AttributeList get(LLVMContext &C, Index Index,
                            ArrayRef<StringRef> Kind);
-  static AttributeList get(LLVMContext &C, unsigned Index,
-                           const AttrBuilder &B);
+  static AttributeList get(LLVMContext &C, Index Index, const AttrBuilder &B);
 
   /// Add an attribute to the attribute set at the given index.
   /// Returns a new list because attribute lists are immutable.
-  LLVM_NODISCARD AttributeList addAttribute(LLVMContext &C, unsigned Index,
+  LLVM_NODISCARD AttributeList addAttribute(LLVMContext &C, Index Index,
                                             Attribute::AttrKind Kind) const;
 
   /// Add an attribute to the attribute set at the given index.
   /// Returns a new list because attribute lists are immutable.
   LLVM_NODISCARD AttributeList
-  addAttribute(LLVMContext &C, unsigned Index, StringRef Kind,
+  addAttribute(LLVMContext &C, Index Index, StringRef Kind,
                StringRef Value = StringRef()) const;
 
   /// Add an attribute to the attribute set at the given index.
   /// Returns a new list because attribute lists are immutable.
-  LLVM_NODISCARD AttributeList addAttribute(LLVMContext &C, unsigned Index,
+  LLVM_NODISCARD AttributeList addAttribute(LLVMContext &C, Index Index,
                                             Attribute A) const;
 
   /// Add attributes to the attribute set at the given index.
   /// Returns a new list because attribute lists are immutable.
-  LLVM_NODISCARD AttributeList addAttributes(LLVMContext &C, unsigned Index,
+  LLVM_NODISCARD AttributeList addAttributes(LLVMContext &C, Index Index,
                                              const AttrBuilder &B) const;
 
   /// Add an argument attribute to the list. Returns a new list because
   /// attribute lists are immutable.
   LLVM_NODISCARD AttributeList addParamAttribute(
       LLVMContext &C, unsigned ArgNo, Attribute::AttrKind Kind) const {
-    return addAttribute(C, ArgNo + FirstArgIndex, Kind);
+    return addAttribute(C, getArgIndex(ArgNo), Kind);
   }
 
   /// Add an argument attribute to the list. Returns a new list because
   /// attribute lists are immutable.
   LLVM_NODISCARD AttributeList
   addParamAttribute(LLVMContext &C, unsigned ArgNo, StringRef Kind,
                     StringRef Value = StringRef()) const {
-    return addAttribute(C, ArgNo + FirstArgIndex, Kind, Value);
+    return addAttribute(C, getArgIndex(ArgNo), Kind, Value);
   }
 
   /// Add an attribute to the attribute list at the given arg indices. Returns a
   /// new list because attribute lists are immutable.
   LLVM_NODISCARD AttributeList addParamAttribute(LLVMContext &C,
                                                  ArrayRef<unsigned> ArgNos,
                                                  Attribute A) const;
 
   /// Add an argument attribute to the list. Returns a new list because
   /// attribute lists are immutable.
   LLVM_NODISCARD AttributeList addParamAttributes(LLVMContext &C,
                                                   unsigned ArgNo,
                                                   const AttrBuilder &B) const {
-    return addAttributes(C, ArgNo + FirstArgIndex, B);
+    return addAttributes(C, getArgIndex(ArgNo), B);
   }
 
   /// Remove the specified attribute at the specified index from this
   /// attribute list. Returns a new list because attribute lists are immutable.
-  LLVM_NODISCARD AttributeList removeAttribute(LLVMContext &C, unsigned Index,
+  LLVM_NODISCARD AttributeList removeAttribute(LLVMContext &C, Index Index,
                                                Attribute::AttrKind Kind) const;
 
   /// Remove the specified attribute at the specified index from this
   /// attribute list. Returns a new list because attribute lists are immutable.
-  LLVM_NODISCARD AttributeList removeAttribute(LLVMContext &C, unsigned Index,
+  LLVM_NODISCARD AttributeList removeAttribute(LLVMContext &C, Index Index,
                                                StringRef Kind) const;
 
   /// Remove the specified attributes at the specified index from this
   /// attribute list. Returns a new list because attribute lists are immutable.
   LLVM_NODISCARD AttributeList removeAttributes(
-      LLVMContext &C, unsigned Index, const AttrBuilder &AttrsToRemove) const;
+      LLVMContext &C, Index Index, const AttrBuilder &AttrsToRemove) const;
 
   /// Remove all attributes at the specified index from this
   /// attribute list. Returns a new list because attribute lists are immutable.
   LLVM_NODISCARD AttributeList removeAttributes(LLVMContext &C,
-                                                unsigned Index) const;
+                                                Index Index) const;
 
   /// Remove the specified attribute at the specified arg index from this
   /// attribute list. Returns a new list because attribute lists are immutable.
   LLVM_NODISCARD AttributeList removeParamAttribute(
       LLVMContext &C, unsigned ArgNo, Attribute::AttrKind Kind) const {
-    return removeAttribute(C, ArgNo + FirstArgIndex, Kind);
+    return removeAttribute(C, getArgIndex(ArgNo), Kind);
   }
 
   /// Remove the specified attribute at the specified arg index from this
   /// attribute list. Returns a new list because attribute lists are immutable.
   LLVM_NODISCARD AttributeList removeParamAttribute(LLVMContext &C,
                                                     unsigned ArgNo,
                                                     StringRef Kind) const {
-    return removeAttribute(C, ArgNo + FirstArgIndex, Kind);
+    return removeAttribute(C, getArgIndex(ArgNo), Kind);
   }
 
   /// Remove the specified attribute at the specified arg index from this
   /// attribute list. Returns a new list because attribute lists are immutable.
   LLVM_NODISCARD AttributeList removeParamAttributes(
       LLVMContext &C, unsigned ArgNo, const AttrBuilder &AttrsToRemove) const {
-    return removeAttributes(C, ArgNo + FirstArgIndex, AttrsToRemove);
+    return removeAttributes(C, getArgIndex(ArgNo), AttrsToRemove);
   }
 
   /// Remove noundef attribute and other attributes that imply undefined
   /// behavior if a `undef` or `poison` value is passed from this attribute
   /// list. Returns a new list because attribute lists are immutable.
   LLVM_NODISCARD AttributeList
   removeParamUndefImplyingAttributes(LLVMContext &C, unsigned ArgNo) const;
 
   /// Remove all attributes at the specified arg index from this
   /// attribute list. Returns a new list because attribute lists are immutable.
   LLVM_NODISCARD AttributeList removeParamAttributes(LLVMContext &C,
                                                      unsigned ArgNo) const {
-    return removeAttributes(C, ArgNo + FirstArgIndex);
+    return removeAttributes(C, getArgIndex(ArgNo));
   }
 
   /// 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);
     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,
+                                                      Index Index,
                                                       uint64_t Bytes) const;
 
   /// \brief Add the dereferenceable attribute to the attribute set at the given
   /// arg index. Returns a new list because attribute lists are immutable.
   LLVM_NODISCARD AttributeList addDereferenceableParamAttr(
       LLVMContext &C, unsigned ArgNo, uint64_t Bytes) const {
-    return addDereferenceableAttr(C, ArgNo + FirstArgIndex, Bytes);
+    return addDereferenceableAttr(C, getArgIndex(ArgNo), Bytes);
   }
 
   /// Add the dereferenceable_or_null attribute to the attribute set at
   /// the given index. Returns a new list because attribute lists are immutable.
   LLVM_NODISCARD AttributeList addDereferenceableOrNullAttr(
-      LLVMContext &C, unsigned Index, uint64_t Bytes) const;
+      LLVMContext &C, Index Index, uint64_t Bytes) const;
 
   /// Add the dereferenceable_or_null attribute to the attribute set at
   /// the given arg index. Returns a new list because attribute lists are
   /// immutable.
   LLVM_NODISCARD AttributeList addDereferenceableOrNullParamAttr(
       LLVMContext &C, unsigned ArgNo, uint64_t Bytes) const {
-    return addDereferenceableOrNullAttr(C, ArgNo + FirstArgIndex, Bytes);
+    return addDereferenceableOrNullAttr(C, getArgIndex(ArgNo), Bytes);
   }
 
   /// Add the allocsize attribute to the attribute set at the given index.
   /// Returns a new list because attribute lists are immutable.
   LLVM_NODISCARD AttributeList
-  addAllocSizeAttr(LLVMContext &C, unsigned Index, unsigned ElemSizeArg,
+  addAllocSizeAttr(LLVMContext &C, Index Index, unsigned ElemSizeArg,
                    const Optional<unsigned> &NumElemsArg);
 
   /// Add the allocsize attribute to the attribute set at the given arg index.
   /// Returns a new list because attribute lists are immutable.
   LLVM_NODISCARD AttributeList
   addAllocSizeParamAttr(LLVMContext &C, unsigned ArgNo, unsigned ElemSizeArg,
                         const Optional<unsigned> &NumElemsArg) {
-    return addAllocSizeAttr(C, ArgNo + FirstArgIndex, ElemSizeArg, NumElemsArg);
+    return addAllocSizeAttr(C, getArgIndex(ArgNo), ElemSizeArg, NumElemsArg);
   }
 
   /// Add the vscale_range attribute to the attribute set at the given index.
   /// Returns a new list because attribute lists are immutable.
-  LLVM_NODISCARD AttributeList addVScaleRangeAttr(LLVMContext &C,
-                                                  unsigned Index,
+  LLVM_NODISCARD AttributeList addVScaleRangeAttr(LLVMContext &C, Index Index,
                                                   unsigned MinValue,
                                                   unsigned MaxValue);
 
   //===--------------------------------------------------------------------===//
   // AttributeList Accessors
   //===--------------------------------------------------------------------===//
 
   /// The attributes for the specified index are returned.
-  AttributeSet getAttributes(unsigned Index) const;
+  AttributeSet getAttributes(Index Index) const;
 
   /// The attributes for the argument or parameter at the given index are
   /// returned.
   AttributeSet getParamAttributes(unsigned ArgNo) const;
 
   /// The attributes for the ret value are returned.
   AttributeSet getRetAttributes() const;
 
   /// The function attributes are returned.
   AttributeSet getFnAttributes() const;
 
   /// Return true if the attribute exists at the given index.
-  bool hasAttribute(unsigned Index, Attribute::AttrKind Kind) const;
+  bool hasAttribute(Index Index, Attribute::AttrKind Kind) const;
 
   /// Return true if the attribute exists at the given index.
-  bool hasAttribute(unsigned Index, StringRef Kind) const;
+  bool hasAttribute(Index Index, StringRef Kind) const;
 
   /// Return true if attribute exists at the given index.
-  bool hasAttributes(unsigned Index) const;
+  bool hasAttributes(Index 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 hasAttribute(getArgIndex(ArgNo), Kind);
   }
 
   /// Return true if the attribute exists for the given argument
   bool hasParamAttr(unsigned ArgNo, StringRef Kind) const {
-    return hasAttribute(ArgNo + FirstArgIndex, Kind);
+    return hasAttribute(getArgIndex(ArgNo), Kind);
   }
 
   /// Return true if attributes exists for the given argument
   bool hasParamAttrs(unsigned ArgNo) const {
-    return hasAttributes(ArgNo + FirstArgIndex);
+    return hasAttributes(getArgIndex(ArgNo));
   }
 
   /// Equivalent to hasAttribute(AttributeList::FunctionIndex, Kind) but
   /// may be faster.
   bool hasFnAttribute(Attribute::AttrKind Kind) const;
 
   /// Equivalent to hasAttribute(AttributeList::FunctionIndex, Kind) but
   /// may be faster.
   bool hasFnAttribute(StringRef Kind) const;
 
-  /// Equivalent to hasAttribute(ArgNo + FirstArgIndex, Kind).
+  /// Equivalent to hasAttribute(getArgIndex(ArgNo), Kind).
   bool hasParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const;
 
   /// 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;
+  bool hasAttrSomewhere(Attribute::AttrKind Kind, Index *Index = nullptr) const;
 
   /// Return the attribute object that exists at the given index.
-  Attribute getAttribute(unsigned Index, Attribute::AttrKind Kind) const;
+  Attribute getAttribute(Index Index, Attribute::AttrKind Kind) const;
 
   /// Return the attribute object that exists at the given index.
-  Attribute getAttribute(unsigned Index, StringRef Kind) const;
+  Attribute getAttribute(Index 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 getAttribute(getArgIndex(ArgNo), Kind);
   }
 
   /// Return the attribute object that exists at the given index.
   Attribute getParamAttr(unsigned ArgNo, StringRef Kind) const {
-    return getAttribute(ArgNo + FirstArgIndex, Kind);
+    return getAttribute(getArgIndex(ArgNo), Kind);
   }
 
   /// Return the alignment of the return value.
   MaybeAlign getRetAlignment() const;
 
   /// Return the alignment for the specified function parameter.
   MaybeAlign getParamAlignment(unsigned ArgNo) const;
 
public:
 
   /// Return the preallocated type for the specified function parameter.
   Type *getParamPreallocatedType(unsigned ArgNo) const;
 
   /// Return the inalloca type for the specified function parameter.
   Type *getParamInAllocaType(unsigned ArgNo) const;
 
   /// Get the stack alignment.
-  MaybeAlign getStackAlignment(unsigned Index) const;
+  MaybeAlign getStackAlignment(Index Index) const;
 
   /// Get the number of dereferenceable bytes (or zero if unknown).
-  uint64_t getDereferenceableBytes(unsigned Index) const;
+  uint64_t getDereferenceableBytes(Index Index) const;
 
   /// Get the number of dereferenceable bytes (or zero if unknown) of an
   /// arg.
   uint64_t getParamDereferenceableBytes(unsigned ArgNo) const {
-    return getDereferenceableBytes(ArgNo + FirstArgIndex);
+    return getDereferenceableBytes(getArgIndex(ArgNo));
   }
 
   /// Get the number of dereferenceable_or_null bytes (or zero if
   /// unknown).
-  uint64_t getDereferenceableOrNullBytes(unsigned Index) const;
+  uint64_t getDereferenceableOrNullBytes(Index Index) const;
 
   /// Get the number of dereferenceable_or_null bytes (or zero if
   /// unknown) of an arg.
   uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const {
-    return getDereferenceableOrNullBytes(ArgNo + FirstArgIndex);
+    return getDereferenceableOrNullBytes(getArgIndex(ArgNo));
   }
 
   /// Get the allocsize argument numbers (or pair(0, 0) if unknown).
-  std::pair<unsigned, Optional<unsigned>>
-  getAllocSizeArgs(unsigned Index) const;
+  std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs(Index Index) const;
 
   /// Get the vscale_range argument numbers (or pair(0, 0) if unknown).
-  std::pair<unsigned, unsigned> getVScaleRangeArgs(unsigned Index) const;
+  std::pair<unsigned, unsigned> getVScaleRangeArgs(Index Index) const;
 
   /// Return the attributes at the index as a string.
-  std::string getAsString(unsigned Index, bool InAttrGrp = false) const;
+  std::string getAsString(Index Index, bool InAttrGrp = false) const;
 
   /// Return true if this attribute list belongs to the LLVMContext.
   bool hasParentContext(LLVMContext &C) const;
 
   //===--------------------------------------------------------------------===//
   // AttributeList Introspection
   //===--------------------------------------------------------------------===//
 
   using iterator = const AttributeSet *;
 
   iterator begin() const;
   iterator end() const;
 
   unsigned getNumAttrSets() const;
 
   /// Use these to iterate over the valid attribute indices.
-  unsigned index_begin() const { return AttributeList::FunctionIndex; }
-  unsigned index_end() const { return getNumAttrSets() - 1; }
+  Index index_begin() const { return FunctionIndex; }
+  Index index_end() const { return {getNumAttrSets() - 1}; }
 
   /// operator==/!= - Provide equality predicates.
   bool operator==(const AttributeList &RHS) const { return pImpl == RHS.pImpl; }
   bool operator!=(const AttributeList &RHS) const { return pImpl != RHS.pImpl; }
 
   /// Return a raw pointer that uniquely identifies this attribute list.
   void *getRawPointer() const {
     return pImpl;
template <> struct DenseMapInfo<AttributeList> {
 
   static bool isEqual(AttributeList LHS, AttributeList RHS) {
     return LHS == RHS;
   }
 };
 
 //===----------------------------------------------------------------------===//
 /// \class
+/// Provide DenseMapInfo for AttributeList::Index.
+template <> struct DenseMapInfo<AttributeList::Index> {
+  static AttributeList::Index getEmptyKey() {
+    return AttributeList::Index(DenseMapInfo<unsigned>::getEmptyKey());
+  }
+
+  static AttributeList::Index getTombstoneKey() {
+    return AttributeList::Index(DenseMapInfo<unsigned>::getTombstoneKey());
+  }
+
+  static unsigned getHashValue(AttributeList::Index AS) {
+    return DenseMapInfo<unsigned>::getHashValue(AS.raw_value());
+  }
+
+  static bool isEqual(AttributeList::Index LHS, AttributeList::Index RHS) {
+    return LHS == RHS;
+  }
+};
+
+//===----------------------------------------------------------------------===//
+/// \class
 /// This class is used in conjunction with the Attribute::get method to
 /// create an Attribute object. The object itself is uniquified. The Builder's
 /// value, however, is not. So this can be used as a quick way to test for
 /// equality, presence of attributes, etc.
 class AttrBuilder {
   std::bitset<Attribute::EndAttrKinds> Attrs;
   std::map<SmallString<32>, SmallString<32>, std::less<>> TargetDepAttrs;
   MaybeAlign Alignment;

 
 public:
   AttrBuilder() = default;
 
   AttrBuilder(const Attribute &A) {
     addAttribute(A);
   }
 
-  AttrBuilder(AttributeList AS, unsigned Idx);
+  AttrBuilder(AttributeList AS, AttributeList::Index Idx);
   AttrBuilder(AttributeSet AS);
 
   void clear();
 
   /// Add an attribute to the builder.
   AttrBuilder &addAttribute(Attribute::AttrKind Val) {
     assert((unsigned)Val < Attribute::EndAttrKinds &&
            "Attribute out of range!");
     assert(!Attribute::doesAttrKindHaveArgument(Val) &&
            "Adding integer attribute without adding a value!");
     Attrs[Val] = true;
     return *this;
   }
 
   /// Add the Attribute object to the builder.
   AttrBuilder &addAttribute(Attribute A);
 
   /// Add the target-dependent attribute to the builder.
   AttrBuilder &addAttribute(StringRef A, StringRef V = StringRef());
 
   /// Remove an attribute from the builder.
   AttrBuilder &removeAttribute(Attribute::AttrKind Val);
 
   /// Remove the attributes from the builder.
-  AttrBuilder &removeAttributes(AttributeList A, uint64_t WithoutIndex);
+  AttrBuilder &removeAttributes(AttributeList A,
+                                AttributeList::Index WithoutIndex);
 
   /// Remove the target-dependent attribute to the builder.
   AttrBuilder &removeAttribute(StringRef A);
 
   /// Add the attributes from the builder.
   AttrBuilder &merge(const AttrBuilder &B);
 
   /// Remove the attributes from the builder.
public:
   /// attribute.
   bool contains(StringRef A) const;
 
   /// Return true if the builder has IR-level attributes.
   bool hasAttributes() const;
 
   /// Return true if the builder has any attribute that's in the
   /// specified attribute.
-  bool hasAttributes(AttributeList A, uint64_t Index) const;
+  bool hasAttributes(AttributeList A, AttributeList::Index Index) const;
 
   /// Return true if the builder has an alignment attribute.
   bool hasAlignmentAttr() const;
 
   /// Retrieve the alignment attribute, if it exists.
   MaybeAlign getAlignment() const { return Alignment; }
 
   /// Retrieve the stack alignment attribute, if it exists.

llvm/include/llvm/IR/Function.h

public:
   const std::string &getGC() const;
   void setGC(std::string Str);
   void clearGC();
 
   /// Returns true if the function has ssp, sspstrong, or sspreq fn attrs.
   bool hasStackProtectorFnAttr() const;
 
   /// adds the attribute to the list of attributes.
-  void addAttribute(unsigned i, Attribute::AttrKind Kind);
+  void addAttribute(AttributeList::Index i, Attribute::AttrKind Kind);
 
   /// adds the attribute to the list of attributes.
-  void addAttribute(unsigned i, Attribute Attr);
+  void addAttribute(AttributeList::Index i, Attribute Attr);
 
   /// adds the attributes to the list of attributes.
-  void addAttributes(unsigned i, const AttrBuilder &Attrs);
+  void addAttributes(AttributeList::Index i, const AttrBuilder &Attrs);
 
   /// adds the attribute to the list of attributes for the given arg.
   void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind);
 
   /// adds the attribute to the list of attributes for the given arg.
   void addParamAttr(unsigned ArgNo, Attribute Attr);
 
   /// adds the attributes to the list of attributes for the given arg.
   void addParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs);
 
   /// removes the attribute from the list of attributes.
-  void removeAttribute(unsigned i, Attribute::AttrKind Kind);
+  void removeAttribute(AttributeList::Index i, Attribute::AttrKind Kind);
 
   /// removes the attribute from the list of attributes.
-  void removeAttribute(unsigned i, StringRef Kind);
+  void removeAttribute(AttributeList::Index i, StringRef Kind);
 
   /// removes the attributes from the list of attributes.
-  void removeAttributes(unsigned i, const AttrBuilder &Attrs);
+  void removeAttributes(AttributeList::Index i, const AttrBuilder &Attrs);
 
   /// removes the attribute from the list of attributes.
   void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind);
 
   /// removes the attribute from the list of attributes.
   void removeParamAttr(unsigned ArgNo, StringRef Kind);
 
   /// removes the attribute from the list of attributes.
   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 {
+  bool hasAttribute(AttributeList::Index i, Attribute::AttrKind Kind) const {
     return getAttributes().hasAttribute(i, Kind);
   }
 
   /// check if an attributes is in the list of attributes.
   bool hasParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const {
     return getAttributes().hasParamAttribute(ArgNo, Kind);
   }
 
   /// gets the specified attribute from the list of attributes.
   Attribute getParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const {
     return getAttributes().getParamAttr(ArgNo, Kind);
   }
 
   /// gets the attribute from the list of attributes.
-  Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const {
+  Attribute getAttribute(AttributeList::Index i,
+                         Attribute::AttrKind Kind) const {
     return AttributeSets.getAttribute(i, Kind);
   }
 
   /// gets the attribute from the list of attributes.
-  Attribute getAttribute(unsigned i, StringRef Kind) const {
+  Attribute getAttribute(AttributeList::Index i, StringRef Kind) const {
     return AttributeSets.getAttribute(i, Kind);
   }
 
   /// adds the dereferenceable attribute to the list of attributes.
-  void addDereferenceableAttr(unsigned i, uint64_t Bytes);
+  void addDereferenceableAttr(AttributeList::Index i, uint64_t Bytes);
 
   /// adds the dereferenceable attribute to the list of attributes for
   /// the given arg.
   void addDereferenceableParamAttr(unsigned ArgNo, uint64_t Bytes);
 
   /// adds the dereferenceable_or_null attribute to the list of
   /// attributes.
-  void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes);
+  void addDereferenceableOrNullAttr(AttributeList::Index i, uint64_t Bytes);
 
   /// adds the dereferenceable_or_null attribute to the list of
   /// attributes for the given arg.
   void addDereferenceableOrNullParamAttr(unsigned ArgNo, uint64_t Bytes);
 
   /// Extract the alignment for a call or parameter (0=unknown).
   /// FIXME: Remove this function once transition to Align is over.
   /// Use getParamAlign() instead.
public:
   /// Extract the byref type for a parameter.
   Type *getParamByRefType(unsigned ArgNo) const {
     return AttributeSets.getParamByRefType(ArgNo);
   }
 
   /// Extract the number of dereferenceable bytes for a call or
   /// parameter (0=unknown).
   /// @param i AttributeList index, referring to a return value or argument.
-  uint64_t getDereferenceableBytes(unsigned i) const {
+  uint64_t getDereferenceableBytes(AttributeList::Index i) const {
     return AttributeSets.getDereferenceableBytes(i);
   }
 
   /// Extract the number of dereferenceable bytes for a parameter.
   /// @param ArgNo Index of an argument, with 0 being the first function arg.
   uint64_t getParamDereferenceableBytes(unsigned ArgNo) const {
     return AttributeSets.getParamDereferenceableBytes(ArgNo);
   }
 
   /// Extract the number of dereferenceable_or_null bytes for a call or
   /// parameter (0=unknown).
   /// @param i AttributeList index, referring to a return value or argument.
-  uint64_t getDereferenceableOrNullBytes(unsigned i) const {
+  uint64_t getDereferenceableOrNullBytes(AttributeList::Index i) const {
     return AttributeSets.getDereferenceableOrNullBytes(i);
   }
 
   /// Extract the number of dereferenceable_or_null bytes for a
   /// parameter.
   /// @param ArgNo AttributeList ArgNo, referring to an argument.
   uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const {
     return AttributeSets.getParamDereferenceableOrNullBytes(ArgNo);

llvm/include/llvm/IR/GlobalVariable.h

public:
   /// Return the attribute set for this global
   AttributeSet getAttributes() const {
     return Attrs;
   }
 
   /// Return attribute set as list with index.
   /// FIXME: This may not be required once ValueEnumerators
   /// in bitcode-writer can enumerate attribute-set.
-  AttributeList getAttributesAsList(unsigned index) const {
+  AttributeList getAttributesAsList(AttributeList::Index index) const {
     if (!hasAttributes())
       return AttributeList();
-    std::pair<unsigned, AttributeSet> AS[1] = {{index, Attrs}};
+    std::pair<AttributeList::Index, AttributeSet> AS[1] = {{index, Attrs}};
     return AttributeList::get(getContext(), AS);
   }
 
   /// Set attribute list for this global
   void setAttributes(AttributeSet A) {
     Attrs = A;
   }
 

llvm/include/llvm/IR/InstrTypes.h

public:
   }
 
   /// Determine whether this call has the given attribute. If it does not
   /// then determine if the called function has the attribute, but only if
   /// the attribute is allowed for the call.
   bool hasFnAttr(StringRef Kind) const { return hasFnAttrImpl(Kind); }
 
   /// adds the attribute to the list of attributes.
-  void addAttribute(unsigned i, Attribute::AttrKind Kind) {
+  void addAttribute(AttributeList::Index i, Attribute::AttrKind Kind) {
     AttributeList PAL = getAttributes();
     PAL = PAL.addAttribute(getContext(), i, Kind);
     setAttributes(PAL);
   }
 
   /// adds the attribute to the list of attributes.
-  void addAttribute(unsigned i, Attribute Attr) {
+  void addAttribute(AttributeList::Index i, Attribute Attr) {
     AttributeList PAL = getAttributes();
     PAL = PAL.addAttribute(getContext(), i, Attr);
     setAttributes(PAL);
   }
 
   /// Adds the attribute to the indicated argument
   void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
     assert(ArgNo < getNumArgOperands() && "Out of bounds");
     AttributeList PAL = getAttributes();
     PAL = PAL.addParamAttribute(getContext(), ArgNo, Kind);
     setAttributes(PAL);
   }
 
   /// Adds the attribute to the indicated argument
   void addParamAttr(unsigned ArgNo, Attribute Attr) {
     assert(ArgNo < getNumArgOperands() && "Out of bounds");
     AttributeList PAL = getAttributes();
     PAL = PAL.addParamAttribute(getContext(), ArgNo, Attr);
     setAttributes(PAL);
   }
 
   /// removes the attribute from the list of attributes.
-  void removeAttribute(unsigned i, Attribute::AttrKind Kind) {
+  void removeAttribute(AttributeList::Index i, Attribute::AttrKind Kind) {
     AttributeList PAL = getAttributes();
     PAL = PAL.removeAttribute(getContext(), i, Kind);
     setAttributes(PAL);
   }
 
   /// removes the attribute from the list of attributes.
-  void removeAttribute(unsigned i, StringRef Kind) {
+  void removeAttribute(AttributeList::Index i, StringRef Kind) {
     AttributeList PAL = getAttributes();
     PAL = PAL.removeAttribute(getContext(), i, Kind);
     setAttributes(PAL);
   }
 
-  void removeAttributes(unsigned i, const AttrBuilder &Attrs) {
+  void removeAttributes(AttributeList::Index i, const AttrBuilder &Attrs) {
     AttributeList PAL = getAttributes();
     PAL = PAL.removeAttributes(getContext(), i, Attrs);
     setAttributes(PAL);
   }
 
   /// Removes the attribute from the given argument
   void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
     assert(ArgNo < getNumArgOperands() && "Out of bounds");
public:
   void removeParamUndefImplyingAttrs(unsigned ArgNo) {
     assert(ArgNo < getNumArgOperands() && "Out of bounds");
     AttributeList PAL = getAttributes();
     PAL = PAL.removeParamUndefImplyingAttributes(getContext(), ArgNo);
     setAttributes(PAL);
   }
 
   /// adds the dereferenceable attribute to the list of attributes.
-  void addDereferenceableAttr(unsigned i, uint64_t Bytes) {
+  void addDereferenceableAttr(AttributeList::Index i, uint64_t Bytes) {
     AttributeList PAL = getAttributes();
     PAL = PAL.addDereferenceableAttr(getContext(), i, Bytes);
     setAttributes(PAL);
   }
 
   /// adds the dereferenceable_or_null attribute to the list of
   /// attributes.
-  void addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes) {
+  void addDereferenceableOrNullAttr(AttributeList::Index i, uint64_t Bytes) {
     AttributeList PAL = getAttributes();
     PAL = PAL.addDereferenceableOrNullAttr(getContext(), i, Bytes);
     setAttributes(PAL);
   }
 
   /// Determine whether the return value has the given attribute.
   bool hasRetAttr(Attribute::AttrKind Kind) const {
     return hasRetAttrImpl(Kind);
   }
   /// 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 {
+  Attribute getAttribute(AttributeList::Index i,
+                         Attribute::AttrKind Kind) const {
     return getAttributes().getAttribute(i, Kind);
   }
 
   /// Get the attribute of a given kind at a position.
-  Attribute getAttribute(unsigned i, StringRef Kind) const {
+  Attribute getAttribute(AttributeList::Index i, StringRef Kind) const {
     return getAttributes().getAttribute(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);
   }
bool dataOperandHasImpliedAttr(unsigned i, Attribute::AttrKind Kind) const {
     // Note that we have to add one because `i` isn't zero-indexed.
     assert(i < (getNumArgOperands() + getNumTotalBundleOperands() + 1) &&
            "Data operand index out of bounds!");
 
     // The attribute A can either be directly specified, if the operand in
     // question is a call argument; or be indirectly implied by the kind of its
     // containing operand bundle, if the operand is a bundle operand.
 
-    if (i == AttributeList::ReturnIndex)
+    if (AttributeList::Index(i) == AttributeList::ReturnIndex)
       return hasRetAttr(Kind);
 
     // FIXME: Avoid these i - 1 calculations and update the API to use
     // zero-based indices.
     if (i < (getNumArgOperands() + 1))
       return paramHasAttr(i - 1, Kind);
 
     assert(hasOperandBundles() && i >= (getBundleOperandsStartIndex() + 1) &&
public:
   /// Extract the preallocated type for a call or parameter.
   Type *getParamPreallocatedType(unsigned ArgNo) const {
     Type *Ty = Attrs.getParamPreallocatedType(ArgNo);
     return Ty ? Ty : getArgOperand(ArgNo)->getType()->getPointerElementType();
   }
 
   /// Extract the number of dereferenceable bytes for a call or
   /// parameter (0=unknown).
-  uint64_t getDereferenceableBytes(unsigned i) const {
+  uint64_t getDereferenceableBytes(AttributeList::Index i) const {
     return Attrs.getDereferenceableBytes(i);
   }
 
   /// Extract the number of dereferenceable_or_null bytes for a call or
   /// parameter (0=unknown).
-  uint64_t getDereferenceableOrNullBytes(unsigned i) const {
+  uint64_t getDereferenceableOrNullBytes(AttributeList::Index i) const {
     return Attrs.getDereferenceableOrNullBytes(i);
   }
 
   /// Return true if the return value is known to be not null.
   /// This may be because it has the nonnull attribute, or because at least
   /// one byte is dereferenceable and the pointer is in addrspace(0).
   bool isReturnNonNull() const;
 

llvm/include/llvm/Transforms/IPO/Attributor.h

struct IRPosition {
   /// `getCalleArgNo` this method will always return the "operand number" from
   /// the perspective of the call site. This may not the same as the callee
   /// perspective if this is a callback call.
   int getCallSiteArgNo() const {
     return getArgNo(/* CallbackCalleeArgIfApplicable */ false);
   }
 
   /// Return the index in the attribute list for this position.
-  unsigned getAttrIdx() const {
+  AttributeList::Index getAttrIdx() const {
     switch (getPositionKind()) {
     case IRPosition::IRP_INVALID:
     case IRPosition::IRP_FLOAT:
       break;
     case IRPosition::IRP_FUNCTION:
     case IRPosition::IRP_CALL_SITE:
       return AttributeList::FunctionIndex;
     case IRPosition::IRP_RETURNED:
     case IRPosition::IRP_CALL_SITE_RETURNED:
       return AttributeList::ReturnIndex;
     case IRPosition::IRP_ARGUMENT:
     case IRPosition::IRP_CALL_SITE_ARGUMENT:
-      return getCallSiteArgNo() + AttributeList::FirstArgIndex;
+      return AttributeList::getArgIndex(getCallSiteArgNo());
     }
     llvm_unreachable(
         "There is no attribute index for a floating or invalid position!");
   }
 
   /// Return the associated position kind.
   Kind getPositionKind() const {
     char EncodingBits = getEncodingBits();

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

void ModuleBitcodeWriter::writeAttributeGroupTable() {
   const std::vector<ValueEnumerator::IndexAndAttrSet> &AttrGrps =
       VE.getAttributeGroups();
   if (AttrGrps.empty()) return;
 
   Stream.EnterSubblock(bitc::PARAMATTR_GROUP_BLOCK_ID, 3);
 
   SmallVector<uint64_t, 64> Record;
   for (ValueEnumerator::IndexAndAttrSet Pair : AttrGrps) {
-    unsigned AttrListIndex = Pair.first;
+    AttributeList::Index AttrListIndex = Pair.first;
     AttributeSet AS = Pair.second;
     Record.push_back(VE.getAttributeGroupID(Pair));
-    Record.push_back(AttrListIndex);
+    Record.push_back(AttrListIndex.raw_value());
 
     for (Attribute Attr : AS) {
       if (Attr.isEnumAttribute()) {
         Record.push_back(0);
         Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));
       } else if (Attr.isIntAttribute()) {
         Record.push_back(1);
         Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));
void ModuleBitcodeWriter::writeAttributeTable() {
   const std::vector<AttributeList> &Attrs = VE.getAttributeLists();
   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) {
+    for (AttributeList::Index i = AL.index_begin(), e = AL.index_end(); i != e;
+         ++i) {
       AttributeSet AS = AL.getAttributes(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.h

 public:
   using TypeList = std::vector<Type *>;
 
   // For each value, we remember its Value* and occurrence frequency.
   using ValueList = std::vector<std::pair<const Value *, unsigned>>;
 
   /// Attribute groups as encoded in bitcode are almost AttributeSets, but they
   /// include the AttributeList index, so we have to track that in our map.
-  using IndexAndAttrSet = std::pair<unsigned, AttributeSet>;
+  using IndexAndAttrSet = std::pair<AttributeList::Index, AttributeSet>;
 
   UseListOrderStack UseListOrders;
 
 private:
   using TypeMapType = DenseMap<Type *, unsigned>;
   TypeMapType TypeMap;
   TypeList Types;
 

llvm/lib/Bitcode/Writer/ValueEnumerator.cpp

void ValueEnumerator::EnumerateAttributes(AttributeList PAL) {
   unsigned &Entry = AttributeListMap[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) {
+  for (AttributeList::Index i = PAL.index_begin(), e = PAL.index_end(); i != e;
+       ++i) {
     AttributeSet AS = PAL.getAttributes(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,
   addFlagsUsingAttrFn(Flags, [&Call, &ArgIdx](Attribute::AttrKind Attr) {
     return Call.paramHasAttr(ArgIdx, Attr);
   });
   return Flags;
 }
 
 void CallLowering::addArgFlagsFromAttributes(ISD::ArgFlagsTy &Flags,
                                              const AttributeList &Attrs,
-                                             unsigned OpIdx) const {
+                                             AttributeList::Index OpIdx) const {
   addFlagsUsingAttrFn(Flags, [&Attrs, &OpIdx](Attribute::AttrKind Attr) {
     return Attrs.hasAttribute(OpIdx, Attr);
   });
 }
 
 bool CallLowering::lowerCall(MachineIRBuilder &MIRBuilder, const CallBase &CB,
                              ArrayRef<Register> ResRegs,
                              ArrayRef<ArrayRef<Register>> ArgRegs,
bool CallLowering::lowerCall(MachineIRBuilder &MIRBuilder, const CallBase &CB,
   // First step is to marshall all the function's parameters into the correct
   // physregs and memory locations. Gather the sequence of argument types that
   // we'll pass to the assigner function.
   unsigned i = 0;
   unsigned NumFixedArgs = CB.getFunctionType()->getNumParams();
   for (auto &Arg : CB.args()) {
     ArgInfo OrigArg{ArgRegs[i], *Arg.get(), getAttributesForArgIdx(CB, i),
                     i < NumFixedArgs};
-    setArgFlags(OrigArg, i + AttributeList::FirstArgIndex, DL, CB);
+    setArgFlags(OrigArg, AttributeList::getArgIndex(i), DL, CB);
 
     // If we have an explicit sret argument that is an Instruction, (i.e., it
     // might point to function-local memory), we can't meaningfully tail-call.
     if (OrigArg.Flags[0].isSRet() && isa<Instruction>(&Arg))
       CanBeTailCalled = false;
 
     Info.OrigArgs.push_back(OrigArg);
     ++i;
bool CallLowering::lowerCall(MachineIRBuilder &MIRBuilder, const CallBase &CB,
   Info.SwiftErrorVReg = SwiftErrorVReg;
   Info.IsMustTailCall = CB.isMustTailCall();
   Info.IsTailCall = CanBeTailCalled;
   Info.IsVarArg = IsVarArg;
   return lowerCall(MIRBuilder, Info);
 }
 
 template <typename FuncInfoTy>
-void CallLowering::setArgFlags(CallLowering::ArgInfo &Arg, unsigned OpIdx,
-                               const DataLayout &DL,
+void CallLowering::setArgFlags(CallLowering::ArgInfo &Arg,
+                               AttributeList::Index OpIdx, const DataLayout &DL,
                                const FuncInfoTy &FuncInfo) const {
   auto &Flags = Arg.Flags[0];
   const AttributeList &Attrs = FuncInfo.getAttributes();
   addArgFlagsFromAttributes(Flags, Attrs, OpIdx);
 
   Align MemAlign = DL.getABITypeAlign(Arg.Ty);
   if (Flags.isByVal() || Flags.isInAlloca() || Flags.isPreallocated()) {
-    assert(OpIdx >= AttributeList::FirstArgIndex);
+    assert(OpIdx.isArg());
     Type *ElementTy = cast<PointerType>(Arg.Ty)->getElementType();
 
     auto Ty = Attrs.getAttribute(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))
+    if (auto ParamAlign = FuncInfo.getParamStackAlign(OpIdx.toArgNo()))
       MemAlign = *ParamAlign;
-    else if ((ParamAlign =
-                  FuncInfo.getParamAlign(OpIdx - AttributeList::FirstArgIndex)))
+    else if ((ParamAlign = FuncInfo.getParamAlign(OpIdx.toArgNo())))
       MemAlign = *ParamAlign;
     else
       MemAlign = Align(getTLI()->getByValTypeAlignment(ElementTy, DL));
-  } else if (OpIdx >= AttributeList::FirstArgIndex) {
-    if (auto ParamAlign =
-            FuncInfo.getParamStackAlign(OpIdx - AttributeList::FirstArgIndex))
+  } else if (OpIdx.isArg()) {
+    if (auto ParamAlign = FuncInfo.getParamStackAlign(OpIdx.toArgNo()))
       MemAlign = *ParamAlign;
   }
   Flags.setMemAlign(MemAlign);
   Flags.setOrigAlign(DL.getABITypeAlign(Arg.Ty));
 
   // Don't try to use the returned attribute if the argument is marked as
   // swiftself, since it won't be passed in x0.
   if (Flags.isSwiftSelf())
     Flags.setReturned(false);
 }
 
-template void
-CallLowering::setArgFlags<Function>(CallLowering::ArgInfo &Arg, unsigned OpIdx,
-                                    const DataLayout &DL,
-                                    const Function &FuncInfo) const;
-
-template void
-CallLowering::setArgFlags<CallBase>(CallLowering::ArgInfo &Arg, unsigned OpIdx,
-                                    const DataLayout &DL,
-                                    const CallBase &FuncInfo) const;
+template void CallLowering::setArgFlags<Function>(
+    CallLowering::ArgInfo &Arg, AttributeList::Index OpIdx,
+    const DataLayout &DL, const Function &FuncInfo) const;
+
+template void CallLowering::setArgFlags<CallBase>(
+    CallLowering::ArgInfo &Arg, AttributeList::Index OpIdx,
+    const DataLayout &DL, const CallBase &FuncInfo) const;
 
 void CallLowering::splitToValueTypes(const ArgInfo &OrigArg,
                                      SmallVectorImpl<ArgInfo> &SplitArgs,
                                      const DataLayout &DL,
                                      CallingConv::ID CallConv) const {
   LLVMContext &Ctx = OrigArg.Ty->getContext();
 
   SmallVector<EVT, 4> SplitVTs;

llvm/lib/IR/AttributeImpl.h

public:
   bool hasFnAttribute(Attribute::AttrKind Kind) const {
     return AvailableFunctionAttrs.hasAttribute(Kind);
   }
 
   /// 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;
+                        AttributeList::Index *Index = nullptr) const;
 
   using iterator = const AttributeSet *;
 
   iterator begin() const { return getTrailingObjects<AttributeSet>(); }
   iterator end() const { return begin() + NumAttrSets; }
 
   void Profile(FoldingSetNodeID &ID) const;
   static void Profile(FoldingSetNodeID &ID, ArrayRef<AttributeSet> Nodes);

llvm/lib/IR/Attributes.cpp

std::string AttributeSetNode::getAsString(bool InAttrGrp) const {
   }
   return Str;
 }
 
 //===----------------------------------------------------------------------===//
 // AttributeListImpl Definition
 //===----------------------------------------------------------------------===//
 
-/// Map from AttributeList index to the internal array index. Adding one happens
-/// to work, because -1 wraps around to 0.
-static unsigned attrIdxToArrayIdx(unsigned Index) {
-  return Index + 1;
-}
-
 AttributeListImpl::AttributeListImpl(ArrayRef<AttributeSet> Sets)
     : NumAttrSets(Sets.size()) {
   assert(!Sets.empty() && "pointless AttributeListImpl");
 
   // There's memory after the node where we can store the entries in.
   llvm::copy(Sets, getTrailingObjects<AttributeSet>());
 
   // Initialize AvailableFunctionAttrs and AvailableSomewhereAttrs
   // summary bitsets.
-  for (const auto &I : Sets[attrIdxToArrayIdx(AttributeList::FunctionIndex)])
+  for (const auto &I : Sets[AttributeList::FunctionIndex.ArrayIndex()])
     if (!I.isStringAttribute())
       AvailableFunctionAttrs.addAttribute(I.getKindAsEnum());
 
   for (const auto &Set : Sets)
     for (const auto &I : Set)
       if (!I.isStringAttribute())
         AvailableSomewhereAttrs.addAttribute(I.getKindAsEnum());
 }
 
 void AttributeListImpl::Profile(FoldingSetNodeID &ID) const {
   Profile(ID, makeArrayRef(begin(), end()));
 }
 
 void AttributeListImpl::Profile(FoldingSetNodeID &ID,
                                 ArrayRef<AttributeSet> Sets) {
   for (const auto &Set : Sets)
     ID.AddPointer(Set.SetNode);
 }
 
 bool AttributeListImpl::hasAttrSomewhere(Attribute::AttrKind Kind,
-                                        unsigned *Index) const {
+                                         AttributeList::Index *Index) const {
   if (!AvailableSomewhereAttrs.hasAttribute(Kind))
     return false;
 
   if (Index) {
     for (unsigned I = 0, E = NumAttrSets; I != E; ++I) {
       if (begin()[I].hasAttribute(Kind)) {
-        *Index = I - 1;
+        *Index = AttributeList::Index::FromArrayIndex(I);
         break;
       }
     }
   }
 
   return true;
 }
 
-
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void AttributeListImpl::dump() const {
   AttributeList(const_cast<AttributeListImpl *>(this)).dump();
 }
 #endif
 
 //===----------------------------------------------------------------------===//
 // AttributeList Construction and Mutation Methods
 //===----------------------------------------------------------------------===//
 
+const AttributeList::Index
+    AttributeList::ReturnIndex(AttributeList::Index::ReturnIndex);
+const AttributeList::Index
+    AttributeList::FunctionIndex(AttributeList::Index::FunctionIndex);
+
 AttributeList AttributeList::getImpl(LLVMContext &C,
                                      ArrayRef<AttributeSet> AttrSets) {
   assert(!AttrSets.empty() && "pointless AttributeListImpl");
 
   LLVMContextImpl *pImpl = C.pImpl;
   FoldingSetNodeID ID;
   AttributeListImpl::Profile(ID, AttrSets);
 
if (!PA) {
     PA = new (Mem) AttributeListImpl(AttrSets);
     pImpl->AttrsLists.InsertNode(PA, InsertPoint);
   }
 
   // Return the AttributesList that we found or created.
   return AttributeList(PA);
 }
 
-AttributeList
-AttributeList::get(LLVMContext &C,
-                   ArrayRef<std::pair<unsigned, Attribute>> Attrs) {
+AttributeList AttributeList::get(LLVMContext &C,
+                                 ArrayRef<std::pair<Index, Attribute>> Attrs) {
   // If there are no attributes then return a null AttributesList pointer.
   if (Attrs.empty())
     return {};
 
   assert(llvm::is_sorted(Attrs,
-                         [](const std::pair<unsigned, Attribute> &LHS,
-                            const std::pair<unsigned, Attribute> &RHS) {
+                         [](const std::pair<Index, Attribute> &LHS,
+                            const std::pair<Index, Attribute> &RHS) {
                            return LHS.first < RHS.first;
                          }) &&
          "Misordered Attributes list!");
   assert(llvm::all_of(Attrs,
-                      [](const std::pair<unsigned, Attribute> &Pair) {
+                      [](const std::pair<Index, Attribute> &Pair) {
                         return Pair.second.isValid();
                       }) &&
          "Pointless attribute!");
 
-  // Create a vector if (unsigned, AttributeSetNode*) pairs from the attributes
+  // Create a vector if (Index, AttributeSetNode*) pairs from the attributes
   // list.
-  SmallVector<std::pair<unsigned, AttributeSet>, 8> AttrPairVec;
-  for (ArrayRef<std::pair<unsigned, Attribute>>::iterator I = Attrs.begin(),
-         E = Attrs.end(); I != E; ) {
-    unsigned Index = I->first;
+  SmallVector<std::pair<Index, AttributeSet>, 8> AttrPairVec;
+  for (ArrayRef<std::pair<Index, Attribute>>::iterator I = Attrs.begin(),
+                                                       E = Attrs.end();
+       I != E;) {
+    Index Index = I->first;
     SmallVector<Attribute, 4> AttrVec;
     while (I != E && I->first == Index) {
       AttrVec.push_back(I->second);
       ++I;
     }
 
     AttrPairVec.emplace_back(Index, AttributeSet::get(C, AttrVec));
   }
 
   return get(C, AttrPairVec);
 }
 
 AttributeList
 AttributeList::get(LLVMContext &C,
-                   ArrayRef<std::pair<unsigned, AttributeSet>> Attrs) {
+                   ArrayRef<std::pair<Index, AttributeSet>> Attrs) {
   // If there are no attributes then return a null AttributesList pointer.
   if (Attrs.empty())
     return {};
 
   assert(llvm::is_sorted(Attrs,
-                         [](const std::pair<unsigned, AttributeSet> &LHS,
-                            const std::pair<unsigned, AttributeSet> &RHS) {
+                         [](const std::pair<Index, AttributeSet> &LHS,
+                            const std::pair<Index, AttributeSet> &RHS) {
                            return LHS.first < RHS.first;
                          }) &&
          "Misordered Attributes list!");
   assert(llvm::none_of(Attrs,
-                       [](const std::pair<unsigned, AttributeSet> &Pair) {
+                       [](const std::pair<Index, AttributeSet> &Pair) {
                          return !Pair.second.hasAttributes();
                        }) &&
          "Pointless attribute!");
 
-  unsigned MaxIndex = Attrs.back().first;
+  Index MaxIndex = Attrs.back().first;
   // If the MaxIndex is FunctionIndex and there are other indices in front
   // of it, we need to use the largest of those to get the right size.
   if (MaxIndex == FunctionIndex && Attrs.size() > 1)
     MaxIndex = Attrs[Attrs.size() - 2].first;
 
-  SmallVector<AttributeSet, 4> AttrVec(attrIdxToArrayIdx(MaxIndex) + 1);
+  SmallVector<AttributeSet, 4> AttrVec(MaxIndex.ArrayIndex() + 1);
   for (const auto &Pair : Attrs)
-    AttrVec[attrIdxToArrayIdx(Pair.first)] = Pair.second;
+    AttrVec[Pair.first.ArrayIndex()] = Pair.second;
 
   return getImpl(C, AttrVec);
 }
 
 AttributeList AttributeList::get(LLVMContext &C, AttributeSet FnAttrs,
                                  AttributeSet RetAttrs,
                                  ArrayRef<AttributeSet> ArgAttrs) {
   // Scan from the end to find the last argument with attributes.  Most
if (NumSets > 2) {
     // Drop the empty argument attribute sets at the end.
     ArgAttrs = ArgAttrs.take_front(NumSets - 2);
     llvm::append_range(AttrSets, ArgAttrs);
   }
 
   return getImpl(C, AttrSets);
 }
 
-AttributeList AttributeList::get(LLVMContext &C, unsigned Index,
+AttributeList AttributeList::get(LLVMContext &C, Index Idx,
                                  const AttrBuilder &B) {
   if (!B.hasAttributes())
     return {};
-  Index = attrIdxToArrayIdx(Index);
-  SmallVector<AttributeSet, 8> AttrSets(Index + 1);
-  AttrSets[Index] = AttributeSet::get(C, B);
+  const unsigned ArrayIdx = Idx.ArrayIndex();
+  SmallVector<AttributeSet, 8> AttrSets(ArrayIdx + 1);
+  AttrSets[ArrayIdx] = AttributeSet::get(C, B);
   return getImpl(C, AttrSets);
 }
 
-AttributeList AttributeList::get(LLVMContext &C, unsigned Index,
+AttributeList AttributeList::get(LLVMContext &C, Index Idx,
                                  ArrayRef<Attribute::AttrKind> Kinds) {
-  SmallVector<std::pair<unsigned, Attribute>, 8> Attrs;
+  SmallVector<std::pair<Index, Attribute>, 8> Attrs;
   for (const auto K : Kinds)
-    Attrs.emplace_back(Index, Attribute::get(C, K));
+    Attrs.emplace_back(Idx, Attribute::get(C, K));
   return get(C, Attrs);
 }
 
-AttributeList AttributeList::get(LLVMContext &C, unsigned Index,
+AttributeList AttributeList::get(LLVMContext &C, Index Idx,
                                  ArrayRef<Attribute::AttrKind> Kinds,
                                  ArrayRef<uint64_t> Values) {
   assert(Kinds.size() == Values.size() && "Mismatched attribute values.");
-  SmallVector<std::pair<unsigned, Attribute>, 8> Attrs;
+  SmallVector<std::pair<Index, Attribute>, 8> Attrs;
   auto VI = Values.begin();
   for (const auto K : Kinds)
-    Attrs.emplace_back(Index, Attribute::get(C, K, *VI++));
+    Attrs.emplace_back(Idx, Attribute::get(C, K, *VI++));
   return get(C, Attrs);
 }
 
-AttributeList AttributeList::get(LLVMContext &C, unsigned Index,
+AttributeList AttributeList::get(LLVMContext &C, Index Idx,
                                  ArrayRef<StringRef> Kinds) {
-  SmallVector<std::pair<unsigned, Attribute>, 8> Attrs;
+  SmallVector<std::pair<Index, Attribute>, 8> Attrs;
   for (const auto &K : Kinds)
-    Attrs.emplace_back(Index, Attribute::get(C, K));
+    Attrs.emplace_back(Idx, Attribute::get(C, K));
   return get(C, Attrs);
 }
 
 AttributeList AttributeList::get(LLVMContext &C,
                                  ArrayRef<AttributeList> Attrs) {
   if (Attrs.empty())
     return {};
   if (Attrs.size() == 1)
for (unsigned I = 0; I < MaxSize; ++I) {
     for (const auto &List : Attrs)
       CurBuilder.merge(List.getAttributes(I - 1));
     NewAttrSets[I] = AttributeSet::get(C, CurBuilder);
   }
 
   return getImpl(C, NewAttrSets);
 }
 
-AttributeList AttributeList::addAttribute(LLVMContext &C, unsigned Index,
+AttributeList AttributeList::addAttribute(LLVMContext &C, Index Index,
                                           Attribute::AttrKind Kind) const {
   if (hasAttribute(Index, Kind)) return *this;
   AttributeSet Attrs = getAttributes(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,
+AttributeList AttributeList::addAttribute(LLVMContext &C, Index Index,
                                           StringRef Kind,
                                           StringRef Value) const {
   AttrBuilder B;
   B.addAttribute(Kind, Value);
   return addAttributes(C, Index, B);
 }
 
-AttributeList AttributeList::addAttribute(LLVMContext &C, unsigned Index,
+AttributeList AttributeList::addAttribute(LLVMContext &C, Index Index,
                                           Attribute A) const {
   AttrBuilder B;
   B.addAttribute(A);
   return addAttributes(C, Index, B);
 }
 
-AttributeList AttributeList::setAttributes(LLVMContext &C, unsigned Index,
+AttributeList AttributeList::setAttributes(LLVMContext &C, Index Index,
                                            AttributeSet Attrs) const {
-  Index = attrIdxToArrayIdx(Index);
   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
-  if (Index >= AttrSets.size())
-    AttrSets.resize(Index + 1);
-  AttrSets[Index] = Attrs;
+  const unsigned ArrayIdx = Index.ArrayIndex();
+  if (ArrayIdx >= AttrSets.size())
+    AttrSets.resize(ArrayIdx + 1);
+  AttrSets[ArrayIdx] = Attrs;
   return AttributeList::getImpl(C, AttrSets);
 }
 
-AttributeList AttributeList::addAttributes(LLVMContext &C, unsigned Index,
+AttributeList AttributeList::addAttributes(LLVMContext &C, Index Index,
                                            const AttrBuilder &B) const {
   if (!B.hasAttributes())
     return *this;
 
   if (!pImpl)
     return AttributeList::get(C, {{Index, AttributeSet::get(C, B)}});
 
 #ifndef NDEBUG

 }
 
 AttributeList AttributeList::addParamAttribute(LLVMContext &C,
                                                ArrayRef<unsigned> ArgNos,
                                                Attribute A) const {
   assert(llvm::is_sorted(ArgNos));
 
   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
-  unsigned MaxIndex = attrIdxToArrayIdx(ArgNos.back() + FirstArgIndex);
+  unsigned MaxIndex = getArgIndex(ArgNos.back()).ArrayIndex();
   if (MaxIndex >= AttrSets.size())
     AttrSets.resize(MaxIndex + 1);
 
   for (unsigned ArgNo : ArgNos) {
-    unsigned Index = attrIdxToArrayIdx(ArgNo + FirstArgIndex);
+    unsigned Index = getArgIndex(ArgNo).ArrayIndex();
     AttrBuilder B(AttrSets[Index]);
     B.addAttribute(A);
     AttrSets[Index] = AttributeSet::get(C, B);
   }
 
   return getImpl(C, AttrSets);
 }
 
-AttributeList AttributeList::removeAttribute(LLVMContext &C, unsigned Index,
+AttributeList AttributeList::removeAttribute(LLVMContext &C, Index Index,
                                              Attribute::AttrKind Kind) const {
   if (!hasAttribute(Index, Kind)) return *this;
 
-  Index = attrIdxToArrayIdx(Index);
   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
-  assert(Index < AttrSets.size());
+  const unsigned ArrayIdx = Index.ArrayIndex();
+  assert(ArrayIdx < AttrSets.size());
 
-  AttrSets[Index] = AttrSets[Index].removeAttribute(C, Kind);
+  AttrSets[ArrayIdx] = AttrSets[ArrayIdx].removeAttribute(C, Kind);
 
   return getImpl(C, AttrSets);
 }
 
-AttributeList AttributeList::removeAttribute(LLVMContext &C, unsigned Index,
+AttributeList AttributeList::removeAttribute(LLVMContext &C, Index Index,
                                              StringRef Kind) const {
   if (!hasAttribute(Index, Kind)) return *this;
 
-  Index = attrIdxToArrayIdx(Index);
   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
-  assert(Index < AttrSets.size());
+  const unsigned ArrayIdx = Index.ArrayIndex();
+  assert(ArrayIdx < AttrSets.size());
 
-  AttrSets[Index] = AttrSets[Index].removeAttribute(C, Kind);
+  AttrSets[ArrayIdx] = AttrSets[ArrayIdx].removeAttribute(C, Kind);
 
   return getImpl(C, AttrSets);
 }
 
 AttributeList
-AttributeList::removeAttributes(LLVMContext &C, unsigned Index,
+AttributeList::removeAttributes(LLVMContext &C, Index Index,
                                 const AttrBuilder &AttrsToRemove) const {
   AttributeSet Attrs = getAttributes(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,
-                                              unsigned WithoutIndex) const {
+                                              Index WithoutIndex) const {
   if (!pImpl)
     return {};
-  WithoutIndex = attrIdxToArrayIdx(WithoutIndex);
-  if (WithoutIndex >= getNumAttrSets())
+  const unsigned WithoutArrayIdx = WithoutIndex.ArrayIndex();
+  if (WithoutArrayIdx >= getNumAttrSets())
     return *this;
   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
-  AttrSets[WithoutIndex] = AttributeSet();
+  AttrSets[WithoutArrayIdx] = AttributeSet();
   return getImpl(C, AttrSets);
 }
 
 AttributeList
 AttributeList::removeParamUndefImplyingAttributes(LLVMContext &C,
                                                   unsigned ArgNo) const {
   AttrBuilder B;
   B.addAttribute(Attribute::NoUndef);
   B.addAttribute(Attribute::NonNull);
   B.addDereferenceableAttr(1);
   B.addDereferenceableOrNullAttr(1);
   return removeParamAttributes(C, ArgNo, B);
 }
 
-AttributeList AttributeList::addDereferenceableAttr(LLVMContext &C,
-                                                    unsigned Index,
+AttributeList AttributeList::addDereferenceableAttr(LLVMContext &C, Index Index,
                                                     uint64_t Bytes) const {
   AttrBuilder B;
   B.addDereferenceableAttr(Bytes);
   return addAttributes(C, Index, B);
 }
 
 AttributeList
-AttributeList::addDereferenceableOrNullAttr(LLVMContext &C, unsigned Index,
+AttributeList::addDereferenceableOrNullAttr(LLVMContext &C, Index Index,
                                             uint64_t Bytes) const {
   AttrBuilder B;
   B.addDereferenceableOrNullAttr(Bytes);
   return addAttributes(C, Index, B);
 }
 
 AttributeList
-AttributeList::addAllocSizeAttr(LLVMContext &C, unsigned Index,
+AttributeList::addAllocSizeAttr(LLVMContext &C, Index Index,
                                 unsigned ElemSizeArg,
                                 const Optional<unsigned> &NumElemsArg) {
   AttrBuilder B;
   B.addAllocSizeAttr(ElemSizeArg, NumElemsArg);
   return addAttributes(C, Index, B);
 }
 
-AttributeList AttributeList::addVScaleRangeAttr(LLVMContext &C, unsigned Index,
+AttributeList AttributeList::addVScaleRangeAttr(LLVMContext &C, Index Index,
                                                 unsigned MinValue,
                                                 unsigned MaxValue) {
   AttrBuilder B;
   B.addVScaleRangeAttr(MinValue, MaxValue);
   return addAttributes(C, Index, B);
 }
 
 //===----------------------------------------------------------------------===//
 // AttributeList Accessor Methods
 //===----------------------------------------------------------------------===//
 
 AttributeSet AttributeList::getParamAttributes(unsigned ArgNo) const {
-  return getAttributes(ArgNo + FirstArgIndex);
+  return getAttributes(getArgIndex(ArgNo));
 }
 
 AttributeSet AttributeList::getRetAttributes() const {
   return getAttributes(ReturnIndex);
 }
 
 AttributeSet AttributeList::getFnAttributes() const {
   return getAttributes(FunctionIndex);
 }
 
-bool AttributeList::hasAttribute(unsigned Index,
-                                 Attribute::AttrKind Kind) const {
+bool AttributeList::hasAttribute(Index Index, Attribute::AttrKind Kind) const {
   return getAttributes(Index).hasAttribute(Kind);
 }
 
-bool AttributeList::hasAttribute(unsigned Index, StringRef Kind) const {
+bool AttributeList::hasAttribute(Index Index, StringRef Kind) const {
   return getAttributes(Index).hasAttribute(Kind);
 }
 
-bool AttributeList::hasAttributes(unsigned Index) const {
+bool AttributeList::hasAttributes(Index Index) const {
   return getAttributes(Index).hasAttributes();
 }
 
 bool AttributeList::hasFnAttribute(Attribute::AttrKind Kind) const {
   return pImpl && pImpl->hasFnAttribute(Kind);
 }
 
 bool AttributeList::hasFnAttribute(StringRef Kind) const {
   return hasAttribute(AttributeList::FunctionIndex, Kind);
 }
 
 bool AttributeList::hasParamAttribute(unsigned ArgNo,
                                       Attribute::AttrKind Kind) const {
-  return hasAttribute(ArgNo + FirstArgIndex, Kind);
+  return hasAttribute(getArgIndex(ArgNo), Kind);
 }
 
 bool AttributeList::hasAttrSomewhere(Attribute::AttrKind Attr,
-                                     unsigned *Index) const {
+                                     Index *Index) const {
   return pImpl && pImpl->hasAttrSomewhere(Attr, Index);
 }
 
-Attribute AttributeList::getAttribute(unsigned Index,
+Attribute AttributeList::getAttribute(Index Index,
                                       Attribute::AttrKind Kind) const {
   return getAttributes(Index).getAttribute(Kind);
 }
 
-Attribute AttributeList::getAttribute(unsigned Index, StringRef Kind) const {
+Attribute AttributeList::getAttribute(Index Index, StringRef Kind) const {
   return getAttributes(Index).getAttribute(Kind);
 }
 
 MaybeAlign AttributeList::getRetAlignment() const {
   return getAttributes(ReturnIndex).getAlignment();
 }
 
 MaybeAlign AttributeList::getParamAlignment(unsigned ArgNo) const {
-  return getAttributes(ArgNo + FirstArgIndex).getAlignment();
+  return getAttributes(getArgIndex(ArgNo)).getAlignment();
 }
 
 MaybeAlign AttributeList::getParamStackAlignment(unsigned ArgNo) const {
-  return getAttributes(ArgNo + FirstArgIndex).getStackAlignment();
+  return getAttributes(getArgIndex(ArgNo)).getStackAlignment();
 }
 
 Type *AttributeList::getParamByValType(unsigned Index) const {
-  return getAttributes(Index+FirstArgIndex).getByValType();
+  return getAttributes(getArgIndex(Index)).getByValType();
 }
 
 Type *AttributeList::getParamStructRetType(unsigned Index) const {
-  return getAttributes(Index + FirstArgIndex).getStructRetType();
+  return getAttributes(getArgIndex(Index)).getStructRetType();
 }
 
 Type *AttributeList::getParamByRefType(unsigned Index) const {
-  return getAttributes(Index + FirstArgIndex).getByRefType();
+  return getAttributes(getArgIndex(Index)).getByRefType();
 }
 
 Type *AttributeList::getParamPreallocatedType(unsigned Index) const {
-  return getAttributes(Index + FirstArgIndex).getPreallocatedType();
+  return getAttributes(getArgIndex(Index)).getPreallocatedType();
 }
 
 Type *AttributeList::getParamInAllocaType(unsigned Index) const {
-  return getAttributes(Index + FirstArgIndex).getInAllocaType();
+  return getAttributes(getArgIndex(Index)).getInAllocaType();
 }
 
-MaybeAlign AttributeList::getStackAlignment(unsigned Index) const {
+MaybeAlign AttributeList::getStackAlignment(Index Index) const {
   return getAttributes(Index).getStackAlignment();
 }
 
-uint64_t AttributeList::getDereferenceableBytes(unsigned Index) const {
+uint64_t AttributeList::getDereferenceableBytes(Index Index) const {
   return getAttributes(Index).getDereferenceableBytes();
 }
 
-uint64_t AttributeList::getDereferenceableOrNullBytes(unsigned Index) const {
+uint64_t AttributeList::getDereferenceableOrNullBytes(Index Index) const {
   return getAttributes(Index).getDereferenceableOrNullBytes();
 }
 
 std::pair<unsigned, Optional<unsigned>>
-AttributeList::getAllocSizeArgs(unsigned Index) const {
+AttributeList::getAllocSizeArgs(Index Index) const {
   return getAttributes(Index).getAllocSizeArgs();
 }
 
 std::pair<unsigned, unsigned>
-AttributeList::getVScaleRangeArgs(unsigned Index) const {
+AttributeList::getVScaleRangeArgs(Index Index) const {
   return getAttributes(Index).getVScaleRangeArgs();
 }
 
-std::string AttributeList::getAsString(unsigned Index, bool InAttrGrp) const {
+std::string AttributeList::getAsString(Index Index, bool InAttrGrp) const {
   return getAttributes(Index).getAsString(InAttrGrp);
 }
 
-AttributeSet AttributeList::getAttributes(unsigned Index) const {
-  Index = attrIdxToArrayIdx(Index);
-  if (!pImpl || Index >= getNumAttrSets())
+AttributeSet AttributeList::getAttributes(Index Index) const {
+  if (!pImpl || Index.ArrayIndex() >= getNumAttrSets())
     return {};
-  return pImpl->begin()[Index];
+  return pImpl->begin()[Index.ArrayIndex()];
 }
 
 bool AttributeList::hasParentContext(LLVMContext &C) const {
   assert(!isEmpty() && "an empty attribute list has no parent context");
   FoldingSetNodeID ID;
   pImpl->Profile(ID);
   void *Unused;
   return C.pImpl->AttrsLists.FindNodeOrInsertPos(ID, Unused) == pImpl;

 
 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) {
+  for (Index i = index_begin(), e = index_end(); i != e; ++i) {
     if (!getAttributes(i).hasAttributes())
       continue;
     O << "  { ";
-    switch (i) {
-    case AttrIndex::ReturnIndex:
+    if (i == ReturnIndex) {
       O << "return";
-      break;
-    case AttrIndex::FunctionIndex:
+    } else if (i == FunctionIndex) {
       O << "function";
-      break;
-    default:
-      O << "arg(" << i - AttrIndex::FirstArgIndex << ")";
+    } else {
+      O << "arg(" << i.toArgNo() << ")";
     }
     O << " => " << getAsString(i) << " }\n";
   }
 
   O << "]\n";
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void AttributeList::dump() const { print(dbgs()); }
 #endif
 
 //===----------------------------------------------------------------------===//
 // AttrBuilder Method Implementations
 //===----------------------------------------------------------------------===//
 
 // FIXME: Remove this ctor, use AttributeSet.
-AttrBuilder::AttrBuilder(AttributeList AL, unsigned Index) {
+AttrBuilder::AttrBuilder(AttributeList AL, AttributeList::Index Index) {
   AttributeSet AS = AL.getAttributes(Index);
   for (const auto &A : AS)
     addAttribute(A);
 }
 
 AttrBuilder::AttrBuilder(AttributeSet AS) {
   for (const auto &A : AS)
     addAttribute(A);
AttrBuilder &AttrBuilder::removeAttribute(Attribute::AttrKind Val) {
   else if (Val == Attribute::AllocSize)
     AllocSizeArgs = 0;
   else if (Val == Attribute::VScaleRange)
     VScaleRangeArgs = 0;
 
   return *this;
 }
 
-AttrBuilder &AttrBuilder::removeAttributes(AttributeList A, uint64_t Index) {
+AttrBuilder &AttrBuilder::removeAttributes(AttributeList A,
+                                           AttributeList::Index Index) {
   remove(A.getAttributes(Index));
   return *this;
 }
 
 AttrBuilder &AttrBuilder::removeAttribute(StringRef A) {
   auto I = TargetDepAttrs.find(A);
   if (I != TargetDepAttrs.end())
     TargetDepAttrs.erase(I);

 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 {
+bool AttrBuilder::hasAttributes(AttributeList AL,
+                                AttributeList::Index Index) const {
   AttributeSet AS = AL.getAttributes(Index);
 
   for (const auto &Attr : AS) {
     if (Attr.isEnumAttribute() || Attr.isIntAttribute()) {
       if (contains(Attr.getKindAsEnum()))
         return true;
     } else {
       assert(Attr.isStringAttribute() && "Invalid attribute kind!");

llvm/lib/IR/Function.cpp

if (getNumOperands()) {
     setNumHungOffUseOperands(0);
     setValueSubclassData(getSubclassDataFromValue() & ~0xe);
   }
 
   // Metadata is stored in a side-table.
   clearMetadata();
 }
 
-void Function::addAttribute(unsigned i, Attribute::AttrKind Kind) {
+void Function::addAttribute(AttributeList::Index i, Attribute::AttrKind Kind) {
   AttributeList PAL = getAttributes();
   PAL = PAL.addAttribute(getContext(), i, Kind);
   setAttributes(PAL);
 }
 
-void Function::addAttribute(unsigned i, Attribute Attr) {
+void Function::addAttribute(AttributeList::Index i, Attribute Attr) {
   AttributeList PAL = getAttributes();
   PAL = PAL.addAttribute(getContext(), i, Attr);
   setAttributes(PAL);
 }
 
-void Function::addAttributes(unsigned i, const AttrBuilder &Attrs) {
+void Function::addAttributes(AttributeList::Index i, const AttrBuilder &Attrs) {
   AttributeList PAL = getAttributes();
   PAL = PAL.addAttributes(getContext(), i, Attrs);
   setAttributes(PAL);
 }
 
 void Function::addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
   AttributeList PAL = getAttributes();
   PAL = PAL.addParamAttribute(getContext(), ArgNo, Kind);
   setAttributes(PAL);
 }
 
 void Function::addParamAttr(unsigned ArgNo, Attribute Attr) {
   AttributeList PAL = getAttributes();
   PAL = PAL.addParamAttribute(getContext(), ArgNo, Attr);
   setAttributes(PAL);
 }
 
 void Function::addParamAttrs(unsigned ArgNo, const AttrBuilder &Attrs) {
   AttributeList PAL = getAttributes();
   PAL = PAL.addParamAttributes(getContext(), ArgNo, Attrs);
   setAttributes(PAL);
 }
 
-void Function::removeAttribute(unsigned i, Attribute::AttrKind Kind) {
+void Function::removeAttribute(AttributeList::Index i,
+                               Attribute::AttrKind Kind) {
   AttributeList PAL = getAttributes();
   PAL = PAL.removeAttribute(getContext(), i, Kind);
   setAttributes(PAL);
 }
 
-void Function::removeAttribute(unsigned i, StringRef Kind) {
+void Function::removeAttribute(AttributeList::Index i, StringRef Kind) {
   AttributeList PAL = getAttributes();
   PAL = PAL.removeAttribute(getContext(), i, Kind);
   setAttributes(PAL);
 }
 
-void Function::removeAttributes(unsigned i, const AttrBuilder &Attrs) {
+void Function::removeAttributes(AttributeList::Index i,
+                                const AttrBuilder &Attrs) {
   AttributeList PAL = getAttributes();
   PAL = PAL.removeAttributes(getContext(), i, Attrs);
   setAttributes(PAL);
 }
 
 void Function::removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
   AttributeList PAL = getAttributes();
   PAL = PAL.removeParamAttribute(getContext(), ArgNo, Kind);

 }
 
 void Function::removeParamUndefImplyingAttrs(unsigned ArgNo) {
   AttributeList PAL = getAttributes();
   PAL = PAL.removeParamUndefImplyingAttributes(getContext(), ArgNo);
   setAttributes(PAL);
 }
 
-void Function::addDereferenceableAttr(unsigned i, uint64_t Bytes) {
+void Function::addDereferenceableAttr(AttributeList::Index i, uint64_t Bytes) {
   AttributeList PAL = getAttributes();
   PAL = PAL.addDereferenceableAttr(getContext(), i, Bytes);
   setAttributes(PAL);
 }
 
 void Function::addDereferenceableParamAttr(unsigned ArgNo, uint64_t Bytes) {
   AttributeList PAL = getAttributes();
   PAL = PAL.addDereferenceableParamAttr(getContext(), ArgNo, Bytes);
   setAttributes(PAL);
 }
 
-void Function::addDereferenceableOrNullAttr(unsigned i, uint64_t Bytes) {
+void Function::addDereferenceableOrNullAttr(AttributeList::Index i,
+                                            uint64_t Bytes) {
   AttributeList PAL = getAttributes();
   PAL = PAL.addDereferenceableOrNullAttr(getContext(), i, Bytes);
   setAttributes(PAL);
 }
 
 void Function::addDereferenceableOrNullParamAttr(unsigned ArgNo,
                                                  uint64_t Bytes) {
   AttributeList PAL = getAttributes();

llvm/lib/IR/Instructions.cpp

if (getDereferenceableBytes(AttributeList::ReturnIndex) > 0 &&
            !NullPointerIsDefined(getCaller(),
                                  getType()->getPointerAddressSpace()))
     return true;
 
   return false;
 }
 
 Value *CallBase::getReturnedArgOperand() const {
-  unsigned Index;
+  AttributeList::Index Index;
 
-  if (Attrs.hasAttrSomewhere(Attribute::Returned, &Index) && Index)
-    return getArgOperand(Index - AttributeList::FirstArgIndex);
+  if (Attrs.hasAttrSomewhere(Attribute::Returned, &Index) && Index.isArg())
+    return getArgOperand(Index.toArgNo());
   if (const Function *F = getCalledFunction())
     if (F->getAttributes().hasAttrSomewhere(Attribute::Returned, &Index) &&
-        Index)
-      return getArgOperand(Index - AttributeList::FirstArgIndex);
+        Index.isArg())
+      return getArgOperand(Index.toArgNo());
 
   return nullptr;
 }
 
 /// Determine whether the argument or parameter has the given attribute.
 bool CallBase::paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const {
   assert(ArgNo < getNumArgOperands() && "Param index out of bounds!");
 

llvm/lib/Target/AArch64/GISel/AArch64CallLowering.cpp

bool AArch64CallLowering::lowerFormalArguments(
 
   SmallVector<ArgInfo, 8> SplitArgs;
   unsigned i = 0;
   for (auto &Arg : F.args()) {
     if (DL.getTypeStoreSize(Arg.getType()).isZero())
       continue;
 
     ArgInfo OrigArg{VRegs[i], Arg};
-    setArgFlags(OrigArg, i + AttributeList::FirstArgIndex, DL, F);
+    setArgFlags(OrigArg, AttributeList::getArgIndex(i), DL, F);
 
     if (Arg.hasAttribute(Attribute::SwiftAsync))
       MF.getInfo<AArch64FunctionInfo>()->setHasSwiftAsyncContext(true);
 
     splitToValueTypes(OrigArg, SplitArgs, DL, F.getCallingConv());
     ++i;
   }
 

llvm/lib/Target/AMDGPU/AMDGPUCallLowering.cpp

if (CC == CallingConv::AMDGPU_PS && !InReg && PSInputNum <= 15) {
           B.buildUndef(VRegs[Idx][I]);
 
         ++Idx;
         continue;
       }
     }
 
     ArgInfo OrigArg(VRegs[Idx], Arg);
-    const unsigned OrigArgIdx = Idx + AttributeList::FirstArgIndex;
-    setArgFlags(OrigArg, OrigArgIdx, DL, F);
+    setArgFlags(OrigArg, AttributeList::getArgIndex(Idx), DL, F);
 
     splitToValueTypes(OrigArg, SplitArgs, DL, CC);
     ++Idx;
   }
 
   // At least one interpolation mode must be enabled or else the GPU will
   // hang.
   //

llvm/lib/Target/ARM/ARMCallLowering.cpp

bool ARMCallLowering::lowerFormalArguments(MachineIRBuilder &MIRBuilder,
   OutgoingValueAssigner ArgAssigner(AssignFn);
   FormalArgHandler ArgHandler(MIRBuilder, MIRBuilder.getMF().getRegInfo());
 
   SmallVector<ArgInfo, 8> SplitArgInfos;
   unsigned Idx = 0;
   for (auto &Arg : F.args()) {
     ArgInfo OrigArgInfo(VRegs[Idx], Arg.getType());
 
-    setArgFlags(OrigArgInfo, Idx + AttributeList::FirstArgIndex, DL, F);
+    setArgFlags(OrigArgInfo, AttributeList::getArgIndex(Idx), DL, F);
     splitToValueTypes(OrigArgInfo, SplitArgInfos, DL, F.getCallingConv());
 
     Idx++;
   }
 
   if (!MBB.empty())
     MIRBuilder.setInstr(*MBB.begin());
 

llvm/lib/Target/Mips/MipsCallLowering.cpp

bool MipsCallLowering::lowerFormalArguments(MachineIRBuilder &MIRBuilder,
   const DataLayout &DL = MF.getDataLayout();
   const MipsTargetLowering &TLI = *getTLI<MipsTargetLowering>();
 
   SmallVector<ArgInfo, 8> ArgInfos;
   SmallVector<unsigned, 8> OrigArgIndices;
   unsigned i = 0;
   for (auto &Arg : F.args()) {
     ArgInfo AInfo(VRegs[i], Arg.getType());
-    setArgFlags(AInfo, i + AttributeList::FirstArgIndex, DL, F);
+    setArgFlags(AInfo, AttributeList::getArgIndex(i), DL, F);
     ArgInfos.push_back(AInfo);
     OrigArgIndices.push_back(i);
     ++i;
   }
 
   SmallVector<ISD::InputArg, 8> Ins;
   subTargetRegTypeForCallingConv(F, ArgInfos, OrigArgIndices, Ins);
 

llvm/lib/Target/PowerPC/GISel/PPCCallLowering.cpp

bool PPCCallLowering::lowerFormalArguments(MachineIRBuilder &MIRBuilder,
   // Loop over each arg, set flags and split to single value types
   SmallVector<ArgInfo, 8> SplitArgs;
   unsigned I = 0;
   for (const auto &Arg : F.args()) {
     if (DL.getTypeStoreSize(Arg.getType()).isZero())
       continue;
 
     ArgInfo OrigArg{VRegs[I], Arg};
-    setArgFlags(OrigArg, I + AttributeList::FirstArgIndex, DL, F);
+    setArgFlags(OrigArg, AttributeList::getArgIndex(I), DL, F);
     splitToValueTypes(OrigArg, SplitArgs, DL, F.getCallingConv());
     ++I;
   }
 
   CCAssignFn *AssignFn =
       TLI.ccAssignFnForCall(F.getCallingConv(), false, F.isVarArg());
   IncomingValueAssigner ArgAssigner(AssignFn);
   FormalArgHandler ArgHandler(MIRBuilder, MRI);

llvm/lib/Target/X86/X86CallLowering.cpp

if (Arg.hasAttribute(Attribute::ByVal) ||
         Arg.hasAttribute(Attribute::InReg) ||
         Arg.hasAttribute(Attribute::StructRet) ||
         Arg.hasAttribute(Attribute::SwiftSelf) ||
         Arg.hasAttribute(Attribute::SwiftError) ||
         Arg.hasAttribute(Attribute::Nest) || VRegs[Idx].size() > 1)
       return false;
 
     ArgInfo OrigArg(VRegs[Idx], Arg.getType());
-    setArgFlags(OrigArg, Idx + AttributeList::FirstArgIndex, DL, F);
+    setArgFlags(OrigArg, AttributeList::getArgIndex(Idx), DL, F);
     splitToValueTypes(OrigArg, SplitArgs, DL, F.getCallingConv());
     Idx++;
   }
 
   MachineBasicBlock &MBB = MIRBuilder.getMBB();
   if (!MBB.empty())
     MIRBuilder.setInstr(*MBB.begin());
 

llvm/lib/Transforms/IPO/Attributor.cpp

static bool isEqualOrWorse(const Attribute &New, const Attribute &Old) {
 
   return Old.getValueAsInt() >= New.getValueAsInt();
 }
 
 /// Return true if the information provided by \p Attr was added to the
 /// 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) {
+                             AttributeList &Attrs,
+                             AttributeList::Index AttrIdx) {
 
   if (Attr.isEnumAttribute()) {
     Attribute::AttrKind Kind = Attr.getKindAsEnum();
     if (Attrs.hasAttribute(AttrIdx, Kind))
       if (isEqualOrWorse(Attr, Attrs.getAttribute(AttrIdx, Kind)))
         return false;
     Attrs = Attrs.addAttribute(Ctx, AttrIdx, Attr);
     return true;

llvm/lib/Transforms/IPO/GlobalOpt.cpp

for (User *U : F->users()) {
     if (isa<BlockAddress>(U))
       continue;
     cast<CallBase>(U)->setCallingConv(CallingConv::Fast);
   }
 }
 
 static AttributeList StripAttr(LLVMContext &C, AttributeList Attrs,
                                Attribute::AttrKind A) {
-  unsigned AttrIndex;
+  AttributeList::Index AttrIndex;
   if (Attrs.hasAttrSomewhere(A, &AttrIndex))
     return Attrs.removeAttribute(C, AttrIndex, A);
   return Attrs;
 }
 
 static void RemoveAttribute(Function *F, Attribute::AttrKind A) {
   F->setAttributes(StripAttr(F->getContext(), F->getAttributes(), A));
   for (User *U : F->users()) {

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

if (FT->isVarArg() &&
       return false;
   }
 
   if (FT->getNumParams() < NumActualArgs && FT->isVarArg() &&
       !CallerPAL.isEmpty()) {
     // In this case we have more arguments than the new function type, but we
     // won't be dropping them.  Check that these extra arguments have attributes
     // that are compatible with being a vararg call argument.
-    unsigned SRetIdx;
+    AttributeList::Index SRetIdx;
     if (CallerPAL.hasAttrSomewhere(Attribute::StructRet, &SRetIdx) &&
-        SRetIdx > FT->getNumParams())
+        SRetIdx.toArgNo() > FT->getNumParams())
       return false;
   }
 
   // Okay, we decided that this is a safe thing to do: go ahead and start
   // inserting cast instructions as necessary.
   SmallVector<Value *, 8> Args;
   SmallVector<AttributeSet, 8> ArgAttrs;
   Args.reserve(NumActualArgs);

llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp

void MemorySanitizer::createUserspaceApi(Module &M) {
 
   VAArgOverflowSizeTLS =
       getOrInsertGlobal(M, "__msan_va_arg_overflow_size_tls", IRB.getInt64Ty());
 
   for (size_t AccessSizeIndex = 0; AccessSizeIndex < kNumberOfAccessSizes;
        AccessSizeIndex++) {
     unsigned AccessSize = 1 << AccessSizeIndex;
     std::string FunctionName = "__msan_maybe_warning_" + itostr(AccessSize);
-    SmallVector<std::pair<unsigned, Attribute>, 2> MaybeWarningFnAttrs;
+    SmallVector<std::pair<AttributeList::Index, Attribute>, 2>
+        MaybeWarningFnAttrs;
     MaybeWarningFnAttrs.push_back(std::make_pair(
-        AttributeList::FirstArgIndex, Attribute::get(*C, Attribute::ZExt)));
+        AttributeList::getArgIndex(0), Attribute::get(*C, Attribute::ZExt)));
     MaybeWarningFnAttrs.push_back(std::make_pair(
-        AttributeList::FirstArgIndex + 1, Attribute::get(*C, Attribute::ZExt)));
+        AttributeList::getArgIndex(1), Attribute::get(*C, Attribute::ZExt)));
     MaybeWarningFn[AccessSizeIndex] = M.getOrInsertFunction(
         FunctionName, AttributeList::get(*C, MaybeWarningFnAttrs),
         IRB.getVoidTy(), IRB.getIntNTy(AccessSize * 8), IRB.getInt32Ty());
 
     FunctionName = "__msan_maybe_store_origin_" + itostr(AccessSize);
-    SmallVector<std::pair<unsigned, Attribute>, 2> MaybeStoreOriginFnAttrs;
+    SmallVector<std::pair<AttributeList::Index, Attribute>, 2>
+        MaybeStoreOriginFnAttrs;
     MaybeStoreOriginFnAttrs.push_back(std::make_pair(
-        AttributeList::FirstArgIndex, Attribute::get(*C, Attribute::ZExt)));
+        AttributeList::getArgIndex(0), Attribute::get(*C, Attribute::ZExt)));
     MaybeStoreOriginFnAttrs.push_back(std::make_pair(
-        AttributeList::FirstArgIndex + 2, Attribute::get(*C, Attribute::ZExt)));
+        AttributeList::getArgIndex(2), Attribute::get(*C, Attribute::ZExt)));
     MaybeStoreOriginFn[AccessSizeIndex] = M.getOrInsertFunction(
         FunctionName, AttributeList::get(*C, MaybeStoreOriginFnAttrs),
         IRB.getVoidTy(), IRB.getIntNTy(AccessSize * 8), IRB.getInt8PtrTy(),
         IRB.getInt32Ty());
   }
 
   MsanSetAllocaOrigin4Fn = M.getOrInsertFunction(
     "__msan_set_alloca_origin4", IRB.getVoidTy(), IRB.getInt8PtrTy(), IntptrTy,

llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

#endif
 
   relocationViaAlloca(F, DT, Live, Records);
   return !Records.empty();
 }
 
 // Handles both return values and arguments for Functions and calls.
 template <typename AttrHolder>
 static void RemoveNonValidAttrAtIndex(LLVMContext &Ctx, AttrHolder &AH,
-                                      unsigned Index) {
+                                      AttributeList::Index Index) {
   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)
static void stripNonValidAttributesFromPrototype(Function &F) {
   if (Intrinsic::ID id = F.getIntrinsicID()) {
     F.setAttributes(Intrinsic::getAttributes(Ctx, id));
     return;
   }
 
   for (Argument &A : F.args())
     if (isa<PointerType>(A.getType()))
       RemoveNonValidAttrAtIndex(Ctx, F,
-                                A.getArgNo() + AttributeList::FirstArgIndex);
+                                AttributeList::getArgIndex(A.getArgNo()));
 
   if (isa<PointerType>(F.getReturnType()))
     RemoveNonValidAttrAtIndex(Ctx, F, AttributeList::ReturnIndex);
 
   for (auto Attr : FnAttrsToStrip)
     F.removeFnAttr(Attr);
 }
 
if (MDNode *Tag = I.getMetadata(LLVMContext::MD_tbaa)) {
       I.setMetadata(LLVMContext::MD_tbaa, MutableTBAA);
     }
 
     stripInvalidMetadataFromInstruction(I);
 
     if (auto *Call = dyn_cast<CallBase>(&I)) {
       for (int i = 0, e = Call->arg_size(); i != e; i++)
         if (isa<PointerType>(Call->getArgOperand(i)->getType()))
-          RemoveNonValidAttrAtIndex(Ctx, *Call,
-                                    i + AttributeList::FirstArgIndex);
+          RemoveNonValidAttrAtIndex(Ctx, *Call, AttributeList::getArgIndex(i));
       if (isa<PointerType>(Call->getType()))
         RemoveNonValidAttrAtIndex(Ctx, *Call, AttributeList::ReturnIndex);
     }
   }
 
   // Delete the invariant.start instructions and RAUW undef.
   for (auto *II : InvariantStartInstructions) {
     II->replaceAllUsesWith(UndefValue::get(II->getType()));

llvm/lib/Transforms/Utils/AssumeBundleBuilder.cpp

void addAttribute(Attribute Attr, Value *WasOn) {
     unsigned AttrArg = 0;
     if (Attr.isIntAttribute())
       AttrArg = Attr.getValueAsInt();
     addKnowledge({Attr.getKindAsEnum(), AttrArg, WasOn});
   }
 
   void addCall(const CallBase *Call) {
     auto addAttrList = [&](AttributeList AttrList) {
-      for (unsigned Idx = AttributeList::FirstArgIndex;
-           Idx < AttrList.getNumAttrSets(); Idx++)
+      for (AttributeList::Index Idx = AttrList.index_begin(),
+                                EndIdx = AttrList.index_end();
+           Idx != EndIdx; ++Idx) {
+        if (!Idx.isArg())
+          continue;
         for (Attribute Attr : AttrList.getAttributes(Idx)) {
           bool IsPoisonAttr = Attr.hasAttribute(Attribute::NonNull) ||
                               Attr.hasAttribute(Attribute::Alignment);
-          if (!IsPoisonAttr || Call->isPassingUndefUB(Idx - 1))
-            addAttribute(Attr, Call->getArgOperand(Idx - 1));
-        }
+          if (!IsPoisonAttr || Call->isPassingUndefUB(Idx.toArgNo()))
+            addAttribute(Attr, Call->getArgOperand(Idx.toArgNo()));
+        }
       for (Attribute Attr : AttrList.getFnAttributes())
         addAttribute(Attr, nullptr);
     };
     addAttrList(Call->getAttributes());
     if (Function *Fn = Call->getCalledFunction())
       addAttrList(Fn->getAttributes());
   }
 

llvm/lib/Transforms/Utils/FunctionComparator.cpp

int FunctionComparator::cmpMem(StringRef L, StringRef R) const {
   return L.compare(R);
 }
 
 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) {
+  for (AttributeList::Index i = L.index_begin(), e = L.index_end(); i != e;
+       ++i) {
     AttributeSet LAS = L.getAttributes(i);
     AttributeSet RAS = R.getAttributes(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()) {

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

static void annotateDereferenceableBytes(CallInst *CI,
   const Function *F = CI->getCaller();
   if (!F)
     return;
   for (unsigned ArgNo : ArgNos) {
     uint64_t DerefBytes = DereferenceableBytes;
     unsigned AS = CI->getArgOperand(ArgNo)->getType()->getPointerAddressSpace();
     if (!llvm::NullPointerIsDefined(F, AS) ||
         CI->paramHasAttr(ArgNo, Attribute::NonNull))
-      DerefBytes = std::max(CI->getDereferenceableOrNullBytes(
-                                ArgNo + AttributeList::FirstArgIndex),
-                            DereferenceableBytes);
-  
-    if (CI->getDereferenceableBytes(ArgNo + AttributeList::FirstArgIndex) <
+      DerefBytes = std::max(
+          CI->getDereferenceableOrNullBytes(AttributeList::getArgIndex(ArgNo)),
+    if (CI->getDereferenceableBytes(AttributeList::getArgIndex(ArgNo)) <
         DerefBytes) {
       CI->removeParamAttr(ArgNo, Attribute::Dereferenceable);
       if (!llvm::NullPointerIsDefined(F, AS) ||
           CI->paramHasAttr(ArgNo, Attribute::NonNull))
         CI->removeParamAttr(ArgNo, Attribute::DereferenceableOrNull);
       CI->addParamAttr(ArgNo, Attribute::getWithDereferenceableBytes(
                                   CI->getContext(), DerefBytes));
     }

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

 class LLVMContext;
 } // namespace llvm
 
 using namespace llvm;
 
 namespace {
 
 using AttrPtrVecTy = std::vector<const Attribute *>;
-using AttrPtrIdxVecVecTy = std::pair<unsigned, AttrPtrVecTy>;
+using AttrPtrIdxVecVecTy = std::pair<AttributeList::Index, AttrPtrVecTy>;
 using AttrPtrVecVecTy = SmallVector<AttrPtrIdxVecVecTy, 3>;
 
 /// Given ChunksToKeep, produce a map of global variables/functions/calls
 /// and indexes of attributes to be preserved for each of them.
 class AttributeRemapper : public InstVisitor<AttributeRemapper> {
   Oracle O;
 
 public:
public:
   void visitCallBase(CallBase &I) {
     visitAttributeList(I.getAttributes(), CallsToRefine[&I]);
   }
 
   void visitAttributeList(const AttributeList &AL,
                           AttrPtrVecVecTy &AttributeSetsToPreserve) {
     assert(AttributeSetsToPreserve.empty() && "Should not be sharing vectors.");
     AttributeSetsToPreserve.reserve(AL.getNumAttrSets());
-    for (unsigned SetIdx : seq(AL.index_begin(), AL.index_end())) {
+    for (AttributeList::Index SetIdx = AL.index_begin(),
+                              SetEndIdx = AL.index_end();
+         SetIdx != SetEndIdx; ++SetIdx) {
       AttrPtrIdxVecVecTy AttributesToPreserve;
       AttributesToPreserve.first = SetIdx;
       visitAttributeSet(AL.getAttributes(AttributesToPreserve.first),
                         AttributesToPreserve.second);
       if (!AttributesToPreserve.second.empty())
         AttributeSetsToPreserve.emplace_back(std::move(AttributesToPreserve));
     }
   }
convertAttributeRefToAttributeSet(LLVMContext &C,
   AttrBuilder B;
   for (const Attribute *A : Attributes)
     B.addAttribute(*A);
   return AttributeSet::get(C, B);
 }
 
 AttributeList convertAttributeRefVecToAttributeList(
     LLVMContext &C, ArrayRef<AttrPtrIdxVecVecTy> AttributeSets) {
-  std::vector<std::pair<unsigned, AttributeSet>> SetVec;
+  std::vector<std::pair<AttributeList::Index, AttributeSet>> SetVec;
   SetVec.reserve(AttributeSets.size());
 
   transform(AttributeSets, std::back_inserter(SetVec),
             [&C](const AttrPtrIdxVecVecTy &V) {
               return std::make_pair(
                   V.first, convertAttributeRefToAttributeSet(C, V.second));
             });
 
-  sort(SetVec, [](const std::pair<unsigned, AttributeSet> &LHS,
-                  const std::pair<unsigned, AttributeSet> &RHS) {
+  sort(SetVec, [](const std::pair<AttributeList::Index, AttributeSet> &LHS,
+                  const std::pair<AttributeList::Index, AttributeSet> &RHS) {
     return LHS.first < RHS.first; // All values are unique.
   });
 
   return AttributeList::get(C, SetVec);
 }
 
 /// Removes out-of-chunk attributes from module.
 static void extractAttributesFromModule(std::vector<Chunk> ChunksToKeep,

llvm/unittests/IR/AttributesTest.cpp

TEST(Attributes, RemoveAlign) {
   EXPECT_TRUE(AL2.hasParamAttr(0, Attribute::ReadOnly));
   EXPECT_FALSE(AL2.hasAttribute(0, Attribute::StackAlignment));
   EXPECT_TRUE(AL2.hasAttribute(0, Attribute::OptimizeNone));
 }
 
 TEST(Attributes, AddMatchingAlignAttr) {
   LLVMContext C;
   AttributeList AL;
-  AL = AL.addAttribute(C, AttributeList::FirstArgIndex,
+  AL = AL.addAttribute(C, AttributeList::getArgIndex(0),
                        Attribute::getWithAlignment(C, Align(8)));
-  AL = AL.addAttribute(C, AttributeList::FirstArgIndex + 1,
+  AL = AL.addAttribute(C, AttributeList::getArgIndex(1),
                        Attribute::getWithAlignment(C, Align(32)));
   EXPECT_EQ(Align(8), AL.getParamAlignment(0));
   EXPECT_EQ(Align(32), AL.getParamAlignment(1));
 
   AttrBuilder B;
   B.addAttribute(Attribute::NonNull);
   B.addAlignmentAttr(8);
-  AL = AL.addAttributes(C, AttributeList::FirstArgIndex, B);
+  AL = AL.addAttributes(C, AttributeList::getArgIndex(0), B);
   EXPECT_EQ(Align(8), AL.getParamAlignment(0));
   EXPECT_EQ(Align(32), AL.getParamAlignment(1));
   EXPECT_TRUE(AL.hasParamAttribute(0, Attribute::NonNull));
 }
 
 TEST(Attributes, EmptyGet) {
   LLVMContext C;
   AttributeList EmptyLists[] = {AttributeList(), AttributeList()};
   AttributeList AL = AttributeList::get(C, EmptyLists);
   EXPECT_TRUE(AL.isEmpty());
 }
 
 TEST(Attributes, OverflowGet) {
   LLVMContext C;
-  std::pair<unsigned, Attribute> Attrs[] = { { AttributeList::ReturnIndex, Attribute::get(C, Attribute::SExt) },
-                                             { AttributeList::FunctionIndex, Attribute::get(C, Attribute::ReadOnly) } };
+  std::pair<AttributeList::Index, Attribute> Attrs[] = {
+      {AttributeList::ReturnIndex, Attribute::get(C, Attribute::SExt)},
+      {AttributeList::FunctionIndex, Attribute::get(C, Attribute::ReadOnly)}};
   AttributeList AL = AttributeList::get(C, Attrs);
   EXPECT_EQ(2U, AL.getNumAttrSets());
 }
 
 TEST(Attributes, StringRepresentation) {
   LLVMContext C;
   StructType *Ty = StructType::create(Type::getInt32Ty(C), "mystruct");