|
0
|
1 /*
|
|
|
2 * Copyright 1999-2005 Sun Microsystems, Inc. All Rights Reserved.
|
|
|
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
|
4 *
|
|
|
5 * This code is free software; you can redistribute it and/or modify it
|
|
|
6 * under the terms of the GNU General Public License version 2 only, as
|
|
|
7 * published by the Free Software Foundation.
|
|
|
8 *
|
|
|
9 * This code is distributed in the hope that it will be useful, but WITHOUT
|
|
|
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
12 * version 2 for more details (a copy is included in the LICENSE file that
|
|
|
13 * accompanied this code).
|
|
|
14 *
|
|
|
15 * You should have received a copy of the GNU General Public License version
|
|
|
16 * 2 along with this work; if not, write to the Free Software Foundation,
|
|
|
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
18 *
|
|
|
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
|
|
20 * CA 95054 USA or visit www.sun.com if you need additional information or
|
|
|
21 * have any questions.
|
|
|
22 *
|
|
|
23 */
|
|
|
24
|
|
|
25 // type hierarchy
|
|
|
26 class ValueType;
|
|
|
27 class VoidType;
|
|
|
28 class IntType;
|
|
|
29 class IntConstant;
|
|
|
30 class IntInterval;
|
|
|
31 class LongType;
|
|
|
32 class LongConstant;
|
|
|
33 class FloatType;
|
|
|
34 class FloatConstant;
|
|
|
35 class DoubleType;
|
|
|
36 class DoubleConstant;
|
|
|
37 class ObjectType;
|
|
|
38 class ObjectConstant;
|
|
|
39 class ArrayType;
|
|
|
40 class ArrayConstant;
|
|
|
41 class InstanceType;
|
|
|
42 class InstanceConstant;
|
|
|
43 class ClassType;
|
|
|
44 class ClassConstant;
|
|
|
45 class AddressType;
|
|
|
46 class AddressConstant;
|
|
|
47 class IllegalType;
|
|
|
48
|
|
|
49
|
|
|
50 // predefined types
|
|
|
51 extern VoidType* voidType;
|
|
|
52 extern IntType* intType;
|
|
|
53 extern LongType* longType;
|
|
|
54 extern FloatType* floatType;
|
|
|
55 extern DoubleType* doubleType;
|
|
|
56 extern ObjectType* objectType;
|
|
|
57 extern ArrayType* arrayType;
|
|
|
58 extern InstanceType* instanceType;
|
|
|
59 extern ClassType* classType;
|
|
|
60 extern AddressType* addressType;
|
|
|
61 extern IllegalType* illegalType;
|
|
|
62
|
|
|
63
|
|
|
64 // predefined constants
|
|
|
65 extern IntConstant* intZero;
|
|
|
66 extern IntConstant* intOne;
|
|
|
67 extern ObjectConstant* objectNull;
|
|
|
68
|
|
|
69
|
|
|
70 // tags
|
|
|
71 enum ValueTag {
|
|
|
72 // all legal tags must come first
|
|
|
73 intTag,
|
|
|
74 longTag,
|
|
|
75 floatTag,
|
|
|
76 doubleTag,
|
|
|
77 objectTag,
|
|
|
78 addressTag,
|
|
|
79 number_of_legal_tags,
|
|
|
80 // all other tags must follow afterwards
|
|
|
81 voidTag = number_of_legal_tags,
|
|
|
82 illegalTag,
|
|
|
83 number_of_tags
|
|
|
84 };
|
|
|
85
|
|
|
86
|
|
|
87 class ValueType: public CompilationResourceObj {
|
|
|
88 private:
|
|
|
89 const int _size;
|
|
|
90 const ValueTag _tag;
|
|
|
91 ValueType();
|
|
|
92 protected:
|
|
|
93 ValueType(ValueTag tag, int size): _tag(tag), _size(size) {}
|
|
|
94
|
|
|
95 public:
|
|
|
96 // initialization
|
|
|
97 static void initialize();
|
|
|
98
|
|
|
99 // accessors
|
|
|
100 virtual ValueType* base() const = 0; // the 'canonical' type (e.g., intType for an IntConstant)
|
|
|
101 ValueTag tag() const { return _tag; } // the 'canonical' tag (useful for type matching)
|
|
|
102 int size() const { // the size of an object of the type in words
|
|
|
103 assert(_size > -1, "shouldn't be asking for size");
|
|
|
104 return _size;
|
|
|
105 }
|
|
|
106 virtual const char tchar() const = 0; // the type 'character' for printing
|
|
|
107 virtual const char* name() const = 0; // the type name for printing
|
|
|
108 virtual bool is_constant() const { return false; }
|
|
|
109
|
|
|
110 // testers
|
|
|
111 bool is_void() { return tag() == voidTag; }
|
|
|
112 bool is_int() { return tag() == intTag; }
|
|
|
113 bool is_long() { return tag() == longTag; }
|
|
|
114 bool is_float() { return tag() == floatTag; }
|
|
|
115 bool is_double() { return tag() == doubleTag; }
|
|
|
116 bool is_object() { return as_ObjectType() != NULL; }
|
|
|
117 bool is_array() { return as_ArrayType() != NULL; }
|
|
|
118 bool is_instance() { return as_InstanceType() != NULL; }
|
|
|
119 bool is_class() { return as_ClassType() != NULL; }
|
|
|
120 bool is_address() { return as_AddressType() != NULL; }
|
|
|
121 bool is_illegal() { return tag() == illegalTag; }
|
|
|
122
|
|
|
123 bool is_int_kind() const { return tag() == intTag || tag() == longTag; }
|
|
|
124 bool is_float_kind() const { return tag() == floatTag || tag() == doubleTag; }
|
|
|
125 bool is_object_kind() const { return tag() == objectTag; }
|
|
|
126
|
|
|
127 bool is_single_word() const { return _size == 1; }
|
|
|
128 bool is_double_word() const { return _size == 2; }
|
|
|
129
|
|
|
130 // casting
|
|
|
131 virtual VoidType* as_VoidType() { return NULL; }
|
|
|
132 virtual IntType* as_IntType() { return NULL; }
|
|
|
133 virtual LongType* as_LongType() { return NULL; }
|
|
|
134 virtual FloatType* as_FloatType() { return NULL; }
|
|
|
135 virtual DoubleType* as_DoubleType() { return NULL; }
|
|
|
136 virtual ObjectType* as_ObjectType() { return NULL; }
|
|
|
137 virtual ArrayType* as_ArrayType() { return NULL; }
|
|
|
138 virtual InstanceType* as_InstanceType() { return NULL; }
|
|
|
139 virtual ClassType* as_ClassType() { return NULL; }
|
|
|
140 virtual AddressType* as_AddressType() { return NULL; }
|
|
|
141 virtual IllegalType* as_IllegalType() { return NULL; }
|
|
|
142
|
|
|
143 virtual IntConstant* as_IntConstant() { return NULL; }
|
|
|
144 virtual LongConstant* as_LongConstant() { return NULL; }
|
|
|
145 virtual FloatConstant* as_FloatConstant() { return NULL; }
|
|
|
146 virtual DoubleConstant* as_DoubleConstant() { return NULL; }
|
|
|
147 virtual ObjectConstant* as_ObjectConstant() { return NULL; }
|
|
|
148 virtual InstanceConstant* as_InstanceConstant(){ return NULL; }
|
|
|
149 virtual ClassConstant* as_ClassConstant() { return NULL; }
|
|
|
150 virtual ArrayConstant* as_ArrayConstant() { return NULL; }
|
|
|
151 virtual AddressConstant* as_AddressConstant() { return NULL; }
|
|
|
152
|
|
|
153 // type operations
|
|
|
154 ValueType* meet(ValueType* y) const;
|
|
|
155 ValueType* join(ValueType* y) const;
|
|
|
156
|
|
|
157 // debugging
|
|
|
158 void print(outputStream* s = tty) { s->print(name()); }
|
|
|
159 };
|
|
|
160
|
|
|
161
|
|
|
162 class VoidType: public ValueType {
|
|
|
163 public:
|
|
|
164 VoidType(): ValueType(voidTag, 0) {}
|
|
|
165 virtual ValueType* base() const { return voidType; }
|
|
|
166 virtual const char tchar() const { return 'v'; }
|
|
|
167 virtual const char* name() const { return "void"; }
|
|
|
168 virtual VoidType* as_VoidType() { return this; }
|
|
|
169 };
|
|
|
170
|
|
|
171
|
|
|
172 class IntType: public ValueType {
|
|
|
173 public:
|
|
|
174 IntType(): ValueType(intTag, 1) {}
|
|
|
175 virtual ValueType* base() const { return intType; }
|
|
|
176 virtual const char tchar() const { return 'i'; }
|
|
|
177 virtual const char* name() const { return "int"; }
|
|
|
178 virtual IntType* as_IntType() { return this; }
|
|
|
179 };
|
|
|
180
|
|
|
181
|
|
|
182 class IntConstant: public IntType {
|
|
|
183 private:
|
|
|
184 jint _value;
|
|
|
185
|
|
|
186 public:
|
|
|
187 IntConstant(jint value) { _value = value; }
|
|
|
188
|
|
|
189 jint value() const { return _value; }
|
|
|
190
|
|
|
191 virtual bool is_constant() const { return true; }
|
|
|
192 virtual IntConstant* as_IntConstant() { return this; }
|
|
|
193 };
|
|
|
194
|
|
|
195
|
|
|
196 class IntInterval: public IntType {
|
|
|
197 private:
|
|
|
198 jint _beg;
|
|
|
199 jint _end;
|
|
|
200
|
|
|
201 public:
|
|
|
202 IntInterval(jint beg, jint end) {
|
|
|
203 assert(beg <= end, "illegal interval");
|
|
|
204 _beg = beg;
|
|
|
205 _end = end;
|
|
|
206 }
|
|
|
207
|
|
|
208 jint beg() const { return _beg; }
|
|
|
209 jint end() const { return _end; }
|
|
|
210
|
|
|
211 virtual bool is_interval() const { return true; }
|
|
|
212 };
|
|
|
213
|
|
|
214
|
|
|
215 class LongType: public ValueType {
|
|
|
216 public:
|
|
|
217 LongType(): ValueType(longTag, 2) {}
|
|
|
218 virtual ValueType* base() const { return longType; }
|
|
|
219 virtual const char tchar() const { return 'l'; }
|
|
|
220 virtual const char* name() const { return "long"; }
|
|
|
221 virtual LongType* as_LongType() { return this; }
|
|
|
222 };
|
|
|
223
|
|
|
224
|
|
|
225 class LongConstant: public LongType {
|
|
|
226 private:
|
|
|
227 jlong _value;
|
|
|
228
|
|
|
229 public:
|
|
|
230 LongConstant(jlong value) { _value = value; }
|
|
|
231
|
|
|
232 jlong value() const { return _value; }
|
|
|
233
|
|
|
234 virtual bool is_constant() const { return true; }
|
|
|
235 virtual LongConstant* as_LongConstant() { return this; }
|
|
|
236 };
|
|
|
237
|
|
|
238
|
|
|
239 class FloatType: public ValueType {
|
|
|
240 public:
|
|
|
241 FloatType(): ValueType(floatTag, 1) {}
|
|
|
242 virtual ValueType* base() const { return floatType; }
|
|
|
243 virtual const char tchar() const { return 'f'; }
|
|
|
244 virtual const char* name() const { return "float"; }
|
|
|
245 virtual FloatType* as_FloatType() { return this; }
|
|
|
246 };
|
|
|
247
|
|
|
248
|
|
|
249 class FloatConstant: public FloatType {
|
|
|
250 private:
|
|
|
251 jfloat _value;
|
|
|
252
|
|
|
253 public:
|
|
|
254 FloatConstant(jfloat value) { _value = value; }
|
|
|
255
|
|
|
256 jfloat value() const { return _value; }
|
|
|
257
|
|
|
258 virtual bool is_constant() const { return true; }
|
|
|
259 virtual FloatConstant* as_FloatConstant() { return this; }
|
|
|
260 };
|
|
|
261
|
|
|
262
|
|
|
263 class DoubleType: public ValueType {
|
|
|
264 public:
|
|
|
265 DoubleType(): ValueType(doubleTag, 2) {}
|
|
|
266 virtual ValueType* base() const { return doubleType; }
|
|
|
267 virtual const char tchar() const { return 'd'; }
|
|
|
268 virtual const char* name() const { return "double"; }
|
|
|
269 virtual DoubleType* as_DoubleType() { return this; }
|
|
|
270 };
|
|
|
271
|
|
|
272
|
|
|
273 class DoubleConstant: public DoubleType {
|
|
|
274 private:
|
|
|
275 jdouble _value;
|
|
|
276
|
|
|
277 public:
|
|
|
278 DoubleConstant(jdouble value) { _value = value; }
|
|
|
279
|
|
|
280 jdouble value() const { return _value; }
|
|
|
281
|
|
|
282 virtual bool is_constant() const { return true; }
|
|
|
283 virtual DoubleConstant* as_DoubleConstant() { return this; }
|
|
|
284 };
|
|
|
285
|
|
|
286
|
|
|
287 class ObjectType: public ValueType {
|
|
|
288 public:
|
|
|
289 ObjectType(): ValueType(objectTag, 1) {}
|
|
|
290 virtual ValueType* base() const { return objectType; }
|
|
|
291 virtual const char tchar() const { return 'a'; }
|
|
|
292 virtual const char* name() const { return "object"; }
|
|
|
293 virtual ObjectType* as_ObjectType() { return this; }
|
|
|
294 virtual ciObject* constant_value() const { ShouldNotReachHere(); return NULL; }
|
|
|
295 bool is_loaded() const;
|
|
|
296 jobject encoding() const;
|
|
|
297 };
|
|
|
298
|
|
|
299
|
|
|
300 class ObjectConstant: public ObjectType {
|
|
|
301 private:
|
|
|
302 ciObject* _value;
|
|
|
303
|
|
|
304 public:
|
|
|
305 ObjectConstant(ciObject* value) { _value = value; }
|
|
|
306
|
|
|
307 ciObject* value() const { return _value; }
|
|
|
308
|
|
|
309 virtual bool is_constant() const { return true; }
|
|
|
310 virtual ObjectConstant* as_ObjectConstant() { return this; }
|
|
|
311 virtual ciObject* constant_value() const;
|
|
|
312 };
|
|
|
313
|
|
|
314
|
|
|
315 class ArrayType: public ObjectType {
|
|
|
316 public:
|
|
|
317 virtual ArrayType* as_ArrayType() { return this; }
|
|
|
318 };
|
|
|
319
|
|
|
320
|
|
|
321 class ArrayConstant: public ArrayType {
|
|
|
322 private:
|
|
|
323 ciArray* _value;
|
|
|
324
|
|
|
325 public:
|
|
|
326 ArrayConstant(ciArray* value) { _value = value; }
|
|
|
327
|
|
|
328 ciArray* value() const { return _value; }
|
|
|
329
|
|
|
330 virtual bool is_constant() const { return true; }
|
|
|
331
|
|
|
332 virtual ArrayConstant* as_ArrayConstant() { return this; }
|
|
|
333 virtual ciObject* constant_value() const;
|
|
|
334 };
|
|
|
335
|
|
|
336
|
|
|
337 class InstanceType: public ObjectType {
|
|
|
338 public:
|
|
|
339 virtual InstanceType* as_InstanceType() { return this; }
|
|
|
340 };
|
|
|
341
|
|
|
342
|
|
|
343 class InstanceConstant: public InstanceType {
|
|
|
344 private:
|
|
|
345 ciInstance* _value;
|
|
|
346
|
|
|
347 public:
|
|
|
348 InstanceConstant(ciInstance* value) { _value = value; }
|
|
|
349
|
|
|
350 ciInstance* value() const { return _value; }
|
|
|
351
|
|
|
352 virtual bool is_constant() const { return true; }
|
|
|
353
|
|
|
354 virtual InstanceConstant* as_InstanceConstant(){ return this; }
|
|
|
355 virtual ciObject* constant_value() const;
|
|
|
356 };
|
|
|
357
|
|
|
358
|
|
|
359 class ClassType: public ObjectType {
|
|
|
360 public:
|
|
|
361 virtual ClassType* as_ClassType() { return this; }
|
|
|
362 };
|
|
|
363
|
|
|
364
|
|
|
365 class ClassConstant: public ClassType {
|
|
|
366 private:
|
|
|
367 ciInstanceKlass* _value;
|
|
|
368
|
|
|
369 public:
|
|
|
370 ClassConstant(ciInstanceKlass* value) { _value = value; }
|
|
|
371
|
|
|
372 ciInstanceKlass* value() const { return _value; }
|
|
|
373
|
|
|
374 virtual bool is_constant() const { return true; }
|
|
|
375
|
|
|
376 virtual ClassConstant* as_ClassConstant() { return this; }
|
|
|
377 virtual ciObject* constant_value() const;
|
|
|
378 };
|
|
|
379
|
|
|
380
|
|
|
381 class AddressType: public ValueType {
|
|
|
382 public:
|
|
|
383 AddressType(): ValueType(addressTag, 1) {}
|
|
|
384 virtual ValueType* base() const { return addressType; }
|
|
|
385 virtual const char tchar() const { return 'r'; }
|
|
|
386 virtual const char* name() const { return "address"; }
|
|
|
387 virtual AddressType* as_AddressType() { return this; }
|
|
|
388 };
|
|
|
389
|
|
|
390
|
|
|
391 class AddressConstant: public AddressType {
|
|
|
392 private:
|
|
|
393 jint _value;
|
|
|
394
|
|
|
395 public:
|
|
|
396 AddressConstant(jint value) { _value = value; }
|
|
|
397
|
|
|
398 jint value() const { return _value; }
|
|
|
399
|
|
|
400 virtual bool is_constant() const { return true; }
|
|
|
401
|
|
|
402 virtual AddressConstant* as_AddressConstant() { return this; }
|
|
|
403 };
|
|
|
404
|
|
|
405
|
|
|
406 class IllegalType: public ValueType {
|
|
|
407 public:
|
|
|
408 IllegalType(): ValueType(illegalTag, -1) {}
|
|
|
409 virtual ValueType* base() const { return illegalType; }
|
|
|
410 virtual const char tchar() const { return ' '; }
|
|
|
411 virtual const char* name() const { return "illegal"; }
|
|
|
412 virtual IllegalType* as_IllegalType() { return this; }
|
|
|
413 };
|
|
|
414
|
|
|
415
|
|
|
416 // conversion between ValueTypes, BasicTypes, and ciConstants
|
|
|
417 ValueType* as_ValueType(BasicType type);
|
|
|
418 ValueType* as_ValueType(ciConstant value);
|
|
|
419 BasicType as_BasicType(ValueType* type);
|
|
|
420
|
|
|
421 inline ValueType* as_ValueType(ciType* type) { return as_ValueType(type->basic_type()); }
|
