Change the AttributeImpl to hold a single Constant* for the values.

This Constant could be an aggregate to represent multiple values.


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

include/llvm/IR/Attributes.h

@@ -128,11 +128,13 @@ public:
   /// \brief Return true if the attribute is present.
   bool hasAttribute(AttrKind Val) const;
 
-  /// \brief Return the kind of this attribute.
+  /// \brief Return the kind of this attribute: enum or string.
   Constant *getAttributeKind() const;
 
-  /// \brief Return the value (if present) of the non-target-specific attribute.
+  /// \brief Return the values (if present) of the attribute. This may be a
-  ArrayRef<Constant*> getAttributeValues() const;
+  /// ConstantVector to represent a list of values associated with the
+  /// attribute.
+  Constant *getAttributeValues() const;
 
   /// \brief Returns the alignment field of an attribute as a byte alignment
   /// value.

lib/IR/AttributeImpl.h

@@ -30,24 +30,23 @@ class LLVMContext;
 /// \brief This class represents a single, uniqued attribute. That attribute
 /// could be a single enum, a tuple, or a string.
 class AttributeImpl : public FoldingSetNode {
-  LLVMContext &Context;
+  LLVMContext &Context; ///< Global context for uniquing objects
-  Constant *Kind;
+  Constant *Kind;       ///< Kind of attribute: enum or string
-  SmallVector<Constant*, 0> Vals;
+  Constant *Values;     ///< Values associated with the attribute
 
   // AttributesImpl is uniqued, these should not be publicly available.
   void operator=(const AttributeImpl &) LLVM_DELETED_FUNCTION;
   AttributeImpl(const AttributeImpl &) LLVM_DELETED_FUNCTION;
 public:
-  AttributeImpl(LLVMContext &C, Constant *Kind,
+  AttributeImpl(LLVMContext &C, Constant *Kind, Constant *Values = 0)
-                ArrayRef<Constant*> Vals = ArrayRef<Constant*>())
+    : Context(C), Kind(Kind), Values(Values) {}
-    : Context(C), Kind(Kind), Vals(Vals.begin(), Vals.end()) {}
 
   LLVMContext &getContext() { return Context; }
 
   bool hasAttribute(Attribute::AttrKind A) const;
 
   Constant *getAttributeKind() const { return Kind; }
-  ArrayRef<Constant*> getAttributeValues() const { return Vals; }
+  Constant *getAttributeValues() const { return Values; }
 
   uint64_t getAlignment() const;
   uint64_t getStackAlignment() const;
@@ -63,13 +62,12 @@ public:
   bool operator<(const AttributeImpl &AI) const;
 
   void Profile(FoldingSetNodeID &ID) const {
-    Profile(ID, Kind, Vals);
+    Profile(ID, Kind, Values);
   }
-  static void Profile(FoldingSetNodeID &ID, Constant *Kind,
+  static void Profile(FoldingSetNodeID &ID, Constant *Kind, Constant *Values) {
-                      ArrayRef<Constant*> Vals) {
     ID.AddPointer(Kind);
-    for (unsigned I = 0, E = Vals.size(); I != E; ++I)
+    if (Values)
-      ID.AddPointer(Vals[I]);
+      ID.AddPointer(Values);
   }
 
   // FIXME: Remove this!

lib/IR/Attributes.cpp

@@ -84,8 +84,8 @@ Constant *Attribute::getAttributeKind() const {
   return pImpl ? pImpl->getAttributeKind() : 0;
 }
 
-ArrayRef<Constant*> Attribute::getAttributeValues() const {
+Constant *Attribute::getAttributeValues() const {
-  return pImpl ? pImpl->getAttributeValues() : ArrayRef<Constant*>();
+  return pImpl ? pImpl->getAttributeValues() : 0;
 }
 
 /// This returns the alignment field of an attribute as a byte alignment value.
@@ -186,24 +186,22 @@ std::string Attribute::getAsString() const {
   //
   //   "kind"
   //   "kind" = "value"
-  //   "kind" = ("value1" "value2" "value3" )
+  //   "kind" = ( "value1" "value2" "value3" )
   //
   if (ConstantDataArray *CDA =
       dyn_cast<ConstantDataArray>(pImpl->getAttributeKind())) {
     std::string Result;
     Result += '\"' + CDA->getAsString().str() + '"';
 
-    ArrayRef<Constant*> Vals = pImpl->getAttributeValues();
+    Constant *Vals = pImpl->getAttributeValues();
-    if (Vals.empty()) return Result;
+    if (!Vals) return Result;
+
+    // FIXME: This should support more than just ConstantDataArrays. Also,
+    // support a vector of attribute values.
+
     Result += " = ";
-    if (Vals.size() > 1) Result += '(';
+    Result += '\"' + cast<ConstantDataArray>(Vals)->getAsString().str() + '"';
-    for (ArrayRef<Constant*>::iterator I = Vals.begin(), E = Vals.end();
+
-         I != E; ) {
-      ConstantDataArray *CDA = cast<ConstantDataArray>(*I++);
-      Result += '\"' + CDA->getAsString().str() + '"';
-      if (I != E) Result += ' ';
-    }
-    if (Vals.size() > 1) Result += ')';
     return Result;
   }
 
@@ -237,13 +235,13 @@ bool AttributeImpl::hasAttribute(Attribute::AttrKind A) const {
 uint64_t AttributeImpl::getAlignment() const {
   assert(hasAttribute(Attribute::Alignment) &&
          "Trying to retrieve the alignment from a non-alignment attr!");
-  return cast<ConstantInt>(Vals[0])->getZExtValue();
+  return cast<ConstantInt>(Values)->getZExtValue();
 }
 
 uint64_t AttributeImpl::getStackAlignment() const {
   assert(hasAttribute(Attribute::StackAlignment) &&
          "Trying to retrieve the stack alignment from a non-alignment attr!");
-  return cast<ConstantInt>(Vals[0])->getZExtValue();
+  return cast<ConstantInt>(Values)->getZExtValue();
 }
 
 bool AttributeImpl::operator==(Attribute::AttrKind kind) const {