-
-
Notifications
You must be signed in to change notification settings - Fork 258
/
irtype.h
190 lines (153 loc) · 4.68 KB
/
irtype.h
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
//===-- ir/irtype.h - IrType base and primitive types -----------*- C++ -*-===//
//
// LDC – the LLVM D compiler
//
// This file is distributed under the BSD-style LDC license. See the LICENSE
// file for details.
//
//===----------------------------------------------------------------------===//
//
// The types derived from IrType are used to attach LLVM type information and
// other codegen metadata (e.g. for vtbl resolution) to frontend Types.
//
//===----------------------------------------------------------------------===//
#ifndef __LDC_IR_IRTYPE_H__
#define __LDC_IR_IRTYPE_H__
#include "ir/irfuncty.h"
//////////////////////////////////////////////////////////////////////////////
// forward declarations
namespace llvm {
class LLVMContext;
class Type;
}
class Type;
class IrTypeAggr;
class IrTypeArray;
class IrTypeBasic;
class IrTypeClass;
class IrTypeDelegate;
class IrTypeFunction;
class IrTypePointer;
class IrTypeSArray;
class IrTypeStruct;
class IrTypeVector;
//////////////////////////////////////////////////////////////////////////////
/// Code generation state/metadata for D types. The mapping from IrType to
/// Type is injective but not surjective.
///
/// Derived classes should be created using their static get() methods, which
/// makes sure that uniqueness is preserved in the face of forward references.
///
/// Note that the get() methods expect the IrType of the passed type/symbol not
/// to be set yet. Another option would be to just return the existing IrType
/// in such cases. This would bring the API more in line with the llvm::Type
/// get() functions. Currently all clients use the DtoType() wrapper anyway
/// instead of directly handling IrType instances, so keeping the assertions
/// allows us to check for any uniqueness violations that might have slipped
/// through.
// TODO: Implement the described changes (now that the forward reference
// handling logic seems to work correctly) and get rid of the "no-op" DtoType
// calls in IrAggr, ... that only exist for their side effect.
class IrType {
public:
virtual ~IrType() = default;
///
virtual IrTypeAggr *isAggr() { return nullptr; }
///
virtual IrTypeArray *isArray() { return nullptr; }
///
virtual IrTypeBasic *isBasic() { return nullptr; }
///
virtual IrTypeClass *isClass() { return nullptr; }
///
virtual IrTypeDelegate *isDelegate() { return nullptr; }
///
virtual IrTypeFunction *isFunction() { return nullptr; }
///
virtual IrTypePointer *isPointer() { return nullptr; }
///
virtual IrTypeSArray *isSArray() { return nullptr; }
///
virtual IrTypeStruct *isStruct() { return nullptr; }
///
virtual IrTypeVector *isVector() { return nullptr; }
///
Type *getDType() { return dtype; }
///
virtual llvm::Type *getLLType() { return type; }
///
virtual IrFuncTy &getIrFuncTy();
protected:
///
IrType(Type *dt, llvm::Type *lt);
///
Type *dtype = nullptr;
/// LLVM type.
llvm::Type *type = nullptr;
};
//////////////////////////////////////////////////////////////////////////////
/// IrType for basic D types.
class IrTypeBasic : public IrType {
public:
///
static IrTypeBasic *get(Type *dt);
///
IrTypeBasic *isBasic() override { return this; }
protected:
///
explicit IrTypeBasic(Type *dt);
///
static llvm::Type *getComplexType(llvm::LLVMContext &ctx, llvm::Type *type);
///
static llvm::Type *basic2llvm(Type *t);
};
//////////////////////////////////////////////////////////////////////////////
/// IrType from pointers.
class IrTypePointer : public IrType {
public:
///
static IrTypePointer *get(Type *dt);
///
IrTypePointer *isPointer() override { return this; }
protected:
///
IrTypePointer(Type *dt, llvm::Type *lt);
};
//////////////////////////////////////////////////////////////////////////////
/// IrType for static arrays
class IrTypeSArray : public IrType {
public:
///
static IrTypeSArray *get(Type *dt);
///
IrTypeSArray *isSArray() override { return this; }
protected:
///
IrTypeSArray(Type *dt, LLType *lt);
};
//////////////////////////////////////////////////////////////////////////////
/// IrType for dynamic arrays
class IrTypeArray : public IrType {
public:
///
static IrTypeArray *get(Type *dt);
///
IrTypeArray *isArray() override { return this; }
protected:
///
IrTypeArray(Type *dt, llvm::Type *lt);
};
//////////////////////////////////////////////////////////////////////////////
/// IrType for vectors
class IrTypeVector : public IrType {
public:
///
static IrTypeVector *get(Type *dt);
///
IrTypeVector *isVector() override { return this; }
protected:
///
explicit IrTypeVector(Type *dt, llvm::Type *lt);
static llvm::Type *vector2llvm(Type *dt);
};
#endif