Make AttributeSet::getFnAttributes() return an AttributeSet instead of an Attribute.

This is more code to isolate the use of the Attribute class to that of just
holding one attribute instead of a collection of attributes.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@173094 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/IR/Attributes.h

@@ -183,43 +183,13 @@ template<> struct DenseMapInfo<Attribute::AttrKind> {
   }
 };
 
-//===----------------------------------------------------------------------===//
-/// \class
-/// \brief This is just a pair of values to associate a set of attributes with
-/// an index.
-struct AttributeWithIndex {
-  Attribute Attrs;  ///< The attributes that are set, or'd together.
-  Constant *Val;    ///< Value attached to attribute, e.g. alignment.
-  unsigned Index;   ///< Index of the parameter for which the attributes apply.
-                    ///< Index 0 is used for return value attributes.
-                    ///< Index ~0U is used for function attributes.
-
-  static AttributeWithIndex get(LLVMContext &C, unsigned Idx,
-                                ArrayRef<Attribute::AttrKind> Attrs) {
-    return get(Idx, Attribute::get(C, Attrs));
-  }
-  static AttributeWithIndex get(unsigned Idx, Attribute Attrs) {
-    AttributeWithIndex P;
-    P.Index = Idx;
-    P.Attrs = Attrs;
-    P.Val = 0;
-    return P;
-  }
-  static AttributeWithIndex get(unsigned Idx, Attribute Attrs, Constant *Val) {
-    AttributeWithIndex P;
-    P.Index = Idx;
-    P.Attrs = Attrs;
-    P.Val = Val;
-    return P;
-  }
-};
-
 //===----------------------------------------------------------------------===//
 // AttributeSet Smart Pointer
 //===----------------------------------------------------------------------===//
 
 class AttrBuilder;
 class AttributeSetImpl;
+struct AttributeWithIndex;
 
 //===----------------------------------------------------------------------===//
 /// \class
@@ -289,9 +259,7 @@ public:
   }
 
   /// \brief The function attributes are returned.
-  Attribute getFnAttributes() const {
+  AttributeSet getFnAttributes() const;
-    return getAttributes(FunctionIndex);
-  }
 
   /// \brief Return the alignment for the specified function parameter.
   unsigned getParamAlignment(unsigned Idx) const;
@@ -352,6 +320,39 @@ public:
   void dump() const;
 };
 
+//===----------------------------------------------------------------------===//
+/// \class
+/// \brief This is just a pair of values to associate a set of attributes with
+/// an index.
+struct AttributeWithIndex {
+  Attribute Attrs;  ///< The attributes that are set, or'd together.
+  Constant *Val;    ///< Value attached to attribute, e.g. alignment.
+  unsigned Index;   ///< Index of the parameter for which the attributes apply.
+                    ///< Index 0 is used for return value attributes.
+                    ///< Index ~0U is used for function attributes.
+
+  // FIXME: These methods all need to be revised. The first one is temporary.
+  static AttributeWithIndex get(LLVMContext &C, unsigned Idx, AttributeSet AS);
+  static AttributeWithIndex get(LLVMContext &C, unsigned Idx,
+                                ArrayRef<Attribute::AttrKind> Attrs) {
+    return get(Idx, Attribute::get(C, Attrs));
+  }
+  static AttributeWithIndex get(unsigned Idx, Attribute Attrs) {
+    AttributeWithIndex P;
+    P.Index = Idx;
+    P.Attrs = Attrs;
+    P.Val = 0;
+    return P;
+  }
+  static AttributeWithIndex get(unsigned Idx, Attribute Attrs, Constant *Val) {
+    AttributeWithIndex P;
+    P.Index = Idx;
+    P.Attrs = Attrs;
+    P.Val = Val;
+    return P;
+  }
+};
+
 //===----------------------------------------------------------------------===//
 /// \class
 /// \brief This class is used in conjunction with the Attribute::get method to

