[Attribute] Remove various AttrBuilder getter methods

[aeubanks]

Summary

Generally we shouldn't need these, instead we should query the original AttributeList/Set directly.

llvm/include/llvm/IR/Attributes.h

public:
   /// not set.
   uint64_t getRawIntAttr(Attribute::AttrKind Kind) const;
 
   /// Retrieve the alignment attribute, if it exists.
   MaybeAlign getAlignment() const {
     return MaybeAlign(getRawIntAttr(Attribute::Alignment));
   }
 
-  /// Retrieve the stack alignment attribute, if it exists.
-  MaybeAlign getStackAlignment() const {
-    return MaybeAlign(getRawIntAttr(Attribute::StackAlignment));
-  }
-
-  /// Retrieve the number of dereferenceable bytes, if the
-  /// dereferenceable attribute exists (zero is returned otherwise).
-  uint64_t getDereferenceableBytes() const {
-    return getRawIntAttr(Attribute::Dereferenceable);
-  }
-
-  /// Retrieve the number of dereferenceable_or_null bytes, if the
-  /// dereferenceable_or_null attribute exists (zero is returned otherwise).
-  uint64_t getDereferenceableOrNullBytes() const {
-    return getRawIntAttr(Attribute::DereferenceableOrNull);
-  }
-
   /// Retrieve type for the given type attribute.
   Type *getTypeAttr(Attribute::AttrKind Kind) const;
 
-  /// Retrieve the byval type.
-  Type *getByValType() const { return getTypeAttr(Attribute::ByVal); }
-
-  /// Retrieve the sret type.
-  Type *getStructRetType() const { return getTypeAttr(Attribute::StructRet); }
-
-  /// Retrieve the byref type.
-  Type *getByRefType() const { return getTypeAttr(Attribute::ByRef); }
-
-  /// Retrieve the preallocated type.
-  Type *getPreallocatedType() const {
-    return getTypeAttr(Attribute::Preallocated);
-  }
-
-  /// Retrieve the inalloca type.
-  Type *getInAllocaType() const { return getTypeAttr(Attribute::InAlloca); }
-
-  /// Retrieve the allocsize args, if the allocsize attribute exists.  If it
-  /// doesn't exist, pair(0, 0) is returned.
-  std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
-
-  /// Retrieve the minimum value of 'vscale_range'.
-  unsigned getVScaleRangeMin() const;
-
-  /// Retrieve the maximum value of 'vscale_range' or None when unknown.
-  Optional<unsigned> getVScaleRangeMax() const;
-
   /// Add integer attribute with raw value (packed/encoded if necessary).
   AttrBuilder &addRawIntAttr(Attribute::AttrKind Kind, uint64_t Value);
 
   /// This turns an alignment into the form used internally in Attribute.
   /// This call has no effect if Align is not set.
   AttrBuilder &addAlignmentAttr(MaybeAlign Align);
 
   /// This turns an int alignment (which must be a power of 2) into the

llvm/lib/IR/Attributes.cpp

AttrBuilder &AttrBuilder::addRawIntAttr(Attribute::AttrKind Kind,
   Optional<unsigned> IntIndex = kindToIntIndex(Kind);
   assert(IntIndex && "Not an int attribute");
   assert(Value && "Value cannot be zero");
   Attrs[Kind] = true;
   IntAttrs[*IntIndex] = Value;
   return *this;
 }
 
-std::pair<unsigned, Optional<unsigned>> AttrBuilder::getAllocSizeArgs() const {
-  return unpackAllocSizeArgs(getRawIntAttr(Attribute::AllocSize));
-}
-
-unsigned AttrBuilder::getVScaleRangeMin() const {
-  return unpackVScaleRangeArgs(getRawIntAttr(Attribute::VScaleRange)).first;
-}
-
-Optional<unsigned> AttrBuilder::getVScaleRangeMax() const {
-  return unpackVScaleRangeArgs(getRawIntAttr(Attribute::VScaleRange)).second;
-}
-
 AttrBuilder &AttrBuilder::addAlignmentAttr(MaybeAlign Align) {
   if (!Align)
     return *this;
 
   assert(*Align <= llvm::Value::MaximumAlignment && "Alignment too large.");
   return addRawIntAttr(Attribute::Alignment, Align->value());
 }
 

llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

