[AttributeList] Change indexes in AttributeList::AttrIndex

[aeubanks]

Summary

The indexes used in AttributeList's methods are very confusing. The
index used for the function was (unsigned) -1, return value 0, and the
arguments 1+. When iterating through indexes, we rely on unsigned
wrapping.

This changes the function index to 0, return value index to 1, and
arguments to 2+.

There are two places we have to keep the old indexes. One is the C API,
and the other is reading/writing bitcode for backwards compatibility.

If this breaks any downstream users, inspect calls to
*AttributeAtIndex() to see if they've hardcoded indexes.

[rnk]

This seems release note worthy. This seems likely to affect every LLVM frontend. +@tstellar for some distributor PoV.

I think one of the reasons I held off on doing this was because I knew we'd have to do the conversion in the C API and the bitcode serialization, and that was two places that needed to know about the index conversion instead of one in the internals.

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

791

typo s/if/is/

llvm/lib/IR/Core.cpp

2464

Re: the lint check, the static helpers in this file do start with lower case names. I also suggest making the directionality a bit clearer, like mapToLlvmAttributeIndex or something like that. We don't need mapFrom, but I was wondering that to myself.

llvm/unittests/IR/AttributesTest.cpp

175

Hm, this seems like an annoying API break that most frontends will discover only at runtime.

[aeubanks]

address comments

[nikic]

I'm not convinced that this change is worthwhile. After your recent cleanup, there's not a lot of places working directly with attribute indexes. Especially because we need to keep backwards-compatibility in multiple places, I don't think this change makes things clearer -- especially the fact that "attribute index" in the C API and in the C++ API will now have different meanings is concerning. I can't even say that the new indexes are less arbitrary than the old ones -- the only real advantage they have is that they're directly usable as array offsets.

[aeubanks]

the main reason I wanted to do this was to avoid the weird unsigned wrapping when doing

for (unsigned i = AL.index_begin(), e = AL.index_end(); i != e; ++i)

but maybe that's not a good enough reason

perhaps instead we could remove the index_begin/index_end methods and provide an iterator via something like indexes

[aeubanks]

In D109397#3034403, @aeubanks wrote:

the main reason I wanted to do this was to avoid the weird unsigned wrapping when doing

for (unsigned i = AL.index_begin(), e = AL.index_end(); i != e; ++i)

but maybe that's not a good enough reason

perhaps instead we could remove the index_begin/index_end methods and provide an iterator via something like indexes

https://reviews.llvm.org/D110885

llvm/include/llvm/IR/Attributes.h

 /// 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,
+    FunctionIndex = 0U,
+    ReturnIndex = 1U,
+    FirstArgIndex = 2U,
   };
 
 private:
   friend class AttrBuilder;
   friend class AttributeListImpl;
   friend class AttributeSet;
   friend class AttributeSetNode;
   template <typename Ty> friend struct DenseMapInfo;
public:
 
   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; }
+  unsigned index_end() const { return getNumAttrSets(); }
 
   /// 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;

llvm/include/llvm/IR/Intrinsics.td

 
 // Throws - This intrinsic can throw.
 def Throws : IntrinsicProperty;
 
 // Attribute index needs to match `AttrIndex` defined `Attributes.h`.
 class AttrIndex<int idx> {
   int Value = idx;
 }
-def FuncIndex : AttrIndex<-1>;
-def RetIndex : AttrIndex<0>;
-class ArgIndex<int argNo> : AttrIndex<!add(argNo, 1)>;
+def FuncIndex : AttrIndex<0>;
+def RetIndex : AttrIndex<1>;
+class ArgIndex<int argNo> : AttrIndex<!add(argNo, 2)>;
 
 // NoCapture - The specified argument pointer is not captured by the intrinsic.
 class NoCapture<AttrIndex idx> : IntrinsicProperty {
   int ArgNo = idx.Value;
 }
 
 // NoAlias - The specified argument pointer is not aliasing other "noalias" pointer
 // arguments of the intrinsic wrt. the intrinsic scope.

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

