Mercurial > hg > truffle
annotate src/share/vm/c1/c1_ValueType.hpp @ 5073:2db1ad9dd385
rename PiNode.value to PiNode.object and UnsafeCastNode.x to UnsafeCastNode.object
author | Lukas Stadler <lukas.stadler@jku.at> |
---|---|
date | Wed, 14 Mar 2012 16:57:18 +0100 |
parents | f95d63e2154a |
children | 1d7922586cf6 |
rev | line source |
---|---|
0 | 1 /* |
1972 | 2 * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved. |
0 | 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 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #ifndef SHARE_VM_C1_C1_VALUETYPE_HPP |
26 #define SHARE_VM_C1_C1_VALUETYPE_HPP | |
27 | |
28 #include "c1/c1_Compilation.hpp" | |
29 #include "ci/ciConstant.hpp" | |
30 | |
0 | 31 // type hierarchy |
32 class ValueType; | |
33 class VoidType; | |
34 class IntType; | |
35 class IntConstant; | |
36 class IntInterval; | |
37 class LongType; | |
38 class LongConstant; | |
39 class FloatType; | |
40 class FloatConstant; | |
41 class DoubleType; | |
42 class DoubleConstant; | |
43 class ObjectType; | |
44 class ObjectConstant; | |
45 class ArrayType; | |
46 class ArrayConstant; | |
47 class InstanceType; | |
48 class InstanceConstant; | |
49 class ClassType; | |
50 class ClassConstant; | |
51 class AddressType; | |
52 class AddressConstant; | |
53 class IllegalType; | |
54 | |
55 | |
56 // predefined types | |
57 extern VoidType* voidType; | |
58 extern IntType* intType; | |
59 extern LongType* longType; | |
60 extern FloatType* floatType; | |
61 extern DoubleType* doubleType; | |
62 extern ObjectType* objectType; | |
63 extern ArrayType* arrayType; | |
64 extern InstanceType* instanceType; | |
65 extern ClassType* classType; | |
66 extern AddressType* addressType; | |
67 extern IllegalType* illegalType; | |
68 | |
69 | |
70 // predefined constants | |
71 extern IntConstant* intZero; | |
72 extern IntConstant* intOne; | |
73 extern ObjectConstant* objectNull; | |
74 | |
75 | |
76 // tags | |
77 enum ValueTag { | |
78 // all legal tags must come first | |
79 intTag, | |
80 longTag, | |
81 floatTag, | |
82 doubleTag, | |
83 objectTag, | |
84 addressTag, | |
85 number_of_legal_tags, | |
86 // all other tags must follow afterwards | |
87 voidTag = number_of_legal_tags, | |
88 illegalTag, | |
89 number_of_tags | |
90 }; | |
91 | |
92 | |
93 class ValueType: public CompilationResourceObj { | |
94 private: | |
95 const int _size; | |
96 const ValueTag _tag; | |
97 ValueType(); | |
98 protected: | |
99 ValueType(ValueTag tag, int size): _tag(tag), _size(size) {} | |
100 | |
101 public: | |
102 // initialization | |
1584 | 103 static void initialize(Arena* arena); |
0 | 104 |
105 // accessors | |
106 virtual ValueType* base() const = 0; // the 'canonical' type (e.g., intType for an IntConstant) | |
107 ValueTag tag() const { return _tag; } // the 'canonical' tag (useful for type matching) | |
108 int size() const { // the size of an object of the type in words | |
109 assert(_size > -1, "shouldn't be asking for size"); | |
110 return _size; | |
111 } | |
112 virtual const char tchar() const = 0; // the type 'character' for printing | |
113 virtual const char* name() const = 0; // the type name for printing | |
114 virtual bool is_constant() const { return false; } | |
115 | |
116 // testers | |
117 bool is_void() { return tag() == voidTag; } | |
118 bool is_int() { return tag() == intTag; } | |
119 bool is_long() { return tag() == longTag; } | |
120 bool is_float() { return tag() == floatTag; } | |
121 bool is_double() { return tag() == doubleTag; } | |
122 bool is_object() { return as_ObjectType() != NULL; } | |
123 bool is_array() { return as_ArrayType() != NULL; } | |
124 bool is_instance() { return as_InstanceType() != NULL; } | |
125 bool is_class() { return as_ClassType() != NULL; } | |
126 bool is_address() { return as_AddressType() != NULL; } | |
127 bool is_illegal() { return tag() == illegalTag; } | |
128 | |
129 bool is_int_kind() const { return tag() == intTag || tag() == longTag; } | |
130 bool is_float_kind() const { return tag() == floatTag || tag() == doubleTag; } | |
131 bool is_object_kind() const { return tag() == objectTag; } | |
132 | |
133 bool is_single_word() const { return _size == 1; } | |
134 bool is_double_word() const { return _size == 2; } | |
135 | |
136 // casting | |
137 virtual VoidType* as_VoidType() { return NULL; } | |
138 virtual IntType* as_IntType() { return NULL; } | |
139 virtual LongType* as_LongType() { return NULL; } | |
140 virtual FloatType* as_FloatType() { return NULL; } | |
141 virtual DoubleType* as_DoubleType() { return NULL; } | |
142 virtual ObjectType* as_ObjectType() { return NULL; } | |
143 virtual ArrayType* as_ArrayType() { return NULL; } | |
144 virtual InstanceType* as_InstanceType() { return NULL; } | |
145 virtual ClassType* as_ClassType() { return NULL; } | |
146 virtual AddressType* as_AddressType() { return NULL; } | |
147 virtual IllegalType* as_IllegalType() { return NULL; } | |
148 | |
149 virtual IntConstant* as_IntConstant() { return NULL; } | |
150 virtual LongConstant* as_LongConstant() { return NULL; } | |
151 virtual FloatConstant* as_FloatConstant() { return NULL; } | |
152 virtual DoubleConstant* as_DoubleConstant() { return NULL; } | |
153 virtual ObjectConstant* as_ObjectConstant() { return NULL; } | |
154 virtual InstanceConstant* as_InstanceConstant(){ return NULL; } | |
155 virtual ClassConstant* as_ClassConstant() { return NULL; } | |
156 virtual ArrayConstant* as_ArrayConstant() { return NULL; } | |
157 virtual AddressConstant* as_AddressConstant() { return NULL; } | |
158 | |
159 // type operations | |
160 ValueType* meet(ValueType* y) const; | |
161 ValueType* join(ValueType* y) const; | |
162 | |
163 // debugging | |
164 void print(outputStream* s = tty) { s->print(name()); } | |
165 }; | |
166 | |
167 | |
168 class VoidType: public ValueType { | |
169 public: | |
170 VoidType(): ValueType(voidTag, 0) {} | |
171 virtual ValueType* base() const { return voidType; } | |
172 virtual const char tchar() const { return 'v'; } | |
173 virtual const char* name() const { return "void"; } | |
174 virtual VoidType* as_VoidType() { return this; } | |
175 }; | |
176 | |
177 | |
178 class IntType: public ValueType { | |
179 public: | |
180 IntType(): ValueType(intTag, 1) {} | |
181 virtual ValueType* base() const { return intType; } | |
182 virtual const char tchar() const { return 'i'; } | |
183 virtual const char* name() const { return "int"; } | |
184 virtual IntType* as_IntType() { return this; } | |
185 }; | |
186 | |
187 | |
188 class IntConstant: public IntType { | |
189 private: | |
190 jint _value; | |
191 | |
192 public: | |
193 IntConstant(jint value) { _value = value; } | |
194 | |
195 jint value() const { return _value; } | |
196 | |
197 virtual bool is_constant() const { return true; } | |
198 virtual IntConstant* as_IntConstant() { return this; } | |
199 }; | |
200 | |
201 | |
202 class IntInterval: public IntType { | |
203 private: | |
204 jint _beg; | |
205 jint _end; | |
206 | |
207 public: | |
208 IntInterval(jint beg, jint end) { | |
209 assert(beg <= end, "illegal interval"); | |
210 _beg = beg; | |
211 _end = end; | |
212 } | |
213 | |
214 jint beg() const { return _beg; } | |
215 jint end() const { return _end; } | |
216 | |
217 virtual bool is_interval() const { return true; } | |
218 }; | |
219 | |
220 | |
221 class LongType: public ValueType { | |
222 public: | |
223 LongType(): ValueType(longTag, 2) {} | |
224 virtual ValueType* base() const { return longType; } | |
225 virtual const char tchar() const { return 'l'; } | |
226 virtual const char* name() const { return "long"; } | |
227 virtual LongType* as_LongType() { return this; } | |
228 }; | |
229 | |
230 | |
231 class LongConstant: public LongType { | |
232 private: | |
233 jlong _value; | |
234 | |
235 public: | |
236 LongConstant(jlong value) { _value = value; } | |
237 | |
238 jlong value() const { return _value; } | |
239 | |
240 virtual bool is_constant() const { return true; } | |
241 virtual LongConstant* as_LongConstant() { return this; } | |
242 }; | |
243 | |
244 | |
245 class FloatType: public ValueType { | |
246 public: | |
247 FloatType(): ValueType(floatTag, 1) {} | |
248 virtual ValueType* base() const { return floatType; } | |
249 virtual const char tchar() const { return 'f'; } | |
250 virtual const char* name() const { return "float"; } | |
251 virtual FloatType* as_FloatType() { return this; } | |
252 }; | |
253 | |
254 | |
255 class FloatConstant: public FloatType { | |
256 private: | |
257 jfloat _value; | |
258 | |
259 public: | |
260 FloatConstant(jfloat value) { _value = value; } | |
261 | |
262 jfloat value() const { return _value; } | |
263 | |
264 virtual bool is_constant() const { return true; } | |
265 virtual FloatConstant* as_FloatConstant() { return this; } | |
266 }; | |
267 | |
268 | |
269 class DoubleType: public ValueType { | |
270 public: | |
271 DoubleType(): ValueType(doubleTag, 2) {} | |
272 virtual ValueType* base() const { return doubleType; } | |
273 virtual const char tchar() const { return 'd'; } | |
274 virtual const char* name() const { return "double"; } | |
275 virtual DoubleType* as_DoubleType() { return this; } | |
276 }; | |
277 | |
278 | |
279 class DoubleConstant: public DoubleType { | |
280 private: | |
281 jdouble _value; | |
282 | |
283 public: | |
284 DoubleConstant(jdouble value) { _value = value; } | |
285 | |
286 jdouble value() const { return _value; } | |
287 | |
288 virtual bool is_constant() const { return true; } | |
289 virtual DoubleConstant* as_DoubleConstant() { return this; } | |
290 }; | |
291 | |
292 | |
293 class ObjectType: public ValueType { | |
294 public: | |
295 ObjectType(): ValueType(objectTag, 1) {} | |
296 virtual ValueType* base() const { return objectType; } | |
297 virtual const char tchar() const { return 'a'; } | |
298 virtual const char* name() const { return "object"; } | |
299 virtual ObjectType* as_ObjectType() { return this; } | |
300 virtual ciObject* constant_value() const { ShouldNotReachHere(); return NULL; } | |
301 bool is_loaded() const; | |
302 jobject encoding() const; | |
303 }; | |
304 | |
305 | |
306 class ObjectConstant: public ObjectType { | |
307 private: | |
308 ciObject* _value; | |
309 | |
310 public: | |
311 ObjectConstant(ciObject* value) { _value = value; } | |
312 | |
313 ciObject* value() const { return _value; } | |
314 | |
315 virtual bool is_constant() const { return true; } | |
316 virtual ObjectConstant* as_ObjectConstant() { return this; } | |
317 virtual ciObject* constant_value() const; | |
318 }; | |
319 | |
320 | |
321 class ArrayType: public ObjectType { | |
322 public: | |
323 virtual ArrayType* as_ArrayType() { return this; } | |
324 }; | |
325 | |
326 | |
327 class ArrayConstant: public ArrayType { | |
328 private: | |
329 ciArray* _value; | |
330 | |
331 public: | |
332 ArrayConstant(ciArray* value) { _value = value; } | |
333 | |
334 ciArray* value() const { return _value; } | |
335 | |
336 virtual bool is_constant() const { return true; } | |
337 | |
338 virtual ArrayConstant* as_ArrayConstant() { return this; } | |
339 virtual ciObject* constant_value() const; | |
340 }; | |
341 | |
342 | |
343 class InstanceType: public ObjectType { | |
344 public: | |
345 virtual InstanceType* as_InstanceType() { return this; } | |
346 }; | |
347 | |
348 | |
349 class InstanceConstant: public InstanceType { | |
350 private: | |
351 ciInstance* _value; | |
352 | |
353 public: | |
354 InstanceConstant(ciInstance* value) { _value = value; } | |
355 | |
356 ciInstance* value() const { return _value; } | |
357 | |
358 virtual bool is_constant() const { return true; } | |
359 | |
360 virtual InstanceConstant* as_InstanceConstant(){ return this; } | |
361 virtual ciObject* constant_value() const; | |
362 }; | |
363 | |
364 | |
365 class ClassType: public ObjectType { | |
366 public: | |
367 virtual ClassType* as_ClassType() { return this; } | |
368 }; | |
369 | |
370 | |
371 class ClassConstant: public ClassType { | |
372 private: | |
373 ciInstanceKlass* _value; | |
374 | |
375 public: | |
376 ClassConstant(ciInstanceKlass* value) { _value = value; } | |
377 | |
378 ciInstanceKlass* value() const { return _value; } | |
379 | |
380 virtual bool is_constant() const { return true; } | |
381 | |
382 virtual ClassConstant* as_ClassConstant() { return this; } | |
383 virtual ciObject* constant_value() const; | |
384 }; | |
385 | |
386 | |
387 class AddressType: public ValueType { | |
388 public: | |
389 AddressType(): ValueType(addressTag, 1) {} | |
390 virtual ValueType* base() const { return addressType; } | |
391 virtual const char tchar() const { return 'r'; } | |
392 virtual const char* name() const { return "address"; } | |
393 virtual AddressType* as_AddressType() { return this; } | |
394 }; | |
395 | |
396 | |
397 class AddressConstant: public AddressType { | |
398 private: | |
399 jint _value; | |
400 | |
401 public: | |
402 AddressConstant(jint value) { _value = value; } | |
403 | |
404 jint value() const { return _value; } | |
405 | |
406 virtual bool is_constant() const { return true; } | |
407 | |
408 virtual AddressConstant* as_AddressConstant() { return this; } | |
409 }; | |
410 | |
411 | |
412 class IllegalType: public ValueType { | |
413 public: | |
414 IllegalType(): ValueType(illegalTag, -1) {} | |
415 virtual ValueType* base() const { return illegalType; } | |
416 virtual const char tchar() const { return ' '; } | |
417 virtual const char* name() const { return "illegal"; } | |
418 virtual IllegalType* as_IllegalType() { return this; } | |
419 }; | |
420 | |
421 | |
422 // conversion between ValueTypes, BasicTypes, and ciConstants | |
423 ValueType* as_ValueType(BasicType type); | |
424 ValueType* as_ValueType(ciConstant value); | |
425 BasicType as_BasicType(ValueType* type); | |
426 | |
427 inline ValueType* as_ValueType(ciType* type) { return as_ValueType(type->basic_type()); } | |
1972 | 428 |
429 #endif // SHARE_VM_C1_C1_VALUETYPE_HPP |