Convert typeIncompatible to return an AttributeSet.

There are still places which treat the Attribute object as a collection of
attributes. I'm systematically removing them.

llvm-svn: 173990

include/llvm/IR/Attributes.h

@@ -377,10 +377,7 @@ public:
   AttrBuilder &addAttributes(Attribute A);
 
   /// \brief Remove the attributes from the builder.
-  AttrBuilder &removeAttributes(Attribute A);
+  AttrBuilder &removeAttributes(AttributeSet A, uint64_t Index);
-
-  /// \brief Add the attributes to the builder.
-  AttrBuilder &addAttributes(AttributeSet A);
 
   /// \brief Return true if the builder has the specified attribute.
   bool contains(Attribute::AttrKind A) const;
@@ -390,7 +387,7 @@ public:
 
   /// \brief Return true if the builder has any attribute that's in the
   /// specified attribute.
-  bool hasAttributes(const Attribute &A) const;
+  bool hasAttributes(AttributeSet A, uint64_t Index) const;
 
   /// \brief Return true if the builder has an alignment attribute.
   bool hasAlignmentAttr() const;
@@ -461,7 +458,7 @@ public:
 namespace AttributeFuncs {
 
 /// \brief Which attributes cannot be applied to a type.
-Attribute typeIncompatible(Type *Ty);
+AttributeSet typeIncompatible(Type *Ty, uint64_t Index);
 
 /// \brief This returns an integer containing an encoding of all the LLVM
 /// attributes found in the given attribute bitset.  Any change to this encoding

lib/IR/Attributes.cpp

@@ -612,15 +612,13 @@ AttributeSet AttributeSet::removeAttributes(LLVMContext &C, unsigned Idx,
     AttrSet.push_back(getSlotAttributes(I));
   }
 
-  // Now add the attribute into the correct slot. There may already be an
+  // Now remove the attribute from the correct slot. There may already be an
   // AttributeSet there.
   AttrBuilder B(AS, Idx);
 
   for (unsigned I = 0, E = Attrs.pImpl->getNumAttributes(); I != E; ++I)
     if (Attrs.getSlotIndex(I) == Idx) {
-      for (AttributeSetImpl::const_iterator II = Attrs.pImpl->begin(I),
+      B.removeAttributes(Attrs.pImpl->getSlotAttributes(I), Idx);
-             IE = Attrs.pImpl->end(I); II != IE; ++II)
-        B.removeAttributes(*II);
       break;
     }
 
@@ -813,8 +811,8 @@ AttrBuilder &AttrBuilder::addAttributes(Attribute Attr) {
   return *this;
 }
 
-AttrBuilder &AttrBuilder::removeAttributes(Attribute A) {
+AttrBuilder &AttrBuilder::removeAttributes(AttributeSet A, uint64_t Index) {
-  uint64_t Mask = A.Raw();
+  uint64_t Mask = A.Raw(Index);
 
   for (Attribute::AttrKind I = Attribute::None; I != Attribute::EndAttrKinds;
        I = Attribute::AttrKind(I + 1)) {
@@ -862,8 +860,8 @@ bool AttrBuilder::hasAttributes() const {
   return !Attrs.empty();
 }
 
-bool AttrBuilder::hasAttributes(const Attribute &A) const {
+bool AttrBuilder::hasAttributes(AttributeSet A, uint64_t Index) const {
-  return Raw() & A.Raw();
+  return Raw() & A.Raw(Index);
 }
 
 bool AttrBuilder::hasAlignmentAttr() const {
@@ -916,7 +914,7 @@ uint64_t AttrBuilder::Raw() const {
 // AttributeFuncs Function Defintions
 //===----------------------------------------------------------------------===//
 
-Attribute AttributeFuncs::typeIncompatible(Type *Ty) {
+AttributeSet AttributeFuncs::typeIncompatible(Type *Ty, uint64_t Index) {
   AttrBuilder Incompatible;
 
   if (!Ty->isIntegerTy())
@@ -932,7 +930,7 @@ Attribute AttributeFuncs::typeIncompatible(Type *Ty) {
       .addAttribute(Attribute::NoCapture)
       .addAttribute(Attribute::StructRet);
 
-  return Attribute::get(Ty->getContext(), Incompatible);
+  return AttributeSet::get(Ty->getContext(), Index, Incompatible);
 }
 
 /// \brief This returns an integer containing an encoding of all the LLVM

lib/IR/Verifier.cpp

@@ -693,9 +693,9 @@ void Verifier::VerifyParameterAttrs(AttributeSet Attrs, uint64_t Idx, Type *Ty,
           "'noinline and alwaysinline' are incompatible!", V);
 
   Assert1(!AttrBuilder(Attrs, Idx).
-            hasAttributes(AttributeFuncs::typeIncompatible(Ty)),
+            hasAttributes(AttributeFuncs::typeIncompatible(Ty, Idx), Idx),
           "Wrong types for attribute: " +
-          AttributeFuncs::typeIncompatible(Ty).getAsString(), V);
+          AttributeFuncs::typeIncompatible(Ty, Idx).getAsString(Idx), V);
 
   if (PointerType *PTy = dyn_cast<PointerType>(Ty))
     Assert1(!Attrs.hasAttribute(Idx, Attribute::ByVal) ||

lib/Transforms/IPO/DeadArgumentElimination.cpp

@@ -764,10 +764,14 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) {
     RAttrs =
       AttributeSet::get(NRetTy->getContext(), AttributeSet::ReturnIndex,
                         AttrBuilder(RAttrs, AttributeSet::ReturnIndex).
-                    removeAttributes(AttributeFuncs::typeIncompatible(NRetTy)));
+         removeAttributes(AttributeFuncs::
+                          typeIncompatible(NRetTy, AttributeSet::ReturnIndex),
+                          AttributeSet::ReturnIndex));
   else
     assert(!AttrBuilder(RAttrs, AttributeSet::ReturnIndex).
-             hasAttributes(AttributeFuncs::typeIncompatible(NRetTy)) &&
+             hasAttributes(AttributeFuncs::
+                           typeIncompatible(NRetTy, AttributeSet::ReturnIndex),
+                           AttributeSet::ReturnIndex) &&
            "Return attributes no longer compatible?");
 
   if (RAttrs.hasAttributes(AttributeSet::ReturnIndex))
@@ -841,7 +845,10 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) {
     RAttrs =
       AttributeSet::get(NF->getContext(), AttributeSet::ReturnIndex,
                         AttrBuilder(RAttrs, AttributeSet::ReturnIndex).
-      removeAttributes(AttributeFuncs::typeIncompatible(NF->getReturnType())));
+        removeAttributes(AttributeFuncs::
+                         typeIncompatible(NF->getReturnType(),
+                                          AttributeSet::ReturnIndex),
+                         AttributeSet::ReturnIndex));
     if (RAttrs.hasAttributes(AttributeSet::ReturnIndex))
       AttributesVec.push_back(AttributeSet::get(NF->getContext(), RAttrs));
 

lib/Transforms/InstCombine/InstCombineCalls.cpp

@@ -1015,7 +1015,10 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) {
 
     if (!CallerPAL.isEmpty() && !Caller->use_empty()) {
       AttrBuilder RAttrs(CallerPAL, AttributeSet::ReturnIndex);
-      if (RAttrs.hasAttributes(AttributeFuncs::typeIncompatible(NewRetTy)))
+      if (RAttrs.
+          hasAttributes(AttributeFuncs::
+                        typeIncompatible(NewRetTy, AttributeSet::ReturnIndex),
+                        AttributeSet::ReturnIndex))
         return false;   // Attribute not compatible with transformed value.
     }
 
@@ -1045,7 +1048,8 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) {
       return false;   // Cannot transform this parameter value.
 
     if (AttrBuilder(CallerPAL.getParamAttributes(i + 1), i + 1).
-          hasAttributes(AttributeFuncs::typeIncompatible(ParamTy)))
+          hasAttributes(AttributeFuncs::
+                        typeIncompatible(ParamTy, i + 1), i + 1))
       return false;   // Attribute not compatible with transformed value.
 
     // If the parameter is passed as a byval argument, then we have to have a
@@ -1124,7 +1128,10 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) {
 
   // If the return value is not being used, the type may not be compatible
   // with the existing attributes.  Wipe out any problematic attributes.
-  RAttrs.removeAttributes(AttributeFuncs::typeIncompatible(NewRetTy));
+  RAttrs.
+    removeAttributes(AttributeFuncs::
+                     typeIncompatible(NewRetTy, AttributeSet::ReturnIndex),
+                     AttributeSet::ReturnIndex);
 
   // Add the new return attributes.
   if (RAttrs.hasAttributes())