[llvm-commits] CVS: llvm/include/llvm/DerivedTypes.h
Reid Spencer
reid at x10sys.com
Sat Dec 30 21:22:27 PST 2006
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);
More information about the llvm-commits
mailing list