lib/IR/AttributeImpl.h

@@ -39,6 +39,8 @@ public:
                 ArrayRef<Constant*> values);
   AttributeImpl(LLVMContext &C, StringRef data);
 
+  LLVMContext &getContext() { return Context; }
+
   ArrayRef<Constant*> getValues() const { return Vals; }
 
   bool hasAttribute(Attribute::AttrKind A) const;

lib/IR/Attributes.cpp

@@ -529,10 +529,30 @@ void AttributeImpl::Profile(FoldingSetNodeID &ID, Constant *Data,
 #endif
 }
 
+//===----------------------------------------------------------------------===//
+// AttributeWithIndex Definition
+//===----------------------------------------------------------------------===//
+
+AttributeWithIndex AttributeWithIndex::get(LLVMContext &C, unsigned Idx,
+                                           AttributeSet AS) {
+  // FIXME: This is temporary, but necessary for the conversion.
+  AttrBuilder B(AS, Idx);
+  return get(Idx, Attribute::get(C, B));
+}
+
 //===----------------------------------------------------------------------===//
 // AttributeSetImpl Definition
 //===----------------------------------------------------------------------===//
 
+AttributeSet AttributeSet::getFnAttributes() const {
+  // FIXME: Remove.
+  return AttrList ?
+    AttributeSet::get(AttrList->getContext(),
+                      AttributeWithIndex::get(FunctionIndex,
+                                              getAttributes(FunctionIndex))) :
+    AttributeSet();
+}
+
 AttributeSet AttributeSet::get(LLVMContext &C,
                                ArrayRef<AttributeWithIndex> Attrs) {
   // If there are no attributes then return a null AttributesList pointer.

lib/Transforms/IPO/ArgumentPromotion.cpp

@@ -591,7 +591,8 @@ CallGraphNode *ArgPromotion::DoPromotion(Function *F,
 
   // Add any function attributes.
   if (PAL.hasAttributes(AttributeSet::FunctionIndex))
-    AttributesVec.push_back(AttributeWithIndex::get(AttributeSet::FunctionIndex,
+    AttributesVec.push_back(AttributeWithIndex::get(FTy->getContext(),
+                                                    AttributeSet::FunctionIndex,
                                                     PAL.getFnAttributes()));
 
   Type *RetTy = FTy->getReturnType();
@@ -719,7 +720,8 @@ CallGraphNode *ArgPromotion::DoPromotion(Function *F,
 
     // Add any function attributes.
     if (CallPAL.hasAttributes(AttributeSet::FunctionIndex))
-      AttributesVec.push_back(AttributeWithIndex::get(AttributeSet::FunctionIndex,
+      AttributesVec.push_back(AttributeWithIndex::get(Call->getContext(),
+                                                      AttributeSet::FunctionIndex,
                                                       CallPAL.getFnAttributes()));
 
     Instruction *New;

lib/Transforms/IPO/DeadArgumentElimination.cpp

@@ -276,10 +276,10 @@ bool DAE::DeleteDeadVarargs(Function &Fn) {
       SmallVector<AttributeWithIndex, 8> AttributesVec;
       for (unsigned i = 0; PAL.getSlot(i).Index <= NumArgs; ++i)
         AttributesVec.push_back(PAL.getSlot(i));
-      Attribute FnAttrs = PAL.getFnAttributes();
       if (PAL.hasAttributes(AttributeSet::FunctionIndex))
-        AttributesVec.push_back(AttributeWithIndex::get(AttributeSet::FunctionIndex,
+        AttributesVec.push_back(AttributeWithIndex::get(Fn.getContext(),
-                                                        FnAttrs));
+                                                        AttributeSet::FunctionIndex,
+                                                        PAL.getFnAttributes()));
       PAL = AttributeSet::get(Fn.getContext(), AttributesVec);
     }
 
@@ -702,10 +702,8 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) {
 
   // The existing function return attributes.
   Attribute RAttrs = PAL.getRetAttributes();
-  Attribute FnAttrs = PAL.getFnAttributes();
 
   // Find out the new return value.
-
   Type *RetTy = FTy->getReturnType();
   Type *NRetTy = NULL;
   unsigned RetCount = NumRetVals(F);
@@ -801,9 +799,10 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) {
     }
   }
 
-  if (FnAttrs.hasAttributes())
+  if (PAL.hasAttributes(AttributeSet::FunctionIndex))
-    AttributesVec.push_back(AttributeWithIndex::get(AttributeSet::FunctionIndex,
+    AttributesVec.push_back(AttributeWithIndex::get(F->getContext(),
-                                                    FnAttrs));
+                                                    AttributeSet::FunctionIndex,
+                                                    PAL.getFnAttributes()));
 
   // Reconstruct the AttributesList based on the vector we constructed.
   AttributeSet NewPAL = AttributeSet::get(F->getContext(), AttributesVec);
@@ -837,7 +836,7 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) {
 
     // The call return attributes.
     Attribute RAttrs = CallPAL.getRetAttributes();
-    Attribute FnAttrs = CallPAL.getFnAttributes();
+
     // Adjust in case the function was changed to return void.
     RAttrs =
       Attribute::get(NF->getContext(), AttrBuilder(RAttrs).
@@ -869,9 +868,10 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) {
         AttributesVec.push_back(AttributeWithIndex::get(Args.size(), Attrs));
     }
 
-    if (FnAttrs.hasAttributes())
+    if (CallPAL.hasAttributes(AttributeSet::FunctionIndex))
-      AttributesVec.push_back(AttributeWithIndex::get(AttributeSet::FunctionIndex,
+      AttributesVec.push_back(AttributeWithIndex::get(Call->getContext(),
-                                                      FnAttrs));
+                                                      AttributeSet::FunctionIndex,
+                                                      CallPAL.getFnAttributes()));
 
     // Reconstruct the AttributesList based on the vector we constructed.
     AttributeSet NewCallPAL = AttributeSet::get(F->getContext(), AttributesVec);

lib/Transforms/InstCombine/InstCombineCalls.cpp

@@ -1175,16 +1175,17 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) {
     }
   }
 
-  Attribute FnAttrs = CallerPAL.getFnAttributes();
+  AttributeSet FnAttrs = CallerPAL.getFnAttributes();
   if (CallerPAL.hasAttributes(AttributeSet::FunctionIndex))
-    attrVec.push_back(AttributeWithIndex::get(AttributeSet::FunctionIndex,
+    attrVec.push_back(AttributeWithIndex::get(Callee->getContext(),
+                                              AttributeSet::FunctionIndex,
                                               FnAttrs));
 
   if (NewRetTy->isVoidTy())
     Caller->setName("");   // Void type should not have a name.
 
   const AttributeSet &NewCallerPAL = AttributeSet::get(Callee->getContext(),
-                                                     attrVec);
+                                                       attrVec);
 
   Instruction *NC;
   if (InvokeInst *II = dyn_cast<InvokeInst>(Caller)) {
@@ -1319,10 +1320,10 @@ InstCombiner::transformCallThroughTrampoline(CallSite CS,
       }
 
       // Add any function attributes.
-      Attr = Attrs.getFnAttributes();
       if (Attrs.hasAttributes(AttributeSet::FunctionIndex))
-        NewAttrs.push_back(AttributeWithIndex::get(AttributeSet::FunctionIndex,
+        NewAttrs.push_back(AttributeWithIndex::get(FTy->getContext(),
-                                                   Attr));
+                                                   AttributeSet::FunctionIndex,
+                                                   Attrs.getFnAttributes()));
 
       // The trampoline may have been bitcast to a bogus type (FTy).
       // Handle this by synthesizing a new function type, equal to FTy