Value *WebAssemblyLowerEmscriptenEHSjLj::wrapInvoke(CallBase *CI) {
 
   // No attributes for the callee pointer.
   ArgAttributes.push_back(AttributeSet());
   // Copy the argument attributes from the original
   for (unsigned I = 0, E = CI->arg_size(); I < E; ++I)
     ArgAttributes.push_back(InvokeAL.getParamAttrs(I));
 
   AttrBuilder FnAttrs(InvokeAL.getFnAttrs());
-  if (FnAttrs.contains(Attribute::AllocSize)) {
+  if (InvokeAL.getFnAttrs().hasAttribute(Attribute::AllocSize)) {
     // The allocsize attribute (if any) referes to parameters by index and needs
     // to be adjusted.
     unsigned SizeArg;
     Optional<unsigned> NEltArg;
-    std::tie(SizeArg, NEltArg) = FnAttrs.getAllocSizeArgs();
+    std::tie(SizeArg, NEltArg) = InvokeAL.getFnAttrs().getAllocSizeArgs();
     SizeArg += 1;
     if (NEltArg.hasValue())
       NEltArg = NEltArg.getValue() + 1;
     FnAttrs.addAllocSizeAttr(SizeArg, NEltArg);
   }
 
   // Reconstruct the AttributesList based on the vector we constructed.
   AttributeList NewCallAL = AttributeList::get(

llvm/lib/Transforms/Utils/CallPromotionUtils.cpp

if (FormalTy != ActualTy) {
       auto *Cast = CastInst::CreateBitOrPointerCast(Arg, FormalTy, "", &CB);
       CB.setArgOperand(ArgNo, Cast);
 
       // Remove any incompatible attributes for the argument.
       AttrBuilder ArgAttrs(CallerPAL.getParamAttrs(ArgNo));
       ArgAttrs.remove(AttributeFuncs::typeIncompatible(FormalTy));
 
       // We may have a different byval/inalloca type.
-      if (ArgAttrs.getByValType())
+      if (CallerPAL.getParamAttrs(ArgNo).getByValType())
         ArgAttrs.addByValAttr(Callee->getParamByValType(ArgNo));
-      if (ArgAttrs.getInAllocaType())
+      if (CallerPAL.getParamAttrs(ArgNo).getInAllocaType())
         ArgAttrs.addInAllocaAttr(Callee->getParamInAllocaType(ArgNo));
 
       NewArgAttrs.push_back(AttributeSet::get(Ctx, ArgAttrs));
       AttributeChanged = true;
     } else
       NewArgAttrs.push_back(CallerPAL.getParamAttrs(ArgNo));
   }
 

llvm/lib/Transforms/Utils/InlineFunction.cpp

static bool MayContainThrowingOrExitingCall(Instruction *Begin,
 
   assert(Begin->getParent() == End->getParent() &&
          "Expected to be in same basic block!");
   return !llvm::isGuaranteedToTransferExecutionToSuccessor(
       Begin->getIterator(), End->getIterator(), InlinerAttributeWindow + 1);
 }
 
 static AttrBuilder IdentifyValidAttributes(CallBase &CB) {
-
-  AttrBuilder AB(CB.getAttributes(), AttributeList::ReturnIndex);
-  if (AB.empty())
-    return AB;
+  auto Attrs = CB.getAttributes().getRetAttrs();
   AttrBuilder Valid;
+  if (!Attrs.hasAttributes())
+    return Valid;
   // Only allow these white listed attributes to be propagated back to the
   // callee. This is because other attributes may only be valid on the call
   // itself, i.e. attributes such as signext and zeroext.
-  if (auto DerefBytes = AB.getDereferenceableBytes())
+  if (auto DerefBytes = Attrs.getDereferenceableBytes())
     Valid.addDereferenceableAttr(DerefBytes);
-  if (auto DerefOrNullBytes = AB.getDereferenceableOrNullBytes())
+  if (auto DerefOrNullBytes = Attrs.getDereferenceableOrNullBytes())
     Valid.addDereferenceableOrNullAttr(DerefOrNullBytes);
-  if (AB.contains(Attribute::NoAlias))
+  if (Attrs.hasAttribute(Attribute::NoAlias))
     Valid.addAttribute(Attribute::NoAlias);
-  if (AB.contains(Attribute::NonNull))
+  if (Attrs.hasAttribute(Attribute::NonNull))
     Valid.addAttribute(Attribute::NonNull);
   return Valid;
 }
 
 static void AddReturnAttributes(CallBase &CB, ValueToValueMapTy &VMap) {
   if (!UpdateReturnAttributes)
     return;