Mercurial > hg > truffle
annotate src/share/vm/c1/c1_ValueType.hpp @ 1721:413ad0331a0c
6977924: Changes for 6975078 produce build error with certain gcc versions
Summary: The changes introduced for 6975078 assign badHeapOopVal to the _allocation field in the ResourceObj class. In 32 bit linux builds with certain versions of gcc this assignment will be flagged as an error while compiling allocation.cpp. In 32 bit builds the constant value badHeapOopVal (which is cast to an intptr_t) is negative. The _allocation field is typed as an unsigned intptr_t and gcc catches this as an error.
Reviewed-by: jcoomes, ysr, phh
| author | johnc |
|---|---|
| date | Wed, 18 Aug 2010 10:59:06 -0700 |
| parents | b812ff5abc73 |
| children | f95d63e2154a |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
2 * Copyright (c) 1999, 2005, 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 | |
| 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 | |
| 1584 | 97 static void initialize(Arena* arena); |
| 0 | 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()); } |