//===-- llvm/Type.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 declaration of the Type class. For more "Type" type
// stuff, look in DerivedTypes.h.
//
// Note that instances of the Type class are immutable: once they are created,
-// they are never changed. Also note that only one instance of a particular
-// type is ever created. Thus seeing if two types are equal is a matter of
+// they are never changed. Also note that only one instance of a particular
+// type is ever created. Thus seeing if two types are equal is a matter of
// doing a trivial pointer comparison.
//
// Types, once allocated, are never free'd, unless they are an abstract type
//
// Opaque types are simple derived types with no state. There may be many
// different Opaque type objects floating around, but two are only considered
-// identical if they are pointer equals of each other. This allows us to have
+// identical if they are pointer equals of each other. This allows us to have
// two opaque types that end up resolving to different concrete types later.
//
-// Opaque types are also kinda wierd and scary and different because they have
+// Opaque types are also kinda weird and scary and different because they have
// to keep a list of uses of the type. When, through linking, parsing, or
// bytecode reading, they become resolved, they need to find and update all
// users of the unknown type, causing them to reference a new, more concrete
#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 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)
- /// Note: If you add an element to this, you need to add an element to the
+ /// Note: If you add an element to this, you need to add an element to the
/// Type::getPrimitiveType function, or else things will break!
///
enum TypeID {
UIntTyID , IntTyID, // 6, 7: 32 bit types...
ULongTyID , LongTyID, // 8, 9: 64 bit types...
FloatTyID , DoubleTyID, // 10,11: Floating point types...
- LabelTyID , // 12 : Labels...
+ LabelTyID , // 12 : Labels...
// Derived types... see DerivedTypes.h file...
// Make sure FirstDerivedTyID stays up to date!!!
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
LastPrimitiveTyID = LabelTyID,
- FirstDerivedTyID = FunctionTyID,
+ FirstDerivedTyID = FunctionTyID
};
private:
///
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; }
std::vector<PATypeHandle> ContainedTys;
public:
- virtual void print(std::ostream &O) const;
+ void print(std::ostream &O) const;
/// @brief Debugging support: print to stderr
- virtual void dump() const;
+ void dump() const;
//===--------------------------------------------------------------------===//
// Property accessors for dealing with types... Some of these virtual methods
/// Float and Double.
///
bool isSigned() const {
- return ID == SByteTyID || ID == ShortTyID ||
- ID == IntTyID || ID == LongTyID;
+ return ID == SByteTyID || ID == ShortTyID ||
+ ID == IntTyID || ID == LongTyID;
}
-
+
/// isUnsigned - Return whether a numeric type is unsigned. This is not quite
/// the complement of isSigned... nonnumeric types return false as they do
/// with isSigned. This returns true for UByteTy, UShortTy, UIntTy, and
/// ULongTy
- ///
+ ///
bool isUnsigned() const {
- return ID == UByteTyID || ID == UShortTyID ||
- ID == UIntTyID || ID == ULongTyID;
+ return ID == UByteTyID || ID == UShortTyID ||
+ ID == UIntTyID || ID == ULongTyID;
}
/// isInteger - Equivalent to isSigned() || isUnsigned()
bool isFloatingPoint() const { return ID == FloatTyID || ID == DoubleTyID; }
/// isAbstract - True if the type is either an Opaque type, or is a derived
- /// type that includes an opaque type somewhere in it.
+ /// type that includes an opaque type somewhere in it.
///
inline bool isAbstract() const { return Abstract; }
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 ||
- isSizedDerivedType();
+ // If it's a primitive, it is always sized.
+ if (ID >= BoolTyID && ID <= DoubleTyID || ID == PointerTyID)
+ return true;
+ // If it is not something that can have a size (e.g. a function or label),
+ // it doesn't have a size.
+ if (ID != StructTyID && ID != ArrayTyID && ID != PackedTyID)
+ return false;
+ // If it is something that can have a size and it's concrete, it definitely
+ // has a size, otherwise we have to try harder to decide.
+ return !isAbstract() || isSizedDerivedType();
}
/// getPrimitiveSize - Return the basic size of this type if it is a primitive
/// return zero if the type does not have a size or is not a primitive type.
///
unsigned getPrimitiveSize() const;
+ unsigned getPrimitiveSizeInBits() const;
/// getUnsignedVersion - If this is an integer type, return the unsigned
/// variant of this type. For example int -> uint.
return getForwardedTypeInternal();
}
+ /// getVAArgsPromotedType - Return the type an argument of this type
+ /// will be promoted to if passed through a variable argument
+ /// function.
+ const Type *getVAArgsPromotedType() const {
+ if (ID == BoolTyID || ID == UByteTyID || ID == UShortTyID)
+ return Type::UIntTy;
+ else if (ID == SByteTyID || ID == ShortTyID)
+ return Type::IntTy;
+ else if (ID == FloatTyID)
+ return Type::DoubleTy;
+ else
+ return this;
+ }
+
//===--------------------------------------------------------------------===//
// Type Iteration support
//
/// 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
static Type *VoidTy , *BoolTy;
static Type *SByteTy, *UByteTy,
*ShortTy, *UShortTy,
- *IntTy , *UIntTy,
+ *IntTy , *UIntTy,
*LongTy , *ULongTy;
static Type *FloatTy, *DoubleTy;
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const Type *T) { return true; }
-#include "llvm/Type.def"
-
// Virtual methods used by callbacks below. These should only be implemented
// in the DerivedType class.
virtual void addAbstractTypeUser(AbstractTypeUser *U) const {
assert(isAbstract() && "Cannot add a reference to a non-abstract type!");
++RefCount;
}
-
+
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
//===----------------------------------------------------------------------===//
// Define some inline methods for the AbstractTypeUser.h:PATypeHandle class.
-// These are defined here because they MUST be inlined, yet are dependent on
+// These are defined here because they MUST be inlined, yet are dependent on
// the definition of the Type class. Of course Type derives from Value, which
// contains an AbstractTypeUser instance, so there is no good way to factor out
// the code. Hence this bit of uglyness.
//===----------------------------------------------------------------------===//
-// Provide specializations of GraphTraits to be able to treat a type as a
+// Provide specializations of GraphTraits to be able to treat a type as a
// graph of sub types...
template <> struct GraphTraits<Type*> {
typedef Type::subtype_iterator ChildIteratorType;
static inline NodeType *getEntryNode(Type *T) { return T; }
- static inline ChildIteratorType child_begin(NodeType *N) {
- return N->subtype_begin();
+ static inline ChildIteratorType child_begin(NodeType *N) {
+ return N->subtype_begin();
}
- static inline ChildIteratorType child_end(NodeType *N) {
+ static inline ChildIteratorType child_end(NodeType *N) {
return N->subtype_end();
}
};
typedef Type::subtype_iterator ChildIteratorType;
static inline NodeType *getEntryNode(const Type *T) { return T; }
- static inline ChildIteratorType child_begin(NodeType *N) {
- return N->subtype_begin();
+ static inline ChildIteratorType child_begin(NodeType *N) {
+ return N->subtype_begin();
}
- static inline ChildIteratorType child_end(NodeType *N) {
+ static inline ChildIteratorType child_end(NodeType *N) {
return N->subtype_end();
}
};
-template <> inline bool isa_impl<PointerType, Type>(const Type &Ty) {
+template <> inline bool isa_impl<PointerType, Type>(const Type &Ty) {
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
projects / oota-llvm.git / blobdiff