From 943c29135e03e55f9a5dab393786171a4a536482 Mon Sep 17 00:00:00 2001
From: Bill Wendling <isanbard@gmail.com>
Date: Tue, 9 Oct 2012 09:51:10 +0000
Subject: [PATCH] Move the 'ParameterOnly' variable inside of the Attributes
 class and make it a method.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165497 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/llvm/Attributes.h | 28 ++++++++++++++++------------
 lib/VMCore/Verifier.cpp   | 27 ++++++++++++---------------
 2 files changed, 28 insertions(+), 27 deletions(-)

diff --git a/include/llvm/Attributes.h b/include/llvm/Attributes.h
index 2a0fbc0ee13..86a963419e5 100644
--- a/include/llvm/Attributes.h
+++ b/include/llvm/Attributes.h
@@ -110,10 +110,6 @@ DECLARE_LLVM_ATTRIBUTE(AddressSafety,1ULL<<32) ///< Address safety checking is o
 ///                      an exception might pass by.
 /// uwtable + nounwind = Needs an entry because the ABI says so.
 
-/// @brief Attributes that only apply to function parameters.
-const AttrConst ParameterOnly = {ByVal_i | Nest_i |
-    StructRet_i | NoCapture_i};
-
 /// @brief Attributes that may be applied to the function itself.  These cannot
 /// be used on return values or function parameters.
 const AttrConst FunctionOnly = {NoReturn_i | NoUnwind_i | ReadNone_i |
@@ -215,11 +211,6 @@ public:
   static Attributes get(Builder &B);
   static Attributes get(LLVMContext &Context, Builder &B);
 
-  /// @brief Parameter attributes that do not apply to vararg call arguments.
-  bool hasIncompatibleWithVarArgsAttrs() const {
-    return hasAttribute(Attributes::StructRet);
-  }
-
   /// @brief Return true if the attribute is present.
   bool hasAttribute(AttrVal Val) const;
 
@@ -231,14 +222,27 @@ public:
   /// @brief Return true if the attributes are a non-null intersection.
   bool hasAttributes(const Attributes &A) const;
 
-  /// This returns the alignment field of an attribute as a byte alignment
+  /// @brief Returns the alignment field of an attribute as a byte alignment
   /// value.
   unsigned getAlignment() const;
 
-  /// This returns the stack alignment field of an attribute as a byte alignment
-  /// value.
+  /// @brief Returns the stack alignment field of an attribute as a byte
+  /// alignment value.
   unsigned getStackAlignment() const;
 
+  /// @brief Parameter attributes that do not apply to vararg call arguments.
+  bool hasIncompatibleWithVarArgsAttrs() const {
+    return hasAttribute(Attributes::StructRet);
+  }
+
+  /// @brief Attributes that only apply to function parameters.
+  bool hasParameterOnlyAttrs() const {
+    return hasAttribute(Attributes::ByVal) ||
+      hasAttribute(Attributes::Nest) ||
+      hasAttribute(Attributes::StructRet) ||
+      hasAttribute(Attributes::NoCapture);
+  }
+
   bool isEmptyOrSingleton() const;
 
   // This is a "safe bool() operator".
diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp
index 6c60745d60f..8b47f2518b9 100644
--- a/lib/VMCore/Verifier.cpp
+++ b/lib/VMCore/Verifier.cpp
@@ -533,11 +533,10 @@ void Verifier::VerifyParameterAttrs(Attributes Attrs, Type *Ty,
   Assert1(!FnCheckAttr, "Attribute " + FnCheckAttr.getAsString() +
           " only applies to the function!", V);
 
-  if (isReturnValue) {
-    Attributes RetI = Attrs & Attribute::ParameterOnly;
-    Assert1(!RetI, "Attribute " + RetI.getAsString() +
-            " does not apply to return values!", V);
-  }
+  if (isReturnValue)
+    Assert1(!Attrs.hasParameterOnlyAttrs(),
+            "Attributes 'byval', 'nest', 'sret', and 'nocapture' "
+            "do not apply to return values!", V);
 
   for (unsigned i = 0;
        i < array_lengthof(Attribute::MutuallyIncompatible); ++i) {
@@ -550,16 +549,14 @@ void Verifier::VerifyParameterAttrs(Attributes Attrs, Type *Ty,
   Assert1(!TypeI, "Wrong type for attribute " +
           TypeI.getAsString(), V);
 
-  Attributes ByValI = Attrs & Attribute::ByVal;
-  if (PointerType *PTy = dyn_cast<PointerType>(Ty)) {
-    Assert1(!ByValI || PTy->getElementType()->isSized(),
-            "Attribute " + ByValI.getAsString() +
-            " does not support unsized types!", V);
-  } else {
-    Assert1(!ByValI,
-            "Attribute " + ByValI.getAsString() +
-            " only applies to parameters with pointer type!", V);
-  }
+  if (PointerType *PTy = dyn_cast<PointerType>(Ty))
+    Assert1(!Attrs.hasAttribute(Attributes::ByVal) ||
+            PTy->getElementType()->isSized(),
+            "Attribute 'byval' does not support unsized types!", V);
+  else
+    Assert1(!Attrs.hasAttribute(Attributes::ByVal),
+            "Attribute 'byval' only applies to parameters with pointer type!",
+            V);
 }
 
 // VerifyFunctionAttrs - Check parameter attributes against a function type.