Add BasicBlock level dominates(A,B) interface.

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

diff --git a/include/llvm/DerivedTypes.h b/include/llvm/DerivedTypes.h
index ced84fd541782632679c9182f5f24beca827b631..5aaa76ede3e3fbc1f46ca1cfa8fb6b0399df7c8d 100644 (file)
--- a/include/llvm/DerivedTypes.h
+++ b/include/llvm/DerivedTypes.h
@@ -31,6 +31,7 @@ class PointerValType;
 class VectorValType;
 class IntegerValType;
 class APInt;
+class ParamAttrsList;
 
 class DerivedType : public Type {
   friend class Type;
@@ -137,33 +138,16 @@ public:
 /// 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 
-    ZExtAttribute     = 1,      ///< zero extended before/after call
-    SExtAttribute     = 1 << 1, ///< sign extended before/after call
-    NoReturnAttribute = 1 << 2, ///< mark the function as not returning
-    InRegAttribute    = 1 << 3, ///< force argument to be passed in register
-    StructRetAttribute= 1 << 4, ///< hidden pointer to structure to return
-    NoUnwindAttribute = 1 << 5  ///< Function doesn't unwind stack
-  };
-  typedef std::vector<ParameterAttributes> ParamAttrsList;
-private:
   friend class TypeMap<FunctionValType, FunctionType>;
   bool isVarArgs;
-  ParamAttrsList *ParamAttrs;
+  const 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, const ParamAttrsList &Attrs);
+               bool IsVarArgs, const ParamAttrsList *Attrs = 0);
 
 public:
-  virtual ~FunctionType() { delete ParamAttrs; }
   /// FunctionType::get - This static method is the primary way of constructing
   /// a FunctionType. 
   ///
@@ -171,10 +155,11 @@ public:
     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()
+    const ParamAttrsList *Attrs = 0
       ///< 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. 
+      ///< starting at 1. This argument must be on the heap and FunctionType
+      ///< owns it after its passed here.
   );
 
   inline bool isVarArg() const { return isVarArgs; }
@@ -192,28 +177,13 @@ public:
   ///
   unsigned getNumParams() const { return NumContainedTys - 1; }
 
-  bool isStructReturn() const {
-    return (getNumParams() && paramHasAttr(1, StructRetAttribute));
-  }
+  bool isStructReturn() const;
   
   /// 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 std::string getParamAttrsText(ParameterAttributes Attr);
+  const ParamAttrsList *getParamAttrs() const { return ParamAttrs; }
 
   // Implement the AbstractTypeUser interface.
   virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy);
@@ -437,14 +407,6 @@ public:
     return new OpaqueType();           // All opaque types are distinct
   }
 
-  // Implement the AbstractTypeUser interface.
-  virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy) {
-    abort();   // FIXME: this is not really an AbstractTypeUser!
-  }
-  virtual void typeBecameConcrete(const DerivedType *AbsTy) {
-    abort();   // FIXME: this is not really an AbstractTypeUser!
-  }
-
   // Implement support for type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const OpaqueType *T) { return true; }
   static inline bool classof(const Type *T) {