Mercurial > hg > truffle
annotate src/share/vm/c1/c1_ValueType.hpp @ 2607:008adfd6d850
Fixed the stateBefore of invokes and monitorenter instructions to include the arguments of the instruction.
This is necessary to ensure correct continuation in the interpreter when the stateBefore is used as a deoptimization point.
| author | Thomas Wuerthinger <thomas@wuerthinger.net> |
|---|---|
| date | Fri, 06 May 2011 17:47:17 +0200 |
| 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 |