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
|
//===-- 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"
class ConstRules;
class ConstPoolVal;
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 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; }
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 ConstRules *getConstRules() const { return ConstRulesImpl; }
inline void setConstRules(const 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 bool isMethodType() const { return ID == MethodTyID; }
inline bool isModuleType() const { return ID == ModuleTyID; }
inline bool isArrayType() const { return ID == ArrayTyID; }
inline bool isPointerType() const { return ID == PointerTyID; }
inline bool isStructType() const { return ID == StructTyID; }
};
#endif
|
