The guaranteed alignment of ptr+offset is only the minimum of

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

diff --git a/include/llvm/DerivedTypes.h b/include/llvm/DerivedTypes.h
index 6013c265f0b1700ae86c76722d30231ef4408736..1ae8cbd45b97f00695a6bec8640734a8fd311c50 100644 (file)
--- a/include/llvm/DerivedTypes.h
+++ b/include/llvm/DerivedTypes.h
@@ -140,12 +140,12 @@ public:
 class FunctionType : public DerivedType {
   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, ParamAttrsList *Attrs = 0);
+               bool IsVarArgs, const ParamAttrsList *Attrs = 0);
 
 public:
   /// FunctionType::get - This static method is the primary way of constructing
@@ -155,7 +155,7 @@ 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
-    ParamAttrsList *Attrs = 0
+    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
@@ -263,11 +263,11 @@ public:
     return T->getTypeID() == StructTyID;
   }
 
-  bool isPacked() const { return getSubclassData(); }
+  bool isPacked() const { return (0 != getSubclassData()) ? true : false; }
 };
 
 
-/// SequentialType - This is the superclass of the array, pointer and packed
+/// SequentialType - This is the superclass of the array, pointer and vector
 /// type classes.  All of these represent "arrays" in memory.  The array type
 /// represents a specifically sized array, pointer types are unsized/unknown
 /// size arrays, vector types represent specifically sized arrays that
@@ -279,9 +279,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;
   }
@@ -407,14 +410,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) {