//===-- llvm/DerivedTypes.h - Classes for handling data types ---*- C++ -*-===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
-// This file contains the declarations of classes that represent "derived
+// This file contains the declarations of classes that represent "derived
// types". These are things like "arrays of x" or "structure of x, y, z" or
// "method returning x taking (y,z) as parameters", etc...
//
class PointerValType;
class PackedValType;
-class DerivedType : public Type, public AbstractTypeUser {
- // AbstractTypeUsers - Implement a list of the users that need to be notified
- // if I am a type, and I get resolved into a more concrete type.
- //
- mutable std::vector<AbstractTypeUser *> AbstractTypeUsers;
+class DerivedType : public Type {
friend class Type;
protected:
- DerivedType(TypeID id) : Type("", id) {}
- ~DerivedType() {
- assert(AbstractTypeUsers.empty());
- }
+ DerivedType(TypeID id) : Type(id) {}
/// notifyUsesThatTypeBecameConcrete - Notify AbstractTypeUsers of this type
/// that the current type has transitioned from being abstract to being
///
void dropAllTypeUses();
- void RefCountIsZero() const {
- if (AbstractTypeUsers.empty())
- delete this;
- }
-
-
public:
//===--------------------------------------------------------------------===//
// are managed by (add|remove)AbstractTypeUser. See comments in
// AbstractTypeUser.h for more information.
- /// addAbstractTypeUser - Notify an abstract type that there is a new user of
- /// it. This function is called primarily by the PATypeHandle class.
- ///
- void addAbstractTypeUser(AbstractTypeUser *U) const {
- assert(isAbstract() && "addAbstractTypeUser: Current type not abstract!");
- AbstractTypeUsers.push_back(U);
- }
-
- /// removeAbstractTypeUser - Notify an abstract type that a user of the class
- /// no longer has a handle to the type. This function is called primarily by
- /// the PATypeHandle class. When there are no users of the abstract type, it
- /// is annihilated, because there is no way to get a reference to it ever
- /// again.
- ///
- void removeAbstractTypeUser(AbstractTypeUser *U) const;
-
/// refineAbstractTypeTo - This function is used to when it is discovered that
/// the 'this' abstract type is actually equivalent to the NewType specified.
/// This causes all users of 'this' to switch to reference the more concrete
const FunctionType &operator=(const FunctionType &); // Do not implement
protected:
/// This should really be private, but it squelches a bogus warning
- /// from GCC to make them protected: warning: `class FunctionType' only
+ /// from GCC to make them protected: warning: `class FunctionType' only
/// defines private constructors and has no friends
///
/// Private ctor - Only can be created by a static member...
///
- FunctionType(const Type *Result, const std::vector<const Type*> &Params,
+ FunctionType(const Type *Result, const std::vector<const Type*> &Params,
bool IsVarArgs);
public:
/// getNumParams - Return the number of fixed parameters this function type
/// requires. This does not consider varargs.
///
- unsigned getNumParams() const { return ContainedTys.size()-1; }
+ unsigned getNumParams() const { return unsigned(ContainedTys.size()-1); }
// Implement the AbstractTypeUser interface.
virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy);
virtual void typeBecameConcrete(const DerivedType *AbsTy);
-
+
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const FunctionType *T) { return true; }
static inline bool classof(const Type *T) {
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const CompositeType *T) { return true; }
static inline bool classof(const Type *T) {
- return T->getTypeID() == ArrayTyID ||
+ return T->getTypeID() == ArrayTyID ||
T->getTypeID() == StructTyID ||
T->getTypeID() == PointerTyID ||
T->getTypeID() == PackedTyID;
protected:
/// This should really be private, but it squelches a bogus warning
- /// from GCC to make them protected: warning: `class StructType' only
+ /// from GCC to make them protected: warning: `class StructType' only
/// defines private constructors and has no friends
///
/// Private ctor - Only can be created by a static member...
element_iterator element_end() const { return ContainedTys.end(); }
// Random access to the elements
- unsigned getNumElements() const { return ContainedTys.size(); }
+ unsigned getNumElements() const { return unsigned(ContainedTys.size()); }
const Type *getElementType(unsigned N) const {
assert(N < ContainedTys.size() && "Element number out of range!");
return ContainedTys[N];
};
-/// SequentialType - This is the superclass of the array, pointer and packed
+/// SequentialType - This is the superclass of the array, pointer and packed
/// type classes. All of these represent "arrays" in memory. The array type
/// represents a specifically sized array, pointer types are unsized/unknown
-/// size arrays, packed types represent specifically sized arrays that
-/// allow for use of SIMD instructions. SequentialType holds the common
-/// features of all, which stem from the fact that all three lay their
+/// size arrays, packed types represent specifically sized arrays that
+/// allow for use of SIMD instructions. SequentialType holds the common
+/// features of all, which stem from the fact that all three lay their
/// components out in memory identically.
///
class SequentialType : public CompositeType {
///
class ArrayType : public SequentialType {
friend class TypeMap<ArrayValType, ArrayType>;
- unsigned NumElements;
+ uint64_t NumElements;
ArrayType(const ArrayType &); // Do not implement
const ArrayType &operator=(const ArrayType &); // Do not implement
protected:
/// This should really be private, but it squelches a bogus warning
- /// from GCC to make them protected: warning: `class ArrayType' only
+ /// from GCC to make them protected: warning: `class ArrayType' only
/// defines private constructors and has no friends
///
/// Private ctor - Only can be created by a static member...
///
- ArrayType(const Type *ElType, unsigned NumEl);
+ ArrayType(const Type *ElType, uint64_t NumEl);
public:
/// ArrayType::get - This static method is the primary way to construct an
/// ArrayType
///
- static ArrayType *get(const Type *ElementType, unsigned NumElements);
+ static ArrayType *get(const Type *ElementType, uint64_t NumElements);
- inline unsigned getNumElements() const { return NumElements; }
+ inline uint64_t getNumElements() const { return NumElements; }
// Implement the AbstractTypeUser interface.
virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy);
const PackedType &operator=(const PackedType &); // Do not implement
protected:
/// This should really be private, but it squelches a bogus warning
- /// from GCC to make them protected: warning: `class PackedType' only
+ /// from GCC to make them protected: warning: `class PackedType' only
/// defines private constructors and has no friends
///
/// Private ctor - Only can be created by a static member...
const PointerType &operator=(const PointerType &); // Do not implement
protected:
// This should really be private, but it squelches a bogus warning
- // from GCC to make them protected: warning: `class PointerType' only
+ // from GCC to make them protected: warning: `class PointerType' only
// defines private constructors and has no friends
// Private ctor - Only can be created by a static member...
const OpaqueType &operator=(const OpaqueType &); // DO NOT IMPLEMENT
protected:
/// This should really be private, but it squelches a bogus warning
- /// from GCC to make them protected: warning: `class OpaqueType' only
+ /// from GCC to make them protected: warning: `class OpaqueType' only
/// defines private constructors and has no friends
///
/// Private ctor - Only can be created by a static member...