#define LLVM_TYPE_H
#include "AbstractTypeUser.h"
-#include "Support/Casting.h"
-#include "Support/GraphTraits.h"
-#include "Support/iterator"
+#include "llvm/Support/Casting.h"
+#include "llvm/ADT/GraphTraits.h"
+#include "llvm/ADT/iterator"
#include <vector>
namespace llvm {
class OpaqueType;
class PointerType;
class StructType;
-class SymbolTable;
+class PackedType;
-struct Type {
+class Type {
+public:
///===-------------------------------------------------------------------===//
/// Definitions of all of the base types for the Type system. Based on this
/// value, you can cast to a "DerivedType" subclass (see DerivedTypes.h)
FunctionTyID , StructTyID, // Functions... Structs...
ArrayTyID , PointerTyID, // Array... pointer...
OpaqueTyID, // Opaque type instances...
- //PackedTyID , // SIMD 'packed' format... TODO
+ PackedTyID, // SIMD 'packed' format...
//...
NumTypeIDs, // Must remain as last defined ID
///
inline void setAbstract(bool Val) { Abstract = Val; }
- /// isTypeAbstract - This method is used to calculate the Abstract bit.
- ///
- bool isTypeAbstract();
+ // PromoteAbstractToConcrete - This is an internal method used to calculate
+ // change "Abstract" from true to false when types are refined.
+ void PromoteAbstractToConcrete();
unsigned getRefCount() const { return RefCount; }
inline bool isDerivedType() const { return ID >= FirstDerivedTyID; }
/// isFirstClassType - Return true if the value is holdable in a register.
+ ///
inline bool isFirstClassType() const {
- return (ID != VoidTyID && ID <= LastPrimitiveTyID) || ID == PointerTyID;
+ return (ID != VoidTyID && ID <= LastPrimitiveTyID) ||
+ ID == PointerTyID || ID == PackedTyID;
}
/// isSized - Return true if it makes sense to take the size of this type. To
/// TargetData subsystem to do this.
///
bool isSized() const {
- return (ID >= BoolTyID && ID <= DoubleTyID) || ID == PointerTyID ||
+ return (ID >= BoolTyID && ID <= DoubleTyID) || ID == PointerTyID ||
isSizedDerivedType();
}
- /// getPrimitiveSize - Return the basic size of this type if it is a primative
+ /// getPrimitiveSize - Return the basic size of this type if it is a primitive
/// type. These are fixed by LLVM and are not target dependent. This will
/// return zero if the type does not have a size or is not a primitive type.
///
/// getNumContainedTypes - Return the number of types in the derived type.
///
- unsigned getNumContainedTypes() const { return ContainedTys.size(); }
+ typedef std::vector<PATypeHandle>::size_type size_type;
+ size_type getNumContainedTypes() const { return ContainedTys.size(); }
//===--------------------------------------------------------------------===//
// Static members exported by the Type class itself. Useful for getting
}
void dropRef() const {
- assert(isAbstract() && "Cannot drop a refernce to a non-abstract type!");
+ assert(isAbstract() && "Cannot drop a reference to a non-abstract type!");
assert(RefCount && "No objects are currently referencing this object!");
// If this is the last PATypeHolder using this object, and there are no
if (--RefCount == 0)
RefCountIsZero();
}
+
+ /// clearAllTypeMaps - This method frees all internal memory used by the
+ /// type subsystem, which can be used in environments where this memory is
+ /// otherwise reported as a leak.
+ static void clearAllTypeMaps();
+
private:
/// isSizedDerivedType - Derived types like structures and arrays are sized
/// iff all of the members of the type are sized as well. Since asking for
/// type we are pointing to is forwarding to a new type. If so, we drop our
/// reference to the type.
///
-inline const Type* PATypeHolder::get() const {
+inline Type* PATypeHolder::get() const {
const Type *NewTy = Ty->getForwardedType();
- if (!NewTy) return Ty;
+ if (!NewTy) return const_cast<Type*>(Ty);
return *const_cast<PATypeHolder*>(this) = NewTy;
}
return Ty.getTypeID() == Type::PointerTyID;
}
-std::ostream &operator<<(std::ostream &OS, const Type *T);
std::ostream &operator<<(std::ostream &OS, const Type &T);
} // End llvm namespace