Reimplement the parameter attributes support, phase #1. hilights:

1. There is now a "PAListPtr" class, which is a smart pointer around
   the underlying uniqued parameter attribute list object, and manages
   its refcount.  It is now impossible to mess up the refcount.
2. PAListPtr is now the main interface to the underlying object, and
   the underlying object is now completely opaque.
3. Implementation details like SmallVector and FoldingSet are now no
   longer part of the interface.
4. You can create a PAListPtr with an arbitrary sequence of
   ParamAttrsWithIndex's, no need to make a SmallVector of a specific 
   size (you can just use an array or scalar or vector if you wish).
5. All the client code that had to check for a null pointer before
   dereferencing the pointer is simplified to just access the 
   PAListPtr directly.
6. The interfaces for adding attrs to a list and removing them is a
   bit simpler.

Phase #2 will rename some stuff (e.g. PAListPtr) and do other less 
invasive changes.



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

6 files changed, 146 insertions, 279 deletions

diff --git a/include/llvm/Function.h b/include/llvm/Function.h
index 3d75db8a03..2ffd5eaacd 100644
--- a/include/llvm/Function.h
+++ b/include/llvm/Function.h
@@ -27,7 +27,6 @@
 namespace llvm {
 
 class FunctionType;
-class ParamAttrsList;
 
 // Traits for intrusive list of instructions...
 template<> struct ilist_traits<BasicBlock>
@@ -69,7 +68,7 @@ private:
   BasicBlockListType  BasicBlocks;        ///< The basic blocks
   mutable ArgumentListType ArgumentList;  ///< The formal arguments
   ValueSymbolTable *SymTab;               ///< Symbol table of args/instructions
-  const ParamAttrsList *ParamAttrs;       ///< Parameter attributes
+  PAListPtr ParamAttrs;                   ///< Parameter attributes
   
   // The Calling Convention is stored in Value::SubclassData.
   /*unsigned CallingConvention;*/
@@ -145,16 +144,11 @@ public:
     SubclassData = (SubclassData & 1) | (CC << 1);
   }
   
-  /// Obtains a constant pointer to the ParamAttrsList object which holds the
-  /// parameter attributes information, if any. 
-  /// @returns 0 if no parameter attributes have been set.
-  /// @brief Get the parameter attributes.
-  const ParamAttrsList *getParamAttrs() const { return ParamAttrs; }
-
-  /// Sets the parameter attributes for this Function. To construct a 
-  /// ParamAttrsList, see ParameterAttributes.h
-  /// @brief Set the parameter attributes.
-  void setParamAttrs(const ParamAttrsList *attrs);
+  /// getParamAttrs - Return the parameter attributes for this function.
+  const PAListPtr &getParamAttrs() const { return ParamAttrs; }
+
+  /// setParamAttrs - Set the parameter attributes for this Function.
+  void setParamAttrs(const PAListPtr &attrs) { ParamAttrs = attrs; }
 
   /// hasCollector/getCollector/setCollector/clearCollector - The name of the
   /// garbage collection algorithm to use during code generation.
diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h
index 3aa8d6879c..d29e11ca27 100644
--- a/include/llvm/Instructions.h
+++ b/include/llvm/Instructions.h
@@ -30,7 +30,6 @@ class PointerType;
 class VectorType;
 class ConstantRange;
 class APInt;
-class ParamAttrsList;
 
 //===----------------------------------------------------------------------===//
 //                             AllocationInst Class
@@ -851,7 +850,7 @@ public:
 ///
 
 class CallInst : public Instruction {
-  const ParamAttrsList *ParamAttrs; ///< parameter attributes for call
+  PAListPtr ParamAttrs; ///< parameter attributes for call
   CallInst(const CallInst &CI);
   void init(Value *Func, Value* const *Params, unsigned NumParams);
   void init(Value *Func, Value *Actual1, Value *Actual2);
@@ -927,16 +926,12 @@ public:
     SubclassData = (SubclassData & 1) | (CC << 1);
   }
 
-  /// Obtains a pointer to the ParamAttrsList object which holds the
-  /// parameter attributes information, if any.
-  /// @returns 0 if no attributes have been set.
-  /// @brief Get the parameter attributes.
-  const ParamAttrsList *getParamAttrs() const { return ParamAttrs; }
+  /// getParamAttrs - Return the PAListPtr for the parameter attributes of this
+  /// call.
+  const PAListPtr &getParamAttrs() const { return ParamAttrs; }
 