while (true) {
     case bitc::PARAMATTR_CODE_ENTRY_OLD: // ENTRY: [paramidx0, attr0, ...]
       // Deprecated, but still needed to read old bitcode files.
       if (Record.size() & 1)
         return error("Invalid record");
 
       for (unsigned i = 0, e = Record.size(); i != e; i += 2) {
         AttrBuilder B;
         decodeLLVMAttributesForBitcode(B, Record[i+1]);
-        Attrs.push_back(AttributeList::get(Context, Record[i], B));
+        // For historical reasons, the attribute index is off by one.
+        Attrs.push_back(AttributeList::get(Context, Record[i] + 1, B));
       }
 
       MAttributes.push_back(AttributeList::get(Context, Attrs));
       Attrs.clear();
       break;
     case bitc::PARAMATTR_CODE_ENTRY: // ENTRY: [attrgrp0, attrgrp1, ...]
       for (unsigned i = 0, e = Record.size(); i != e; ++i)
         Attrs.push_back(MAttributeGroups[Record[i]]);
while (true) {
     switch (MaybeRecord.get()) {
     default:  // Default behavior: ignore.
       break;
     case bitc::PARAMATTR_GRP_CODE_ENTRY: { // ENTRY: [grpid, idx, a0, a1, ...]
       if (Record.size() < 3)
         return error("Invalid record");
 
       uint64_t GrpID = Record[0];
-      uint64_t Idx = Record[1]; // Index of the object this attribute refers to.
+      // Index of the object this attribute refers to.
+      // For historical reasons, the attribute index is off by one.
+      uint64_t Idx = static_cast<unsigned>(Record[1]) + 1;
 
       AttrBuilder B;
       for (unsigned i = 2, e = Record.size(); i != e; ++i) {
         if (Record[i] == 0) {        // Enum attribute
           Attribute::AttrKind Kind;
           if (Error Err = parseAttrKind(Record[++i], &Kind))
             return Err;
 

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

void ModuleBitcodeWriter::writeAttributeGroupTable() {
 
   Stream.EnterSubblock(bitc::PARAMATTR_GROUP_BLOCK_ID, 3);
 
   SmallVector<uint64_t, 64> Record;
   for (ValueEnumerator::IndexAndAttrSet Pair : AttrGrps) {
     unsigned AttrListIndex = Pair.first;
     AttributeSet AS = Pair.second;
     Record.push_back(VE.getAttributeGroupID(Pair));
-    Record.push_back(AttrListIndex);
+    // For historical reasons, the attribute index if off by one.
+    Record.push_back(AttrListIndex - 1);
 
     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()));

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])
     if (!I.isStringAttribute())
       AvailableFunctionAttrs.addAttribute(I.getKindAsEnum());
 
   for (const auto &Set : Sets)
     for (const auto &I : Set)
       if (!I.isStringAttribute())
         AvailableSomewhereAttrs.addAttribute(I.getKindAsEnum());
 }

 }
 
 bool AttributeListImpl::hasAttrSomewhere(Attribute::AttrKind Kind,
                                         unsigned *Index) const {
   if (!AvailableSomewhereAttrs.hasAttribute(Kind))
     return false;
 
   if (Index) {
-    for (unsigned I = 0, E = NumAttrSets; I != E; ++I) {
+    for (unsigned I = AttributeList::ReturnIndex, E = NumAttrSets; I != E;
+         ++I) {
       if (begin()[I].hasAttribute(Kind)) {
-        *Index = I - 1;
+        *Index = I;
         break;
       }
     }
   }
 
   return true;
 }
 
assert(llvm::none_of(Attrs,
          "Pointless attribute!");
 
   unsigned 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 + 1);
   for (const auto &Pair : Attrs)
-    AttrVec[attrIdxToArrayIdx(Pair.first)] = Pair.second;
+    AttrVec[Pair.first] = 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
AttributeList AttributeList::get(LLVMContext &C, AttributeSet FnAttrs,
 
   return getImpl(C, AttrSets);
 }
 
 AttributeList AttributeList::get(LLVMContext &C, unsigned Index,
                                  const AttrBuilder &B) {
   if (!B.hasAttributes())
     return {};
-  Index = attrIdxToArrayIdx(Index);
   SmallVector<AttributeSet, 8> AttrSets(Index + 1);
   AttrSets[Index] = AttributeSet::get(C, B);
   return getImpl(C, AttrSets);
 }
 
 AttributeList AttributeList::get(LLVMContext &C, unsigned Index,
                                  ArrayRef<Attribute::AttrKind> Kinds) {
   SmallVector<std::pair<unsigned, Attribute>, 8> Attrs;
AttributeList AttributeList::get(LLVMContext &C,
   // If every list was empty, there is no point in merging the lists.
   if (MaxSize == 0)
     return {};
 
   SmallVector<AttributeSet, 8> NewAttrSets(MaxSize);
   for (unsigned I = 0; I < MaxSize; ++I) {
     AttrBuilder CurBuilder;
     for (const auto &List : Attrs)
-      CurBuilder.merge(List.getAttributes(I - 1));
+      CurBuilder.merge(List.getAttributes(I));
     NewAttrSets[I] = AttributeSet::get(C, CurBuilder);
   }
 
   return getImpl(C, NewAttrSets);
 }
 
 AttributeList
 AttributeList::addAttributeAtIndex(LLVMContext &C, unsigned Index,
AttributeList AttributeList::addAttributeAtIndex(LLVMContext &C, unsigned Index,
   AttrBuilder B;
   B.addAttribute(A);
   return addAttributesAtIndex(C, Index, B);
 }
 
 AttributeList AttributeList::setAttributesAtIndex(LLVMContext &C,
                                                   unsigned 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;
   return AttributeList::getImpl(C, AttrSets);
 }
 
 AttributeList AttributeList::addAttributesAtIndex(LLVMContext &C,

 }
 
 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 = ArgNos.back() + FirstArgIndex;
   if (MaxIndex >= AttrSets.size())
     AttrSets.resize(MaxIndex + 1);
 
   for (unsigned ArgNo : ArgNos) {
-    unsigned Index = attrIdxToArrayIdx(ArgNo + FirstArgIndex);
+    unsigned Index = ArgNo + FirstArgIndex;
     AttrBuilder B(AttrSets[Index]);
     B.addAttribute(A);
     AttrSets[Index] = AttributeSet::get(C, B);
   }
 
   return getImpl(C, AttrSets);
 }
 
 AttributeList
 AttributeList::removeAttributeAtIndex(LLVMContext &C, unsigned Index,
                                       Attribute::AttrKind Kind) const {
   if (!hasAttributeAtIndex(Index, Kind))
     return *this;
 
-  Index = attrIdxToArrayIdx(Index);
   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
   assert(Index < AttrSets.size());
 
   AttrSets[Index] = AttrSets[Index].removeAttribute(C, Kind);
 
   return getImpl(C, AttrSets);
 }
 
 AttributeList AttributeList::removeAttributeAtIndex(LLVMContext &C,
                                                     unsigned Index,
                                                     StringRef Kind) const {
   if (!hasAttributeAtIndex(Index, Kind))
     return *this;
 
-  Index = attrIdxToArrayIdx(Index);
   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
   assert(Index < AttrSets.size());
 
   AttrSets[Index] = AttrSets[Index].removeAttribute(C, Kind);
 
   return getImpl(C, AttrSets);
 }
 
 AttributeList
 AttributeList::removeAttributesAtIndex(LLVMContext &C, unsigned 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 setAttributesAtIndex(C, Index, NewAttrs);
 }
 
 AttributeList
 AttributeList::removeAttributesAtIndex(LLVMContext &C,
                                        unsigned WithoutIndex) const {
   if (!pImpl)
     return {};
-  WithoutIndex = attrIdxToArrayIdx(WithoutIndex);
   if (WithoutIndex >= getNumAttrSets())
     return *this;
   SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
   AttrSets[WithoutIndex] = AttributeSet();
   return getImpl(C, AttrSets);
 }
 
 AttributeList AttributeList::addDereferenceableRetAttr(LLVMContext &C,
AttributeList::getParamDereferenceableOrNullBytes(unsigned Index) const {
   return getParamAttrs(Index).getDereferenceableOrNullBytes();
 }
 
 std::string AttributeList::getAsString(unsigned Index, bool InAttrGrp) const {
   return getAttributes(Index).getAsString(InAttrGrp);
 }
 
 AttributeSet AttributeList::getAttributes(unsigned Index) const {
-  Index = attrIdxToArrayIdx(Index);
   if (!pImpl || Index >= getNumAttrSets())
     return {};
   return pImpl->begin()[Index];
 }
 
 bool AttributeList::hasParentContext(LLVMContext &C) const {
   assert(!isEmpty() && "an empty attribute list has no parent context");
   FoldingSetNodeID ID;

llvm/lib/IR/Core.cpp

 void LLVMSetGC(LLVMValueRef Fn, const char *GC) {
   Function *F = unwrap<Function>(Fn);
   if (GC)
     F->setGC(GC);
   else
     F->clearGC();
 }
 
+// Attributes indexes within LLVM were changed to be less confusing. However,
+// to avoid making changes to the C API, we keep the indexes exposed to the C
+// API the same.
+static unsigned ConvertAttributeIndex(LLVMAttributeIndex Idx) {
+  return Idx + 1;
+}
+
 void LLVMAddAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
                              LLVMAttributeRef A) {
-  unwrap<Function>(F)->addAttributeAtIndex(Idx, unwrap(A));
+  unwrap<Function>(F)->addAttributeAtIndex(ConvertAttributeIndex(Idx),
+                                           unwrap(A));
 }
 
 unsigned LLVMGetAttributeCountAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx) {
-  auto AS = unwrap<Function>(F)->getAttributes().getAttributes(Idx);
+  auto AS = unwrap<Function>(F)->getAttributes().getAttributes(
+      ConvertAttributeIndex(Idx));
   return AS.getNumAttributes();
 }
 
 void LLVMGetAttributesAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
                               LLVMAttributeRef *Attrs) {
-  auto AS = unwrap<Function>(F)->getAttributes().getAttributes(Idx);
+  auto AS = unwrap<Function>(F)->getAttributes().getAttributes(
+      ConvertAttributeIndex(Idx));
   for (auto A : AS)
     *Attrs++ = wrap(A);
 }
 
 LLVMAttributeRef LLVMGetEnumAttributeAtIndex(LLVMValueRef F,
                                              LLVMAttributeIndex Idx,
                                              unsigned KindID) {
   return wrap(unwrap<Function>(F)->getAttributeAtIndex(
-      Idx, (Attribute::AttrKind)KindID));
+      ConvertAttributeIndex(Idx), (Attribute::AttrKind)KindID));
 }
 
 LLVMAttributeRef LLVMGetStringAttributeAtIndex(LLVMValueRef F,
                                                LLVMAttributeIndex Idx,
                                                const char *K, unsigned KLen) {
-  return wrap(
-      unwrap<Function>(F)->getAttributeAtIndex(Idx, StringRef(K, KLen)));
+  return wrap(unwrap<Function>(F)->getAttributeAtIndex(
+      ConvertAttributeIndex(Idx), StringRef(K, KLen)));
 }
 
 void LLVMRemoveEnumAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
                                     unsigned KindID) {
-  unwrap<Function>(F)->removeAttributeAtIndex(Idx, (Attribute::AttrKind)KindID);
+  unwrap<Function>(F)->removeAttributeAtIndex(ConvertAttributeIndex(Idx),
+                                              (Attribute::AttrKind)KindID);
 }
 
 void LLVMRemoveStringAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
                                       const char *K, unsigned KLen) {
-  unwrap<Function>(F)->removeAttributeAtIndex(Idx, StringRef(K, KLen));
+  unwrap<Function>(F)->removeAttributeAtIndex(ConvertAttributeIndex(Idx),
+                                              StringRef(K, KLen));
 }
 
 void LLVMAddTargetDependentFunctionAttr(LLVMValueRef Fn, const char *A,
                                         const char *V) {
   Function *Func = unwrap<Function>(Fn);
   Attribute Attr = Attribute::get(Func->getContext(), A, V);
   Func->addFnAttr(Attr);
 }
