[llvm-commits] CVS: llvm/include/llvm/DerivedTypes.h

[Reid Spencer]

Changes in directory llvm/include/llvm:

DerivedTypes.h updated: 1.74 -> 1.75
---
Log message:

For PR950: http://llvm.org/PR950 :
Add a new feature to FunctionType, Parameter Attributes. This allows tags
such as "sext" and "zext" to be associated with a faunction's arguments
or return type. This allows signedness information to be carried forward
from the frontend to the backend for arguments and result types.


---
Diffs of the changes:  (+43 -5)

 DerivedTypes.h |   48 +++++++++++++++++++++++++++++++++++++++++++-----
 1 files changed, 43 insertions(+), 5 deletions(-)


Index: llvm/include/llvm/DerivedTypes.h
diff -u llvm/include/llvm/DerivedTypes.h:1.74 llvm/include/llvm/DerivedTypes.h:1.75
--- llvm/include/llvm/DerivedTypes.h:1.74	Thu Dec 28 22:12:03 2006
+++ llvm/include/llvm/DerivedTypes.h	Sat Dec 30 23:22:12 2006
@@ -75,21 +75,40 @@
 /// FunctionType - Class to represent function types
 ///
 class FunctionType : public DerivedType {
+public:
+  /// Function parameters can have attributes to indicate how they should be
+  /// treated by optimizations and code generation. This enumeration lists the
+  /// set of possible attributes.
+  /// @brief Function parameter attributes enumeration.
+  enum ParameterAttributes {
+    NoAttributeSet = 0, ///< No attribute value has been set on the parameter
+    ZExtAttribute  = 1, ///< The parameter should be zero extended before call
+    SExtAttribute  = 2  ///< The parameter should be sign extended before call
+  };
+  typedef std::vector<ParameterAttributes> ParamAttrsList;
+private:
   friend class TypeMap<FunctionValType, FunctionType>;
   bool isVarArgs;
+  ParamAttrsList *ParamAttrs;
 
   FunctionType(const FunctionType &);                   // Do not implement
   const FunctionType &operator=(const FunctionType &);  // Do not implement
   FunctionType(const Type *Result, const std::vector<const Type*> &Params,
-               bool IsVarArgs);
+               bool IsVarArgs, const ParamAttrsList &Attrs);
 
 public:
   /// FunctionType::get - This static method is the primary way of constructing
-  /// a FunctionType
+  /// a FunctionType. 
   ///
-  static FunctionType *get(const Type *Result,
-                           const std::vector<const Type*> &Params,
-                           bool isVarArg);
+  static FunctionType *get(
+    const Type *Result, ///< The result type
+    const std::vector<const Type*> &Params, ///< The types of the parameters
+    bool isVarArg, ///< Whether this is a variable argument length function
+    const ParamAttrsList & Attrs = ParamAttrsList()
+      ///< Indicates the parameter attributes to use, if any. The 0th entry
+      ///< in the list refers to the return type. Parameters are numbered
+      ///< starting at 1. 
+  );
 
   inline bool isVarArg() const { return isVarArgs; }
   inline const Type *getReturnType() const { return ContainedTys[0]; }
@@ -106,6 +125,25 @@
   ///
   unsigned getNumParams() const { return unsigned(ContainedTys.size()-1); }
 
+  /// The parameter attributes for the \p ith parameter are returned. The 0th
+  /// parameter refers to the return type of the function.
+  /// @returns The ParameterAttributes for the \p ith parameter.
+  /// @brief Get the attributes for a parameter
+  ParameterAttributes getParamAttrs(unsigned i) const;
+
+  /// @brief Determine if a parameter attribute is set
+  bool paramHasAttr(unsigned i, ParameterAttributes attr) const {
+    return getParamAttrs(i) & attr;
+  }
+
+  /// @brief Return the number of parameter attributes this type has.
+  unsigned getNumAttrs() const { 
+    return (ParamAttrs ?  unsigned(ParamAttrs->size()) : 0);
+  }
+
+  /// @brief Convert a ParameterAttribute into its assembly text
+  static const char * getParamAttrsText(ParameterAttributes Attr);
+
   // Implement the AbstractTypeUser interface.
   virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy);
   virtual void typeBecameConcrete(const DerivedType *AbsTy);