Type.h revision 6bfd6a578a3a4fa95c585c988ee712ba880f9923 
1//===-- llvm/Type.h - Classes for handling data types ------------*- C++ -*--=//
2//
3// This file contains the declaration of the Type class.  For more "Type" type
4// stuff, look in DerivedTypes.h and Opt/ConstantHandling.h
5//
6// Note that instances of the Type class are immutable: once they are created,
7// they are never changed.  Also note that only one instance of a particular
8// type is ever created.  Thus seeing if two types are equal is a matter of
9// doing a trivial pointer comparison.
10//
11// Types, once allocated, are never free'd.
12//
13// Opaque types are simple derived types with no state.  There may be many
14// different Opaque type objects floating around, but two are only considered
15// identical if they are pointer equals of each other.  This allows us to have
16// two opaque types that end up resolving to different concrete types later.
17//
18// Opaque types are also kinda wierd and scary and different because they have
19// to keep a list of uses of the type.  When, through linking, parsing, or
20// bytecode reading, they become resolved, they need to find and update all
21// users of the unknown type, causing them to reference a new, more concrete
22// type.  Opaque types are deleted when their use list dwindles to zero users.
23//
24//===----------------------------------------------------------------------===//
25
26#ifndef LLVM_TYPE_H
27#define LLVM_TYPE_H
28
29#include "llvm/Value.h"
30#include "Support/GraphTraits.h"
31
32class DerivedType;
33class FunctionType;
34class ArrayType;
35class PointerType;
36class StructType;
37class OpaqueType;
38
39class Type : public Value {
40public:
41  //===--------------------------------------------------------------------===//
42  // Definitions of all of the base types for the Type system.  Based on this
43  // value, you can cast to a "DerivedType" subclass (see DerivedTypes.h)
44  // Note: If you add an element to this, you need to add an element to the
45  // Type::getPrimitiveType function, or else things will break!
46  //
47  enum PrimitiveID {
48    VoidTyID = 0  , BoolTyID,           //  0, 1: Basics...
49    UByteTyID     , SByteTyID,          //  2, 3: 8 bit types...
50    UShortTyID    , ShortTyID,          //  4, 5: 16 bit types...
51    UIntTyID      , IntTyID,            //  6, 7: 32 bit types...
52    ULongTyID     , LongTyID,           //  8, 9: 64 bit types...
53
54    FloatTyID     , DoubleTyID,         // 10,11: Floating point types...
55
56    TypeTyID,                           // 12   : Type definitions
57    LabelTyID     ,                     // 13   : Labels...
58
59    // Derived types... see DerivedTypes.h file...
60    // Make sure FirstDerivedTyID stays up to date!!!
61    FunctionTyID  , StructTyID,         // Functions... Structs...
62    ArrayTyID     , PointerTyID,        // Array... pointer...
63    OpaqueTyID,                         // Opaque type instances...
64    //PackedTyID  ,                     // SIMD 'packed' format... TODO
65    //...
66
67    NumPrimitiveIDs,                    // Must remain as last defined ID
68    FirstDerivedTyID = FunctionTyID,
69  };
70
71private:
72  PrimitiveID ID;        // The current base type of this type...
73  unsigned    UID;       // The unique ID number for this class
74  std::string Desc;      // The printed name of the string...
75  bool        Abstract;  // True if type contains an OpaqueType
76  bool        Recursive; // True if the type is recursive
77
78protected:
79  // ctor is protected, so only subclasses can create Type objects...
80  Type(const std::string &Name, PrimitiveID id);
81  virtual ~Type() {}
82
83  // When types are refined, they update their description to be more concrete.
84  //
85  inline void setDescription(const std::string &D) { Desc = D; }
86
87  // setName - Associate the name with this type in the symbol table, but don't
88  // set the local name to be equal specified name.
89  //
90  virtual void setName(const std::string &Name, SymbolTable *ST = 0);
91
92  // Types can become nonabstract later, if they are refined.
93  //
94  inline void setAbstract(bool Val) { Abstract = Val; }
95
96  // Types can become recursive later, if they are refined.
97  //
98  inline void setRecursive(bool Val) { Recursive = Val; }
99
100public:
101
102  //===--------------------------------------------------------------------===//
103  // Property accessors for dealing with types...
104  //
105
106  // getPrimitiveID - Return the base type of the type.  This will return one
107  // of the PrimitiveID enum elements defined above.
108  //
109  inline PrimitiveID getPrimitiveID() const { return ID; }
110
111  // getUniqueID - Returns the UID of the type.  This can be thought of as a
112  // small integer version of the pointer to the type class.  Two types that are
113  // structurally different have different UIDs.  This can be used for indexing
114  // types into an array.
115  //
116  inline unsigned getUniqueID() const { return UID; }
117
118  // getDescription - Return the string representation of the type...
119  inline const std::string &getDescription() const { return Desc; }
120
121  // isSigned - Return whether a numeric type is signed.
122  virtual bool isSigned() const { return 0; }
123
124  // isUnsigned - Return whether a numeric type is unsigned.  This is not
125  // quite the complement of isSigned... nonnumeric types return false as they
126  // do with isSigned.
127  //
128  virtual bool isUnsigned() const { return 0; }
129
130  // isIntegral - Equilivent to isSigned() || isUnsigned, but with only a single
131  // virtual function invocation.
132  //
133  virtual bool isIntegral() const { return 0; }
134
135  // isAbstract - True if the type is either an Opaque type, or is a derived
136  // type that includes an opaque type somewhere in it.
137  //
138  inline bool isAbstract() const { return Abstract; }
139
140  // isRecursive - True if the type graph contains a cycle.
141  //
142  inline bool isRecursive() const { return Recursive; }
143
144  // isLosslesslyConvertableTo - Return true if this type can be converted to
145  // 'Ty' without any reinterpretation of bits.  For example, uint to int.
146  //
147  bool isLosslesslyConvertableTo(const Type *Ty) const;
148
149  // isSized - Return true if it makes sense to take the size of this type.  To
150  // get the actual size for a particular target, it is reasonable to use the
151  // TargetData subsystem to do this.
152  //
153  bool isSized() const {
154    return ID != TypeTyID && ID != FunctionTyID && ID != OpaqueTyID;
155  }
156
157  //===--------------------------------------------------------------------===//
158  // Type Iteration support
159  //
160  class TypeIterator;
161  typedef TypeIterator subtype_iterator;
162  inline subtype_iterator subtype_begin() const;   // DEFINED BELOW
163  inline subtype_iterator subtype_end() const;     // DEFINED BELOW
164
165  // getContainedType - This method is used to implement the type iterator
166  // (defined a the end of the file).  For derived types, this returns the types
167  // 'contained' in the derived type, returning 0 when 'i' becomes invalid. This
168  // allows the user to iterate over the types in a struct, for example, really
169  // easily.
170  //
171  virtual const Type *getContainedType(unsigned i) const { return 0; }
172
173  // getNumContainedTypes - Return the number of types in the derived type
174  virtual unsigned getNumContainedTypes() const { return 0; }
175
176  //===--------------------------------------------------------------------===//
177  // Static members exported by the Type class itself.  Useful for getting
178  // instances of Type.
179  //
180
181  // getPrimitiveType/getUniqueIDType - Return a type based on an identifier.
182  static const Type *getPrimitiveType(PrimitiveID IDNumber);
183  static const Type *getUniqueIDType(unsigned UID);
184
185  //===--------------------------------------------------------------------===//
186  // These are the builtin types that are always available...
187  //
188  static Type *VoidTy , *BoolTy;
189  static Type *SByteTy, *UByteTy,
190              *ShortTy, *UShortTy,
191              *IntTy  , *UIntTy,
192              *LongTy , *ULongTy;
193  static Type *FloatTy, *DoubleTy;
194
195  static Type *TypeTy , *LabelTy;
196
197  // Here are some useful little methods to query what type derived types are
198  // Note that all other types can just compare to see if this == Type::xxxTy;
199  //
200  inline bool isPrimitiveType() const { return ID < FirstDerivedTyID;  }
201  inline bool isDerivedType()   const { return ID >= FirstDerivedTyID; }
202
203  // isFirstClassType - Return true if the value is holdable in a register.
204  inline bool isFirstClassType() const {
205    return isPrimitiveType() || ID == PointerTyID;
206  }
207
208  // Methods for support type inquiry through isa, cast, and dyn_cast:
209  static inline bool classof(const Type *T) { return true; }
210  static inline bool classof(const Value *V) {
211    return V->getValueType() == Value::TypeVal;
212  }
213
214  // Methods for determining the subtype of this Type. This section defines a
215  // family of isArrayType(), isLabelType(),  etc functions...
216  //
217#define HANDLE_PRIM_TYPE(NAME, SIZE)                                      \
218  inline bool is##NAME##Type() const { return ID == NAME##TyID; }
219#define HANDLE_DERV_TYPE(NAME, CLASS)                                     \
220  inline bool is##NAME##Type() const { return ID == NAME##TyID; }
221
222#include "llvm/Type.def"
223
224private:
225  class TypeIterator : public std::bidirectional_iterator<const Type,
226		                                          ptrdiff_t> {
227    const Type * const Ty;
228    unsigned Idx;
229
230    typedef TypeIterator _Self;
231  public:
232    inline TypeIterator(const Type *ty, unsigned idx) : Ty(ty), Idx(idx) {}
233    inline ~TypeIterator() {}
234
235    inline bool operator==(const _Self& x) const { return Idx == x.Idx; }
236    inline bool operator!=(const _Self& x) const { return !operator==(x); }
237
238    inline pointer operator*() const { return Ty->getContainedType(Idx); }
239    inline pointer operator->() const { return operator*(); }
240
241    inline _Self& operator++() { ++Idx; return *this; } // Preincrement
242    inline _Self operator++(int) { // Postincrement
243      _Self tmp = *this; ++*this; return tmp;
244    }
245
246    inline _Self& operator--() { --Idx; return *this; }  // Predecrement
247    inline _Self operator--(int) { // Postdecrement
248      _Self tmp = *this; --*this; return tmp;
249    }
250  };
251};
252
253inline Type::TypeIterator Type::subtype_begin() const {
254  return TypeIterator(this, 0);
255}
256
257inline Type::TypeIterator Type::subtype_end() const {
258  return TypeIterator(this, getNumContainedTypes());
259}
260
261
262// Provide specializations of GraphTraits to be able to treat a type as a
263// graph of sub types...
264
265template <> struct GraphTraits<Type*> {
266  typedef Type NodeType;
267  typedef Type::subtype_iterator ChildIteratorType;
268
269  static inline NodeType *getEntryNode(Type *T) { return T; }
270  static inline ChildIteratorType child_begin(NodeType *N) {
271    return N->subtype_begin();
272  }
273  static inline ChildIteratorType child_end(NodeType *N) {
274    return N->subtype_end();
275  }
276};
277
278template <> struct GraphTraits<const Type*> {
279  typedef const Type NodeType;
280  typedef Type::subtype_iterator ChildIteratorType;
281
282  static inline NodeType *getEntryNode(const Type *T) { return T; }
283  static inline ChildIteratorType child_begin(NodeType *N) {
284    return N->subtype_begin();
285  }
286  static inline ChildIteratorType child_end(NodeType *N) {
287    return N->subtype_end();
288  }
289};
290
291#endif
292