return unwrap<CallBase>(Instr)->setCallingConv(
       static_cast<CallingConv::ID>(CC));
 }
 
 void LLVMSetInstrParamAlignment(LLVMValueRef Instr, LLVMAttributeIndex Idx,
                                 unsigned align) {
   auto *Call = unwrap<CallBase>(Instr);
   Attribute AlignAttr =
       Attribute::getWithAlignment(Call->getContext(), Align(align));
-  Call->addAttributeAtIndex(Idx, AlignAttr);
+  Call->addAttributeAtIndex(ConvertAttributeIndex(Idx), AlignAttr);
 }
 
 void LLVMAddCallSiteAttribute(LLVMValueRef C, LLVMAttributeIndex Idx,
                               LLVMAttributeRef A) {
-  unwrap<CallBase>(C)->addAttributeAtIndex(Idx, unwrap(A));
+  unwrap<CallBase>(C)->addAttributeAtIndex(ConvertAttributeIndex(Idx),
+                                           unwrap(A));
 }
 
 unsigned LLVMGetCallSiteAttributeCount(LLVMValueRef C,
                                        LLVMAttributeIndex Idx) {
   auto *Call = unwrap<CallBase>(C);
-  auto AS = Call->getAttributes().getAttributes(Idx);
+  auto AS = Call->getAttributes().getAttributes(ConvertAttributeIndex(Idx));
   return AS.getNumAttributes();
 }
 
 void LLVMGetCallSiteAttributes(LLVMValueRef C, LLVMAttributeIndex Idx,
                                LLVMAttributeRef *Attrs) {
   auto *Call = unwrap<CallBase>(C);
-  auto AS = Call->getAttributes().getAttributes(Idx);
+  auto AS = Call->getAttributes().getAttributes(ConvertAttributeIndex(Idx));
   for (auto A : AS)
     *Attrs++ = wrap(A);
 }
 
 LLVMAttributeRef LLVMGetCallSiteEnumAttribute(LLVMValueRef C,
                                               LLVMAttributeIndex Idx,
                                               unsigned KindID) {
   return wrap(unwrap<CallBase>(C)->getAttributeAtIndex(
-      Idx, (Attribute::AttrKind)KindID));
+      ConvertAttributeIndex(Idx), (Attribute::AttrKind)KindID));
 }
 
 LLVMAttributeRef LLVMGetCallSiteStringAttribute(LLVMValueRef C,
                                                 LLVMAttributeIndex Idx,
                                                 const char *K, unsigned KLen) {
-  return wrap(
-      unwrap<CallBase>(C)->getAttributeAtIndex(Idx, StringRef(K, KLen)));
+  return wrap(unwrap<CallBase>(C)->getAttributeAtIndex(
+      ConvertAttributeIndex(Idx), StringRef(K, KLen)));
 }
 
 void LLVMRemoveCallSiteEnumAttribute(LLVMValueRef C, LLVMAttributeIndex Idx,
                                      unsigned KindID) {
-  unwrap<CallBase>(C)->removeAttributeAtIndex(Idx, (Attribute::AttrKind)KindID);
+  unwrap<CallBase>(C)->removeAttributeAtIndex(ConvertAttributeIndex(Idx),
+                                              (Attribute::AttrKind)KindID);
 }
 
 void LLVMRemoveCallSiteStringAttribute(LLVMValueRef C, LLVMAttributeIndex Idx,
                                        const char *K, unsigned KLen) {
-  unwrap<CallBase>(C)->removeAttributeAtIndex(Idx, StringRef(K, KLen));
+  unwrap<CallBase>(C)->removeAttributeAtIndex(ConvertAttributeIndex(Idx),
+                                              StringRef(K, KLen));
 }
 
 LLVMValueRef LLVMGetCalledValue(LLVMValueRef Instr) {
   return wrap(unwrap<CallBase>(Instr)->getCalledOperand());
 }
 
 LLVMTypeRef LLVMGetCalledFunctionType(LLVMValueRef Instr) {
   return wrap(unwrap<CallBase>(Instr)->getFunctionType());

llvm/unittests/IR/AttributesTest.cpp

TEST(Attributes, Ordering) {
   EXPECT_TRUE(Align4 < Deref5);
   EXPECT_TRUE(Align5 < Deref4);
 
   Attribute ByVal = Attribute::get(C, Attribute::ByVal, Type::getInt32Ty(C));
   EXPECT_FALSE(ByVal < Attribute::get(C, Attribute::ZExt));
   EXPECT_TRUE(ByVal < Align4);
   EXPECT_FALSE(ByVal < ByVal);
 
-  AttributeList ASs[] = {AttributeList::get(C, 2, Attribute::ZExt),
-                         AttributeList::get(C, 1, Attribute::SExt)};
+  AttributeList ASs[] = {
+      AttributeList::get(C, AttributeList::FirstArgIndex + 1, Attribute::ZExt),
+      AttributeList::get(C, AttributeList::FirstArgIndex, Attribute::SExt)};
 
   AttributeList SetA = AttributeList::get(C, ASs);
   AttributeList SetB =
       SetA.removeParamAttributes(C, 0, ASs[1].getParamAttrs(0));
   EXPECT_NE(SetA, SetB);
 }
 
 TEST(Attributes, AddAttributes) {
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<unsigned, Attribute> Attrs[] = {
+      {AttributeList::FunctionIndex, Attribute::get(C, Attribute::ReadOnly)},
+      {AttributeList::ReturnIndex, Attribute::get(C, Attribute::SExt)}};
   AttributeList AL = AttributeList::get(C, Attrs);
   EXPECT_EQ(2U, AL.getNumAttrSets());
 }
 
 TEST(Attributes, StringRepresentation) {
   LLVMContext C;
   StructType *Ty = StructType::create(Type::getInt32Ty(C), "mystruct");
 

llvm/utils/TableGen/CodeGenTarget.cpp

bool CodeGenIntrinsic::isParamAPointer(unsigned ParamIdx) const {
   if (ParamIdx >= IS.ParamVTs.size())
     return false;
   MVT ParamType = MVT(IS.ParamVTs[ParamIdx]);
   return ParamType == MVT::iPTR || ParamType == MVT::iPTRAny;
 }
 
 bool CodeGenIntrinsic::isParamImmArg(unsigned ParamIdx) const {
   // Convert argument index to attribute index starting from `FirstArgIndex`.
-  ArgAttribute Val{ParamIdx + 1, ImmArg, 0};
+  ArgAttribute Val{ParamIdx + 2, ImmArg, 0};
   return std::binary_search(ArgumentAttributes.begin(),
                             ArgumentAttributes.end(), Val);
 }