-  /// Sets the parameter attributes for this CallInst. To construct a 
-  /// ParamAttrsList, see ParameterAttributes.h
-  /// @brief Set the parameter attributes.
-  void setParamAttrs(const ParamAttrsList *attrs);
+  /// setParamAttrs - Sets the parameter attributes for this CallInst.
+  void setParamAttrs(const PAListPtr &Attrs) { ParamAttrs = Attrs; }
 
   /// @brief Determine whether the call or the callee has the given attribute.
   bool paramHasAttr(uint16_t i, unsigned attr) const;
@@ -1678,7 +1673,7 @@ private:
 /// calling convention of the call.
 ///
 class InvokeInst : public TerminatorInst {
-  const ParamAttrsList *ParamAttrs;
+  PAListPtr ParamAttrs;
   InvokeInst(const InvokeInst &BI);
   void init(Value *Fn, BasicBlock *IfNormal, BasicBlock *IfException,
             Value* const *Args, unsigned NumArgs);
@@ -1745,16 +1740,13 @@ public:
     SubclassData = CC;
   }
 
-  /// Obtains a pointer to the ParamAttrsList object which holds the
-  /// parameter attributes information, if any.
-  /// @returns 0 if no attributes have been set.
-  /// @brief Get the parameter attributes.
-  const ParamAttrsList *getParamAttrs() const { return ParamAttrs; }
+  /// getParamAttrs - Return the parameter attribute list for this invoke.
+  ///
+  const PAListPtr &getParamAttrs() const { return ParamAttrs; }
 
-  /// Sets the parameter attributes for this InvokeInst. To construct a 
-  /// ParamAttrsList, see ParameterAttributes.h
-  /// @brief Set the parameter attributes.
-  void setParamAttrs(const ParamAttrsList *attrs);
+  /// setParamAttrs - Set the parameter attribute list for this invoke.
+  ///
+  void setParamAttrs(const PAListPtr &Attrs) { ParamAttrs = Attrs; }
 
   /// @brief Determine whether the call or the callee has the given attribute.
   bool paramHasAttr(uint16_t i, ParameterAttributes attr) const;
diff --git a/include/llvm/Intrinsics.h b/include/llvm/Intrinsics.h
index d3aed6b7cf..2027383dbf 100644
--- a/include/llvm/Intrinsics.h
+++ b/include/llvm/Intrinsics.h
@@ -22,7 +22,7 @@ class Type;
 class FunctionType;
 class Function;
 class Module;
-class ParamAttrsList;
+class PAListPtr;
 
 /// Intrinsic Namespace - This namespace contains an enum with a value for
 /// every intrinsic/builtin function known by LLVM.  These enum values are
