Change the PointerType api for creating pointer types. The old functionality of Point...

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

diff --git a/include/llvm/DerivedTypes.h b/include/llvm/DerivedTypes.h
index ba35d783b8a546c3e8af0b5931d195a95158006f..c294f402e686078cb1e231bef34219bef70074fc 100644 (file)
--- a/include/llvm/DerivedTypes.h
+++ b/include/llvm/DerivedTypes.h
@@ -31,7 +31,6 @@ class PointerValType;
 class VectorValType;
 class IntegerValType;
 class APInt;
-class ParamAttrsList;
 
 class DerivedType : public Type {
   friend class Type;
@@ -140,12 +139,11 @@ public:
 class FunctionType : public DerivedType {
   friend class TypeMap<FunctionValType, FunctionType>;
   bool isVarArgs;
-  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 = 0);
+               bool IsVarArgs);
 
 public:
   /// FunctionType::get - This static method is the primary way of constructing
@@ -154,12 +152,7 @@ public:
   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 = 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. This argument must be on the heap and FunctionType
-      ///< owns it after its passed here.
+    bool isVarArg  ///< Whether this is a variable argument length function
   );
 
   inline bool isVarArg() const { return isVarArgs; }
@@ -177,14 +170,6 @@ public:
   ///
   unsigned getNumParams() const { return NumContainedTys - 1; }
 
-  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
-  const ParamAttrsList *getParamAttrs() const { return ParamAttrs; }
-
   // Implement the AbstractTypeUser interface.
   virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy);
   virtual void typeBecameConcrete(const DerivedType *AbsTy);
@@ -263,7 +248,7 @@ public:
     return T->getTypeID() == StructTyID;
   }
 
-  bool isPacked() const { return getSubclassData(); }
+  bool isPacked() const { return (0 != getSubclassData()) ? true : false; }
 };
 
 
@@ -279,9 +264,12 @@ class SequentialType : public CompositeType {
   PATypeHandle ContainedType; ///< Storage for the single contained type
   SequentialType(const SequentialType &);                  // Do not implement!
   const SequentialType &operator=(const SequentialType &); // Do not implement!
+
+  // avoiding warning: 'this' : used in base member initializer list
+  SequentialType* this_() { return this; }
 protected:
   SequentialType(TypeID TID, const Type *ElType) 
-    : CompositeType(TID), ContainedType(ElType, this) {
+    : CompositeType(TID), ContainedType(ElType, this_()) {
     ContainedTys = &ContainedType; 
     NumContainedTys = 1;
   }
@@ -375,12 +363,24 @@ public:
 ///
 class PointerType : public SequentialType {
   friend class TypeMap<PointerValType, PointerType>;
+  unsigned AddressSpace;
+  
   PointerType(const PointerType &);                   // Do not implement
   const PointerType &operator=(const PointerType &);  // Do not implement
-  explicit PointerType(const Type *ElType);
+  explicit PointerType(const Type *ElType, unsigned AddrSpace);
 public:
-  /// PointerType::get - This is the only way to construct a new pointer type.
-  static PointerType *get(const Type *ElementType);
+  /// PointerType::get - This constructs a pointer to an object of the specified 
+  /// type in a numbered address space.
+  static PointerType *get(const Type *ElementType, unsigned AddressSpace);
+  
+  /// PointerType::getUnqual - This constructs a pointer to an object of the  
+  /// specified type in the generic address space (address space zero).
+  static PointerType *getUnqual(const Type *ElementType) { 
+    return PointerType::get(ElementType, 0);
+  }
+  
+  /// @brief Return the address space of the Pointer type.
+  inline unsigned getAddressSpace() const { return AddressSpace; }
 
   // Implement the AbstractTypeUser interface.
   virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy);