1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
//===-- llvm/Type.h - Classes for handling data types ------------*- C++ -*--=//
//
// This file contains the declaration of the Type class. For more "Type" type
// stuff, look in DerivedTypes.h and Opt/ConstantHandling.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
// doing a trivial pointer comparison.
//
// Types, once allocated, are never free'd.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TYPE_H
#define LLVM_TYPE_H
#include "llvm/Value.h"
namespace opt {
class ConstRules;
}
class ConstPoolVal;
class MethodType;
class ArrayType;
class StructType;
class PointerType;
class Type : public Value {
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
// Type::getPrimitiveType function, or else things will break!
//
enum PrimitiveID {
VoidTyID = 0 , BoolTyID, // 0, 1: Basics...
UByteTyID , SByteTyID, // 2, 3: 8 bit types...
UShortTyID , ShortTyID, // 4, 5: 16 bit types...
UIntTyID , IntTyID, // 6, 7: 32 bit types...
ULongTyID , LongTyID, // 8, 9: 64 bit types...
FloatTyID , DoubleTyID, // 10,11: Floating point types...
TypeTyID, // 12 : Type definitions
LabelTyID , LockTyID, // 13,14: Labels... mutexes...
// TODO: Kill FillerTyID. It just makes FirstDerivedTyID = 0x10
FillerTyID , // 15 : filler
// Derived types... see DerivedTypes.h file...
// Make sure FirstDerivedTyID stays up to date!!!
MethodTyID , ModuleTyID, // Methods... Modules...
ArrayTyID , PointerTyID, // Array... pointer...
StructTyID , PackedTyID, // Structure... SIMD 'packed' format...
//...
NumPrimitiveIDs, // Must remain as last defined ID
FirstDerivedTyID = MethodTyID,
};
private:
PrimitiveID ID; // The current base type of this type...
unsigned UID; // The unique ID number for this class
// ConstRulesImpl - See Opt/ConstantHandling.h for more info
mutable const opt::ConstRules *ConstRulesImpl;
protected:
// ctor is protected, so only subclasses can create Type objects...
Type(const string &Name, PrimitiveID id);
public:
virtual ~Type() {}
// isSigned - Return whether a numeric type is signed.
virtual bool isSigned() const { return 0; }
// 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.
//
virtual bool isUnsigned() const { return 0; }
// isIntegral - Equilivent to isSigned() || isUnsigned, but with only a single
// virtual function invocation.
//
virtual bool isIntegral() const { return 0; }
inline unsigned getUniqueID() const { return UID; }
inline PrimitiveID getPrimitiveID() const { return ID; }
// getPrimitiveType/getUniqueIDType - Return a type based on an identifier.
static const Type *getPrimitiveType(PrimitiveID IDNumber);
static const Type *getUniqueIDType(unsigned UID);
// Methods for dealing with constants uniformly. See Opt/ConstantHandling.h
// for more info on this...
//
inline const opt::ConstRules *getConstRules() const { return ConstRulesImpl; }
inline void setConstRules(const opt::ConstRules *R) const { ConstRulesImpl = R; }
public: // These are the builtin types that are always available...
static const Type *VoidTy , *BoolTy;
static const Type *SByteTy, *UByteTy,
*ShortTy, *UShortTy,
*IntTy , *UIntTy,
*LongTy , *ULongTy;
static const Type *FloatTy, *DoubleTy;
static const Type *TypeTy , *LabelTy, *LockTy;
// Here are some useful little methods to query what type derived types are
// Note that all other types can just compare to see if this == Type::xxxTy;
//
inline bool isDerivedType() const { return ID >= FirstDerivedTyID; }
inline bool isPrimitiveType() const { return ID < FirstDerivedTyID; }
inline bool isLabelType() const { return this == LabelTy; }
inline const MethodType *isMethodType() const {
return ID == MethodTyID ? (const MethodType*)this : 0;
}
inline bool isModuleType() const { return ID == ModuleTyID; }
inline const ArrayType *isArrayType() const {
return ID == ArrayTyID ? (const ArrayType*)this : 0;
}
inline const PointerType *isPointerType() const {
return ID == PointerTyID ? (const PointerType*)this : 0;
}
inline const StructType *isStructType() const {
return ID == StructTyID ? (const StructType*)this : 0;
}
};
#endif
|