@@ -49,7 +49,7 @@ namespace Intrinsic {
 
   /// Intrinsic::getParamAttrs(ID) - Return the attributes for an intrinsic.
   ///
-  const ParamAttrsList *getParamAttrs(ID id);
+  PAListPtr getParamAttrs(ID id);
 
   /// Intrinsic::getDeclaration(M, ID) - Create or insert an LLVM Function
   /// declaration for an intrinsic, and return it.
diff --git a/include/llvm/ParamAttrsList.h b/include/llvm/ParamAttrsList.h
deleted file mode 100644
index 00e9707beb..0000000000
--- a/include/llvm/ParamAttrsList.h
+++ /dev/null
@@ -1,226 +0,0 @@
-//===-- llvm/ParamAttrsList.h - List and Vector of ParamAttrs ---*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains classes used to represent the parameter attributes
-// associated with functions and their calls.
-//
-// The implementation of ParamAttrsList is in VMCore/ParameterAttributes.cpp.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_PARAM_ATTRS_LIST_H
-#define LLVM_PARAM_ATTRS_LIST_H
-
-#include "llvm/ParameterAttributes.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/FoldingSet.h"
-
-namespace llvm {
-
-/// @brief A vector of attribute/index pairs.
-typedef SmallVector<ParamAttrsWithIndex,4> ParamAttrsVector;
-
-/// This class represents a list of attribute/index pairs for parameter 
-/// attributes. Each entry in the list contains the index of a function 
-/// parameter and the associated ParameterAttributes. If a parameter's index is
-/// not present in the list, then no attributes are set for that parameter. The
-/// list may also be empty, but this does not occur in practice. An item in
-/// the list with an index of 0 refers to the function as a whole or its result.
-/// To construct a ParamAttrsList, you must first fill a ParamAttrsVector with 
-/// the attribute/index pairs you wish to set.  The list of attributes can be 
-/// turned into a string of mnemonics suitable for LLVM Assembly output. 
-/// Various accessors are provided to obtain information about the attributes.
-/// Note that objects of this class are "uniqued". The \p get method can return
-/// the pointer of an existing and identical instance. Consequently, reference
-/// counting is necessary in order to determine when the last reference to a 
-/// ParamAttrsList of a given shape is dropped. Users of this class should use
-/// the addRef and dropRef methods to add/drop references. When the reference
-/// count goes to zero, the ParamAttrsList object is deleted.
-/// This class is used by Function, CallInst and InvokeInst to represent their
-/// sets of parameter attributes. 
-/// @brief A List of ParameterAttributes.
-class ParamAttrsList : public FoldingSetNode {
-  /// @name Construction
-  /// @{
-  private:
-    // ParamAttrsList is uniqued, these should not be publicly available
-    void operator=(const ParamAttrsList &); // Do not implement
-    ParamAttrsList(const ParamAttrsList &); // Do not implement
-    ~ParamAttrsList();                      // Private implementation
-
-    /// Only the \p get method can invoke this when it wants to create a
-    /// new instance.
-    /// @brief Construct an ParamAttrsList from a ParamAttrsVector
-    explicit ParamAttrsList(const ParamAttrsVector &attrVec);
-
-  public:
-    /// This method ensures the uniqueness of ParamAttrsList instances.  The
-    /// argument is a vector of attribute/index pairs as represented by the
-    /// ParamAttrsWithIndex structure.  The index values must be in strictly
-    /// increasing order and ParamAttr::None is not allowed.  The vector is
-    /// used to construct the ParamAttrsList instance.  If an instance with
-    /// identical vector pairs exists, it will be returned instead of creating
-    /// a new instance.
-    /// @brief Get a ParamAttrsList instance.
-    static const ParamAttrsList *get(const ParamAttrsVector &attrVec);
-
-    /// Returns the ParamAttrsList obtained by modifying PAL using the supplied
-    /// list of attribute/index pairs.  Any existing attributes for the given
-    /// index are replaced by the given attributes.  If there were no attributes
-    /// then the new ones are inserted.  Attributes can be deleted by replacing
-    /// them with ParamAttr::None.  Index values must be strictly increasing.
-    /// @brief Get a new ParamAttrsList instance by modifying an existing one.
-    static const ParamAttrsList *getModified(const ParamAttrsList *PAL,
-                                             const ParamAttrsVector &modVec);
-
-    /// @brief Add the specified attributes to those in PAL at index idx.
-    static const ParamAttrsList *includeAttrs(const ParamAttrsList *PAL,
-                                              uint16_t idx, 
-                                              ParameterAttributes attrs);
-
-    /// @brief Remove the specified attributes from those in PAL at index idx.
-    static const ParamAttrsList *excludeAttrs(const ParamAttrsList *PAL,
-                                              uint16_t idx, 
-                                              ParameterAttributes attrs);
-
-  /// @}
-  /// @name Accessors
-  /// @{
-  public:
-    /// The parameter attributes for the \p indexth parameter are returned. 
-    /// The 0th parameter refers to the return type of the function. Note that
-    /// the \p param_index is an index into the function's parameters, not an
-    /// index into this class's list of attributes. The result of getParamIndex
-    /// is always suitable input to this function.
-    /// @returns The all the ParameterAttributes for the \p indexth parameter
-    /// as a uint16_t of enumeration values OR'd together.
-    /// @brief Get the attributes for a parameter
-    ParameterAttributes getParamAttrs(uint16_t param_index) const;
-
-    /// This checks to see if the \p ith function parameter has the parameter
-    /// attribute given by \p attr set.
-    /// @returns true if the parameter attribute is set
-    /// @brief Determine if a ParameterAttributes is set
-    bool paramHasAttr(uint16_t i, ParameterAttributes attr) const {
-      return getParamAttrs(i) & attr;
-    }
-  
-    /// This extracts the alignment for the \p ith function parameter.
-    /// @returns 0 if unknown, else the alignment in bytes
-    /// @brief Extract the Alignment
-    uint16_t getParamAlignment(uint16_t i) const {
-      return (getParamAttrs(i) & ParamAttr::Alignment) >> 16;
-    }
-
-    /// This returns whether the given attribute is set for at least one
-    /// parameter or for the return value.
-    /// @returns true if the parameter attribute is set somewhere
-    /// @brief Determine if a ParameterAttributes is set somewhere
-    bool hasAttrSomewhere(ParameterAttributes attr) const;
-
-    /// The set of ParameterAttributes set in Attributes is converted to a
-    /// string of equivalent mnemonics. This is, presumably, for writing out
-    /// the mnemonics for the assembly writer. 
-    /// @brief Convert parameter attribute bits to text
-    static std::string getParamAttrsText(ParameterAttributes Attributes);
-
-    /// The \p Indexth parameter attribute is converted to string.
-    /// @brief Get the text for the parmeter attributes for one parameter.
-    std::string getParamAttrsTextByIndex(uint16_t Index) const {
-      return getParamAttrsText(getParamAttrs(Index));
-    }
-
-    /// @brief Comparison operator for ParamAttrsList
-    bool operator < (const ParamAttrsList& that) const {
-      if (this->attrs.size() < that.attrs.size())
-        return true;
-      if (this->attrs.size() > that.attrs.size())
-        return false;
-      for (unsigned i = 0; i < attrs.size(); ++i) {
-        if (attrs[i].index < that.attrs[i].index)
-          return true;
-        if (attrs[i].index > that.attrs[i].index)
-          return false;
-        if (attrs[i].attrs < that.attrs[i].attrs)
-          return true;
-        if (attrs[i].attrs > that.attrs[i].attrs)
-          return false;
-      }
-      return false;
-    }
-
-    /// Returns the parameter index of a particular parameter attribute in this
-    /// list of attributes. Note that the attr_index is an index into this 
-    /// class's list of attributes, not the index of a parameter. The result
-    /// is the index of the parameter. Clients generally should not use this
-    /// method. It is used internally by LLVM.
-    /// @brief Get a parameter index
-    uint16_t getParamIndex(unsigned attr_index) const {
-      return attrs[attr_index].index;
-    }
-
-    ParameterAttributes getParamAttrsAtIndex(unsigned attr_index) const {
-      return attrs[attr_index].attrs;
-    }
-    
-    /// Determines how many parameter attributes are set in this ParamAttrsList.
-    /// This says nothing about how many parameters the function has. It also
-    /// says nothing about the highest parameter index that has attributes. 
-    /// Clients generally should not use this method. It is used internally by
-    /// LLVM.
-    /// @returns the number of parameter attributes in this ParamAttrsList.
-    /// @brief Return the number of parameter attributes this type has.
-    unsigned size() const { return attrs.size(); }
-
-    /// @brief Return the number of references to this ParamAttrsList.
-    unsigned numRefs() const { return refCount; }
-
-  /// @}
-  /// @name Mutators
-  /// @{
-  public:
-    /// Classes retaining references to ParamAttrsList objects should call this
-    /// method to increment the reference count. This ensures that the
-    /// ParamAttrsList object will not disappear until the class drops it.
-    /// @brief Add a reference to this instance.
-    void addRef() const { refCount++; }
-
-    /// Classes retaining references to ParamAttrsList objects should call this
-    /// method to decrement the reference count and possibly delete the 
-    /// ParamAttrsList object. This ensures that ParamAttrsList objects are 
-    /// cleaned up only when the last reference to them is dropped.
-    /// @brief Drop a reference to this instance.
-    void dropRef() const { 
-      assert(refCount != 0 && "dropRef without addRef");
-      if (--refCount == 0) 
-        delete this; 
-    }
-
-  /// @}
-  /// @name Implementation Details
-  /// @{
-  public:
-    void Profile(FoldingSetNodeID &ID) const {
-      Profile(ID, attrs);
-    }
-    static void Profile(FoldingSetNodeID &ID, const ParamAttrsVector &Attrs);
-    void dump() const;
-
-  /// @}
-  /// @name Data
-  /// @{
-  private:
-    ParamAttrsVector attrs;     ///< The list of attributes
-    mutable unsigned refCount;  ///< The number of references to this object
-  /// @}
-};
-
-} // End llvm namespace
-
-#endif
diff --git a/include/llvm/ParameterAttributes.h b/include/llvm/ParameterAttributes.h
index 3de5f0537a..4a68a7d7b6 100644
--- a/include/llvm/ParameterAttributes.h
+++ b/include/llvm/ParameterAttributes.h
@@ -15,12 +15,14 @@
 #ifndef LLVM_PARAMETER_ATTRIBUTES_H
 #define LLVM_PARAMETER_ATTRIBUTES_H
 
-#include "llvm/Support/DataTypes.h"
-#include <cassert>
+#include <string>
 
 namespace llvm {
 class Type;
 
+/// ParameterAttributes - A bitset of attributes for a parameter.
+typedef unsigned ParameterAttributes;
+  
 namespace ParamAttr {
 
 /// Function parameters and results can have attributes to indicate how they 
@@ -28,9 +30,7 @@ namespace ParamAttr {
 /// lists the attributes that can be associated with parameters or function 
 /// results.
 /// @brief Function parameter attributes.
-
-/// @brief A more friendly way to reference the attributes.
-typedef uint32_t Attributes;
+typedef ParameterAttributes Attributes;
 
 const Attributes None      = 0;     ///< No attributes have been set
 const Attributes ZExt      = 1<<0;  ///< Zero extended before/after call
@@ -64,33 +64,141 @@ const Attributes MutuallyIncompatible[3] = {
 };
 
 /// @brief Which attributes cannot be applied to a type.
-Attributes typeIncompatible (const Type *Ty);
+Attributes typeIncompatible(const Type *Ty);
 
 /// This turns an int alignment (a power of 2, normally) into the
 /// form used internally in ParameterAttributes.
-ParamAttr::Attributes inline constructAlignmentFromInt(uint32_t i) {
+ParamAttr::Attributes inline constructAlignmentFromInt(unsigned i) {
   return (i << 16);
 }
 
+/// The set of ParameterAttributes set in Attributes is converted to a
+/// string of equivalent mnemonics. This is, presumably, for writing out
+/// the mnemonics for the assembly writer. 
+/// @brief Convert parameter attribute bits to text
+std::string getAsString(ParameterAttributes Attrs);
 } // end namespace ParamAttr
 
-/// @brief A more friendly way to reference the attributes.
-typedef ParamAttr::Attributes ParameterAttributes;
 
 /// This is just a pair of values to associate a set of parameter attributes
 /// with a parameter index. 
-/// @brief ParameterAttributes with a parameter index.
 struct ParamAttrsWithIndex {
-  ParameterAttributes attrs; ///< The attributes that are set, or'd together
-  uint16_t index; ///< Index of the parameter for which the attributes apply
+  ParameterAttributes Attrs; ///< The attributes that are set, or'd together.
+  unsigned Index; ///< Index of the parameter for which the attributes apply.
   
-  static ParamAttrsWithIndex get(uint16_t idx, ParameterAttributes attrs) {
+  static ParamAttrsWithIndex get(unsigned Idx, ParameterAttributes Attrs) {
     ParamAttrsWithIndex P;
-    P.index = idx;
-    P.attrs = attrs;
+    P.Index = Idx;
+    P.Attrs = Attrs;
     return P;
   }
 };
+  
+//===----------------------------------------------------------------------===//
+// PAListPtr Smart Pointer
+//===----------------------------------------------------------------------===//
+
+class ParamAttributeListImpl;
+  
+/// PAListPtr - This class manages the ref count for the opaque 
+/// ParamAttributeListImpl object and provides accessors for it.
+class PAListPtr {
+  /// PAList - The parameter attributes that we are managing.  This can be null
+  /// to represent the empty parameter attributes list.
+  ParamAttributeListImpl *PAList;
+public:
+  PAListPtr() : PAList(0) {}
+  PAListPtr(const PAListPtr &P);
+  const PAListPtr &operator=(const PAListPtr &RHS);
+  ~PAListPtr();
+  
+  //===--------------------------------------------------------------------===//
+  // Parameter Attribute List Construction and Mutation
+  //===--------------------------------------------------------------------===//
+  
+  /// get - Return a ParamAttrs list with the specified parameter in it.
+  static PAListPtr get(const ParamAttrsWithIndex *Attr, unsigned NumAttrs);
+  
+  /// get - Return a ParamAttr list with the parameters specified by the
+  /// consequtive random access iterator range.
+  template <typename Iter>
+  static PAListPtr get(const Iter &I, const Iter &E) {
+    if (I == E) return PAListPtr();  // Empty list.
+    return get(&*I, E-I);
+  }
+
+  /// addAttr - Add the specified attribute at the specified index to this
+  /// attribute list.  Since parameter attribute lists are immutable, this
+  /// returns the new list.
+  PAListPtr addAttr(unsigned Idx, ParameterAttributes Attrs) const;
+  
+  /// removeAttr - Remove the specified attribute at the specified index from
+  /// this attribute list.  Since parameter attribute lists are immutable, this
+  /// returns the new list.
+  PAListPtr removeAttr(unsigned Idx, ParameterAttributes Attrs) const;
+  
+  //===--------------------------------------------------------------------===//
+  // Parameter Attribute List Accessors
+  //===--------------------------------------------------------------------===//
+  
+  /// getParamAttrs - The parameter attributes for the specified parameter are
+  /// returned.  Parameters for the result are denoted with Idx = 0.
+  ParameterAttributes getParamAttrs(unsigned Idx) const;
+  
+  /// paramHasAttr - Return true if the specified parameter index has the
+  /// specified attribute set.
+  bool paramHasAttr(unsigned Idx, ParameterAttributes Attr) const {
+    return getParamAttrs(Idx) & Attr;
+  }
+  
+  /// getParamAlignment - Return the alignment for the specified function
+  /// parameter.
+  unsigned getParamAlignment(unsigned Idx) const {
+    return (getParamAttrs(Idx) & ParamAttr::Alignment) >> 16;
+  }
+  
+  /// hasAttrSomewhere - Return true if the specified attribute is set for at
+  /// least one parameter or for the return value.
+  bool hasAttrSomewhere(ParameterAttributes Attr) const;
+
+  /// operator< - Provide an ordering for parameter attribute lists.
+  bool operator==(const PAListPtr &RHS) const { return PAList == RHS.PAList; }
+  bool operator!=(const PAListPtr &RHS) const { return PAList != RHS.PAList; }
+  
+  void dump() const;
+
+  //===--------------------------------------------------------------------===//
+  // Parameter Attribute List Introspection
+  //===--------------------------------------------------------------------===//
+  
+  /// getRawPointer - Return a raw pointer that uniquely identifies this
+  /// parameter attribute list. 
+  void *getRawPointer() const {
+    return PAList;
+  }
+  
+  // Parameter attributes are stored as a dense set of slots, where there is one
+  // slot for each argument that has an attribute.  This allows walking over the
+  // dense set instead of walking the sparse list of attributes.
+  
+  /// isEmpty - Return true if no parameters have an attribute.
+  ///
+  bool isEmpty() const {
+    return PAList == 0;
+  }
+  
+  /// getNumSlots - Return the number of slots used in this attribute list. 
+  /// This is the number of arguments that have an attribute set on them
+  /// (including the function itself).
+  unsigned getNumSlots() const;
+  
+  /// getSlot - Return the ParamAttrsWithIndex at the specified slot.  This
+  /// holds a parameter number plus a set of attributes.
+  const ParamAttrsWithIndex &getSlot(unsigned Slot) const;
+  
+private:
+  explicit PAListPtr(ParamAttributeListImpl *L);
+};
 
 } // End llvm namespace
 
diff --git a/include/llvm/Support/CallSite.h b/include/llvm/Support/CallSite.h
index 3bd4ef256c..6a6bcf185b 100644
--- a/include/llvm/Support/CallSite.h
+++ b/include/llvm/Support/CallSite.h
@@ -28,7 +28,6 @@ namespace llvm {
 
 class CallInst;
 class InvokeInst;
-class ParamAttrsList;
 
 class CallSite {
   Instruction *I;
@@ -62,8 +61,8 @@ public:
 
   /// getParamAttrs/setParamAttrs - get or set the parameter attributes of
   /// the call.
-  const ParamAttrsList *getParamAttrs() const;
-  void setParamAttrs(const ParamAttrsList *PAL);
+  const PAListPtr &getParamAttrs() const;
+  void setParamAttrs(const PAListPtr &PAL);
 
   /// paramHasAttr - whether the call or the callee has the given attribute.
   bool paramHasAttr(uint16_t i, ParameterAttributes attr) const;