Cosmetic change.

[oota-llvm.git] / include / llvm / ParameterAttributes.h

diff --git a/include/llvm/ParameterAttributes.h b/include/llvm/ParameterAttributes.h
index 5d3ef9aba72ee59bc9aa610af131a3ef67580c9e..29bbd23abc172004d3f8ef92461a54ec884a0d9c 100644 (file)
--- a/include/llvm/ParameterAttributes.h
+++ b/include/llvm/ParameterAttributes.h
@@ -39,8 +39,36 @@ enum Attributes {
   NoAlias    = 1 << 6,  ///< Considered to not alias after call
   ByVal      = 1 << 7,  ///< Pass structure by value
   Nest       = 1 << 8,  ///< Nested function static chain
-  Pure       = 1 << 9,  ///< Function is pure
-  Const      = 1 << 10  ///< Function is const
+  ReadNone   = 1 << 9,  ///< Function does not access memory
+  ReadOnly   = 1 << 10  ///< Function only reads from memory
+};
+
+/// These attributes can safely be dropped from a function or a function call:
+/// doing so may reduce the number of optimizations performed, but it will not
+/// change a correct program into an incorrect one.
+/// @brief Attributes that do not change the calling convention.
+const uint16_t Informative = NoReturn | NoUnwind | NoAlias |
+                             ReadNone | ReadOnly;
+
+/// The following attribute sets are used by the verifier:
+
+/// @brief Attributes that only apply to function parameters.
+const uint16_t ParameterOnly = ByVal | InReg | Nest | StructRet;
+
+/// @brief Attributes that only apply to function return values.
+const uint16_t ReturnOnly = NoReturn | NoUnwind | ReadNone | ReadOnly;
+
+/// @brief Attributes that only apply to integers.
+const uint16_t IntegerTypeOnly = SExt | ZExt;
+
+/// @brief Attributes that only apply to pointers.
+const uint16_t PointerTypeOnly = ByVal | Nest | NoAlias | StructRet;
+
+/// @brief Attributes that are mutually incompatible.
+const uint16_t MutuallyIncompatible[3] = {
+  ByVal | InReg | Nest  | StructRet,
+  ZExt  | SExt,
+  ReadNone | ReadOnly
 };
 
 }
@@ -49,7 +77,7 @@ enum Attributes {
 /// with a parameter index. 
 /// @brief ParameterAttributes with a parameter index.
 struct ParamAttrsWithIndex {
-  uint16_t attrs; ///< The attributes that are set, |'d together
+  uint16_t attrs; ///< The attributes that are set, or'd together
   uint16_t index; ///< Index of the parameter for which the attributes apply
   
   static ParamAttrsWithIndex get(uint16_t idx, uint16_t attrs) {
@@ -102,13 +130,29 @@ class ParamAttrsList : public FoldingSetNode {
       : attrs(attrVec), refCount(0) {}
 
   public:
-    /// This method ensures the uniqueness of ParamAttrsList instances. The
+    /// This method ensures the uniqueness of ParamAttrsList instances.  The
     /// argument is a vector of attribute/index pairs as represented by the
-    /// ParamAttrsWithIndex structure. The vector is used in the construction of
-    /// the ParamAttrsList instance. If an instance with identical vector pairs
-    /// exists, it will be returned instead of creating a new instance.
+    /// 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 ParamAttrsList *get(const ParamAttrsVector &attrVec);
+    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);
+
+    /// Returns whether each of the specified lists of attributes can be safely
+    /// replaced with the other in a function or a function call.
+    /// @brief Whether one attribute list can safely replace the other.
+    static bool areCompatible(const ParamAttrsList *A, const ParamAttrsList *B);
 
   /// @}
   /// @name Accessors
@@ -186,6 +230,13 @@ class ParamAttrsList : public FoldingSetNode {
     /// @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.