Mercurial > hg > truffle
annotate src/share/vm/opto/type.cpp @ 452:00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
Summary: When we encounter marking stack overflow during precleaning of Reference lists, we were using the overflow list mechanism, which can cause problems on account of mutating the mark word of the header because of conflicts with mutator accesses and updates of that field. Instead we should use the usual mechanism for overflow handling in concurrent phases, namely dirtying of the card on which the overflowed object lies. Since precleaning effectively does a form of discovered list processing, albeit with discovery enabled, we needed to adjust some code to be correct in the face of interleaved processing and discovery.
Reviewed-by: apetrusenko, jcoomes
| author | ysr |
|---|---|
| date | Thu, 20 Nov 2008 12:27:41 -0800 |
| parents | f4fe12e429a4 |
| children | 35ae4dd6c27c |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 196 | 2 * Copyright 1997-2008 Sun Microsystems, Inc. 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 * | |
| 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 // Portions of code courtesy of Clifford Click | |
| 26 | |
| 27 // Optimization - Graph Style | |
| 28 | |
| 29 #include "incls/_precompiled.incl" | |
| 30 #include "incls/_type.cpp.incl" | |
| 31 | |
| 32 // Dictionary of types shared among compilations. | |
| 33 Dict* Type::_shared_type_dict = NULL; | |
| 34 | |
| 35 // Array which maps compiler types to Basic Types | |
| 36 const BasicType Type::_basic_type[Type::lastype] = { | |
| 37 T_ILLEGAL, // Bad | |
| 38 T_ILLEGAL, // Control | |
| 39 T_VOID, // Top | |
| 40 T_INT, // Int | |
| 41 T_LONG, // Long | |
| 42 T_VOID, // Half | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
43 T_NARROWOOP, // NarrowOop |
| 0 | 44 |
| 45 T_ILLEGAL, // Tuple | |
| 46 T_ARRAY, // Array | |
| 47 | |
| 48 T_ADDRESS, // AnyPtr // shows up in factory methods for NULL_PTR | |
| 49 T_ADDRESS, // RawPtr | |
| 50 T_OBJECT, // OopPtr | |
| 51 T_OBJECT, // InstPtr | |
| 52 T_OBJECT, // AryPtr | |
| 53 T_OBJECT, // KlassPtr | |
| 54 | |
| 55 T_OBJECT, // Function | |
| 56 T_ILLEGAL, // Abio | |
| 57 T_ADDRESS, // Return_Address | |
| 58 T_ILLEGAL, // Memory | |
| 59 T_FLOAT, // FloatTop | |
| 60 T_FLOAT, // FloatCon | |
| 61 T_FLOAT, // FloatBot | |
| 62 T_DOUBLE, // DoubleTop | |
| 63 T_DOUBLE, // DoubleCon | |
| 64 T_DOUBLE, // DoubleBot | |
| 65 T_ILLEGAL, // Bottom | |
| 66 }; | |
| 67 | |
| 68 // Map ideal registers (machine types) to ideal types | |
| 69 const Type *Type::mreg2type[_last_machine_leaf]; | |
| 70 | |
| 71 // Map basic types to canonical Type* pointers. | |
| 72 const Type* Type:: _const_basic_type[T_CONFLICT+1]; | |
| 73 | |
| 74 // Map basic types to constant-zero Types. | |
| 75 const Type* Type:: _zero_type[T_CONFLICT+1]; | |
| 76 | |
| 77 // Map basic types to array-body alias types. | |
| 78 const TypeAryPtr* TypeAryPtr::_array_body_type[T_CONFLICT+1]; | |
| 79 | |
| 80 //============================================================================= | |
| 81 // Convenience common pre-built types. | |
| 82 const Type *Type::ABIO; // State-of-machine only | |
| 83 const Type *Type::BOTTOM; // All values | |
| 84 const Type *Type::CONTROL; // Control only | |
| 85 const Type *Type::DOUBLE; // All doubles | |
| 86 const Type *Type::FLOAT; // All floats | |
| 87 const Type *Type::HALF; // Placeholder half of doublewide type | |
| 88 const Type *Type::MEMORY; // Abstract store only | |
| 89 const Type *Type::RETURN_ADDRESS; | |
| 90 const Type *Type::TOP; // No values in set | |
| 91 | |
| 92 //------------------------------get_const_type--------------------------- | |
| 93 const Type* Type::get_const_type(ciType* type) { | |
| 94 if (type == NULL) { | |
| 95 return NULL; | |
| 96 } else if (type->is_primitive_type()) { | |
| 97 return get_const_basic_type(type->basic_type()); | |
| 98 } else { | |
| 99 return TypeOopPtr::make_from_klass(type->as_klass()); | |
| 100 } | |
| 101 } | |
| 102 | |
| 103 //---------------------------array_element_basic_type--------------------------------- | |
| 104 // Mapping to the array element's basic type. | |
| 105 BasicType Type::array_element_basic_type() const { | |
| 106 BasicType bt = basic_type(); | |
| 107 if (bt == T_INT) { | |
| 108 if (this == TypeInt::INT) return T_INT; | |
| 109 if (this == TypeInt::CHAR) return T_CHAR; | |
| 110 if (this == TypeInt::BYTE) return T_BYTE; | |
| 111 if (this == TypeInt::BOOL) return T_BOOLEAN; | |
| 112 if (this == TypeInt::SHORT) return T_SHORT; | |
| 113 return T_VOID; | |
| 114 } | |
| 115 return bt; | |
| 116 } | |
| 117 | |
| 118 //---------------------------get_typeflow_type--------------------------------- | |
| 119 // Import a type produced by ciTypeFlow. | |
| 120 const Type* Type::get_typeflow_type(ciType* type) { | |
| 121 switch (type->basic_type()) { | |
| 122 | |
| 123 case ciTypeFlow::StateVector::T_BOTTOM: | |
| 124 assert(type == ciTypeFlow::StateVector::bottom_type(), ""); | |
| 125 return Type::BOTTOM; | |
| 126 | |
| 127 case ciTypeFlow::StateVector::T_TOP: | |
| 128 assert(type == ciTypeFlow::StateVector::top_type(), ""); | |
| 129 return Type::TOP; | |
| 130 | |
| 131 case ciTypeFlow::StateVector::T_NULL: | |
| 132 assert(type == ciTypeFlow::StateVector::null_type(), ""); | |
| 133 return TypePtr::NULL_PTR; | |
| 134 | |
| 135 case ciTypeFlow::StateVector::T_LONG2: | |
| 136 // The ciTypeFlow pass pushes a long, then the half. | |
| 137 // We do the same. | |
| 138 assert(type == ciTypeFlow::StateVector::long2_type(), ""); | |
| 139 return TypeInt::TOP; | |
| 140 | |
| 141 case ciTypeFlow::StateVector::T_DOUBLE2: | |
| 142 // The ciTypeFlow pass pushes double, then the half. | |
| 143 // Our convention is the same. | |
| 144 assert(type == ciTypeFlow::StateVector::double2_type(), ""); | |
| 145 return Type::TOP; | |
| 146 | |
| 147 case T_ADDRESS: | |
| 148 assert(type->is_return_address(), ""); | |
| 149 return TypeRawPtr::make((address)(intptr_t)type->as_return_address()->bci()); | |
| 150 | |
| 151 default: | |
| 152 // make sure we did not mix up the cases: | |
| 153 assert(type != ciTypeFlow::StateVector::bottom_type(), ""); | |
| 154 assert(type != ciTypeFlow::StateVector::top_type(), ""); | |
| 155 assert(type != ciTypeFlow::StateVector::null_type(), ""); | |
| 156 assert(type != ciTypeFlow::StateVector::long2_type(), ""); | |
| 157 assert(type != ciTypeFlow::StateVector::double2_type(), ""); | |
| 158 assert(!type->is_return_address(), ""); | |
| 159 | |
| 160 return Type::get_const_type(type); | |
| 161 } | |
| 162 } | |
| 163 | |
| 164 | |
| 165 //------------------------------make------------------------------------------- | |
| 166 // Create a simple Type, with default empty symbol sets. Then hashcons it | |
| 167 // and look for an existing copy in the type dictionary. | |
| 168 const Type *Type::make( enum TYPES t ) { | |
| 169 return (new Type(t))->hashcons(); | |
| 170 } | |
| 223 | 171 |
| 0 | 172 //------------------------------cmp-------------------------------------------- |
| 173 int Type::cmp( const Type *const t1, const Type *const t2 ) { | |
| 174 if( t1->_base != t2->_base ) | |
| 175 return 1; // Missed badly | |
| 176 assert(t1 != t2 || t1->eq(t2), "eq must be reflexive"); | |
| 177 return !t1->eq(t2); // Return ZERO if equal | |
| 178 } | |
| 179 | |
| 180 //------------------------------hash------------------------------------------- | |
| 181 int Type::uhash( const Type *const t ) { | |
| 182 return t->hash(); | |
| 183 } | |
| 184 | |
| 185 //--------------------------Initialize_shared---------------------------------- | |
| 186 void Type::Initialize_shared(Compile* current) { | |
| 187 // This method does not need to be locked because the first system | |
| 188 // compilations (stub compilations) occur serially. If they are | |
| 189 // changed to proceed in parallel, then this section will need | |
| 190 // locking. | |
| 191 | |
| 192 Arena* save = current->type_arena(); | |
| 193 Arena* shared_type_arena = new Arena(); | |
| 194 | |
| 195 current->set_type_arena(shared_type_arena); | |
| 196 _shared_type_dict = | |
| 197 new (shared_type_arena) Dict( (CmpKey)Type::cmp, (Hash)Type::uhash, | |
| 198 shared_type_arena, 128 ); | |
| 199 current->set_type_dict(_shared_type_dict); | |
| 200 | |
| 201 // Make shared pre-built types. | |
| 202 CONTROL = make(Control); // Control only | |
| 203 TOP = make(Top); // No values in set | |
| 204 MEMORY = make(Memory); // Abstract store only | |
| 205 ABIO = make(Abio); // State-of-machine only | |
| 206 RETURN_ADDRESS=make(Return_Address); | |
| 207 FLOAT = make(FloatBot); // All floats | |
| 208 DOUBLE = make(DoubleBot); // All doubles | |
| 209 BOTTOM = make(Bottom); // Everything | |
| 210 HALF = make(Half); // Placeholder half of doublewide type | |
| 211 | |
| 212 TypeF::ZERO = TypeF::make(0.0); // Float 0 (positive zero) | |
| 213 TypeF::ONE = TypeF::make(1.0); // Float 1 | |
| 214 | |
| 215 TypeD::ZERO = TypeD::make(0.0); // Double 0 (positive zero) | |
| 216 TypeD::ONE = TypeD::make(1.0); // Double 1 | |
| 217 | |
| 218 TypeInt::MINUS_1 = TypeInt::make(-1); // -1 | |
| 219 TypeInt::ZERO = TypeInt::make( 0); // 0 | |
| 220 TypeInt::ONE = TypeInt::make( 1); // 1 | |
| 221 TypeInt::BOOL = TypeInt::make(0,1, WidenMin); // 0 or 1, FALSE or TRUE. | |
| 222 TypeInt::CC = TypeInt::make(-1, 1, WidenMin); // -1, 0 or 1, condition codes | |
| 223 TypeInt::CC_LT = TypeInt::make(-1,-1, WidenMin); // == TypeInt::MINUS_1 | |
| 224 TypeInt::CC_GT = TypeInt::make( 1, 1, WidenMin); // == TypeInt::ONE | |
| 225 TypeInt::CC_EQ = TypeInt::make( 0, 0, WidenMin); // == TypeInt::ZERO | |
| 226 TypeInt::CC_LE = TypeInt::make(-1, 0, WidenMin); | |
| 227 TypeInt::CC_GE = TypeInt::make( 0, 1, WidenMin); // == TypeInt::BOOL | |
| 228 TypeInt::BYTE = TypeInt::make(-128,127, WidenMin); // Bytes | |
| 229 TypeInt::CHAR = TypeInt::make(0,65535, WidenMin); // Java chars | |
| 230 TypeInt::SHORT = TypeInt::make(-32768,32767, WidenMin); // Java shorts | |
| 231 TypeInt::POS = TypeInt::make(0,max_jint, WidenMin); // Non-neg values | |
| 232 TypeInt::POS1 = TypeInt::make(1,max_jint, WidenMin); // Positive values | |
| 233 TypeInt::INT = TypeInt::make(min_jint,max_jint, WidenMax); // 32-bit integers | |
| 234 TypeInt::SYMINT = TypeInt::make(-max_jint,max_jint,WidenMin); // symmetric range | |
| 235 // CmpL is overloaded both as the bytecode computation returning | |
| 236 // a trinary (-1,0,+1) integer result AND as an efficient long | |
| 237 // compare returning optimizer ideal-type flags. | |
| 238 assert( TypeInt::CC_LT == TypeInt::MINUS_1, "types must match for CmpL to work" ); | |
| 239 assert( TypeInt::CC_GT == TypeInt::ONE, "types must match for CmpL to work" ); | |
| 240 assert( TypeInt::CC_EQ == TypeInt::ZERO, "types must match for CmpL to work" ); | |
| 241 assert( TypeInt::CC_GE == TypeInt::BOOL, "types must match for CmpL to work" ); | |
| 242 | |
| 243 TypeLong::MINUS_1 = TypeLong::make(-1); // -1 | |
| 244 TypeLong::ZERO = TypeLong::make( 0); // 0 | |
| 245 TypeLong::ONE = TypeLong::make( 1); // 1 | |
| 246 TypeLong::POS = TypeLong::make(0,max_jlong, WidenMin); // Non-neg values | |
| 247 TypeLong::LONG = TypeLong::make(min_jlong,max_jlong,WidenMax); // 64-bit integers | |
| 248 TypeLong::INT = TypeLong::make((jlong)min_jint,(jlong)max_jint,WidenMin); | |
| 249 TypeLong::UINT = TypeLong::make(0,(jlong)max_juint,WidenMin); | |
| 250 | |
| 251 const Type **fboth =(const Type**)shared_type_arena->Amalloc_4(2*sizeof(Type*)); | |
| 252 fboth[0] = Type::CONTROL; | |
| 253 fboth[1] = Type::CONTROL; | |
| 254 TypeTuple::IFBOTH = TypeTuple::make( 2, fboth ); | |
| 255 | |
| 256 const Type **ffalse =(const Type**)shared_type_arena->Amalloc_4(2*sizeof(Type*)); | |
| 257 ffalse[0] = Type::CONTROL; | |
| 258 ffalse[1] = Type::TOP; | |
| 259 TypeTuple::IFFALSE = TypeTuple::make( 2, ffalse ); | |
| 260 | |
| 261 const Type **fneither =(const Type**)shared_type_arena->Amalloc_4(2*sizeof(Type*)); | |
| 262 fneither[0] = Type::TOP; | |
| 263 fneither[1] = Type::TOP; | |
| 264 TypeTuple::IFNEITHER = TypeTuple::make( 2, fneither ); | |
| 265 | |
| 266 const Type **ftrue =(const Type**)shared_type_arena->Amalloc_4(2*sizeof(Type*)); | |
| 267 ftrue[0] = Type::TOP; | |
| 268 ftrue[1] = Type::CONTROL; | |
| 269 TypeTuple::IFTRUE = TypeTuple::make( 2, ftrue ); | |
| 270 | |
| 271 const Type **floop =(const Type**)shared_type_arena->Amalloc_4(2*sizeof(Type*)); | |
| 272 floop[0] = Type::CONTROL; | |
| 273 floop[1] = TypeInt::INT; | |
| 274 TypeTuple::LOOPBODY = TypeTuple::make( 2, floop ); | |
| 275 | |
| 276 TypePtr::NULL_PTR= TypePtr::make( AnyPtr, TypePtr::Null, 0 ); | |
| 277 TypePtr::NOTNULL = TypePtr::make( AnyPtr, TypePtr::NotNull, OffsetBot ); | |
| 278 TypePtr::BOTTOM = TypePtr::make( AnyPtr, TypePtr::BotPTR, OffsetBot ); | |
| 279 | |
| 280 TypeRawPtr::BOTTOM = TypeRawPtr::make( TypePtr::BotPTR ); | |
| 281 TypeRawPtr::NOTNULL= TypeRawPtr::make( TypePtr::NotNull ); | |
| 282 | |
| 283 const Type **fmembar = TypeTuple::fields(0); | |
| 284 TypeTuple::MEMBAR = TypeTuple::make(TypeFunc::Parms+0, fmembar); | |
| 285 | |
| 286 const Type **fsc = (const Type**)shared_type_arena->Amalloc_4(2*sizeof(Type*)); | |
| 287 fsc[0] = TypeInt::CC; | |
| 288 fsc[1] = Type::MEMORY; | |
| 289 TypeTuple::STORECONDITIONAL = TypeTuple::make(2, fsc); | |
| 290 | |
| 291 TypeInstPtr::NOTNULL = TypeInstPtr::make(TypePtr::NotNull, current->env()->Object_klass()); | |
| 292 TypeInstPtr::BOTTOM = TypeInstPtr::make(TypePtr::BotPTR, current->env()->Object_klass()); | |
| 293 TypeInstPtr::MIRROR = TypeInstPtr::make(TypePtr::NotNull, current->env()->Class_klass()); | |
| 294 TypeInstPtr::MARK = TypeInstPtr::make(TypePtr::BotPTR, current->env()->Object_klass(), | |
| 295 false, 0, oopDesc::mark_offset_in_bytes()); | |
| 296 TypeInstPtr::KLASS = TypeInstPtr::make(TypePtr::BotPTR, current->env()->Object_klass(), | |
| 297 false, 0, oopDesc::klass_offset_in_bytes()); | |
| 298 TypeOopPtr::BOTTOM = TypeOopPtr::make(TypePtr::BotPTR, OffsetBot); | |
| 299 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
300 TypeNarrowOop::NULL_PTR = TypeNarrowOop::make( TypePtr::NULL_PTR ); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
301 TypeNarrowOop::BOTTOM = TypeNarrowOop::make( TypeInstPtr::BOTTOM ); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
302 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
303 mreg2type[Op_Node] = Type::BOTTOM; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
304 mreg2type[Op_Set ] = 0; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
305 mreg2type[Op_RegN] = TypeNarrowOop::BOTTOM; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
306 mreg2type[Op_RegI] = TypeInt::INT; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
307 mreg2type[Op_RegP] = TypePtr::BOTTOM; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
308 mreg2type[Op_RegF] = Type::FLOAT; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
309 mreg2type[Op_RegD] = Type::DOUBLE; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
310 mreg2type[Op_RegL] = TypeLong::LONG; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
311 mreg2type[Op_RegFlags] = TypeInt::CC; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
312 |
| 0 | 313 TypeAryPtr::RANGE = TypeAryPtr::make( TypePtr::BotPTR, TypeAry::make(Type::BOTTOM,TypeInt::POS), current->env()->Object_klass(), false, arrayOopDesc::length_offset_in_bytes()); |
| 163 | 314 |
| 315 TypeAryPtr::NARROWOOPS = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeNarrowOop::BOTTOM, TypeInt::POS), NULL /*ciArrayKlass::make(o)*/, false, Type::OffsetBot); | |
| 316 | |
| 317 #ifdef _LP64 | |
| 318 if (UseCompressedOops) { | |
| 319 TypeAryPtr::OOPS = TypeAryPtr::NARROWOOPS; | |
| 320 } else | |
| 321 #endif | |
| 322 { | |
| 323 // There is no shared klass for Object[]. See note in TypeAryPtr::klass(). | |
| 324 TypeAryPtr::OOPS = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeInstPtr::BOTTOM,TypeInt::POS), NULL /*ciArrayKlass::make(o)*/, false, Type::OffsetBot); | |
| 325 } | |
| 0 | 326 TypeAryPtr::BYTES = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeInt::BYTE ,TypeInt::POS), ciTypeArrayKlass::make(T_BYTE), true, Type::OffsetBot); |
| 327 TypeAryPtr::SHORTS = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeInt::SHORT ,TypeInt::POS), ciTypeArrayKlass::make(T_SHORT), true, Type::OffsetBot); | |
| 328 TypeAryPtr::CHARS = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeInt::CHAR ,TypeInt::POS), ciTypeArrayKlass::make(T_CHAR), true, Type::OffsetBot); | |
| 329 TypeAryPtr::INTS = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeInt::INT ,TypeInt::POS), ciTypeArrayKlass::make(T_INT), true, Type::OffsetBot); | |
| 330 TypeAryPtr::LONGS = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeLong::LONG ,TypeInt::POS), ciTypeArrayKlass::make(T_LONG), true, Type::OffsetBot); | |
| 331 TypeAryPtr::FLOATS = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(Type::FLOAT ,TypeInt::POS), ciTypeArrayKlass::make(T_FLOAT), true, Type::OffsetBot); | |
| 332 TypeAryPtr::DOUBLES = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(Type::DOUBLE ,TypeInt::POS), ciTypeArrayKlass::make(T_DOUBLE), true, Type::OffsetBot); | |
| 333 | |
| 163 | 334 // Nobody should ask _array_body_type[T_NARROWOOP]. Use NULL as assert. |
| 335 TypeAryPtr::_array_body_type[T_NARROWOOP] = NULL; | |
| 0 | 336 TypeAryPtr::_array_body_type[T_OBJECT] = TypeAryPtr::OOPS; |
| 163 | 337 TypeAryPtr::_array_body_type[T_ARRAY] = TypeAryPtr::OOPS; // arrays are stored in oop arrays |
| 0 | 338 TypeAryPtr::_array_body_type[T_BYTE] = TypeAryPtr::BYTES; |
| 339 TypeAryPtr::_array_body_type[T_BOOLEAN] = TypeAryPtr::BYTES; // boolean[] is a byte array | |
| 340 TypeAryPtr::_array_body_type[T_SHORT] = TypeAryPtr::SHORTS; | |
| 341 TypeAryPtr::_array_body_type[T_CHAR] = TypeAryPtr::CHARS; | |
| 342 TypeAryPtr::_array_body_type[T_INT] = TypeAryPtr::INTS; | |
| 343 TypeAryPtr::_array_body_type[T_LONG] = TypeAryPtr::LONGS; | |
| 344 TypeAryPtr::_array_body_type[T_FLOAT] = TypeAryPtr::FLOATS; | |
| 345 TypeAryPtr::_array_body_type[T_DOUBLE] = TypeAryPtr::DOUBLES; | |
| 346 | |
| 347 TypeKlassPtr::OBJECT = TypeKlassPtr::make( TypePtr::NotNull, current->env()->Object_klass(), 0 ); | |
| 348 TypeKlassPtr::OBJECT_OR_NULL = TypeKlassPtr::make( TypePtr::BotPTR, current->env()->Object_klass(), 0 ); | |
| 349 | |
| 350 const Type **fi2c = TypeTuple::fields(2); | |
| 351 fi2c[TypeFunc::Parms+0] = TypeInstPtr::BOTTOM; // methodOop | |
| 352 fi2c[TypeFunc::Parms+1] = TypeRawPtr::BOTTOM; // argument pointer | |
| 353 TypeTuple::START_I2C = TypeTuple::make(TypeFunc::Parms+2, fi2c); | |
| 354 | |
| 355 const Type **intpair = TypeTuple::fields(2); | |
| 356 intpair[0] = TypeInt::INT; | |
| 357 intpair[1] = TypeInt::INT; | |
| 358 TypeTuple::INT_PAIR = TypeTuple::make(2, intpair); | |
| 359 | |
| 360 const Type **longpair = TypeTuple::fields(2); | |
| 361 longpair[0] = TypeLong::LONG; | |
| 362 longpair[1] = TypeLong::LONG; | |
| 363 TypeTuple::LONG_PAIR = TypeTuple::make(2, longpair); | |
| 364 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
365 _const_basic_type[T_NARROWOOP] = TypeNarrowOop::BOTTOM; |
| 0 | 366 _const_basic_type[T_BOOLEAN] = TypeInt::BOOL; |
| 367 _const_basic_type[T_CHAR] = TypeInt::CHAR; | |
| 368 _const_basic_type[T_BYTE] = TypeInt::BYTE; | |
| 369 _const_basic_type[T_SHORT] = TypeInt::SHORT; | |
| 370 _const_basic_type[T_INT] = TypeInt::INT; | |
| 371 _const_basic_type[T_LONG] = TypeLong::LONG; | |
| 372 _const_basic_type[T_FLOAT] = Type::FLOAT; | |
| 373 _const_basic_type[T_DOUBLE] = Type::DOUBLE; | |
| 374 _const_basic_type[T_OBJECT] = TypeInstPtr::BOTTOM; | |
| 375 _const_basic_type[T_ARRAY] = TypeInstPtr::BOTTOM; // there is no separate bottom for arrays | |
| 376 _const_basic_type[T_VOID] = TypePtr::NULL_PTR; // reflection represents void this way | |
| 377 _const_basic_type[T_ADDRESS] = TypeRawPtr::BOTTOM; // both interpreter return addresses & random raw ptrs | |
| 378 _const_basic_type[T_CONFLICT]= Type::BOTTOM; // why not? | |
| 379 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
380 _zero_type[T_NARROWOOP] = TypeNarrowOop::NULL_PTR; |
| 0 | 381 _zero_type[T_BOOLEAN] = TypeInt::ZERO; // false == 0 |
| 382 _zero_type[T_CHAR] = TypeInt::ZERO; // '\0' == 0 | |
| 383 _zero_type[T_BYTE] = TypeInt::ZERO; // 0x00 == 0 | |
| 384 _zero_type[T_SHORT] = TypeInt::ZERO; // 0x0000 == 0 | |
| 385 _zero_type[T_INT] = TypeInt::ZERO; | |
| 386 _zero_type[T_LONG] = TypeLong::ZERO; | |
| 387 _zero_type[T_FLOAT] = TypeF::ZERO; | |
| 388 _zero_type[T_DOUBLE] = TypeD::ZERO; | |
| 389 _zero_type[T_OBJECT] = TypePtr::NULL_PTR; | |
| 390 _zero_type[T_ARRAY] = TypePtr::NULL_PTR; // null array is null oop | |
| 391 _zero_type[T_ADDRESS] = TypePtr::NULL_PTR; // raw pointers use the same null | |
| 392 _zero_type[T_VOID] = Type::TOP; // the only void value is no value at all | |
| 393 | |
| 394 // get_zero_type() should not happen for T_CONFLICT | |
| 395 _zero_type[T_CONFLICT]= NULL; | |
| 396 | |
| 397 // Restore working type arena. | |
| 398 current->set_type_arena(save); | |
| 399 current->set_type_dict(NULL); | |
| 400 } | |
| 401 | |
| 402 //------------------------------Initialize------------------------------------- | |
| 403 void Type::Initialize(Compile* current) { | |
| 404 assert(current->type_arena() != NULL, "must have created type arena"); | |
| 405 | |
| 406 if (_shared_type_dict == NULL) { | |
| 407 Initialize_shared(current); | |
| 408 } | |
| 409 | |
| 410 Arena* type_arena = current->type_arena(); | |
| 411 | |
| 412 // Create the hash-cons'ing dictionary with top-level storage allocation | |
| 413 Dict *tdic = new (type_arena) Dict( (CmpKey)Type::cmp,(Hash)Type::uhash, type_arena, 128 ); | |
| 414 current->set_type_dict(tdic); | |
| 415 | |
| 416 // Transfer the shared types. | |
| 417 DictI i(_shared_type_dict); | |
| 418 for( ; i.test(); ++i ) { | |
| 419 Type* t = (Type*)i._value; | |
| 420 tdic->Insert(t,t); // New Type, insert into Type table | |
| 421 } | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
422 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
423 #ifdef ASSERT |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
424 verify_lastype(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
425 #endif |
| 0 | 426 } |
| 427 | |
| 428 //------------------------------hashcons--------------------------------------- | |
| 429 // Do the hash-cons trick. If the Type already exists in the type table, | |
| 430 // delete the current Type and return the existing Type. Otherwise stick the | |
| 431 // current Type in the Type table. | |
| 432 const Type *Type::hashcons(void) { | |
| 433 debug_only(base()); // Check the assertion in Type::base(). | |
| 434 // Look up the Type in the Type dictionary | |
| 435 Dict *tdic = type_dict(); | |
| 436 Type* old = (Type*)(tdic->Insert(this, this, false)); | |
| 437 if( old ) { // Pre-existing Type? | |
| 438 if( old != this ) // Yes, this guy is not the pre-existing? | |
| 439 delete this; // Yes, Nuke this guy | |
| 440 assert( old->_dual, "" ); | |
| 441 return old; // Return pre-existing | |
| 442 } | |
| 443 | |
| 444 // Every type has a dual (to make my lattice symmetric). | |
| 445 // Since we just discovered a new Type, compute its dual right now. | |
| 446 assert( !_dual, "" ); // No dual yet | |
| 447 _dual = xdual(); // Compute the dual | |
| 448 if( cmp(this,_dual)==0 ) { // Handle self-symmetric | |
| 449 _dual = this; | |
| 450 return this; | |
| 451 } | |
| 452 assert( !_dual->_dual, "" ); // No reverse dual yet | |
| 453 assert( !(*tdic)[_dual], "" ); // Dual not in type system either | |
| 454 // New Type, insert into Type table | |
| 455 tdic->Insert((void*)_dual,(void*)_dual); | |
| 456 ((Type*)_dual)->_dual = this; // Finish up being symmetric | |
| 457 #ifdef ASSERT | |
| 458 Type *dual_dual = (Type*)_dual->xdual(); | |
| 459 assert( eq(dual_dual), "xdual(xdual()) should be identity" ); | |
| 460 delete dual_dual; | |
| 461 #endif | |
| 462 return this; // Return new Type | |
| 463 } | |
| 464 | |
| 465 //------------------------------eq--------------------------------------------- | |
| 466 // Structural equality check for Type representations | |
| 467 bool Type::eq( const Type * ) const { | |
| 468 return true; // Nothing else can go wrong | |
| 469 } | |
| 470 | |
| 471 //------------------------------hash------------------------------------------- | |
| 472 // Type-specific hashing function. | |
| 473 int Type::hash(void) const { | |
| 474 return _base; | |
| 475 } | |
| 476 | |
| 477 //------------------------------is_finite-------------------------------------- | |
| 478 // Has a finite value | |
| 479 bool Type::is_finite() const { | |
| 480 return false; | |
| 481 } | |
| 482 | |
| 483 //------------------------------is_nan----------------------------------------- | |
| 484 // Is not a number (NaN) | |
| 485 bool Type::is_nan() const { | |
| 486 return false; | |
| 487 } | |
| 488 | |
| 489 //------------------------------meet------------------------------------------- | |
| 490 // Compute the MEET of two types. NOT virtual. It enforces that meet is | |
| 491 // commutative and the lattice is symmetric. | |
| 492 const Type *Type::meet( const Type *t ) const { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
493 if (isa_narrowoop() && t->isa_narrowoop()) { |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
183
diff
changeset
|
494 const Type* result = make_ptr()->meet(t->make_ptr()); |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
183
diff
changeset
|
495 return result->make_narrowoop(); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
496 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
497 |
| 0 | 498 const Type *mt = xmeet(t); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
499 if (isa_narrowoop() || t->isa_narrowoop()) return mt; |
| 0 | 500 #ifdef ASSERT |
| 501 assert( mt == t->xmeet(this), "meet not commutative" ); | |
| 502 const Type* dual_join = mt->_dual; | |
| 503 const Type *t2t = dual_join->xmeet(t->_dual); | |
| 504 const Type *t2this = dual_join->xmeet( _dual); | |
| 505 | |
| 506 // Interface meet Oop is Not Symmetric: | |
| 507 // Interface:AnyNull meet Oop:AnyNull == Interface:AnyNull | |
| 508 // Interface:NotNull meet Oop:NotNull == java/lang/Object:NotNull | |
| 509 const TypeInstPtr* this_inst = this->isa_instptr(); | |
| 510 const TypeInstPtr* t_inst = t->isa_instptr(); | |
| 511 bool interface_vs_oop = false; | |
| 512 if( this_inst && this_inst->is_loaded() && t_inst && t_inst->is_loaded() ) { | |
| 513 bool this_interface = this_inst->klass()->is_interface(); | |
| 514 bool t_interface = t_inst->klass()->is_interface(); | |
| 515 interface_vs_oop = this_interface ^ t_interface; | |
| 516 } | |
| 223 | 517 |
| 518 if( !interface_vs_oop && (t2t != t->_dual || t2this != _dual) ) { | |
| 0 | 519 tty->print_cr("=== Meet Not Symmetric ==="); |
| 520 tty->print("t = "); t->dump(); tty->cr(); | |
| 521 tty->print("this= "); dump(); tty->cr(); | |
| 522 tty->print("mt=(t meet this)= "); mt->dump(); tty->cr(); | |
| 523 | |
| 524 tty->print("t_dual= "); t->_dual->dump(); tty->cr(); | |
| 525 tty->print("this_dual= "); _dual->dump(); tty->cr(); | |
| 526 tty->print("mt_dual= "); mt->_dual->dump(); tty->cr(); | |
| 527 | |
| 528 tty->print("mt_dual meet t_dual= "); t2t ->dump(); tty->cr(); | |
| 529 tty->print("mt_dual meet this_dual= "); t2this ->dump(); tty->cr(); | |
| 530 | |
| 531 fatal("meet not symmetric" ); | |
| 532 } | |
| 533 #endif | |
| 534 return mt; | |
| 535 } | |
| 536 | |
| 537 //------------------------------xmeet------------------------------------------ | |
| 538 // Compute the MEET of two types. It returns a new Type object. | |
| 539 const Type *Type::xmeet( const Type *t ) const { | |
| 540 // Perform a fast test for common case; meeting the same types together. | |
| 541 if( this == t ) return this; // Meeting same type-rep? | |
| 542 | |
| 543 // Meeting TOP with anything? | |
| 544 if( _base == Top ) return t; | |
| 545 | |
| 546 // Meeting BOTTOM with anything? | |
| 547 if( _base == Bottom ) return BOTTOM; | |
| 548 | |
| 549 // Current "this->_base" is one of: Bad, Multi, Control, Top, | |
| 550 // Abio, Abstore, Floatxxx, Doublexxx, Bottom, lastype. | |
| 551 switch (t->base()) { // Switch on original type | |
| 552 | |
| 553 // Cut in half the number of cases I must handle. Only need cases for when | |
| 554 // the given enum "t->type" is less than or equal to the local enum "type". | |
| 555 case FloatCon: | |
| 556 case DoubleCon: | |
| 557 case Int: | |
| 558 case Long: | |
| 559 return t->xmeet(this); | |
| 560 | |
| 561 case OopPtr: | |
| 562 return t->xmeet(this); | |
| 563 | |
| 564 case InstPtr: | |
| 565 return t->xmeet(this); | |
| 566 | |
| 567 case KlassPtr: | |
| 568 return t->xmeet(this); | |
| 569 | |
| 570 case AryPtr: | |
| 571 return t->xmeet(this); | |
| 572 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
573 case NarrowOop: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
574 return t->xmeet(this); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
575 |
| 0 | 576 case Bad: // Type check |
| 577 default: // Bogus type not in lattice | |
| 578 typerr(t); | |
| 579 return Type::BOTTOM; | |
| 580 | |
| 581 case Bottom: // Ye Olde Default | |
| 582 return t; | |
| 583 | |
| 584 case FloatTop: | |
| 585 if( _base == FloatTop ) return this; | |
| 586 case FloatBot: // Float | |
| 587 if( _base == FloatBot || _base == FloatTop ) return FLOAT; | |
| 588 if( _base == DoubleTop || _base == DoubleBot ) return Type::BOTTOM; | |
| 589 typerr(t); | |
| 590 return Type::BOTTOM; | |
| 591 | |
| 592 case DoubleTop: | |
| 593 if( _base == DoubleTop ) return this; | |
| 594 case DoubleBot: // Double | |
| 595 if( _base == DoubleBot || _base == DoubleTop ) return DOUBLE; | |
| 596 if( _base == FloatTop || _base == FloatBot ) return Type::BOTTOM; | |
| 597 typerr(t); | |
| 598 return Type::BOTTOM; | |
| 599 | |
| 600 // These next few cases must match exactly or it is a compile-time error. | |
| 601 case Control: // Control of code | |
| 602 case Abio: // State of world outside of program | |
| 603 case Memory: | |
| 604 if( _base == t->_base ) return this; | |
| 605 typerr(t); | |
| 606 return Type::BOTTOM; | |
| 607 | |
| 608 case Top: // Top of the lattice | |
| 609 return this; | |
| 610 } | |
| 611 | |
| 612 // The type is unchanged | |
| 613 return this; | |
| 614 } | |
| 615 | |
| 616 //-----------------------------filter------------------------------------------ | |
| 617 const Type *Type::filter( const Type *kills ) const { | |
| 618 const Type* ft = join(kills); | |
| 619 if (ft->empty()) | |
| 620 return Type::TOP; // Canonical empty value | |
| 621 return ft; | |
| 622 } | |
| 623 | |
| 624 //------------------------------xdual------------------------------------------ | |
| 625 // Compute dual right now. | |
| 626 const Type::TYPES Type::dual_type[Type::lastype] = { | |
| 627 Bad, // Bad | |
| 628 Control, // Control | |
| 629 Bottom, // Top | |
| 630 Bad, // Int - handled in v-call | |
| 631 Bad, // Long - handled in v-call | |
| 632 Half, // Half | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
633 Bad, // NarrowOop - handled in v-call |
| 0 | 634 |
| 635 Bad, // Tuple - handled in v-call | |
| 636 Bad, // Array - handled in v-call | |
| 637 | |
| 638 Bad, // AnyPtr - handled in v-call | |
| 639 Bad, // RawPtr - handled in v-call | |
| 640 Bad, // OopPtr - handled in v-call | |
| 641 Bad, // InstPtr - handled in v-call | |
| 642 Bad, // AryPtr - handled in v-call | |
| 643 Bad, // KlassPtr - handled in v-call | |
| 644 | |
| 645 Bad, // Function - handled in v-call | |
| 646 Abio, // Abio | |
| 647 Return_Address,// Return_Address | |
| 648 Memory, // Memory | |
| 649 FloatBot, // FloatTop | |
| 650 FloatCon, // FloatCon | |
| 651 FloatTop, // FloatBot | |
| 652 DoubleBot, // DoubleTop | |
| 653 DoubleCon, // DoubleCon | |
| 654 DoubleTop, // DoubleBot | |
| 655 Top // Bottom | |
| 656 }; | |
| 657 | |
| 658 const Type *Type::xdual() const { | |
| 659 // Note: the base() accessor asserts the sanity of _base. | |
| 660 assert(dual_type[base()] != Bad, "implement with v-call"); | |
| 661 return new Type(dual_type[_base]); | |
| 662 } | |
| 663 | |
| 664 //------------------------------has_memory------------------------------------- | |
| 665 bool Type::has_memory() const { | |
| 666 Type::TYPES tx = base(); | |
| 667 if (tx == Memory) return true; | |
| 668 if (tx == Tuple) { | |
| 669 const TypeTuple *t = is_tuple(); | |
| 670 for (uint i=0; i < t->cnt(); i++) { | |
| 671 tx = t->field_at(i)->base(); | |
| 672 if (tx == Memory) return true; | |
| 673 } | |
| 674 } | |
| 675 return false; | |
| 676 } | |
| 677 | |
| 678 #ifndef PRODUCT | |
| 679 //------------------------------dump2------------------------------------------ | |
| 680 void Type::dump2( Dict &d, uint depth, outputStream *st ) const { | |
| 681 st->print(msg[_base]); | |
| 682 } | |
| 683 | |
| 684 //------------------------------dump------------------------------------------- | |
| 685 void Type::dump_on(outputStream *st) const { | |
| 686 ResourceMark rm; | |
| 687 Dict d(cmpkey,hashkey); // Stop recursive type dumping | |
| 688 dump2(d,1, st); | |
| 163 | 689 if (is_ptr_to_narrowoop()) { |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
690 st->print(" [narrow]"); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
691 } |
| 0 | 692 } |
| 693 | |
| 694 //------------------------------data------------------------------------------- | |
| 695 const char * const Type::msg[Type::lastype] = { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
696 "bad","control","top","int:","long:","half", "narrowoop:", |
| 0 | 697 "tuple:", "aryptr", |
| 698 "anyptr:", "rawptr:", "java:", "inst:", "ary:", "klass:", | |
| 699 "func", "abIO", "return_address", "memory", | |
| 700 "float_top", "ftcon:", "float", | |
| 701 "double_top", "dblcon:", "double", | |
| 702 "bottom" | |
| 703 }; | |
| 704 #endif | |
| 705 | |
| 706 //------------------------------singleton-------------------------------------- | |
| 707 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple | |
| 708 // constants (Ldi nodes). Singletons are integer, float or double constants. | |
| 709 bool Type::singleton(void) const { | |
| 710 return _base == Top || _base == Half; | |
| 711 } | |
| 712 | |
| 713 //------------------------------empty------------------------------------------ | |
| 714 // TRUE if Type is a type with no values, FALSE otherwise. | |
| 715 bool Type::empty(void) const { | |
| 716 switch (_base) { | |
| 717 case DoubleTop: | |
| 718 case FloatTop: | |
| 719 case Top: | |
| 720 return true; | |
| 721 | |
| 722 case Half: | |
| 723 case Abio: | |
| 724 case Return_Address: | |
| 725 case Memory: | |
| 726 case Bottom: | |
| 727 case FloatBot: | |
| 728 case DoubleBot: | |
| 729 return false; // never a singleton, therefore never empty | |
| 730 } | |
| 731 | |
| 732 ShouldNotReachHere(); | |
| 733 return false; | |
| 734 } | |
| 735 | |
| 736 //------------------------------dump_stats------------------------------------- | |
| 737 // Dump collected statistics to stderr | |
| 738 #ifndef PRODUCT | |
| 739 void Type::dump_stats() { | |
| 740 tty->print("Types made: %d\n", type_dict()->Size()); | |
| 741 } | |
| 742 #endif | |
| 743 | |
| 744 //------------------------------typerr----------------------------------------- | |
| 745 void Type::typerr( const Type *t ) const { | |
| 746 #ifndef PRODUCT | |
| 747 tty->print("\nError mixing types: "); | |
| 748 dump(); | |
| 749 tty->print(" and "); | |
| 750 t->dump(); | |
| 751 tty->print("\n"); | |
| 752 #endif | |
| 753 ShouldNotReachHere(); | |
| 754 } | |
| 755 | |
| 756 //------------------------------isa_oop_ptr------------------------------------ | |
| 757 // Return true if type is an oop pointer type. False for raw pointers. | |
| 758 static char isa_oop_ptr_tbl[Type::lastype] = { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
759 0,0,0,0,0,0,0/*narrowoop*/,0/*tuple*/, 0/*ary*/, |
| 0 | 760 0/*anyptr*/,0/*rawptr*/,1/*OopPtr*/,1/*InstPtr*/,1/*AryPtr*/,1/*KlassPtr*/, |
| 761 0/*func*/,0,0/*return_address*/,0, | |
| 762 /*floats*/0,0,0, /*doubles*/0,0,0, | |
| 763 0 | |
| 764 }; | |
| 765 bool Type::isa_oop_ptr() const { | |
| 766 return isa_oop_ptr_tbl[_base] != 0; | |
| 767 } | |
| 768 | |
| 769 //------------------------------dump_stats------------------------------------- | |
| 770 // // Check that arrays match type enum | |
| 771 #ifndef PRODUCT | |
| 772 void Type::verify_lastype() { | |
| 773 // Check that arrays match enumeration | |
| 774 assert( Type::dual_type [Type::lastype - 1] == Type::Top, "did not update array"); | |
| 775 assert( strcmp(Type::msg [Type::lastype - 1],"bottom") == 0, "did not update array"); | |
| 776 // assert( PhiNode::tbl [Type::lastype - 1] == NULL, "did not update array"); | |
| 777 assert( Matcher::base2reg[Type::lastype - 1] == 0, "did not update array"); | |
| 778 assert( isa_oop_ptr_tbl [Type::lastype - 1] == (char)0, "did not update array"); | |
| 779 } | |
| 780 #endif | |
| 781 | |
| 782 //============================================================================= | |
| 783 // Convenience common pre-built types. | |
| 784 const TypeF *TypeF::ZERO; // Floating point zero | |
| 785 const TypeF *TypeF::ONE; // Floating point one | |
| 786 | |
| 787 //------------------------------make------------------------------------------- | |
| 788 // Create a float constant | |
| 789 const TypeF *TypeF::make(float f) { | |
| 790 return (TypeF*)(new TypeF(f))->hashcons(); | |
| 791 } | |
| 792 | |
| 793 //------------------------------meet------------------------------------------- | |
| 794 // Compute the MEET of two types. It returns a new Type object. | |
| 795 const Type *TypeF::xmeet( const Type *t ) const { | |
| 796 // Perform a fast test for common case; meeting the same types together. | |
| 797 if( this == t ) return this; // Meeting same type-rep? | |
| 798 | |
| 799 // Current "this->_base" is FloatCon | |
| 800 switch (t->base()) { // Switch on original type | |
| 801 case AnyPtr: // Mixing with oops happens when javac | |
| 802 case RawPtr: // reuses local variables | |
| 803 case OopPtr: | |
| 804 case InstPtr: | |
| 805 case KlassPtr: | |
| 806 case AryPtr: | |
|
293
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
247
diff
changeset
|
807 case NarrowOop: |
| 0 | 808 case Int: |
| 809 case Long: | |
| 810 case DoubleTop: | |
| 811 case DoubleCon: | |
| 812 case DoubleBot: | |
| 813 case Bottom: // Ye Olde Default | |
| 814 return Type::BOTTOM; | |
| 815 | |
| 816 case FloatBot: | |
| 817 return t; | |
| 818 | |
| 819 default: // All else is a mistake | |
| 820 typerr(t); | |
| 821 | |
| 822 case FloatCon: // Float-constant vs Float-constant? | |
| 823 if( jint_cast(_f) != jint_cast(t->getf()) ) // unequal constants? | |
| 824 // must compare bitwise as positive zero, negative zero and NaN have | |
| 825 // all the same representation in C++ | |
| 826 return FLOAT; // Return generic float | |
| 827 // Equal constants | |
| 828 case Top: | |
| 829 case FloatTop: | |
| 830 break; // Return the float constant | |
| 831 } | |
| 832 return this; // Return the float constant | |
| 833 } | |
| 834 | |
| 835 //------------------------------xdual------------------------------------------ | |
| 836 // Dual: symmetric | |
| 837 const Type *TypeF::xdual() const { | |
| 838 return this; | |
| 839 } | |
| 840 | |
| 841 //------------------------------eq--------------------------------------------- | |
| 842 // Structural equality check for Type representations | |
| 843 bool TypeF::eq( const Type *t ) const { | |
| 844 if( g_isnan(_f) || | |
| 845 g_isnan(t->getf()) ) { | |
| 846 // One or both are NANs. If both are NANs return true, else false. | |
| 847 return (g_isnan(_f) && g_isnan(t->getf())); | |
| 848 } | |
| 849 if (_f == t->getf()) { | |
| 850 // (NaN is impossible at this point, since it is not equal even to itself) | |
| 851 if (_f == 0.0) { | |
| 852 // difference between positive and negative zero | |
| 853 if (jint_cast(_f) != jint_cast(t->getf())) return false; | |
| 854 } | |
| 855 return true; | |
| 856 } | |
| 857 return false; | |
| 858 } | |
| 859 | |
| 860 //------------------------------hash------------------------------------------- | |
| 861 // Type-specific hashing function. | |
| 862 int TypeF::hash(void) const { | |
| 863 return *(int*)(&_f); | |
| 864 } | |
| 865 | |
| 866 //------------------------------is_finite-------------------------------------- | |
| 867 // Has a finite value | |
| 868 bool TypeF::is_finite() const { | |
| 869 return g_isfinite(getf()) != 0; | |
| 870 } | |
| 871 | |
| 872 //------------------------------is_nan----------------------------------------- | |
| 873 // Is not a number (NaN) | |
| 874 bool TypeF::is_nan() const { | |
| 875 return g_isnan(getf()) != 0; | |
| 876 } | |
| 877 | |
| 878 //------------------------------dump2------------------------------------------ | |
| 879 // Dump float constant Type | |
| 880 #ifndef PRODUCT | |
| 881 void TypeF::dump2( Dict &d, uint depth, outputStream *st ) const { | |
| 882 Type::dump2(d,depth, st); | |
| 883 st->print("%f", _f); | |
| 884 } | |
| 885 #endif | |
| 886 | |
| 887 //------------------------------singleton-------------------------------------- | |
| 888 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple | |
| 889 // constants (Ldi nodes). Singletons are integer, float or double constants | |
| 890 // or a single symbol. | |
| 891 bool TypeF::singleton(void) const { | |
| 892 return true; // Always a singleton | |
| 893 } | |
| 894 | |
| 895 bool TypeF::empty(void) const { | |
| 896 return false; // always exactly a singleton | |
| 897 } | |
| 898 | |
| 899 //============================================================================= | |
| 900 // Convenience common pre-built types. | |
| 901 const TypeD *TypeD::ZERO; // Floating point zero | |
| 902 const TypeD *TypeD::ONE; // Floating point one | |
| 903 | |
| 904 //------------------------------make------------------------------------------- | |
| 905 const TypeD *TypeD::make(double d) { | |
| 906 return (TypeD*)(new TypeD(d))->hashcons(); | |
| 907 } | |
| 908 | |
| 909 //------------------------------meet------------------------------------------- | |
| 910 // Compute the MEET of two types. It returns a new Type object. | |
| 911 const Type *TypeD::xmeet( const Type *t ) const { | |
| 912 // Perform a fast test for common case; meeting the same types together. | |
| 913 if( this == t ) return this; // Meeting same type-rep? | |
| 914 | |
| 915 // Current "this->_base" is DoubleCon | |
| 916 switch (t->base()) { // Switch on original type | |
| 917 case AnyPtr: // Mixing with oops happens when javac | |
| 918 case RawPtr: // reuses local variables | |
| 919 case OopPtr: | |
| 920 case InstPtr: | |
| 921 case KlassPtr: | |
| 922 case AryPtr: | |
|
183
d4dbd9f91680
6711083: 64bit JVM crashes with Internal Error (type.cpp:763) - ShouldNotReachHere() with enabled COOPs
never
parents:
163
diff
changeset
|
923 case NarrowOop: |
| 0 | 924 case Int: |
| 925 case Long: | |
| 926 case FloatTop: | |
| 927 case FloatCon: | |
| 928 case FloatBot: | |
| 929 case Bottom: // Ye Olde Default | |
| 930 return Type::BOTTOM; | |
| 931 | |
| 932 case DoubleBot: | |
| 933 return t; | |
| 934 | |
| 935 default: // All else is a mistake | |
| 936 typerr(t); | |
| 937 | |
| 938 case DoubleCon: // Double-constant vs Double-constant? | |
| 939 if( jlong_cast(_d) != jlong_cast(t->getd()) ) // unequal constants? (see comment in TypeF::xmeet) | |
| 940 return DOUBLE; // Return generic double | |
| 941 case Top: | |
| 942 case DoubleTop: | |
| 943 break; | |
| 944 } | |
| 945 return this; // Return the double constant | |
| 946 } | |
| 947 | |
| 948 //------------------------------xdual------------------------------------------ | |
| 949 // Dual: symmetric | |
| 950 const Type *TypeD::xdual() const { | |
| 951 return this; | |
| 952 } | |
| 953 | |
| 954 //------------------------------eq--------------------------------------------- | |
| 955 // Structural equality check for Type representations | |
| 956 bool TypeD::eq( const Type *t ) const { | |
| 957 if( g_isnan(_d) || | |
| 958 g_isnan(t->getd()) ) { | |
| 959 // One or both are NANs. If both are NANs return true, else false. | |
| 960 return (g_isnan(_d) && g_isnan(t->getd())); | |
| 961 } | |
| 962 if (_d == t->getd()) { | |
| 963 // (NaN is impossible at this point, since it is not equal even to itself) | |
| 964 if (_d == 0.0) { | |
| 965 // difference between positive and negative zero | |
| 966 if (jlong_cast(_d) != jlong_cast(t->getd())) return false; | |
| 967 } | |
| 968 return true; | |
| 969 } | |
| 970 return false; | |
| 971 } | |
| 972 | |
| 973 //------------------------------hash------------------------------------------- | |
| 974 // Type-specific hashing function. | |
| 975 int TypeD::hash(void) const { | |
| 976 return *(int*)(&_d); | |
| 977 } | |
| 978 | |
| 979 //------------------------------is_finite-------------------------------------- | |
| 980 // Has a finite value | |
| 981 bool TypeD::is_finite() const { | |
| 982 return g_isfinite(getd()) != 0; | |
| 983 } | |
| 984 | |
| 985 //------------------------------is_nan----------------------------------------- | |
| 986 // Is not a number (NaN) | |
| 987 bool TypeD::is_nan() const { | |
| 988 return g_isnan(getd()) != 0; | |
| 989 } | |
| 990 | |
| 991 //------------------------------dump2------------------------------------------ | |
| 992 // Dump double constant Type | |
| 993 #ifndef PRODUCT | |
| 994 void TypeD::dump2( Dict &d, uint depth, outputStream *st ) const { | |
| 995 Type::dump2(d,depth,st); | |
| 996 st->print("%f", _d); | |
| 997 } | |
| 998 #endif | |
| 999 | |
| 1000 //------------------------------singleton-------------------------------------- | |
| 1001 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple | |
| 1002 // constants (Ldi nodes). Singletons are integer, float or double constants | |
| 1003 // or a single symbol. | |
| 1004 bool TypeD::singleton(void) const { | |
| 1005 return true; // Always a singleton | |
| 1006 } | |
| 1007 | |
| 1008 bool TypeD::empty(void) const { | |
| 1009 return false; // always exactly a singleton | |
| 1010 } | |
| 1011 | |
| 1012 //============================================================================= | |
| 1013 // Convience common pre-built types. | |
| 1014 const TypeInt *TypeInt::MINUS_1;// -1 | |
| 1015 const TypeInt *TypeInt::ZERO; // 0 | |
| 1016 const TypeInt *TypeInt::ONE; // 1 | |
| 1017 const TypeInt *TypeInt::BOOL; // 0 or 1, FALSE or TRUE. | |
| 1018 const TypeInt *TypeInt::CC; // -1,0 or 1, condition codes | |
| 1019 const TypeInt *TypeInt::CC_LT; // [-1] == MINUS_1 | |
| 1020 const TypeInt *TypeInt::CC_GT; // [1] == ONE | |
| 1021 const TypeInt *TypeInt::CC_EQ; // [0] == ZERO | |
| 1022 const TypeInt *TypeInt::CC_LE; // [-1,0] | |
| 1023 const TypeInt *TypeInt::CC_GE; // [0,1] == BOOL (!) | |
| 1024 const TypeInt *TypeInt::BYTE; // Bytes, -128 to 127 | |
| 1025 const TypeInt *TypeInt::CHAR; // Java chars, 0-65535 | |
| 1026 const TypeInt *TypeInt::SHORT; // Java shorts, -32768-32767 | |
| 1027 const TypeInt *TypeInt::POS; // Positive 32-bit integers or zero | |
| 1028 const TypeInt *TypeInt::POS1; // Positive 32-bit integers | |
| 1029 const TypeInt *TypeInt::INT; // 32-bit integers | |
| 1030 const TypeInt *TypeInt::SYMINT; // symmetric range [-max_jint..max_jint] | |
| 1031 | |
| 1032 //------------------------------TypeInt---------------------------------------- | |
| 1033 TypeInt::TypeInt( jint lo, jint hi, int w ) : Type(Int), _lo(lo), _hi(hi), _widen(w) { | |
| 1034 } | |
| 1035 | |
| 1036 //------------------------------make------------------------------------------- | |
| 1037 const TypeInt *TypeInt::make( jint lo ) { | |
| 1038 return (TypeInt*)(new TypeInt(lo,lo,WidenMin))->hashcons(); | |
| 1039 } | |
| 1040 | |
| 1041 #define SMALLINT ((juint)3) // a value too insignificant to consider widening | |
| 1042 | |
| 1043 const TypeInt *TypeInt::make( jint lo, jint hi, int w ) { | |
| 1044 // Certain normalizations keep us sane when comparing types. | |
| 1045 // The 'SMALLINT' covers constants and also CC and its relatives. | |
| 1046 assert(CC == NULL || (juint)(CC->_hi - CC->_lo) <= SMALLINT, "CC is truly small"); | |
| 1047 if (lo <= hi) { | |
| 1048 if ((juint)(hi - lo) <= SMALLINT) w = Type::WidenMin; | |
| 1049 if ((juint)(hi - lo) >= max_juint) w = Type::WidenMax; // plain int | |
| 1050 } | |
| 1051 return (TypeInt*)(new TypeInt(lo,hi,w))->hashcons(); | |
| 1052 } | |
| 1053 | |
| 1054 //------------------------------meet------------------------------------------- | |
| 1055 // Compute the MEET of two types. It returns a new Type representation object | |
| 1056 // with reference count equal to the number of Types pointing at it. | |
| 1057 // Caller should wrap a Types around it. | |
| 1058 const Type *TypeInt::xmeet( const Type *t ) const { | |
| 1059 // Perform a fast test for common case; meeting the same types together. | |
| 1060 if( this == t ) return this; // Meeting same type? | |
| 1061 | |
| 1062 // Currently "this->_base" is a TypeInt | |
| 1063 switch (t->base()) { // Switch on original type | |
| 1064 case AnyPtr: // Mixing with oops happens when javac | |
| 1065 case RawPtr: // reuses local variables | |
| 1066 case OopPtr: | |
| 1067 case InstPtr: | |
| 1068 case KlassPtr: | |
| 1069 case AryPtr: | |
|
183
d4dbd9f91680
6711083: 64bit JVM crashes with Internal Error (type.cpp:763) - ShouldNotReachHere() with enabled COOPs
never
parents:
163
diff
changeset
|
1070 case NarrowOop: |
| 0 | 1071 case Long: |
| 1072 case FloatTop: | |
| 1073 case FloatCon: | |
| 1074 case FloatBot: | |
| 1075 case DoubleTop: | |
| 1076 case DoubleCon: | |
| 1077 case DoubleBot: | |
| 1078 case Bottom: // Ye Olde Default | |
| 1079 return Type::BOTTOM; | |
| 1080 default: // All else is a mistake | |
| 1081 typerr(t); | |
| 1082 case Top: // No change | |
| 1083 return this; | |
| 1084 case Int: // Int vs Int? | |
| 1085 break; | |
| 1086 } | |
| 1087 | |
| 1088 // Expand covered set | |
| 1089 const TypeInt *r = t->is_int(); | |
| 1090 // (Avoid TypeInt::make, to avoid the argument normalizations it enforces.) | |
| 1091 return (new TypeInt( MIN2(_lo,r->_lo), MAX2(_hi,r->_hi), MAX2(_widen,r->_widen) ))->hashcons(); | |
| 1092 } | |
| 1093 | |
| 1094 //------------------------------xdual------------------------------------------ | |
| 1095 // Dual: reverse hi & lo; flip widen | |
| 1096 const Type *TypeInt::xdual() const { | |
| 1097 return new TypeInt(_hi,_lo,WidenMax-_widen); | |
| 1098 } | |
| 1099 | |
| 1100 //------------------------------widen------------------------------------------ | |
| 1101 // Only happens for optimistic top-down optimizations. | |
| 1102 const Type *TypeInt::widen( const Type *old ) const { | |
| 1103 // Coming from TOP or such; no widening | |
| 1104 if( old->base() != Int ) return this; | |
| 1105 const TypeInt *ot = old->is_int(); | |
| 1106 | |
| 1107 // If new guy is equal to old guy, no widening | |
| 1108 if( _lo == ot->_lo && _hi == ot->_hi ) | |
| 1109 return old; | |
| 1110 | |
| 1111 // If new guy contains old, then we widened | |
| 1112 if( _lo <= ot->_lo && _hi >= ot->_hi ) { | |
| 1113 // New contains old | |
| 1114 // If new guy is already wider than old, no widening | |
| 1115 if( _widen > ot->_widen ) return this; | |
| 1116 // If old guy was a constant, do not bother | |
| 1117 if (ot->_lo == ot->_hi) return this; | |
| 1118 // Now widen new guy. | |
| 1119 // Check for widening too far | |
| 1120 if (_widen == WidenMax) { | |
| 1121 if (min_jint < _lo && _hi < max_jint) { | |
| 1122 // If neither endpoint is extremal yet, push out the endpoint | |
| 1123 // which is closer to its respective limit. | |
| 1124 if (_lo >= 0 || // easy common case | |
| 1125 (juint)(_lo - min_jint) >= (juint)(max_jint - _hi)) { | |
| 1126 // Try to widen to an unsigned range type of 31 bits: | |
| 1127 return make(_lo, max_jint, WidenMax); | |
| 1128 } else { | |
| 1129 return make(min_jint, _hi, WidenMax); | |
| 1130 } | |
| 1131 } | |
| 1132 return TypeInt::INT; | |
| 1133 } | |
| 1134 // Returned widened new guy | |
| 1135 return make(_lo,_hi,_widen+1); | |
| 1136 } | |
| 1137 | |
| 1138 // If old guy contains new, then we probably widened too far & dropped to | |
| 1139 // bottom. Return the wider fellow. | |
| 1140 if ( ot->_lo <= _lo && ot->_hi >= _hi ) | |
| 1141 return old; | |
| 1142 | |
| 1143 //fatal("Integer value range is not subset"); | |
| 1144 //return this; | |
| 1145 return TypeInt::INT; | |
| 1146 } | |
| 1147 | |
| 1148 //------------------------------narrow--------------------------------------- | |
| 1149 // Only happens for pessimistic optimizations. | |
| 1150 const Type *TypeInt::narrow( const Type *old ) const { | |
| 1151 if (_lo >= _hi) return this; // already narrow enough | |
| 1152 if (old == NULL) return this; | |
| 1153 const TypeInt* ot = old->isa_int(); | |
| 1154 if (ot == NULL) return this; | |
| 1155 jint olo = ot->_lo; | |
| 1156 jint ohi = ot->_hi; | |
| 1157 | |
| 1158 // If new guy is equal to old guy, no narrowing | |
| 1159 if (_lo == olo && _hi == ohi) return old; | |
| 1160 | |
| 1161 // If old guy was maximum range, allow the narrowing | |
| 1162 if (olo == min_jint && ohi == max_jint) return this; | |
| 1163 | |
| 1164 if (_lo < olo || _hi > ohi) | |
| 1165 return this; // doesn't narrow; pretty wierd | |
| 1166 | |
| 1167 // The new type narrows the old type, so look for a "death march". | |
| 1168 // See comments on PhaseTransform::saturate. | |
| 1169 juint nrange = _hi - _lo; | |
| 1170 juint orange = ohi - olo; | |
| 1171 if (nrange < max_juint - 1 && nrange > (orange >> 1) + (SMALLINT*2)) { | |
| 1172 // Use the new type only if the range shrinks a lot. | |
| 1173 // We do not want the optimizer computing 2^31 point by point. | |
| 1174 return old; | |
| 1175 } | |
| 1176 | |
| 1177 return this; | |
| 1178 } | |
| 1179 | |
| 1180 //-----------------------------filter------------------------------------------ | |
| 1181 const Type *TypeInt::filter( const Type *kills ) const { | |
| 1182 const TypeInt* ft = join(kills)->isa_int(); | |
| 1183 if (ft == NULL || ft->_lo > ft->_hi) | |
| 1184 return Type::TOP; // Canonical empty value | |
| 1185 if (ft->_widen < this->_widen) { | |
| 1186 // Do not allow the value of kill->_widen to affect the outcome. | |
| 1187 // The widen bits must be allowed to run freely through the graph. | |
| 1188 ft = TypeInt::make(ft->_lo, ft->_hi, this->_widen); | |
| 1189 } | |
| 1190 return ft; | |
| 1191 } | |
| 1192 | |
| 1193 //------------------------------eq--------------------------------------------- | |
| 1194 // Structural equality check for Type representations | |
| 1195 bool TypeInt::eq( const Type *t ) const { | |
| 1196 const TypeInt *r = t->is_int(); // Handy access | |
| 1197 return r->_lo == _lo && r->_hi == _hi && r->_widen == _widen; | |
| 1198 } | |
| 1199 | |
| 1200 //------------------------------hash------------------------------------------- | |
| 1201 // Type-specific hashing function. | |
| 1202 int TypeInt::hash(void) const { | |
| 1203 return _lo+_hi+_widen+(int)Type::Int; | |
| 1204 } | |
| 1205 | |
| 1206 //------------------------------is_finite-------------------------------------- | |
| 1207 // Has a finite value | |
| 1208 bool TypeInt::is_finite() const { | |
| 1209 return true; | |
| 1210 } | |
| 1211 | |
| 1212 //------------------------------dump2------------------------------------------ | |
| 1213 // Dump TypeInt | |
| 1214 #ifndef PRODUCT | |
| 1215 static const char* intname(char* buf, jint n) { | |
| 1216 if (n == min_jint) | |
| 1217 return "min"; | |
| 1218 else if (n < min_jint + 10000) | |
| 1219 sprintf(buf, "min+" INT32_FORMAT, n - min_jint); | |
| 1220 else if (n == max_jint) | |
| 1221 return "max"; | |
| 1222 else if (n > max_jint - 10000) | |
| 1223 sprintf(buf, "max-" INT32_FORMAT, max_jint - n); | |
| 1224 else | |
| 1225 sprintf(buf, INT32_FORMAT, n); | |
| 1226 return buf; | |
| 1227 } | |
| 1228 | |
| 1229 void TypeInt::dump2( Dict &d, uint depth, outputStream *st ) const { | |
| 1230 char buf[40], buf2[40]; | |
| 1231 if (_lo == min_jint && _hi == max_jint) | |
| 1232 st->print("int"); | |
| 1233 else if (is_con()) | |
| 1234 st->print("int:%s", intname(buf, get_con())); | |
| 1235 else if (_lo == BOOL->_lo && _hi == BOOL->_hi) | |
| 1236 st->print("bool"); | |
| 1237 else if (_lo == BYTE->_lo && _hi == BYTE->_hi) | |
| 1238 st->print("byte"); | |
| 1239 else if (_lo == CHAR->_lo && _hi == CHAR->_hi) | |
| 1240 st->print("char"); | |
| 1241 else if (_lo == SHORT->_lo && _hi == SHORT->_hi) | |
| 1242 st->print("short"); | |
| 1243 else if (_hi == max_jint) | |
| 1244 st->print("int:>=%s", intname(buf, _lo)); | |
| 1245 else if (_lo == min_jint) | |
| 1246 st->print("int:<=%s", intname(buf, _hi)); | |
| 1247 else | |
| 1248 st->print("int:%s..%s", intname(buf, _lo), intname(buf2, _hi)); | |
| 1249 | |
| 1250 if (_widen != 0 && this != TypeInt::INT) | |
| 1251 st->print(":%.*s", _widen, "wwww"); | |
| 1252 } | |
| 1253 #endif | |
| 1254 | |
| 1255 //------------------------------singleton-------------------------------------- | |
| 1256 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple | |
| 1257 // constants. | |
| 1258 bool TypeInt::singleton(void) const { | |
| 1259 return _lo >= _hi; | |
| 1260 } | |
| 1261 | |
| 1262 bool TypeInt::empty(void) const { | |
| 1263 return _lo > _hi; | |
| 1264 } | |
| 1265 | |
| 1266 //============================================================================= | |
| 1267 // Convenience common pre-built types. | |
| 1268 const TypeLong *TypeLong::MINUS_1;// -1 | |
| 1269 const TypeLong *TypeLong::ZERO; // 0 | |
| 1270 const TypeLong *TypeLong::ONE; // 1 | |
| 1271 const TypeLong *TypeLong::POS; // >=0 | |
| 1272 const TypeLong *TypeLong::LONG; // 64-bit integers | |
| 1273 const TypeLong *TypeLong::INT; // 32-bit subrange | |
| 1274 const TypeLong *TypeLong::UINT; // 32-bit unsigned subrange | |
| 1275 | |
| 1276 //------------------------------TypeLong--------------------------------------- | |
| 1277 TypeLong::TypeLong( jlong lo, jlong hi, int w ) : Type(Long), _lo(lo), _hi(hi), _widen(w) { | |
| 1278 } | |
| 1279 | |
| 1280 //------------------------------make------------------------------------------- | |
| 1281 const TypeLong *TypeLong::make( jlong lo ) { | |
| 1282 return (TypeLong*)(new TypeLong(lo,lo,WidenMin))->hashcons(); | |
| 1283 } | |
| 1284 | |
| 1285 const TypeLong *TypeLong::make( jlong lo, jlong hi, int w ) { | |
| 1286 // Certain normalizations keep us sane when comparing types. | |
| 1287 // The '1' covers constants. | |
| 1288 if (lo <= hi) { | |
| 1289 if ((julong)(hi - lo) <= SMALLINT) w = Type::WidenMin; | |
| 1290 if ((julong)(hi - lo) >= max_julong) w = Type::WidenMax; // plain long | |
| 1291 } | |
| 1292 return (TypeLong*)(new TypeLong(lo,hi,w))->hashcons(); | |
| 1293 } | |
| 1294 | |
| 1295 | |
| 1296 //------------------------------meet------------------------------------------- | |
| 1297 // Compute the MEET of two types. It returns a new Type representation object | |
| 1298 // with reference count equal to the number of Types pointing at it. | |
| 1299 // Caller should wrap a Types around it. | |
| 1300 const Type *TypeLong::xmeet( const Type *t ) const { | |
| 1301 // Perform a fast test for common case; meeting the same types together. | |
| 1302 if( this == t ) return this; // Meeting same type? | |
| 1303 | |
| 1304 // Currently "this->_base" is a TypeLong | |
| 1305 switch (t->base()) { // Switch on original type | |
| 1306 case AnyPtr: // Mixing with oops happens when javac | |
| 1307 case RawPtr: // reuses local variables | |
| 1308 case OopPtr: | |
| 1309 case InstPtr: | |
| 1310 case KlassPtr: | |
| 1311 case AryPtr: | |
|
183
d4dbd9f91680
6711083: 64bit JVM crashes with Internal Error (type.cpp:763) - ShouldNotReachHere() with enabled COOPs
never
parents:
163
diff
changeset
|
1312 case NarrowOop: |
| 0 | 1313 case Int: |
| 1314 case FloatTop: | |
| 1315 case FloatCon: | |
| 1316 case FloatBot: | |
| 1317 case DoubleTop: | |
| 1318 case DoubleCon: | |
| 1319 case DoubleBot: | |
| 1320 case Bottom: // Ye Olde Default | |
| 1321 return Type::BOTTOM; | |
| 1322 default: // All else is a mistake | |
| 1323 typerr(t); | |
| 1324 case Top: // No change | |
| 1325 return this; | |
| 1326 case Long: // Long vs Long? | |
| 1327 break; | |
| 1328 } | |
| 1329 | |
| 1330 // Expand covered set | |
| 1331 const TypeLong *r = t->is_long(); // Turn into a TypeLong | |
| 1332 // (Avoid TypeLong::make, to avoid the argument normalizations it enforces.) | |
| 1333 return (new TypeLong( MIN2(_lo,r->_lo), MAX2(_hi,r->_hi), MAX2(_widen,r->_widen) ))->hashcons(); | |
| 1334 } | |
| 1335 | |
| 1336 //------------------------------xdual------------------------------------------ | |
| 1337 // Dual: reverse hi & lo; flip widen | |
| 1338 const Type *TypeLong::xdual() const { | |
| 1339 return new TypeLong(_hi,_lo,WidenMax-_widen); | |
| 1340 } | |
| 1341 | |
| 1342 //------------------------------widen------------------------------------------ | |
| 1343 // Only happens for optimistic top-down optimizations. | |
| 1344 const Type *TypeLong::widen( const Type *old ) const { | |
| 1345 // Coming from TOP or such; no widening | |
| 1346 if( old->base() != Long ) return this; | |
| 1347 const TypeLong *ot = old->is_long(); | |
| 1348 | |
| 1349 // If new guy is equal to old guy, no widening | |
| 1350 if( _lo == ot->_lo && _hi == ot->_hi ) | |
| 1351 return old; | |
| 1352 | |
| 1353 // If new guy contains old, then we widened | |
| 1354 if( _lo <= ot->_lo && _hi >= ot->_hi ) { | |
| 1355 // New contains old | |
| 1356 // If new guy is already wider than old, no widening | |
| 1357 if( _widen > ot->_widen ) return this; | |
| 1358 // If old guy was a constant, do not bother | |
| 1359 if (ot->_lo == ot->_hi) return this; | |
| 1360 // Now widen new guy. | |
| 1361 // Check for widening too far | |
| 1362 if (_widen == WidenMax) { | |
| 1363 if (min_jlong < _lo && _hi < max_jlong) { | |
| 1364 // If neither endpoint is extremal yet, push out the endpoint | |
| 1365 // which is closer to its respective limit. | |
| 1366 if (_lo >= 0 || // easy common case | |
| 1367 (julong)(_lo - min_jlong) >= (julong)(max_jlong - _hi)) { | |
| 1368 // Try to widen to an unsigned range type of 32/63 bits: | |
| 1369 if (_hi < max_juint) | |
| 1370 return make(_lo, max_juint, WidenMax); | |
| 1371 else | |
| 1372 return make(_lo, max_jlong, WidenMax); | |
| 1373 } else { | |
| 1374 return make(min_jlong, _hi, WidenMax); | |
| 1375 } | |
| 1376 } | |
| 1377 return TypeLong::LONG; | |
| 1378 } | |
| 1379 // Returned widened new guy | |
| 1380 return make(_lo,_hi,_widen+1); | |
| 1381 } | |
| 1382 | |
| 1383 // If old guy contains new, then we probably widened too far & dropped to | |
| 1384 // bottom. Return the wider fellow. | |
| 1385 if ( ot->_lo <= _lo && ot->_hi >= _hi ) | |
| 1386 return old; | |
| 1387 | |
| 1388 // fatal("Long value range is not subset"); | |
| 1389 // return this; | |
| 1390 return TypeLong::LONG; | |
| 1391 } | |
| 1392 | |
| 1393 //------------------------------narrow---------------------------------------- | |
| 1394 // Only happens for pessimistic optimizations. | |
| 1395 const Type *TypeLong::narrow( const Type *old ) const { | |
| 1396 if (_lo >= _hi) return this; // already narrow enough | |
| 1397 if (old == NULL) return this; | |
| 1398 const TypeLong* ot = old->isa_long(); | |
| 1399 if (ot == NULL) return this; | |
| 1400 jlong olo = ot->_lo; | |
| 1401 jlong ohi = ot->_hi; | |
| 1402 | |
| 1403 // If new guy is equal to old guy, no narrowing | |
| 1404 if (_lo == olo && _hi == ohi) return old; | |
| 1405 | |
| 1406 // If old guy was maximum range, allow the narrowing | |
| 1407 if (olo == min_jlong && ohi == max_jlong) return this; | |
| 1408 | |
| 1409 if (_lo < olo || _hi > ohi) | |
| 1410 return this; // doesn't narrow; pretty wierd | |
| 1411 | |
| 1412 // The new type narrows the old type, so look for a "death march". | |
| 1413 // See comments on PhaseTransform::saturate. | |
| 1414 julong nrange = _hi - _lo; | |
| 1415 julong orange = ohi - olo; | |
| 1416 if (nrange < max_julong - 1 && nrange > (orange >> 1) + (SMALLINT*2)) { | |
| 1417 // Use the new type only if the range shrinks a lot. | |
| 1418 // We do not want the optimizer computing 2^31 point by point. | |
| 1419 return old; | |
| 1420 } | |
| 1421 | |
| 1422 return this; | |
| 1423 } | |
| 1424 | |
| 1425 //-----------------------------filter------------------------------------------ | |
| 1426 const Type *TypeLong::filter( const Type *kills ) const { | |
| 1427 const TypeLong* ft = join(kills)->isa_long(); | |
| 1428 if (ft == NULL || ft->_lo > ft->_hi) | |
| 1429 return Type::TOP; // Canonical empty value | |
| 1430 if (ft->_widen < this->_widen) { | |
| 1431 // Do not allow the value of kill->_widen to affect the outcome. | |
| 1432 // The widen bits must be allowed to run freely through the graph. | |
| 1433 ft = TypeLong::make(ft->_lo, ft->_hi, this->_widen); | |
| 1434 } | |
| 1435 return ft; | |
| 1436 } | |
| 1437 | |
| 1438 //------------------------------eq--------------------------------------------- | |
| 1439 // Structural equality check for Type representations | |
| 1440 bool TypeLong::eq( const Type *t ) const { | |
| 1441 const TypeLong *r = t->is_long(); // Handy access | |
| 1442 return r->_lo == _lo && r->_hi == _hi && r->_widen == _widen; | |
| 1443 } | |
| 1444 | |
| 1445 //------------------------------hash------------------------------------------- | |
| 1446 // Type-specific hashing function. | |
| 1447 int TypeLong::hash(void) const { | |
| 1448 return (int)(_lo+_hi+_widen+(int)Type::Long); | |
| 1449 } | |
| 1450 | |
| 1451 //------------------------------is_finite-------------------------------------- | |
| 1452 // Has a finite value | |
| 1453 bool TypeLong::is_finite() const { | |
| 1454 return true; | |
| 1455 } | |
| 1456 | |
| 1457 //------------------------------dump2------------------------------------------ | |
| 1458 // Dump TypeLong | |
| 1459 #ifndef PRODUCT | |
| 1460 static const char* longnamenear(jlong x, const char* xname, char* buf, jlong n) { | |
| 1461 if (n > x) { | |
| 1462 if (n >= x + 10000) return NULL; | |
| 1463 sprintf(buf, "%s+" INT64_FORMAT, xname, n - x); | |
| 1464 } else if (n < x) { | |
| 1465 if (n <= x - 10000) return NULL; | |
| 1466 sprintf(buf, "%s-" INT64_FORMAT, xname, x - n); | |
| 1467 } else { | |
| 1468 return xname; | |
| 1469 } | |
| 1470 return buf; | |
| 1471 } | |
| 1472 | |
| 1473 static const char* longname(char* buf, jlong n) { | |
| 1474 const char* str; | |
| 1475 if (n == min_jlong) | |
| 1476 return "min"; | |
| 1477 else if (n < min_jlong + 10000) | |
| 1478 sprintf(buf, "min+" INT64_FORMAT, n - min_jlong); | |
| 1479 else if (n == max_jlong) | |
| 1480 return "max"; | |
| 1481 else if (n > max_jlong - 10000) | |
| 1482 sprintf(buf, "max-" INT64_FORMAT, max_jlong - n); | |
| 1483 else if ((str = longnamenear(max_juint, "maxuint", buf, n)) != NULL) | |
| 1484 return str; | |
| 1485 else if ((str = longnamenear(max_jint, "maxint", buf, n)) != NULL) | |
| 1486 return str; | |
| 1487 else if ((str = longnamenear(min_jint, "minint", buf, n)) != NULL) | |
| 1488 return str; | |
| 1489 else | |
| 1490 sprintf(buf, INT64_FORMAT, n); | |
| 1491 return buf; | |
| 1492 } | |
| 1493 | |
| 1494 void TypeLong::dump2( Dict &d, uint depth, outputStream *st ) const { | |
| 1495 char buf[80], buf2[80]; | |
| 1496 if (_lo == min_jlong && _hi == max_jlong) | |
| 1497 st->print("long"); | |
| 1498 else if (is_con()) | |
| 1499 st->print("long:%s", longname(buf, get_con())); | |
| 1500 else if (_hi == max_jlong) | |
| 1501 st->print("long:>=%s", longname(buf, _lo)); | |
| 1502 else if (_lo == min_jlong) | |
| 1503 st->print("long:<=%s", longname(buf, _hi)); | |
| 1504 else | |
| 1505 st->print("long:%s..%s", longname(buf, _lo), longname(buf2, _hi)); | |
| 1506 | |
| 1507 if (_widen != 0 && this != TypeLong::LONG) | |
| 1508 st->print(":%.*s", _widen, "wwww"); | |
| 1509 } | |
| 1510 #endif | |
| 1511 | |
| 1512 //------------------------------singleton-------------------------------------- | |
| 1513 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple | |
| 1514 // constants | |
| 1515 bool TypeLong::singleton(void) const { | |
| 1516 return _lo >= _hi; | |
| 1517 } | |
| 1518 | |
| 1519 bool TypeLong::empty(void) const { | |
| 1520 return _lo > _hi; | |
| 1521 } | |
| 1522 | |
| 1523 //============================================================================= | |
| 1524 // Convenience common pre-built types. | |
| 1525 const TypeTuple *TypeTuple::IFBOTH; // Return both arms of IF as reachable | |
| 1526 const TypeTuple *TypeTuple::IFFALSE; | |
| 1527 const TypeTuple *TypeTuple::IFTRUE; | |
| 1528 const TypeTuple *TypeTuple::IFNEITHER; | |
| 1529 const TypeTuple *TypeTuple::LOOPBODY; | |
| 1530 const TypeTuple *TypeTuple::MEMBAR; | |
| 1531 const TypeTuple *TypeTuple::STORECONDITIONAL; | |
| 1532 const TypeTuple *TypeTuple::START_I2C; | |
| 1533 const TypeTuple *TypeTuple::INT_PAIR; | |
| 1534 const TypeTuple *TypeTuple::LONG_PAIR; | |
| 1535 | |
| 1536 | |
| 1537 //------------------------------make------------------------------------------- | |
| 1538 // Make a TypeTuple from the range of a method signature | |
| 1539 const TypeTuple *TypeTuple::make_range(ciSignature* sig) { | |
| 1540 ciType* return_type = sig->return_type(); | |
| 1541 uint total_fields = TypeFunc::Parms + return_type->size(); | |
| 1542 const Type **field_array = fields(total_fields); | |
| 1543 switch (return_type->basic_type()) { | |
| 1544 case T_LONG: | |
| 1545 field_array[TypeFunc::Parms] = TypeLong::LONG; | |
| 1546 field_array[TypeFunc::Parms+1] = Type::HALF; | |
| 1547 break; | |
| 1548 case T_DOUBLE: | |
| 1549 field_array[TypeFunc::Parms] = Type::DOUBLE; | |
| 1550 field_array[TypeFunc::Parms+1] = Type::HALF; | |
| 1551 break; | |
| 1552 case T_OBJECT: | |
| 1553 case T_ARRAY: | |
| 1554 case T_BOOLEAN: | |
| 1555 case T_CHAR: | |
| 1556 case T_FLOAT: | |
| 1557 case T_BYTE: | |
| 1558 case T_SHORT: | |
| 1559 case T_INT: | |
| 1560 field_array[TypeFunc::Parms] = get_const_type(return_type); | |
| 1561 break; | |
| 1562 case T_VOID: | |
| 1563 break; | |
| 1564 default: | |
| 1565 ShouldNotReachHere(); | |
| 1566 } | |
| 1567 return (TypeTuple*)(new TypeTuple(total_fields,field_array))->hashcons(); | |
| 1568 } | |
| 1569 | |
| 1570 // Make a TypeTuple from the domain of a method signature | |
| 1571 const TypeTuple *TypeTuple::make_domain(ciInstanceKlass* recv, ciSignature* sig) { | |
| 1572 uint total_fields = TypeFunc::Parms + sig->size(); | |
| 1573 | |
| 1574 uint pos = TypeFunc::Parms; | |
| 1575 const Type **field_array; | |
| 1576 if (recv != NULL) { | |
| 1577 total_fields++; | |
| 1578 field_array = fields(total_fields); | |
| 1579 // Use get_const_type here because it respects UseUniqueSubclasses: | |
| 1580 field_array[pos++] = get_const_type(recv)->join(TypePtr::NOTNULL); | |
| 1581 } else { | |
| 1582 field_array = fields(total_fields); | |
| 1583 } | |
| 1584 | |
| 1585 int i = 0; | |
| 1586 while (pos < total_fields) { | |
| 1587 ciType* type = sig->type_at(i); | |
| 1588 | |
| 1589 switch (type->basic_type()) { | |
| 1590 case T_LONG: | |
| 1591 field_array[pos++] = TypeLong::LONG; | |
| 1592 field_array[pos++] = Type::HALF; | |
| 1593 break; | |
| 1594 case T_DOUBLE: | |
| 1595 field_array[pos++] = Type::DOUBLE; | |
| 1596 field_array[pos++] = Type::HALF; | |
| 1597 break; | |
| 1598 case T_OBJECT: | |
| 1599 case T_ARRAY: | |
| 1600 case T_BOOLEAN: | |
| 1601 case T_CHAR: | |
| 1602 case T_FLOAT: | |
| 1603 case T_BYTE: | |
| 1604 case T_SHORT: | |
| 1605 case T_INT: | |
| 1606 field_array[pos++] = get_const_type(type); | |
| 1607 break; | |
| 1608 default: | |
| 1609 ShouldNotReachHere(); | |
| 1610 } | |
| 1611 i++; | |
| 1612 } | |
| 1613 return (TypeTuple*)(new TypeTuple(total_fields,field_array))->hashcons(); | |
| 1614 } | |
| 1615 | |
| 1616 const TypeTuple *TypeTuple::make( uint cnt, const Type **fields ) { | |
| 1617 return (TypeTuple*)(new TypeTuple(cnt,fields))->hashcons(); | |
| 1618 } | |
| 1619 | |
| 1620 //------------------------------fields----------------------------------------- | |
| 1621 // Subroutine call type with space allocated for argument types | |
| 1622 const Type **TypeTuple::fields( uint arg_cnt ) { | |
| 1623 const Type **flds = (const Type **)(Compile::current()->type_arena()->Amalloc_4((TypeFunc::Parms+arg_cnt)*sizeof(Type*) )); | |
| 1624 flds[TypeFunc::Control ] = Type::CONTROL; | |
| 1625 flds[TypeFunc::I_O ] = Type::ABIO; | |
| 1626 flds[TypeFunc::Memory ] = Type::MEMORY; | |
| 1627 flds[TypeFunc::FramePtr ] = TypeRawPtr::BOTTOM; | |
| 1628 flds[TypeFunc::ReturnAdr] = Type::RETURN_ADDRESS; | |
| 1629 | |
| 1630 return flds; | |
| 1631 } | |
| 1632 | |
| 1633 //------------------------------meet------------------------------------------- | |
| 1634 // Compute the MEET of two types. It returns a new Type object. | |
| 1635 const Type *TypeTuple::xmeet( const Type *t ) const { | |
| 1636 // Perform a fast test for common case; meeting the same types together. | |
| 1637 if( this == t ) return this; // Meeting same type-rep? | |
| 1638 | |
| 1639 // Current "this->_base" is Tuple | |
| 1640 switch (t->base()) { // switch on original type | |
| 1641 | |
| 1642 case Bottom: // Ye Olde Default | |
| 1643 return t; | |
| 1644 | |
| 1645 default: // All else is a mistake | |
| 1646 typerr(t); | |
| 1647 | |
| 1648 case Tuple: { // Meeting 2 signatures? | |
| 1649 const TypeTuple *x = t->is_tuple(); | |
| 1650 assert( _cnt == x->_cnt, "" ); | |
| 1651 const Type **fields = (const Type **)(Compile::current()->type_arena()->Amalloc_4( _cnt*sizeof(Type*) )); | |
| 1652 for( uint i=0; i<_cnt; i++ ) | |
| 1653 fields[i] = field_at(i)->xmeet( x->field_at(i) ); | |
| 1654 return TypeTuple::make(_cnt,fields); | |
| 1655 } | |
| 1656 case Top: | |
| 1657 break; | |
| 1658 } | |
| 1659 return this; // Return the double constant | |
| 1660 } | |
| 1661 | |
| 1662 //------------------------------xdual------------------------------------------ | |
| 1663 // Dual: compute field-by-field dual | |
| 1664 const Type *TypeTuple::xdual() const { | |
| 1665 const Type **fields = (const Type **)(Compile::current()->type_arena()->Amalloc_4( _cnt*sizeof(Type*) )); | |
| 1666 for( uint i=0; i<_cnt; i++ ) | |
| 1667 fields[i] = _fields[i]->dual(); | |
| 1668 return new TypeTuple(_cnt,fields); | |
| 1669 } | |
| 1670 | |
| 1671 //------------------------------eq--------------------------------------------- | |
| 1672 // Structural equality check for Type representations | |
| 1673 bool TypeTuple::eq( const Type *t ) const { | |
| 1674 const TypeTuple *s = (const TypeTuple *)t; | |
| 1675 if (_cnt != s->_cnt) return false; // Unequal field counts | |
| 1676 for (uint i = 0; i < _cnt; i++) | |
| 1677 if (field_at(i) != s->field_at(i)) // POINTER COMPARE! NO RECURSION! | |
| 1678 return false; // Missed | |
| 1679 return true; | |
| 1680 } | |
| 1681 | |
| 1682 //------------------------------hash------------------------------------------- | |
| 1683 // Type-specific hashing function. | |
| 1684 int TypeTuple::hash(void) const { | |
| 1685 intptr_t sum = _cnt; | |
| 1686 for( uint i=0; i<_cnt; i++ ) | |
| 1687 sum += (intptr_t)_fields[i]; // Hash on pointers directly | |
| 1688 return sum; | |
| 1689 } | |
| 1690 | |
| 1691 //------------------------------dump2------------------------------------------ | |
| 1692 // Dump signature Type | |
| 1693 #ifndef PRODUCT | |
| 1694 void TypeTuple::dump2( Dict &d, uint depth, outputStream *st ) const { | |
| 1695 st->print("{"); | |
| 1696 if( !depth || d[this] ) { // Check for recursive print | |
| 1697 st->print("...}"); | |
| 1698 return; | |
| 1699 } | |
| 1700 d.Insert((void*)this, (void*)this); // Stop recursion | |
| 1701 if( _cnt ) { | |
| 1702 uint i; | |
| 1703 for( i=0; i<_cnt-1; i++ ) { | |
| 1704 st->print("%d:", i); | |
| 1705 _fields[i]->dump2(d, depth-1, st); | |
| 1706 st->print(", "); | |
| 1707 } | |
| 1708 st->print("%d:", i); | |
| 1709 _fields[i]->dump2(d, depth-1, st); | |
| 1710 } | |
| 1711 st->print("}"); | |
| 1712 } | |
| 1713 #endif | |
| 1714 | |
| 1715 //------------------------------singleton-------------------------------------- | |
| 1716 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple | |
| 1717 // constants (Ldi nodes). Singletons are integer, float or double constants | |
| 1718 // or a single symbol. | |
| 1719 bool TypeTuple::singleton(void) const { | |
| 1720 return false; // Never a singleton | |
| 1721 } | |
| 1722 | |
| 1723 bool TypeTuple::empty(void) const { | |
| 1724 for( uint i=0; i<_cnt; i++ ) { | |
| 1725 if (_fields[i]->empty()) return true; | |
| 1726 } | |
| 1727 return false; | |
| 1728 } | |
| 1729 | |
| 1730 //============================================================================= | |
| 1731 // Convenience common pre-built types. | |
| 1732 | |
| 1733 inline const TypeInt* normalize_array_size(const TypeInt* size) { | |
| 1734 // Certain normalizations keep us sane when comparing types. | |
| 1735 // We do not want arrayOop variables to differ only by the wideness | |
| 1736 // of their index types. Pick minimum wideness, since that is the | |
| 1737 // forced wideness of small ranges anyway. | |
| 1738 if (size->_widen != Type::WidenMin) | |
| 1739 return TypeInt::make(size->_lo, size->_hi, Type::WidenMin); | |
| 1740 else | |
| 1741 return size; | |
| 1742 } | |
| 1743 | |
| 1744 //------------------------------make------------------------------------------- | |
| 1745 const TypeAry *TypeAry::make( const Type *elem, const TypeInt *size) { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1746 if (UseCompressedOops && elem->isa_oopptr()) { |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
183
diff
changeset
|
1747 elem = elem->make_narrowoop(); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1748 } |
| 0 | 1749 size = normalize_array_size(size); |
| 1750 return (TypeAry*)(new TypeAry(elem,size))->hashcons(); | |
| 1751 } | |
| 1752 | |
| 1753 //------------------------------meet------------------------------------------- | |
| 1754 // Compute the MEET of two types. It returns a new Type object. | |
| 1755 const Type *TypeAry::xmeet( const Type *t ) const { | |
| 1756 // Perform a fast test for common case; meeting the same types together. | |
| 1757 if( this == t ) return this; // Meeting same type-rep? | |
| 1758 | |
| 1759 // Current "this->_base" is Ary | |
| 1760 switch (t->base()) { // switch on original type | |
| 1761 | |
| 1762 case Bottom: // Ye Olde Default | |
| 1763 return t; | |
| 1764 | |
| 1765 default: // All else is a mistake | |
| 1766 typerr(t); | |
| 1767 | |
| 1768 case Array: { // Meeting 2 arrays? | |
| 1769 const TypeAry *a = t->is_ary(); | |
| 1770 return TypeAry::make(_elem->meet(a->_elem), | |
| 1771 _size->xmeet(a->_size)->is_int()); | |
| 1772 } | |
| 1773 case Top: | |
| 1774 break; | |
| 1775 } | |
| 1776 return this; // Return the double constant | |
| 1777 } | |
| 1778 | |
| 1779 //------------------------------xdual------------------------------------------ | |
| 1780 // Dual: compute field-by-field dual | |
| 1781 const Type *TypeAry::xdual() const { | |
| 1782 const TypeInt* size_dual = _size->dual()->is_int(); | |
| 1783 size_dual = normalize_array_size(size_dual); | |
| 1784 return new TypeAry( _elem->dual(), size_dual); | |
| 1785 } | |
| 1786 | |
| 1787 //------------------------------eq--------------------------------------------- | |
| 1788 // Structural equality check for Type representations | |
| 1789 bool TypeAry::eq( const Type *t ) const { | |
| 1790 const TypeAry *a = (const TypeAry*)t; | |
| 1791 return _elem == a->_elem && | |
| 1792 _size == a->_size; | |
| 1793 } | |
| 1794 | |
| 1795 //------------------------------hash------------------------------------------- | |
| 1796 // Type-specific hashing function. | |
| 1797 int TypeAry::hash(void) const { | |
| 1798 return (intptr_t)_elem + (intptr_t)_size; | |
| 1799 } | |
| 1800 | |
| 1801 //------------------------------dump2------------------------------------------ | |
| 1802 #ifndef PRODUCT | |
| 1803 void TypeAry::dump2( Dict &d, uint depth, outputStream *st ) const { | |
| 1804 _elem->dump2(d, depth, st); | |
| 1805 st->print("["); | |
| 1806 _size->dump2(d, depth, st); | |
| 1807 st->print("]"); | |
| 1808 } | |
| 1809 #endif | |
| 1810 | |
| 1811 //------------------------------singleton-------------------------------------- | |
| 1812 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple | |
| 1813 // constants (Ldi nodes). Singletons are integer, float or double constants | |
| 1814 // or a single symbol. | |
| 1815 bool TypeAry::singleton(void) const { | |
| 1816 return false; // Never a singleton | |
| 1817 } | |
| 1818 | |
| 1819 bool TypeAry::empty(void) const { | |
| 1820 return _elem->empty() || _size->empty(); | |
| 1821 } | |
| 1822 | |
| 1823 //--------------------------ary_must_be_exact---------------------------------- | |
| 1824 bool TypeAry::ary_must_be_exact() const { | |
| 1825 if (!UseExactTypes) return false; | |
| 1826 // This logic looks at the element type of an array, and returns true | |
| 1827 // if the element type is either a primitive or a final instance class. | |
| 1828 // In such cases, an array built on this ary must have no subclasses. | |
| 1829 if (_elem == BOTTOM) return false; // general array not exact | |
| 1830 if (_elem == TOP ) return false; // inverted general array not exact | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1831 const TypeOopPtr* toop = NULL; |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
183
diff
changeset
|
1832 if (UseCompressedOops && _elem->isa_narrowoop()) { |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
183
diff
changeset
|
1833 toop = _elem->make_ptr()->isa_oopptr(); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1834 } else { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1835 toop = _elem->isa_oopptr(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1836 } |
| 0 | 1837 if (!toop) return true; // a primitive type, like int |
| 1838 ciKlass* tklass = toop->klass(); | |
| 1839 if (tklass == NULL) return false; // unloaded class | |
| 1840 if (!tklass->is_loaded()) return false; // unloaded class | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1841 const TypeInstPtr* tinst; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1842 if (_elem->isa_narrowoop()) |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
183
diff
changeset
|
1843 tinst = _elem->make_ptr()->isa_instptr(); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1844 else |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1845 tinst = _elem->isa_instptr(); |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
183
diff
changeset
|
1846 if (tinst) |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
183
diff
changeset
|
1847 return tklass->as_instance_klass()->is_final(); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1848 const TypeAryPtr* tap; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1849 if (_elem->isa_narrowoop()) |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
183
diff
changeset
|
1850 tap = _elem->make_ptr()->isa_aryptr(); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1851 else |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1852 tap = _elem->isa_aryptr(); |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
183
diff
changeset
|
1853 if (tap) |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
183
diff
changeset
|
1854 return tap->ary()->ary_must_be_exact(); |
| 0 | 1855 return false; |
| 1856 } | |
| 1857 | |
| 1858 //============================================================================= | |
| 1859 // Convenience common pre-built types. | |
| 1860 const TypePtr *TypePtr::NULL_PTR; | |
| 1861 const TypePtr *TypePtr::NOTNULL; | |
| 1862 const TypePtr *TypePtr::BOTTOM; | |
| 1863 | |
| 1864 //------------------------------meet------------------------------------------- | |
| 1865 // Meet over the PTR enum | |
| 1866 const TypePtr::PTR TypePtr::ptr_meet[TypePtr::lastPTR][TypePtr::lastPTR] = { | |
| 1867 // TopPTR, AnyNull, Constant, Null, NotNull, BotPTR, | |
| 1868 { /* Top */ TopPTR, AnyNull, Constant, Null, NotNull, BotPTR,}, | |
| 1869 { /* AnyNull */ AnyNull, AnyNull, Constant, BotPTR, NotNull, BotPTR,}, | |
| 1870 { /* Constant*/ Constant, Constant, Constant, BotPTR, NotNull, BotPTR,}, | |
| 1871 { /* Null */ Null, BotPTR, BotPTR, Null, BotPTR, BotPTR,}, | |
| 1872 { /* NotNull */ NotNull, NotNull, NotNull, BotPTR, NotNull, BotPTR,}, | |
| 1873 { /* BotPTR */ BotPTR, BotPTR, BotPTR, BotPTR, BotPTR, BotPTR,} | |
| 1874 }; | |
| 1875 | |
| 1876 //------------------------------make------------------------------------------- | |
| 1877 const TypePtr *TypePtr::make( TYPES t, enum PTR ptr, int offset ) { | |
| 1878 return (TypePtr*)(new TypePtr(t,ptr,offset))->hashcons(); | |
| 1879 } | |
| 1880 | |
| 1881 //------------------------------cast_to_ptr_type------------------------------- | |
| 1882 const Type *TypePtr::cast_to_ptr_type(PTR ptr) const { | |
| 1883 assert(_base == AnyPtr, "subclass must override cast_to_ptr_type"); | |
| 1884 if( ptr == _ptr ) return this; | |
| 1885 return make(_base, ptr, _offset); | |
| 1886 } | |
| 1887 | |
| 1888 //------------------------------get_con---------------------------------------- | |
| 1889 intptr_t TypePtr::get_con() const { | |
| 1890 assert( _ptr == Null, "" ); | |
| 1891 return _offset; | |
| 1892 } | |
| 1893 | |
| 1894 //------------------------------meet------------------------------------------- | |
| 1895 // Compute the MEET of two types. It returns a new Type object. | |
| 1896 const Type *TypePtr::xmeet( const Type *t ) const { | |
| 1897 // Perform a fast test for common case; meeting the same types together. | |
| 1898 if( this == t ) return this; // Meeting same type-rep? | |
| 1899 | |
| 1900 // Current "this->_base" is AnyPtr | |
| 1901 switch (t->base()) { // switch on original type | |
| 1902 case Int: // Mixing ints & oops happens when javac | |
| 1903 case Long: // reuses local variables | |
| 1904 case FloatTop: | |
| 1905 case FloatCon: | |
| 1906 case FloatBot: | |
| 1907 case DoubleTop: | |
| 1908 case DoubleCon: | |
| 1909 case DoubleBot: | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
1910 case NarrowOop: |
| 0 | 1911 case Bottom: // Ye Olde Default |
| 1912 return Type::BOTTOM; | |
| 1913 case Top: | |
| 1914 return this; | |
| 1915 | |
| 1916 case AnyPtr: { // Meeting to AnyPtrs | |
| 1917 const TypePtr *tp = t->is_ptr(); | |
| 1918 return make( AnyPtr, meet_ptr(tp->ptr()), meet_offset(tp->offset()) ); | |
| 1919 } | |
| 1920 case RawPtr: // For these, flip the call around to cut down | |
| 1921 case OopPtr: | |
| 1922 case InstPtr: // on the cases I have to handle. | |
| 1923 case KlassPtr: | |
| 1924 case AryPtr: | |
| 1925 return t->xmeet(this); // Call in reverse direction | |
| 1926 default: // All else is a mistake | |
| 1927 typerr(t); | |
| 1928 | |
| 1929 } | |
| 1930 return this; | |
| 1931 } | |
| 1932 | |
| 1933 //------------------------------meet_offset------------------------------------ | |
| 1934 int TypePtr::meet_offset( int offset ) const { | |
| 1935 // Either is 'TOP' offset? Return the other offset! | |
| 1936 if( _offset == OffsetTop ) return offset; | |
| 1937 if( offset == OffsetTop ) return _offset; | |
| 1938 // If either is different, return 'BOTTOM' offset | |
| 1939 if( _offset != offset ) return OffsetBot; | |
| 1940 return _offset; | |
| 1941 } | |
| 1942 | |
| 1943 //------------------------------dual_offset------------------------------------ | |
| 1944 int TypePtr::dual_offset( ) const { | |
| 1945 if( _offset == OffsetTop ) return OffsetBot;// Map 'TOP' into 'BOTTOM' | |
| 1946 if( _offset == OffsetBot ) return OffsetTop;// Map 'BOTTOM' into 'TOP' | |
| 1947 return _offset; // Map everything else into self | |
| 1948 } | |
| 1949 | |
| 1950 //------------------------------xdual------------------------------------------ | |
| 1951 // Dual: compute field-by-field dual | |
| 1952 const TypePtr::PTR TypePtr::ptr_dual[TypePtr::lastPTR] = { | |
| 1953 BotPTR, NotNull, Constant, Null, AnyNull, TopPTR | |
| 1954 }; | |
| 1955 const Type *TypePtr::xdual() const { | |
| 1956 return new TypePtr( AnyPtr, dual_ptr(), dual_offset() ); | |
| 1957 } | |
| 1958 | |
|
306
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
1959 //------------------------------xadd_offset------------------------------------ |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
1960 int TypePtr::xadd_offset( intptr_t offset ) const { |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
1961 // Adding to 'TOP' offset? Return 'TOP'! |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
1962 if( _offset == OffsetTop || offset == OffsetTop ) return OffsetTop; |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
1963 // Adding to 'BOTTOM' offset? Return 'BOTTOM'! |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
1964 if( _offset == OffsetBot || offset == OffsetBot ) return OffsetBot; |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
1965 // Addition overflows or "accidentally" equals to OffsetTop? Return 'BOTTOM'! |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
1966 offset += (intptr_t)_offset; |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
1967 if (offset != (int)offset || offset == OffsetTop) return OffsetBot; |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
1968 |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
1969 // assert( _offset >= 0 && _offset+offset >= 0, "" ); |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
1970 // It is possible to construct a negative offset during PhaseCCP |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
1971 |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
1972 return (int)offset; // Sum valid offsets |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
1973 } |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
1974 |
| 0 | 1975 //------------------------------add_offset------------------------------------- |
|
306
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
1976 const TypePtr *TypePtr::add_offset( intptr_t offset ) const { |
|
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
1977 return make( AnyPtr, _ptr, xadd_offset(offset) ); |
| 0 | 1978 } |
| 1979 | |
| 1980 //------------------------------eq--------------------------------------------- | |
| 1981 // Structural equality check for Type representations | |
| 1982 bool TypePtr::eq( const Type *t ) const { | |
| 1983 const TypePtr *a = (const TypePtr*)t; | |
| 1984 return _ptr == a->ptr() && _offset == a->offset(); | |
| 1985 } | |
| 1986 | |
| 1987 //------------------------------hash------------------------------------------- | |
| 1988 // Type-specific hashing function. | |
| 1989 int TypePtr::hash(void) const { | |
| 1990 return _ptr + _offset; | |
| 1991 } | |
| 1992 | |
| 1993 //------------------------------dump2------------------------------------------ | |
| 1994 const char *const TypePtr::ptr_msg[TypePtr::lastPTR] = { | |
| 1995 "TopPTR","AnyNull","Constant","NULL","NotNull","BotPTR" | |
| 1996 }; | |
| 1997 | |
| 1998 #ifndef PRODUCT | |
| 1999 void TypePtr::dump2( Dict &d, uint depth, outputStream *st ) const { | |
| 2000 if( _ptr == Null ) st->print("NULL"); | |
| 2001 else st->print("%s *", ptr_msg[_ptr]); | |
| 2002 if( _offset == OffsetTop ) st->print("+top"); | |
| 2003 else if( _offset == OffsetBot ) st->print("+bot"); | |
| 2004 else if( _offset ) st->print("+%d", _offset); | |
| 2005 } | |
| 2006 #endif | |
| 2007 | |
| 2008 //------------------------------singleton-------------------------------------- | |
| 2009 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple | |
| 2010 // constants | |
| 2011 bool TypePtr::singleton(void) const { | |
| 2012 // TopPTR, Null, AnyNull, Constant are all singletons | |
| 2013 return (_offset != OffsetBot) && !below_centerline(_ptr); | |
| 2014 } | |
| 2015 | |
| 2016 bool TypePtr::empty(void) const { | |
| 2017 return (_offset == OffsetTop) || above_centerline(_ptr); | |
| 2018 } | |
| 2019 | |
| 2020 //============================================================================= | |
| 2021 // Convenience common pre-built types. | |
| 2022 const TypeRawPtr *TypeRawPtr::BOTTOM; | |
| 2023 const TypeRawPtr *TypeRawPtr::NOTNULL; | |
| 2024 | |
| 2025 //------------------------------make------------------------------------------- | |
| 2026 const TypeRawPtr *TypeRawPtr::make( enum PTR ptr ) { | |
| 2027 assert( ptr != Constant, "what is the constant?" ); | |
| 2028 assert( ptr != Null, "Use TypePtr for NULL" ); | |
| 2029 return (TypeRawPtr*)(new TypeRawPtr(ptr,0))->hashcons(); | |
| 2030 } | |
| 2031 | |
| 2032 const TypeRawPtr *TypeRawPtr::make( address bits ) { | |
| 2033 assert( bits, "Use TypePtr for NULL" ); | |
| 2034 return (TypeRawPtr*)(new TypeRawPtr(Constant,bits))->hashcons(); | |
| 2035 } | |
| 2036 | |
| 2037 //------------------------------cast_to_ptr_type------------------------------- | |
| 2038 const Type *TypeRawPtr::cast_to_ptr_type(PTR ptr) const { | |
| 2039 assert( ptr != Constant, "what is the constant?" ); | |
| 2040 assert( ptr != Null, "Use TypePtr for NULL" ); | |
| 2041 assert( _bits==0, "Why cast a constant address?"); | |
| 2042 if( ptr == _ptr ) return this; | |
| 2043 return make(ptr); | |
| 2044 } | |
| 2045 | |
| 2046 //------------------------------get_con---------------------------------------- | |
| 2047 intptr_t TypeRawPtr::get_con() const { | |
| 2048 assert( _ptr == Null || _ptr == Constant, "" ); | |
| 2049 return (intptr_t)_bits; | |
| 2050 } | |
| 2051 | |
| 2052 //------------------------------meet------------------------------------------- | |
| 2053 // Compute the MEET of two types. It returns a new Type object. | |
| 2054 const Type *TypeRawPtr::xmeet( const Type *t ) const { | |
| 2055 // Perform a fast test for common case; meeting the same types together. | |
| 2056 if( this == t ) return this; // Meeting same type-rep? | |
| 2057 | |
| 2058 // Current "this->_base" is RawPtr | |
| 2059 switch( t->base() ) { // switch on original type | |
| 2060 case Bottom: // Ye Olde Default | |
| 2061 return t; | |
| 2062 case Top: | |
| 2063 return this; | |
| 2064 case AnyPtr: // Meeting to AnyPtrs | |
| 2065 break; | |
| 2066 case RawPtr: { // might be top, bot, any/not or constant | |
| 2067 enum PTR tptr = t->is_ptr()->ptr(); | |
| 2068 enum PTR ptr = meet_ptr( tptr ); | |
| 2069 if( ptr == Constant ) { // Cannot be equal constants, so... | |
| 2070 if( tptr == Constant && _ptr != Constant) return t; | |
| 2071 if( _ptr == Constant && tptr != Constant) return this; | |
| 2072 ptr = NotNull; // Fall down in lattice | |
| 2073 } | |
| 2074 return make( ptr ); | |
| 2075 } | |
| 2076 | |
| 2077 case OopPtr: | |
| 2078 case InstPtr: | |
| 2079 case KlassPtr: | |
| 2080 case AryPtr: | |
| 2081 return TypePtr::BOTTOM; // Oop meet raw is not well defined | |
| 2082 default: // All else is a mistake | |
| 2083 typerr(t); | |
| 2084 } | |
| 2085 | |
| 2086 // Found an AnyPtr type vs self-RawPtr type | |
| 2087 const TypePtr *tp = t->is_ptr(); | |
| 2088 switch (tp->ptr()) { | |
| 2089 case TypePtr::TopPTR: return this; | |
| 2090 case TypePtr::BotPTR: return t; | |
| 2091 case TypePtr::Null: | |
| 2092 if( _ptr == TypePtr::TopPTR ) return t; | |
| 2093 return TypeRawPtr::BOTTOM; | |
| 2094 case TypePtr::NotNull: return TypePtr::make( AnyPtr, meet_ptr(TypePtr::NotNull), tp->meet_offset(0) ); | |
| 2095 case TypePtr::AnyNull: | |
| 2096 if( _ptr == TypePtr::Constant) return this; | |
| 2097 return make( meet_ptr(TypePtr::AnyNull) ); | |
| 2098 default: ShouldNotReachHere(); | |
| 2099 } | |
| 2100 return this; | |
| 2101 } | |
| 2102 | |
| 2103 //------------------------------xdual------------------------------------------ | |
| 2104 // Dual: compute field-by-field dual | |
| 2105 const Type *TypeRawPtr::xdual() const { | |
| 2106 return new TypeRawPtr( dual_ptr(), _bits ); | |
| 2107 } | |
| 2108 | |
| 2109 //------------------------------add_offset------------------------------------- | |
|
306
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
2110 const TypePtr *TypeRawPtr::add_offset( intptr_t offset ) const { |
| 0 | 2111 if( offset == OffsetTop ) return BOTTOM; // Undefined offset-> undefined pointer |
| 2112 if( offset == OffsetBot ) return BOTTOM; // Unknown offset-> unknown pointer | |
| 2113 if( offset == 0 ) return this; // No change | |
| 2114 switch (_ptr) { | |
| 2115 case TypePtr::TopPTR: | |
| 2116 case TypePtr::BotPTR: | |
| 2117 case TypePtr::NotNull: | |
| 2118 return this; | |
| 2119 case TypePtr::Null: | |
| 2120 case TypePtr::Constant: | |
| 2121 return make( _bits+offset ); | |
| 2122 default: ShouldNotReachHere(); | |
| 2123 } | |
| 2124 return NULL; // Lint noise | |
| 2125 } | |
| 2126 | |
| 2127 //------------------------------eq--------------------------------------------- | |
| 2128 // Structural equality check for Type representations | |
| 2129 bool TypeRawPtr::eq( const Type *t ) const { | |
| 2130 const TypeRawPtr *a = (const TypeRawPtr*)t; | |
| 2131 return _bits == a->_bits && TypePtr::eq(t); | |
| 2132 } | |
| 2133 | |
| 2134 //------------------------------hash------------------------------------------- | |
| 2135 // Type-specific hashing function. | |
| 2136 int TypeRawPtr::hash(void) const { | |
| 2137 return (intptr_t)_bits + TypePtr::hash(); | |
| 2138 } | |
| 2139 | |
| 2140 //------------------------------dump2------------------------------------------ | |
| 2141 #ifndef PRODUCT | |
| 2142 void TypeRawPtr::dump2( Dict &d, uint depth, outputStream *st ) const { | |
| 2143 if( _ptr == Constant ) | |
| 2144 st->print(INTPTR_FORMAT, _bits); | |
| 2145 else | |
| 2146 st->print("rawptr:%s", ptr_msg[_ptr]); | |
| 2147 } | |
| 2148 #endif | |
| 2149 | |
| 2150 //============================================================================= | |
| 2151 // Convenience common pre-built type. | |
| 2152 const TypeOopPtr *TypeOopPtr::BOTTOM; | |
| 2153 | |
| 163 | 2154 //------------------------------TypeOopPtr------------------------------------- |
| 2155 TypeOopPtr::TypeOopPtr( TYPES t, PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id ) | |
| 2156 : TypePtr(t, ptr, offset), | |
| 2157 _const_oop(o), _klass(k), | |
| 2158 _klass_is_exact(xk), | |
| 2159 _is_ptr_to_narrowoop(false), | |
| 2160 _instance_id(instance_id) { | |
| 2161 #ifdef _LP64 | |
| 2162 if (UseCompressedOops && _offset != 0) { | |
| 2163 if (klass() == NULL) { | |
| 2164 assert(this->isa_aryptr(), "only arrays without klass"); | |
| 2165 _is_ptr_to_narrowoop = true; | |
| 2166 } else if (_offset == oopDesc::klass_offset_in_bytes()) { | |
| 2167 _is_ptr_to_narrowoop = true; | |
| 2168 } else if (this->isa_aryptr()) { | |
| 2169 _is_ptr_to_narrowoop = (klass()->is_obj_array_klass() && | |
| 2170 _offset != arrayOopDesc::length_offset_in_bytes()); | |
| 2171 } else if (klass() == ciEnv::current()->Class_klass() && | |
| 2172 (_offset == java_lang_Class::klass_offset_in_bytes() || | |
| 2173 _offset == java_lang_Class::array_klass_offset_in_bytes())) { | |
| 2174 // Special hidden fields from the Class. | |
| 2175 assert(this->isa_instptr(), "must be an instance ptr."); | |
| 2176 _is_ptr_to_narrowoop = true; | |
| 2177 } else if (klass()->is_instance_klass()) { | |
| 2178 ciInstanceKlass* ik = klass()->as_instance_klass(); | |
| 2179 ciField* field = NULL; | |
| 2180 if (this->isa_klassptr()) { | |
| 2181 // Perm objects don't use compressed references, except for | |
| 2182 // static fields which are currently compressed. | |
| 2183 field = ik->get_field_by_offset(_offset, true); | |
| 2184 if (field != NULL) { | |
| 2185 BasicType basic_elem_type = field->layout_type(); | |
| 2186 _is_ptr_to_narrowoop = (basic_elem_type == T_OBJECT || | |
| 2187 basic_elem_type == T_ARRAY); | |
| 2188 } | |
| 2189 } else if (_offset == OffsetBot || _offset == OffsetTop) { | |
| 2190 // unsafe access | |
| 2191 _is_ptr_to_narrowoop = true; | |
| 2192 } else { // exclude unsafe ops | |
| 2193 assert(this->isa_instptr(), "must be an instance ptr."); | |
| 2194 // Field which contains a compressed oop references. | |
| 2195 field = ik->get_field_by_offset(_offset, false); | |
| 2196 if (field != NULL) { | |
| 2197 BasicType basic_elem_type = field->layout_type(); | |
| 2198 _is_ptr_to_narrowoop = (basic_elem_type == T_OBJECT || | |
| 2199 basic_elem_type == T_ARRAY); | |
| 2200 } else if (klass()->equals(ciEnv::current()->Object_klass())) { | |
| 2201 // Compile::find_alias_type() cast exactness on all types to verify | |
| 2202 // that it does not affect alias type. | |
| 2203 _is_ptr_to_narrowoop = true; | |
| 2204 } else { | |
| 2205 // Type for the copy start in LibraryCallKit::inline_native_clone(). | |
| 2206 assert(!klass_is_exact(), "only non-exact klass"); | |
| 2207 _is_ptr_to_narrowoop = true; | |
| 2208 } | |
| 2209 } | |
| 2210 } | |
| 2211 } | |
| 2212 #endif | |
| 2213 } | |
| 2214 | |
| 0 | 2215 //------------------------------make------------------------------------------- |
| 2216 const TypeOopPtr *TypeOopPtr::make(PTR ptr, | |
| 2217 int offset) { | |
| 2218 assert(ptr != Constant, "no constant generic pointers"); | |
| 2219 ciKlass* k = ciKlassKlass::make(); | |
| 2220 bool xk = false; | |
| 2221 ciObject* o = NULL; | |
| 223 | 2222 return (TypeOopPtr*)(new TypeOopPtr(OopPtr, ptr, k, xk, o, offset, InstanceBot))->hashcons(); |
| 0 | 2223 } |
| 2224 | |
| 2225 | |
| 2226 //------------------------------cast_to_ptr_type------------------------------- | |
| 2227 const Type *TypeOopPtr::cast_to_ptr_type(PTR ptr) const { | |
| 2228 assert(_base == OopPtr, "subclass must override cast_to_ptr_type"); | |
| 2229 if( ptr == _ptr ) return this; | |
| 2230 return make(ptr, _offset); | |
| 2231 } | |
| 2232 | |
| 247 | 2233 //-----------------------------cast_to_instance_id---------------------------- |
| 223 | 2234 const TypeOopPtr *TypeOopPtr::cast_to_instance_id(int instance_id) const { |
| 0 | 2235 // There are no instances of a general oop. |
| 2236 // Return self unchanged. | |
| 2237 return this; | |
| 2238 } | |
| 2239 | |
| 2240 //-----------------------------cast_to_exactness------------------------------- | |
| 2241 const Type *TypeOopPtr::cast_to_exactness(bool klass_is_exact) const { | |
| 2242 // There is no such thing as an exact general oop. | |
| 2243 // Return self unchanged. | |
| 2244 return this; | |
| 2245 } | |
| 2246 | |
| 2247 | |
| 2248 //------------------------------as_klass_type---------------------------------- | |
| 2249 // Return the klass type corresponding to this instance or array type. | |
| 2250 // It is the type that is loaded from an object of this type. | |
| 2251 const TypeKlassPtr* TypeOopPtr::as_klass_type() const { | |
| 2252 ciKlass* k = klass(); | |
| 2253 bool xk = klass_is_exact(); | |
| 2254 if (k == NULL || !k->is_java_klass()) | |
| 2255 return TypeKlassPtr::OBJECT; | |
| 2256 else | |
| 2257 return TypeKlassPtr::make(xk? Constant: NotNull, k, 0); | |
| 2258 } | |
| 2259 | |
| 2260 | |
| 2261 //------------------------------meet------------------------------------------- | |
| 2262 // Compute the MEET of two types. It returns a new Type object. | |
| 2263 const Type *TypeOopPtr::xmeet( const Type *t ) const { | |
| 2264 // Perform a fast test for common case; meeting the same types together. | |
| 2265 if( this == t ) return this; // Meeting same type-rep? | |
| 2266 | |
| 2267 // Current "this->_base" is OopPtr | |
| 2268 switch (t->base()) { // switch on original type | |
| 2269 | |
| 2270 case Int: // Mixing ints & oops happens when javac | |
| 2271 case Long: // reuses local variables | |
| 2272 case FloatTop: | |
| 2273 case FloatCon: | |
| 2274 case FloatBot: | |
| 2275 case DoubleTop: | |
| 2276 case DoubleCon: | |
| 2277 case DoubleBot: | |
|
293
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
247
diff
changeset
|
2278 case NarrowOop: |
| 0 | 2279 case Bottom: // Ye Olde Default |
| 2280 return Type::BOTTOM; | |
| 2281 case Top: | |
| 2282 return this; | |
| 2283 | |
| 2284 default: // All else is a mistake | |
| 2285 typerr(t); | |
| 2286 | |
| 2287 case RawPtr: | |
| 2288 return TypePtr::BOTTOM; // Oop meet raw is not well defined | |
| 2289 | |
| 2290 case AnyPtr: { | |
| 2291 // Found an AnyPtr type vs self-OopPtr type | |
| 2292 const TypePtr *tp = t->is_ptr(); | |
| 2293 int offset = meet_offset(tp->offset()); | |
| 2294 PTR ptr = meet_ptr(tp->ptr()); | |
| 2295 switch (tp->ptr()) { | |
| 2296 case Null: | |
| 2297 if (ptr == Null) return TypePtr::make(AnyPtr, ptr, offset); | |
| 2298 // else fall through: | |
| 2299 case TopPTR: | |
| 2300 case AnyNull: | |
| 2301 return make(ptr, offset); | |
| 2302 case BotPTR: | |
| 2303 case NotNull: | |
| 2304 return TypePtr::make(AnyPtr, ptr, offset); | |
| 2305 default: typerr(t); | |
| 2306 } | |
| 2307 } | |
| 2308 | |
| 2309 case OopPtr: { // Meeting to other OopPtrs | |
| 2310 const TypeOopPtr *tp = t->is_oopptr(); | |
| 2311 return make( meet_ptr(tp->ptr()), meet_offset(tp->offset()) ); | |
| 2312 } | |
| 2313 | |
| 2314 case InstPtr: // For these, flip the call around to cut down | |
| 2315 case KlassPtr: // on the cases I have to handle. | |
| 2316 case AryPtr: | |
| 2317 return t->xmeet(this); // Call in reverse direction | |
| 2318 | |
| 2319 } // End of switch | |
| 2320 return this; // Return the double constant | |
| 2321 } | |
| 2322 | |
| 2323 | |
| 2324 //------------------------------xdual------------------------------------------ | |
| 2325 // Dual of a pure heap pointer. No relevant klass or oop information. | |
| 2326 const Type *TypeOopPtr::xdual() const { | |
| 2327 assert(klass() == ciKlassKlass::make(), "no klasses here"); | |
| 2328 assert(const_oop() == NULL, "no constants here"); | |
| 223 | 2329 return new TypeOopPtr(_base, dual_ptr(), klass(), klass_is_exact(), const_oop(), dual_offset(), dual_instance_id() ); |
| 0 | 2330 } |
| 2331 | |
| 2332 //--------------------------make_from_klass_common----------------------------- | |
| 2333 // Computes the element-type given a klass. | |
| 2334 const TypeOopPtr* TypeOopPtr::make_from_klass_common(ciKlass *klass, bool klass_change, bool try_for_exact) { | |
| 2335 assert(klass->is_java_klass(), "must be java language klass"); | |
| 2336 if (klass->is_instance_klass()) { | |
| 2337 Compile* C = Compile::current(); | |
| 2338 Dependencies* deps = C->dependencies(); | |
| 2339 assert((deps != NULL) == (C->method() != NULL && C->method()->code_size() > 0), "sanity"); | |
| 2340 // Element is an instance | |
| 2341 bool klass_is_exact = false; | |
| 2342 if (klass->is_loaded()) { | |
| 2343 // Try to set klass_is_exact. | |
| 2344 ciInstanceKlass* ik = klass->as_instance_klass(); | |
| 2345 klass_is_exact = ik->is_final(); | |
| 2346 if (!klass_is_exact && klass_change | |
| 2347 && deps != NULL && UseUniqueSubclasses) { | |
| 2348 ciInstanceKlass* sub = ik->unique_concrete_subklass(); | |
| 2349 if (sub != NULL) { | |
| 2350 deps->assert_abstract_with_unique_concrete_subtype(ik, sub); | |
| 2351 klass = ik = sub; | |
| 2352 klass_is_exact = sub->is_final(); | |
| 2353 } | |
| 2354 } | |
| 2355 if (!klass_is_exact && try_for_exact | |
| 2356 && deps != NULL && UseExactTypes) { | |
| 2357 if (!ik->is_interface() && !ik->has_subklass()) { | |
| 2358 // Add a dependence; if concrete subclass added we need to recompile | |
| 2359 deps->assert_leaf_type(ik); | |
| 2360 klass_is_exact = true; | |
| 2361 } | |
| 2362 } | |
| 2363 } | |
| 2364 return TypeInstPtr::make(TypePtr::BotPTR, klass, klass_is_exact, NULL, 0); | |
| 2365 } else if (klass->is_obj_array_klass()) { | |
| 2366 // Element is an object array. Recursively call ourself. | |
| 2367 const TypeOopPtr *etype = TypeOopPtr::make_from_klass_common(klass->as_obj_array_klass()->element_klass(), false, try_for_exact); | |
| 2368 bool xk = etype->klass_is_exact(); | |
| 2369 const TypeAry* arr0 = TypeAry::make(etype, TypeInt::POS); | |
| 2370 // We used to pass NotNull in here, asserting that the sub-arrays | |
| 2371 // are all not-null. This is not true in generally, as code can | |
| 2372 // slam NULLs down in the subarrays. | |
| 2373 const TypeAryPtr* arr = TypeAryPtr::make(TypePtr::BotPTR, arr0, klass, xk, 0); | |
| 2374 return arr; | |
| 2375 } else if (klass->is_type_array_klass()) { | |
| 2376 // Element is an typeArray | |
| 2377 const Type* etype = get_const_basic_type(klass->as_type_array_klass()->element_type()); | |
| 2378 const TypeAry* arr0 = TypeAry::make(etype, TypeInt::POS); | |
| 2379 // We used to pass NotNull in here, asserting that the array pointer | |
| 2380 // is not-null. That was not true in general. | |
| 2381 const TypeAryPtr* arr = TypeAryPtr::make(TypePtr::BotPTR, arr0, klass, true, 0); | |
| 2382 return arr; | |
| 2383 } else { | |
| 2384 ShouldNotReachHere(); | |
| 2385 return NULL; | |
| 2386 } | |
| 2387 } | |
| 2388 | |
| 2389 //------------------------------make_from_constant----------------------------- | |
| 2390 // Make a java pointer from an oop constant | |
| 2391 const TypeOopPtr* TypeOopPtr::make_from_constant(ciObject* o) { | |
| 2392 if (o->is_method_data() || o->is_method()) { | |
| 2393 // Treat much like a typeArray of bytes, like below, but fake the type... | |
| 2394 assert(o->has_encoding(), "must be a perm space object"); | |
| 2395 const Type* etype = (Type*)get_const_basic_type(T_BYTE); | |
| 2396 const TypeAry* arr0 = TypeAry::make(etype, TypeInt::POS); | |
| 2397 ciKlass *klass = ciTypeArrayKlass::make((BasicType) T_BYTE); | |
| 2398 assert(o->has_encoding(), "method data oops should be tenured"); | |
| 2399 const TypeAryPtr* arr = TypeAryPtr::make(TypePtr::Constant, o, arr0, klass, true, 0); | |
| 2400 return arr; | |
| 2401 } else { | |
| 2402 assert(o->is_java_object(), "must be java language object"); | |
| 2403 assert(!o->is_null_object(), "null object not yet handled here."); | |
| 2404 ciKlass *klass = o->klass(); | |
| 2405 if (klass->is_instance_klass()) { | |
| 2406 // Element is an instance | |
| 2407 if (!o->has_encoding()) { // not a perm-space constant | |
| 2408 // %%% remove this restriction by rewriting non-perm ConPNodes in a later phase | |
| 2409 return TypeInstPtr::make(TypePtr::NotNull, klass, true, NULL, 0); | |
| 2410 } | |
| 2411 return TypeInstPtr::make(o); | |
| 2412 } else if (klass->is_obj_array_klass()) { | |
| 2413 // Element is an object array. Recursively call ourself. | |
| 2414 const Type *etype = | |
| 2415 TypeOopPtr::make_from_klass_raw(klass->as_obj_array_klass()->element_klass()); | |
| 2416 const TypeAry* arr0 = TypeAry::make(etype, TypeInt::make(o->as_array()->length())); | |
| 2417 // We used to pass NotNull in here, asserting that the sub-arrays | |
| 2418 // are all not-null. This is not true in generally, as code can | |
| 2419 // slam NULLs down in the subarrays. | |
| 2420 if (!o->has_encoding()) { // not a perm-space constant | |
| 2421 // %%% remove this restriction by rewriting non-perm ConPNodes in a later phase | |
| 2422 return TypeAryPtr::make(TypePtr::NotNull, arr0, klass, true, 0); | |
| 2423 } | |
| 2424 const TypeAryPtr* arr = TypeAryPtr::make(TypePtr::Constant, o, arr0, klass, true, 0); | |
| 2425 return arr; | |
| 2426 } else if (klass->is_type_array_klass()) { | |
| 2427 // Element is an typeArray | |
| 2428 const Type* etype = | |
| 2429 (Type*)get_const_basic_type(klass->as_type_array_klass()->element_type()); | |
| 2430 const TypeAry* arr0 = TypeAry::make(etype, TypeInt::make(o->as_array()->length())); | |
| 2431 // We used to pass NotNull in here, asserting that the array pointer | |
| 2432 // is not-null. That was not true in general. | |
| 2433 if (!o->has_encoding()) { // not a perm-space constant | |
| 2434 // %%% remove this restriction by rewriting non-perm ConPNodes in a later phase | |
| 2435 return TypeAryPtr::make(TypePtr::NotNull, arr0, klass, true, 0); | |
| 2436 } | |
| 2437 const TypeAryPtr* arr = TypeAryPtr::make(TypePtr::Constant, o, arr0, klass, true, 0); | |
| 2438 return arr; | |
| 2439 } | |
| 2440 } | |
| 2441 | |
| 2442 ShouldNotReachHere(); | |
| 2443 return NULL; | |
| 2444 } | |
| 2445 | |
| 2446 //------------------------------get_con---------------------------------------- | |
| 2447 intptr_t TypeOopPtr::get_con() const { | |
| 2448 assert( _ptr == Null || _ptr == Constant, "" ); | |
| 2449 assert( _offset >= 0, "" ); | |
| 2450 | |
| 2451 if (_offset != 0) { | |
| 2452 // After being ported to the compiler interface, the compiler no longer | |
| 2453 // directly manipulates the addresses of oops. Rather, it only has a pointer | |
| 2454 // to a handle at compile time. This handle is embedded in the generated | |
| 2455 // code and dereferenced at the time the nmethod is made. Until that time, | |
| 2456 // it is not reasonable to do arithmetic with the addresses of oops (we don't | |
| 2457 // have access to the addresses!). This does not seem to currently happen, | |
| 2458 // but this assertion here is to help prevent its occurrance. | |
| 2459 tty->print_cr("Found oop constant with non-zero offset"); | |
| 2460 ShouldNotReachHere(); | |
| 2461 } | |
| 2462 | |
| 2463 return (intptr_t)const_oop()->encoding(); | |
| 2464 } | |
| 2465 | |
| 2466 | |
| 2467 //-----------------------------filter------------------------------------------ | |
| 2468 // Do not allow interface-vs.-noninterface joins to collapse to top. | |
| 2469 const Type *TypeOopPtr::filter( const Type *kills ) const { | |
| 2470 | |
| 2471 const Type* ft = join(kills); | |
| 2472 const TypeInstPtr* ftip = ft->isa_instptr(); | |
| 2473 const TypeInstPtr* ktip = kills->isa_instptr(); | |
| 2474 | |
| 2475 if (ft->empty()) { | |
| 2476 // Check for evil case of 'this' being a class and 'kills' expecting an | |
| 2477 // interface. This can happen because the bytecodes do not contain | |
| 2478 // enough type info to distinguish a Java-level interface variable | |
| 2479 // from a Java-level object variable. If we meet 2 classes which | |
| 2480 // both implement interface I, but their meet is at 'j/l/O' which | |
| 2481 // doesn't implement I, we have no way to tell if the result should | |
| 2482 // be 'I' or 'j/l/O'. Thus we'll pick 'j/l/O'. If this then flows | |
| 2483 // into a Phi which "knows" it's an Interface type we'll have to | |
| 2484 // uplift the type. | |
| 2485 if (!empty() && ktip != NULL && ktip->is_loaded() && ktip->klass()->is_interface()) | |
| 2486 return kills; // Uplift to interface | |
| 2487 | |
| 2488 return Type::TOP; // Canonical empty value | |
| 2489 } | |
| 2490 | |
| 2491 // If we have an interface-typed Phi or cast and we narrow to a class type, | |
| 2492 // the join should report back the class. However, if we have a J/L/Object | |
| 2493 // class-typed Phi and an interface flows in, it's possible that the meet & | |
| 2494 // join report an interface back out. This isn't possible but happens | |
| 2495 // because the type system doesn't interact well with interfaces. | |
| 2496 if (ftip != NULL && ktip != NULL && | |
| 2497 ftip->is_loaded() && ftip->klass()->is_interface() && | |
| 2498 ktip->is_loaded() && !ktip->klass()->is_interface()) { | |
| 2499 // Happens in a CTW of rt.jar, 320-341, no extra flags | |
| 2500 return ktip->cast_to_ptr_type(ftip->ptr()); | |
| 2501 } | |
| 2502 | |
| 2503 return ft; | |
| 2504 } | |
| 2505 | |
| 2506 //------------------------------eq--------------------------------------------- | |
| 2507 // Structural equality check for Type representations | |
| 2508 bool TypeOopPtr::eq( const Type *t ) const { | |
| 2509 const TypeOopPtr *a = (const TypeOopPtr*)t; | |
| 2510 if (_klass_is_exact != a->_klass_is_exact || | |
| 2511 _instance_id != a->_instance_id) return false; | |
| 2512 ciObject* one = const_oop(); | |
| 2513 ciObject* two = a->const_oop(); | |
| 2514 if (one == NULL || two == NULL) { | |
| 2515 return (one == two) && TypePtr::eq(t); | |
| 2516 } else { | |
| 2517 return one->equals(two) && TypePtr::eq(t); | |
| 2518 } | |
| 2519 } | |
| 2520 | |
| 2521 //------------------------------hash------------------------------------------- | |
| 2522 // Type-specific hashing function. | |
| 2523 int TypeOopPtr::hash(void) const { | |
| 2524 return | |
| 2525 (const_oop() ? const_oop()->hash() : 0) + | |
| 2526 _klass_is_exact + | |
| 2527 _instance_id + | |
| 2528 TypePtr::hash(); | |
| 2529 } | |
| 2530 | |
| 2531 //------------------------------dump2------------------------------------------ | |
| 2532 #ifndef PRODUCT | |
| 2533 void TypeOopPtr::dump2( Dict &d, uint depth, outputStream *st ) const { | |
| 2534 st->print("oopptr:%s", ptr_msg[_ptr]); | |
| 2535 if( _klass_is_exact ) st->print(":exact"); | |
| 2536 if( const_oop() ) st->print(INTPTR_FORMAT, const_oop()); | |
| 2537 switch( _offset ) { | |
| 2538 case OffsetTop: st->print("+top"); break; | |
| 2539 case OffsetBot: st->print("+any"); break; | |
| 2540 case 0: break; | |
| 2541 default: st->print("+%d",_offset); break; | |
| 2542 } | |
| 223 | 2543 if (_instance_id == InstanceTop) |
| 2544 st->print(",iid=top"); | |
| 2545 else if (_instance_id != InstanceBot) | |
| 0 | 2546 st->print(",iid=%d",_instance_id); |
| 2547 } | |
| 2548 #endif | |
| 2549 | |
| 2550 //------------------------------singleton-------------------------------------- | |
| 2551 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple | |
| 2552 // constants | |
| 2553 bool TypeOopPtr::singleton(void) const { | |
| 2554 // detune optimizer to not generate constant oop + constant offset as a constant! | |
| 2555 // TopPTR, Null, AnyNull, Constant are all singletons | |
| 2556 return (_offset == 0) && !below_centerline(_ptr); | |
| 2557 } | |
| 2558 | |
| 2559 //------------------------------add_offset------------------------------------- | |
|
306
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
2560 const TypePtr *TypeOopPtr::add_offset( intptr_t offset ) const { |
| 0 | 2561 return make( _ptr, xadd_offset(offset) ); |
| 2562 } | |
| 2563 | |
| 223 | 2564 //------------------------------meet_instance_id-------------------------------- |
| 2565 int TypeOopPtr::meet_instance_id( int instance_id ) const { | |
| 2566 // Either is 'TOP' instance? Return the other instance! | |
| 2567 if( _instance_id == InstanceTop ) return instance_id; | |
| 2568 if( instance_id == InstanceTop ) return _instance_id; | |
| 2569 // If either is different, return 'BOTTOM' instance | |
| 2570 if( _instance_id != instance_id ) return InstanceBot; | |
| 2571 return _instance_id; | |
| 0 | 2572 } |
| 2573 | |
| 223 | 2574 //------------------------------dual_instance_id-------------------------------- |
| 2575 int TypeOopPtr::dual_instance_id( ) const { | |
| 2576 if( _instance_id == InstanceTop ) return InstanceBot; // Map TOP into BOTTOM | |
| 2577 if( _instance_id == InstanceBot ) return InstanceTop; // Map BOTTOM into TOP | |
| 2578 return _instance_id; // Map everything else into self | |
| 2579 } | |
| 2580 | |
| 2581 | |
| 0 | 2582 //============================================================================= |
| 2583 // Convenience common pre-built types. | |
| 2584 const TypeInstPtr *TypeInstPtr::NOTNULL; | |
| 2585 const TypeInstPtr *TypeInstPtr::BOTTOM; | |
| 2586 const TypeInstPtr *TypeInstPtr::MIRROR; | |
| 2587 const TypeInstPtr *TypeInstPtr::MARK; | |
| 2588 const TypeInstPtr *TypeInstPtr::KLASS; | |
| 2589 | |
| 2590 //------------------------------TypeInstPtr------------------------------------- | |
| 2591 TypeInstPtr::TypeInstPtr(PTR ptr, ciKlass* k, bool xk, ciObject* o, int off, int instance_id) | |
| 2592 : TypeOopPtr(InstPtr, ptr, k, xk, o, off, instance_id), _name(k->name()) { | |
| 2593 assert(k != NULL && | |
| 2594 (k->is_loaded() || o == NULL), | |
| 2595 "cannot have constants with non-loaded klass"); | |
| 2596 }; | |
| 2597 | |
| 2598 //------------------------------make------------------------------------------- | |
| 2599 const TypeInstPtr *TypeInstPtr::make(PTR ptr, | |
| 2600 ciKlass* k, | |
| 2601 bool xk, | |
| 2602 ciObject* o, | |
| 2603 int offset, | |
| 2604 int instance_id) { | |
| 2605 assert( !k->is_loaded() || k->is_instance_klass() || | |
| 2606 k->is_method_klass(), "Must be for instance or method"); | |
| 2607 // Either const_oop() is NULL or else ptr is Constant | |
| 2608 assert( (!o && ptr != Constant) || (o && ptr == Constant), | |
| 2609 "constant pointers must have a value supplied" ); | |
| 2610 // Ptr is never Null | |
| 2611 assert( ptr != Null, "NULL pointers are not typed" ); | |
| 2612 | |
| 247 | 2613 assert(instance_id <= 0 || xk || !UseExactTypes, "instances are always exactly typed"); |
| 0 | 2614 if (!UseExactTypes) xk = false; |
| 2615 if (ptr == Constant) { | |
| 2616 // Note: This case includes meta-object constants, such as methods. | |
| 2617 xk = true; | |
| 2618 } else if (k->is_loaded()) { | |
| 2619 ciInstanceKlass* ik = k->as_instance_klass(); | |
| 2620 if (!xk && ik->is_final()) xk = true; // no inexact final klass | |
| 2621 if (xk && ik->is_interface()) xk = false; // no exact interface | |
| 2622 } | |
| 2623 | |
| 2624 // Now hash this baby | |
| 2625 TypeInstPtr *result = | |
| 2626 (TypeInstPtr*)(new TypeInstPtr(ptr, k, xk, o ,offset, instance_id))->hashcons(); | |
| 2627 | |
| 2628 return result; | |
| 2629 } | |
| 2630 | |
| 2631 | |
| 2632 //------------------------------cast_to_ptr_type------------------------------- | |
| 2633 const Type *TypeInstPtr::cast_to_ptr_type(PTR ptr) const { | |
| 2634 if( ptr == _ptr ) return this; | |
| 2635 // Reconstruct _sig info here since not a problem with later lazy | |
| 2636 // construction, _sig will show up on demand. | |
| 223 | 2637 return make(ptr, klass(), klass_is_exact(), const_oop(), _offset, _instance_id); |
| 0 | 2638 } |
| 2639 | |
| 2640 | |
| 2641 //-----------------------------cast_to_exactness------------------------------- | |
| 2642 const Type *TypeInstPtr::cast_to_exactness(bool klass_is_exact) const { | |
| 2643 if( klass_is_exact == _klass_is_exact ) return this; | |
| 2644 if (!UseExactTypes) return this; | |
| 2645 if (!_klass->is_loaded()) return this; | |
| 2646 ciInstanceKlass* ik = _klass->as_instance_klass(); | |
| 2647 if( (ik->is_final() || _const_oop) ) return this; // cannot clear xk | |
| 2648 if( ik->is_interface() ) return this; // cannot set xk | |
| 2649 return make(ptr(), klass(), klass_is_exact, const_oop(), _offset, _instance_id); | |
| 2650 } | |
| 2651 | |
| 247 | 2652 //-----------------------------cast_to_instance_id---------------------------- |
| 223 | 2653 const TypeOopPtr *TypeInstPtr::cast_to_instance_id(int instance_id) const { |
| 2654 if( instance_id == _instance_id ) return this; | |
| 247 | 2655 return make(_ptr, klass(), _klass_is_exact, const_oop(), _offset, instance_id); |
| 0 | 2656 } |
| 2657 | |
| 2658 //------------------------------xmeet_unloaded--------------------------------- | |
| 2659 // Compute the MEET of two InstPtrs when at least one is unloaded. | |
| 2660 // Assume classes are different since called after check for same name/class-loader | |
| 2661 const TypeInstPtr *TypeInstPtr::xmeet_unloaded(const TypeInstPtr *tinst) const { | |
| 2662 int off = meet_offset(tinst->offset()); | |
| 2663 PTR ptr = meet_ptr(tinst->ptr()); | |
| 2664 | |
| 2665 const TypeInstPtr *loaded = is_loaded() ? this : tinst; | |
| 2666 const TypeInstPtr *unloaded = is_loaded() ? tinst : this; | |
| 2667 if( loaded->klass()->equals(ciEnv::current()->Object_klass()) ) { | |
| 2668 // | |
| 2669 // Meet unloaded class with java/lang/Object | |
| 2670 // | |
| 2671 // Meet | |
| 2672 // | Unloaded Class | |
| 2673 // Object | TOP | AnyNull | Constant | NotNull | BOTTOM | | |
| 2674 // =================================================================== | |
| 2675 // TOP | ..........................Unloaded......................| | |
| 2676 // AnyNull | U-AN |................Unloaded......................| | |
| 2677 // Constant | ... O-NN .................................. | O-BOT | | |
| 2678 // NotNull | ... O-NN .................................. | O-BOT | | |
| 2679 // BOTTOM | ........................Object-BOTTOM ..................| | |
| 2680 // | |
| 2681 assert(loaded->ptr() != TypePtr::Null, "insanity check"); | |
| 2682 // | |
| 2683 if( loaded->ptr() == TypePtr::TopPTR ) { return unloaded; } | |
| 2684 else if (loaded->ptr() == TypePtr::AnyNull) { return TypeInstPtr::make( ptr, unloaded->klass() ); } | |
| 2685 else if (loaded->ptr() == TypePtr::BotPTR ) { return TypeInstPtr::BOTTOM; } | |
| 2686 else if (loaded->ptr() == TypePtr::Constant || loaded->ptr() == TypePtr::NotNull) { | |
| 2687 if (unloaded->ptr() == TypePtr::BotPTR ) { return TypeInstPtr::BOTTOM; } | |
| 2688 else { return TypeInstPtr::NOTNULL; } | |
| 2689 } | |
| 2690 else if( unloaded->ptr() == TypePtr::TopPTR ) { return unloaded; } | |
| 2691 | |
| 2692 return unloaded->cast_to_ptr_type(TypePtr::AnyNull)->is_instptr(); | |
| 2693 } | |
| 2694 | |
| 2695 // Both are unloaded, not the same class, not Object | |
| 2696 // Or meet unloaded with a different loaded class, not java/lang/Object | |
| 2697 if( ptr != TypePtr::BotPTR ) { | |
| 2698 return TypeInstPtr::NOTNULL; | |
| 2699 } | |
| 2700 return TypeInstPtr::BOTTOM; | |
| 2701 } | |
| 2702 | |
| 2703 | |
| 2704 //------------------------------meet------------------------------------------- | |
| 2705 // Compute the MEET of two types. It returns a new Type object. | |
| 2706 const Type *TypeInstPtr::xmeet( const Type *t ) const { | |
| 2707 // Perform a fast test for common case; meeting the same types together. | |
| 2708 if( this == t ) return this; // Meeting same type-rep? | |
| 2709 | |
| 2710 // Current "this->_base" is Pointer | |
| 2711 switch (t->base()) { // switch on original type | |
| 2712 | |
| 2713 case Int: // Mixing ints & oops happens when javac | |
| 2714 case Long: // reuses local variables | |
| 2715 case FloatTop: | |
| 2716 case FloatCon: | |
| 2717 case FloatBot: | |
| 2718 case DoubleTop: | |
| 2719 case DoubleCon: | |
| 2720 case DoubleBot: | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
2721 case NarrowOop: |
| 0 | 2722 case Bottom: // Ye Olde Default |
| 2723 return Type::BOTTOM; | |
| 2724 case Top: | |
| 2725 return this; | |
| 2726 | |
| 2727 default: // All else is a mistake | |
| 2728 typerr(t); | |
| 2729 | |
| 2730 case RawPtr: return TypePtr::BOTTOM; | |
| 2731 | |
| 2732 case AryPtr: { // All arrays inherit from Object class | |
| 2733 const TypeAryPtr *tp = t->is_aryptr(); | |
| 2734 int offset = meet_offset(tp->offset()); | |
| 2735 PTR ptr = meet_ptr(tp->ptr()); | |
| 223 | 2736 int instance_id = meet_instance_id(tp->instance_id()); |
| 0 | 2737 switch (ptr) { |
| 2738 case TopPTR: | |
| 2739 case AnyNull: // Fall 'down' to dual of object klass | |
| 2740 if (klass()->equals(ciEnv::current()->Object_klass())) { | |
| 223 | 2741 return TypeAryPtr::make(ptr, tp->ary(), tp->klass(), tp->klass_is_exact(), offset, instance_id); |
| 0 | 2742 } else { |
| 2743 // cannot subclass, so the meet has to fall badly below the centerline | |
| 2744 ptr = NotNull; | |
| 223 | 2745 instance_id = InstanceBot; |
| 2746 return TypeInstPtr::make( ptr, ciEnv::current()->Object_klass(), false, NULL, offset, instance_id); | |
| 0 | 2747 } |
| 2748 case Constant: | |
| 2749 case NotNull: | |
| 2750 case BotPTR: // Fall down to object klass | |
| 2751 // LCA is object_klass, but if we subclass from the top we can do better | |
| 2752 if( above_centerline(_ptr) ) { // if( _ptr == TopPTR || _ptr == AnyNull ) | |
| 2753 // If 'this' (InstPtr) is above the centerline and it is Object class | |
| 2754 // then we can subclass in the Java class heirarchy. | |
| 2755 if (klass()->equals(ciEnv::current()->Object_klass())) { | |
| 2756 // that is, tp's array type is a subtype of my klass | |
| 223 | 2757 return TypeAryPtr::make(ptr, tp->ary(), tp->klass(), tp->klass_is_exact(), offset, instance_id); |
| 0 | 2758 } |
| 2759 } | |
| 2760 // The other case cannot happen, since I cannot be a subtype of an array. | |
| 2761 // The meet falls down to Object class below centerline. | |
| 2762 if( ptr == Constant ) | |
| 2763 ptr = NotNull; | |
| 223 | 2764 instance_id = InstanceBot; |
| 2765 return make( ptr, ciEnv::current()->Object_klass(), false, NULL, offset, instance_id ); | |
| 0 | 2766 default: typerr(t); |
| 2767 } | |
| 2768 } | |
| 2769 | |
| 2770 case OopPtr: { // Meeting to OopPtrs | |
| 2771 // Found a OopPtr type vs self-InstPtr type | |
| 2772 const TypePtr *tp = t->is_oopptr(); | |
| 2773 int offset = meet_offset(tp->offset()); | |
| 2774 PTR ptr = meet_ptr(tp->ptr()); | |
| 2775 switch (tp->ptr()) { | |
| 2776 case TopPTR: | |
| 223 | 2777 case AnyNull: { |
| 2778 int instance_id = meet_instance_id(InstanceTop); | |
| 0 | 2779 return make(ptr, klass(), klass_is_exact(), |
| 223 | 2780 (ptr == Constant ? const_oop() : NULL), offset, instance_id); |
| 2781 } | |
| 0 | 2782 case NotNull: |
| 2783 case BotPTR: | |
| 2784 return TypeOopPtr::make(ptr, offset); | |
| 2785 default: typerr(t); | |
| 2786 } | |
| 2787 } | |
| 2788 | |
| 2789 case AnyPtr: { // Meeting to AnyPtrs | |
| 2790 // Found an AnyPtr type vs self-InstPtr type | |
| 2791 const TypePtr *tp = t->is_ptr(); | |
| 2792 int offset = meet_offset(tp->offset()); | |
| 2793 PTR ptr = meet_ptr(tp->ptr()); | |
| 2794 switch (tp->ptr()) { | |
| 2795 case Null: | |
| 2796 if( ptr == Null ) return TypePtr::make( AnyPtr, ptr, offset ); | |
| 223 | 2797 // else fall through to AnyNull |
| 0 | 2798 case TopPTR: |
| 223 | 2799 case AnyNull: { |
| 2800 int instance_id = meet_instance_id(InstanceTop); | |
| 0 | 2801 return make( ptr, klass(), klass_is_exact(), |
| 223 | 2802 (ptr == Constant ? const_oop() : NULL), offset, instance_id); |
| 2803 } | |
| 0 | 2804 case NotNull: |
| 2805 case BotPTR: | |
| 2806 return TypePtr::make( AnyPtr, ptr, offset ); | |
| 2807 default: typerr(t); | |
| 2808 } | |
| 2809 } | |
| 2810 | |
| 2811 /* | |
| 2812 A-top } | |
| 2813 / | \ } Tops | |
| 2814 B-top A-any C-top } | |
| 2815 | / | \ | } Any-nulls | |
| 2816 B-any | C-any } | |
| 2817 | | | | |
| 2818 B-con A-con C-con } constants; not comparable across classes | |
| 2819 | | | | |
| 2820 B-not | C-not } | |
| 2821 | \ | / | } not-nulls | |
| 2822 B-bot A-not C-bot } | |
| 2823 \ | / } Bottoms | |
| 2824 A-bot } | |
| 2825 */ | |
| 2826 | |
| 2827 case InstPtr: { // Meeting 2 Oops? | |
| 2828 // Found an InstPtr sub-type vs self-InstPtr type | |
| 2829 const TypeInstPtr *tinst = t->is_instptr(); | |
| 2830 int off = meet_offset( tinst->offset() ); | |
| 2831 PTR ptr = meet_ptr( tinst->ptr() ); | |
| 223 | 2832 int instance_id = meet_instance_id(tinst->instance_id()); |
| 0 | 2833 |
| 2834 // Check for easy case; klasses are equal (and perhaps not loaded!) | |
| 2835 // If we have constants, then we created oops so classes are loaded | |
| 2836 // and we can handle the constants further down. This case handles | |
| 2837 // both-not-loaded or both-loaded classes | |
| 2838 if (ptr != Constant && klass()->equals(tinst->klass()) && klass_is_exact() == tinst->klass_is_exact()) { | |
| 2839 return make( ptr, klass(), klass_is_exact(), NULL, off, instance_id ); | |
| 2840 } | |
| 2841 | |
| 2842 // Classes require inspection in the Java klass hierarchy. Must be loaded. | |
| 2843 ciKlass* tinst_klass = tinst->klass(); | |
| 2844 ciKlass* this_klass = this->klass(); | |
| 2845 bool tinst_xk = tinst->klass_is_exact(); | |
| 2846 bool this_xk = this->klass_is_exact(); | |
| 2847 if (!tinst_klass->is_loaded() || !this_klass->is_loaded() ) { | |
| 2848 // One of these classes has not been loaded | |
| 2849 const TypeInstPtr *unloaded_meet = xmeet_unloaded(tinst); | |
| 2850 #ifndef PRODUCT | |
| 2851 if( PrintOpto && Verbose ) { | |
| 2852 tty->print("meet of unloaded classes resulted in: "); unloaded_meet->dump(); tty->cr(); | |
| 2853 tty->print(" this == "); this->dump(); tty->cr(); | |
| 2854 tty->print(" tinst == "); tinst->dump(); tty->cr(); | |
| 2855 } | |
| 2856 #endif | |
| 2857 return unloaded_meet; | |
| 2858 } | |
| 2859 | |
| 2860 // Handle mixing oops and interfaces first. | |
| 2861 if( this_klass->is_interface() && !tinst_klass->is_interface() ) { | |
| 2862 ciKlass *tmp = tinst_klass; // Swap interface around | |
| 2863 tinst_klass = this_klass; | |
| 2864 this_klass = tmp; | |
| 2865 bool tmp2 = tinst_xk; | |
| 2866 tinst_xk = this_xk; | |
| 2867 this_xk = tmp2; | |
| 2868 } | |
| 2869 if (tinst_klass->is_interface() && | |
| 2870 !(this_klass->is_interface() || | |
| 2871 // Treat java/lang/Object as an honorary interface, | |
| 2872 // because we need a bottom for the interface hierarchy. | |
| 2873 this_klass == ciEnv::current()->Object_klass())) { | |
| 2874 // Oop meets interface! | |
| 2875 | |
| 2876 // See if the oop subtypes (implements) interface. | |
| 2877 ciKlass *k; | |
| 2878 bool xk; | |
| 2879 if( this_klass->is_subtype_of( tinst_klass ) ) { | |
| 2880 // Oop indeed subtypes. Now keep oop or interface depending | |
| 2881 // on whether we are both above the centerline or either is | |
| 2882 // below the centerline. If we are on the centerline | |
| 2883 // (e.g., Constant vs. AnyNull interface), use the constant. | |
| 2884 k = below_centerline(ptr) ? tinst_klass : this_klass; | |
| 2885 // If we are keeping this_klass, keep its exactness too. | |
| 2886 xk = below_centerline(ptr) ? tinst_xk : this_xk; | |
| 2887 } else { // Does not implement, fall to Object | |
| 2888 // Oop does not implement interface, so mixing falls to Object | |
| 2889 // just like the verifier does (if both are above the | |
| 2890 // centerline fall to interface) | |
| 2891 k = above_centerline(ptr) ? tinst_klass : ciEnv::current()->Object_klass(); | |
| 2892 xk = above_centerline(ptr) ? tinst_xk : false; | |
| 2893 // Watch out for Constant vs. AnyNull interface. | |
| 2894 if (ptr == Constant) ptr = NotNull; // forget it was a constant | |
| 247 | 2895 instance_id = InstanceBot; |
| 0 | 2896 } |
| 2897 ciObject* o = NULL; // the Constant value, if any | |
| 2898 if (ptr == Constant) { | |
| 2899 // Find out which constant. | |
| 2900 o = (this_klass == klass()) ? const_oop() : tinst->const_oop(); | |
| 2901 } | |
| 223 | 2902 return make( ptr, k, xk, o, off, instance_id ); |
| 0 | 2903 } |
| 2904 | |
| 2905 // Either oop vs oop or interface vs interface or interface vs Object | |
| 2906 | |
| 2907 // !!! Here's how the symmetry requirement breaks down into invariants: | |
| 2908 // If we split one up & one down AND they subtype, take the down man. | |
| 2909 // If we split one up & one down AND they do NOT subtype, "fall hard". | |
| 2910 // If both are up and they subtype, take the subtype class. | |
| 2911 // If both are up and they do NOT subtype, "fall hard". | |
| 2912 // If both are down and they subtype, take the supertype class. | |
| 2913 // If both are down and they do NOT subtype, "fall hard". | |
| 2914 // Constants treated as down. | |
| 2915 | |
| 2916 // Now, reorder the above list; observe that both-down+subtype is also | |
| 2917 // "fall hard"; "fall hard" becomes the default case: | |
| 2918 // If we split one up & one down AND they subtype, take the down man. | |
| 2919 // If both are up and they subtype, take the subtype class. | |
| 2920 | |
| 2921 // If both are down and they subtype, "fall hard". | |
| 2922 // If both are down and they do NOT subtype, "fall hard". | |
| 2923 // If both are up and they do NOT subtype, "fall hard". | |
| 2924 // If we split one up & one down AND they do NOT subtype, "fall hard". | |
| 2925 | |
| 2926 // If a proper subtype is exact, and we return it, we return it exactly. | |
| 2927 // If a proper supertype is exact, there can be no subtyping relationship! | |
| 2928 // If both types are equal to the subtype, exactness is and-ed below the | |
| 2929 // centerline and or-ed above it. (N.B. Constants are always exact.) | |
| 2930 | |
| 2931 // Check for subtyping: | |
| 2932 ciKlass *subtype = NULL; | |
| 2933 bool subtype_exact = false; | |
| 2934 if( tinst_klass->equals(this_klass) ) { | |
| 2935 subtype = this_klass; | |
| 2936 subtype_exact = below_centerline(ptr) ? (this_xk & tinst_xk) : (this_xk | tinst_xk); | |
| 2937 } else if( !tinst_xk && this_klass->is_subtype_of( tinst_klass ) ) { | |
| 2938 subtype = this_klass; // Pick subtyping class | |
| 2939 subtype_exact = this_xk; | |
| 2940 } else if( !this_xk && tinst_klass->is_subtype_of( this_klass ) ) { | |
| 2941 subtype = tinst_klass; // Pick subtyping class | |
| 2942 subtype_exact = tinst_xk; | |
| 2943 } | |
| 2944 | |
| 2945 if( subtype ) { | |
| 2946 if( above_centerline(ptr) ) { // both are up? | |
| 2947 this_klass = tinst_klass = subtype; | |
| 2948 this_xk = tinst_xk = subtype_exact; | |
| 2949 } else if( above_centerline(this ->_ptr) && !above_centerline(tinst->_ptr) ) { | |
| 2950 this_klass = tinst_klass; // tinst is down; keep down man | |
| 2951 this_xk = tinst_xk; | |
| 2952 } else if( above_centerline(tinst->_ptr) && !above_centerline(this ->_ptr) ) { | |
| 2953 tinst_klass = this_klass; // this is down; keep down man | |
| 2954 tinst_xk = this_xk; | |
| 2955 } else { | |
| 2956 this_xk = subtype_exact; // either they are equal, or we'll do an LCA | |
| 2957 } | |
| 2958 } | |
| 2959 | |
| 2960 // Check for classes now being equal | |
| 2961 if (tinst_klass->equals(this_klass)) { | |
| 2962 // If the klasses are equal, the constants may still differ. Fall to | |
| 2963 // NotNull if they do (neither constant is NULL; that is a special case | |
| 2964 // handled elsewhere). | |
| 2965 ciObject* o = NULL; // Assume not constant when done | |
| 2966 ciObject* this_oop = const_oop(); | |
| 2967 ciObject* tinst_oop = tinst->const_oop(); | |
| 2968 if( ptr == Constant ) { | |
| 2969 if (this_oop != NULL && tinst_oop != NULL && | |
| 2970 this_oop->equals(tinst_oop) ) | |
| 2971 o = this_oop; | |
| 2972 else if (above_centerline(this ->_ptr)) | |
| 2973 o = tinst_oop; | |
| 2974 else if (above_centerline(tinst ->_ptr)) | |
| 2975 o = this_oop; | |
| 2976 else | |
| 2977 ptr = NotNull; | |
| 2978 } | |
| 2979 return make( ptr, this_klass, this_xk, o, off, instance_id ); | |
| 2980 } // Else classes are not equal | |
| 2981 | |
| 2982 // Since klasses are different, we require a LCA in the Java | |
| 2983 // class hierarchy - which means we have to fall to at least NotNull. | |
| 2984 if( ptr == TopPTR || ptr == AnyNull || ptr == Constant ) | |
| 2985 ptr = NotNull; | |
| 247 | 2986 instance_id = InstanceBot; |
| 0 | 2987 |
| 2988 // Now we find the LCA of Java classes | |
| 2989 ciKlass* k = this_klass->least_common_ancestor(tinst_klass); | |
| 223 | 2990 return make( ptr, k, false, NULL, off, instance_id ); |
| 0 | 2991 } // End of case InstPtr |
| 2992 | |
| 2993 case KlassPtr: | |
| 2994 return TypeInstPtr::BOTTOM; | |
| 2995 | |
| 2996 } // End of switch | |
| 2997 return this; // Return the double constant | |
| 2998 } | |
| 2999 | |
| 3000 | |
| 3001 //------------------------java_mirror_type-------------------------------------- | |
| 3002 ciType* TypeInstPtr::java_mirror_type() const { | |
| 3003 // must be a singleton type | |
| 3004 if( const_oop() == NULL ) return NULL; | |
| 3005 | |
| 3006 // must be of type java.lang.Class | |
| 3007 if( klass() != ciEnv::current()->Class_klass() ) return NULL; | |
| 3008 | |
| 3009 return const_oop()->as_instance()->java_mirror_type(); | |
| 3010 } | |
| 3011 | |
| 3012 | |
| 3013 //------------------------------xdual------------------------------------------ | |
| 3014 // Dual: do NOT dual on klasses. This means I do NOT understand the Java | |
| 3015 // inheritence mechanism. | |
| 3016 const Type *TypeInstPtr::xdual() const { | |
| 223 | 3017 return new TypeInstPtr( dual_ptr(), klass(), klass_is_exact(), const_oop(), dual_offset(), dual_instance_id() ); |
| 0 | 3018 } |
| 3019 | |
| 3020 //------------------------------eq--------------------------------------------- | |
| 3021 // Structural equality check for Type representations | |
| 3022 bool TypeInstPtr::eq( const Type *t ) const { | |
| 3023 const TypeInstPtr *p = t->is_instptr(); | |
| 3024 return | |
| 3025 klass()->equals(p->klass()) && | |
| 3026 TypeOopPtr::eq(p); // Check sub-type stuff | |
| 3027 } | |
| 3028 | |
| 3029 //------------------------------hash------------------------------------------- | |
| 3030 // Type-specific hashing function. | |
| 3031 int TypeInstPtr::hash(void) const { | |
| 3032 int hash = klass()->hash() + TypeOopPtr::hash(); | |
| 3033 return hash; | |
| 3034 } | |
| 3035 | |
| 3036 //------------------------------dump2------------------------------------------ | |
| 3037 // Dump oop Type | |
| 3038 #ifndef PRODUCT | |
| 3039 void TypeInstPtr::dump2( Dict &d, uint depth, outputStream *st ) const { | |
| 3040 // Print the name of the klass. | |
| 3041 klass()->print_name_on(st); | |
| 3042 | |
| 3043 switch( _ptr ) { | |
| 3044 case Constant: | |
| 3045 // TO DO: Make CI print the hex address of the underlying oop. | |
| 3046 if (WizardMode || Verbose) { | |
| 3047 const_oop()->print_oop(st); | |
| 3048 } | |
| 3049 case BotPTR: | |
| 3050 if (!WizardMode && !Verbose) { | |
| 3051 if( _klass_is_exact ) st->print(":exact"); | |
| 3052 break; | |
| 3053 } | |
| 3054 case TopPTR: | |
| 3055 case AnyNull: | |
| 3056 case NotNull: | |
| 3057 st->print(":%s", ptr_msg[_ptr]); | |
| 3058 if( _klass_is_exact ) st->print(":exact"); | |
| 3059 break; | |
| 3060 } | |
| 3061 | |
| 3062 if( _offset ) { // Dump offset, if any | |
| 3063 if( _offset == OffsetBot ) st->print("+any"); | |
| 3064 else if( _offset == OffsetTop ) st->print("+unknown"); | |
| 3065 else st->print("+%d", _offset); | |
| 3066 } | |
| 3067 | |
| 3068 st->print(" *"); | |
| 223 | 3069 if (_instance_id == InstanceTop) |
| 3070 st->print(",iid=top"); | |
| 3071 else if (_instance_id != InstanceBot) | |
| 0 | 3072 st->print(",iid=%d",_instance_id); |
| 3073 } | |
| 3074 #endif | |
| 3075 | |
| 3076 //------------------------------add_offset------------------------------------- | |
|
306
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
3077 const TypePtr *TypeInstPtr::add_offset( intptr_t offset ) const { |
| 0 | 3078 return make( _ptr, klass(), klass_is_exact(), const_oop(), xadd_offset(offset), _instance_id ); |
| 3079 } | |
| 3080 | |
| 3081 //============================================================================= | |
| 3082 // Convenience common pre-built types. | |
| 3083 const TypeAryPtr *TypeAryPtr::RANGE; | |
| 3084 const TypeAryPtr *TypeAryPtr::OOPS; | |
| 163 | 3085 const TypeAryPtr *TypeAryPtr::NARROWOOPS; |
| 0 | 3086 const TypeAryPtr *TypeAryPtr::BYTES; |
| 3087 const TypeAryPtr *TypeAryPtr::SHORTS; | |
| 3088 const TypeAryPtr *TypeAryPtr::CHARS; | |
| 3089 const TypeAryPtr *TypeAryPtr::INTS; | |
| 3090 const TypeAryPtr *TypeAryPtr::LONGS; | |
| 3091 const TypeAryPtr *TypeAryPtr::FLOATS; | |
| 3092 const TypeAryPtr *TypeAryPtr::DOUBLES; | |
| 3093 | |
| 3094 //------------------------------make------------------------------------------- | |
| 3095 const TypeAryPtr *TypeAryPtr::make( PTR ptr, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id ) { | |
| 3096 assert(!(k == NULL && ary->_elem->isa_int()), | |
| 3097 "integral arrays must be pre-equipped with a class"); | |
| 3098 if (!xk) xk = ary->ary_must_be_exact(); | |
| 247 | 3099 assert(instance_id <= 0 || xk || !UseExactTypes, "instances are always exactly typed"); |
| 0 | 3100 if (!UseExactTypes) xk = (ptr == Constant); |
| 3101 return (TypeAryPtr*)(new TypeAryPtr(ptr, NULL, ary, k, xk, offset, instance_id))->hashcons(); | |
| 3102 } | |
| 3103 | |
| 3104 //------------------------------make------------------------------------------- | |
| 3105 const TypeAryPtr *TypeAryPtr::make( PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id ) { | |
| 3106 assert(!(k == NULL && ary->_elem->isa_int()), | |
| 3107 "integral arrays must be pre-equipped with a class"); | |
| 3108 assert( (ptr==Constant && o) || (ptr!=Constant && !o), "" ); | |
| 3109 if (!xk) xk = (o != NULL) || ary->ary_must_be_exact(); | |
| 247 | 3110 assert(instance_id <= 0 || xk || !UseExactTypes, "instances are always exactly typed"); |
| 0 | 3111 if (!UseExactTypes) xk = (ptr == Constant); |
| 3112 return (TypeAryPtr*)(new TypeAryPtr(ptr, o, ary, k, xk, offset, instance_id))->hashcons(); | |
| 3113 } | |
| 3114 | |
| 3115 //------------------------------cast_to_ptr_type------------------------------- | |
| 3116 const Type *TypeAryPtr::cast_to_ptr_type(PTR ptr) const { | |
| 3117 if( ptr == _ptr ) return this; | |
| 223 | 3118 return make(ptr, const_oop(), _ary, klass(), klass_is_exact(), _offset, _instance_id); |
| 0 | 3119 } |
| 3120 | |
| 3121 | |
| 3122 //-----------------------------cast_to_exactness------------------------------- | |
| 3123 const Type *TypeAryPtr::cast_to_exactness(bool klass_is_exact) const { | |
| 3124 if( klass_is_exact == _klass_is_exact ) return this; | |
| 3125 if (!UseExactTypes) return this; | |
| 3126 if (_ary->ary_must_be_exact()) return this; // cannot clear xk | |
| 3127 return make(ptr(), const_oop(), _ary, klass(), klass_is_exact, _offset, _instance_id); | |
| 3128 } | |
| 3129 | |
| 247 | 3130 //-----------------------------cast_to_instance_id---------------------------- |
| 223 | 3131 const TypeOopPtr *TypeAryPtr::cast_to_instance_id(int instance_id) const { |
| 3132 if( instance_id == _instance_id ) return this; | |
| 247 | 3133 return make(_ptr, const_oop(), _ary, klass(), _klass_is_exact, _offset, instance_id); |
| 0 | 3134 } |
| 3135 | |
| 3136 //-----------------------------narrow_size_type------------------------------- | |
| 3137 // Local cache for arrayOopDesc::max_array_length(etype), | |
| 3138 // which is kind of slow (and cached elsewhere by other users). | |
| 3139 static jint max_array_length_cache[T_CONFLICT+1]; | |
| 3140 static jint max_array_length(BasicType etype) { | |
| 3141 jint& cache = max_array_length_cache[etype]; | |
| 3142 jint res = cache; | |
| 3143 if (res == 0) { | |
| 3144 switch (etype) { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3145 case T_NARROWOOP: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3146 etype = T_OBJECT; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3147 break; |
| 0 | 3148 case T_CONFLICT: |
| 3149 case T_ILLEGAL: | |
| 3150 case T_VOID: | |
| 3151 etype = T_BYTE; // will produce conservatively high value | |
| 3152 } | |
| 3153 cache = res = arrayOopDesc::max_array_length(etype); | |
| 3154 } | |
| 3155 return res; | |
| 3156 } | |
| 3157 | |
| 3158 // Narrow the given size type to the index range for the given array base type. | |
| 3159 // Return NULL if the resulting int type becomes empty. | |
|
366
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
306
diff
changeset
|
3160 const TypeInt* TypeAryPtr::narrow_size_type(const TypeInt* size) const { |
| 0 | 3161 jint hi = size->_hi; |
| 3162 jint lo = size->_lo; | |
| 3163 jint min_lo = 0; | |
|
366
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
306
diff
changeset
|
3164 jint max_hi = max_array_length(elem()->basic_type()); |
| 0 | 3165 //if (index_not_size) --max_hi; // type of a valid array index, FTR |
| 3166 bool chg = false; | |
| 3167 if (lo < min_lo) { lo = min_lo; chg = true; } | |
| 3168 if (hi > max_hi) { hi = max_hi; chg = true; } | |
|
366
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
306
diff
changeset
|
3169 // Negative length arrays will produce weird intermediate dead fath-path code |
| 0 | 3170 if (lo > hi) |
|
366
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
306
diff
changeset
|
3171 return TypeInt::ZERO; |
| 0 | 3172 if (!chg) |
| 3173 return size; | |
| 3174 return TypeInt::make(lo, hi, Type::WidenMin); | |
| 3175 } | |
| 3176 | |
| 3177 //-------------------------------cast_to_size---------------------------------- | |
| 3178 const TypeAryPtr* TypeAryPtr::cast_to_size(const TypeInt* new_size) const { | |
| 3179 assert(new_size != NULL, ""); | |
|
366
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
306
diff
changeset
|
3180 new_size = narrow_size_type(new_size); |
| 0 | 3181 if (new_size == size()) return this; |
| 3182 const TypeAry* new_ary = TypeAry::make(elem(), new_size); | |
| 223 | 3183 return make(ptr(), const_oop(), new_ary, klass(), klass_is_exact(), _offset, _instance_id); |
| 0 | 3184 } |
| 3185 | |
| 3186 | |
| 3187 //------------------------------eq--------------------------------------------- | |
| 3188 // Structural equality check for Type representations | |
| 3189 bool TypeAryPtr::eq( const Type *t ) const { | |
| 3190 const TypeAryPtr *p = t->is_aryptr(); | |
| 3191 return | |
| 3192 _ary == p->_ary && // Check array | |
| 3193 TypeOopPtr::eq(p); // Check sub-parts | |
| 3194 } | |
| 3195 | |
| 3196 //------------------------------hash------------------------------------------- | |
| 3197 // Type-specific hashing function. | |
| 3198 int TypeAryPtr::hash(void) const { | |
| 3199 return (intptr_t)_ary + TypeOopPtr::hash(); | |
| 3200 } | |
| 3201 | |
| 3202 //------------------------------meet------------------------------------------- | |
| 3203 // Compute the MEET of two types. It returns a new Type object. | |
| 3204 const Type *TypeAryPtr::xmeet( const Type *t ) const { | |
| 3205 // Perform a fast test for common case; meeting the same types together. | |
| 3206 if( this == t ) return this; // Meeting same type-rep? | |
| 3207 // Current "this->_base" is Pointer | |
| 3208 switch (t->base()) { // switch on original type | |
| 3209 | |
| 3210 // Mixing ints & oops happens when javac reuses local variables | |
| 3211 case Int: | |
| 3212 case Long: | |
| 3213 case FloatTop: | |
| 3214 case FloatCon: | |
| 3215 case FloatBot: | |
| 3216 case DoubleTop: | |
| 3217 case DoubleCon: | |
| 3218 case DoubleBot: | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3219 case NarrowOop: |
| 0 | 3220 case Bottom: // Ye Olde Default |
| 3221 return Type::BOTTOM; | |
| 3222 case Top: | |
| 3223 return this; | |
| 3224 | |
| 3225 default: // All else is a mistake | |
| 3226 typerr(t); | |
| 3227 | |
| 3228 case OopPtr: { // Meeting to OopPtrs | |
| 3229 // Found a OopPtr type vs self-AryPtr type | |
| 3230 const TypePtr *tp = t->is_oopptr(); | |
| 3231 int offset = meet_offset(tp->offset()); | |
| 3232 PTR ptr = meet_ptr(tp->ptr()); | |
| 3233 switch (tp->ptr()) { | |
| 3234 case TopPTR: | |
| 223 | 3235 case AnyNull: { |
| 3236 int instance_id = meet_instance_id(InstanceTop); | |
| 3237 return make(ptr, (ptr == Constant ? const_oop() : NULL), | |
| 3238 _ary, _klass, _klass_is_exact, offset, instance_id); | |
| 3239 } | |
| 0 | 3240 case BotPTR: |
| 3241 case NotNull: | |
| 3242 return TypeOopPtr::make(ptr, offset); | |
| 3243 default: ShouldNotReachHere(); | |
| 3244 } | |
| 3245 } | |
| 3246 | |
| 3247 case AnyPtr: { // Meeting two AnyPtrs | |
| 3248 // Found an AnyPtr type vs self-AryPtr type | |
| 3249 const TypePtr *tp = t->is_ptr(); | |
| 3250 int offset = meet_offset(tp->offset()); | |
| 3251 PTR ptr = meet_ptr(tp->ptr()); | |
| 3252 switch (tp->ptr()) { | |
| 3253 case TopPTR: | |
| 3254 return this; | |
| 3255 case BotPTR: | |
| 3256 case NotNull: | |
| 3257 return TypePtr::make(AnyPtr, ptr, offset); | |
| 3258 case Null: | |
| 3259 if( ptr == Null ) return TypePtr::make(AnyPtr, ptr, offset); | |
| 223 | 3260 // else fall through to AnyNull |
| 3261 case AnyNull: { | |
| 3262 int instance_id = meet_instance_id(InstanceTop); | |
| 3263 return make( ptr, (ptr == Constant ? const_oop() : NULL), | |
| 3264 _ary, _klass, _klass_is_exact, offset, instance_id); | |
| 3265 } | |
| 0 | 3266 default: ShouldNotReachHere(); |
| 3267 } | |
| 3268 } | |
| 3269 | |
| 3270 case RawPtr: return TypePtr::BOTTOM; | |
| 3271 | |
| 3272 case AryPtr: { // Meeting 2 references? | |
| 3273 const TypeAryPtr *tap = t->is_aryptr(); | |
| 3274 int off = meet_offset(tap->offset()); | |
| 3275 const TypeAry *tary = _ary->meet(tap->_ary)->is_ary(); | |
| 3276 PTR ptr = meet_ptr(tap->ptr()); | |
| 223 | 3277 int instance_id = meet_instance_id(tap->instance_id()); |
| 0 | 3278 ciKlass* lazy_klass = NULL; |
| 3279 if (tary->_elem->isa_int()) { | |
| 3280 // Integral array element types have irrelevant lattice relations. | |
| 3281 // It is the klass that determines array layout, not the element type. | |
| 3282 if (_klass == NULL) | |
| 3283 lazy_klass = tap->_klass; | |
| 3284 else if (tap->_klass == NULL || tap->_klass == _klass) { | |
| 3285 lazy_klass = _klass; | |
| 3286 } else { | |
| 3287 // Something like byte[int+] meets char[int+]. | |
| 3288 // This must fall to bottom, not (int[-128..65535])[int+]. | |
| 247 | 3289 instance_id = InstanceBot; |
| 0 | 3290 tary = TypeAry::make(Type::BOTTOM, tary->_size); |
| 3291 } | |
| 3292 } | |
| 3293 bool xk; | |
| 3294 switch (tap->ptr()) { | |
| 3295 case AnyNull: | |
| 3296 case TopPTR: | |
| 3297 // Compute new klass on demand, do not use tap->_klass | |
| 3298 xk = (tap->_klass_is_exact | this->_klass_is_exact); | |
| 223 | 3299 return make( ptr, const_oop(), tary, lazy_klass, xk, off, instance_id ); |
| 0 | 3300 case Constant: { |
| 3301 ciObject* o = const_oop(); | |
| 3302 if( _ptr == Constant ) { | |
| 3303 if( tap->const_oop() != NULL && !o->equals(tap->const_oop()) ) { | |
| 3304 ptr = NotNull; | |
| 3305 o = NULL; | |
| 247 | 3306 instance_id = InstanceBot; |
| 0 | 3307 } |
| 3308 } else if( above_centerline(_ptr) ) { | |
| 3309 o = tap->const_oop(); | |
| 3310 } | |
| 3311 xk = true; | |
| 223 | 3312 return TypeAryPtr::make( ptr, o, tary, tap->_klass, xk, off, instance_id ); |
| 0 | 3313 } |
| 3314 case NotNull: | |
| 3315 case BotPTR: | |
| 3316 // Compute new klass on demand, do not use tap->_klass | |
| 3317 if (above_centerline(this->_ptr)) | |
| 3318 xk = tap->_klass_is_exact; | |
| 3319 else if (above_centerline(tap->_ptr)) | |
| 3320 xk = this->_klass_is_exact; | |
| 3321 else xk = (tap->_klass_is_exact & this->_klass_is_exact) && | |
| 3322 (klass() == tap->klass()); // Only precise for identical arrays | |
| 223 | 3323 return TypeAryPtr::make( ptr, NULL, tary, lazy_klass, xk, off, instance_id ); |
| 0 | 3324 default: ShouldNotReachHere(); |
| 3325 } | |
| 3326 } | |
| 3327 | |
| 3328 // All arrays inherit from Object class | |
| 3329 case InstPtr: { | |
| 3330 const TypeInstPtr *tp = t->is_instptr(); | |
| 3331 int offset = meet_offset(tp->offset()); | |
| 3332 PTR ptr = meet_ptr(tp->ptr()); | |
| 223 | 3333 int instance_id = meet_instance_id(tp->instance_id()); |
| 0 | 3334 switch (ptr) { |
| 3335 case TopPTR: | |
| 3336 case AnyNull: // Fall 'down' to dual of object klass | |
| 3337 if( tp->klass()->equals(ciEnv::current()->Object_klass()) ) { | |
| 223 | 3338 return TypeAryPtr::make( ptr, _ary, _klass, _klass_is_exact, offset, instance_id ); |
| 0 | 3339 } else { |
| 3340 // cannot subclass, so the meet has to fall badly below the centerline | |
| 3341 ptr = NotNull; | |
| 223 | 3342 instance_id = InstanceBot; |
| 3343 return TypeInstPtr::make( ptr, ciEnv::current()->Object_klass(), false, NULL,offset, instance_id); | |
| 0 | 3344 } |
| 3345 case Constant: | |
| 3346 case NotNull: | |
| 3347 case BotPTR: // Fall down to object klass | |
| 3348 // LCA is object_klass, but if we subclass from the top we can do better | |
| 3349 if (above_centerline(tp->ptr())) { | |
| 3350 // If 'tp' is above the centerline and it is Object class | |
| 3351 // then we can subclass in the Java class heirarchy. | |
| 3352 if( tp->klass()->equals(ciEnv::current()->Object_klass()) ) { | |
| 3353 // that is, my array type is a subtype of 'tp' klass | |
| 223 | 3354 return make( ptr, _ary, _klass, _klass_is_exact, offset, instance_id ); |
| 0 | 3355 } |
| 3356 } | |
| 3357 // The other case cannot happen, since t cannot be a subtype of an array. | |
| 3358 // The meet falls down to Object class below centerline. | |
| 3359 if( ptr == Constant ) | |
| 3360 ptr = NotNull; | |
| 223 | 3361 instance_id = InstanceBot; |
| 3362 return TypeInstPtr::make( ptr, ciEnv::current()->Object_klass(), false, NULL,offset, instance_id); | |
| 0 | 3363 default: typerr(t); |
| 3364 } | |
| 3365 } | |
| 3366 | |
| 3367 case KlassPtr: | |
| 3368 return TypeInstPtr::BOTTOM; | |
| 3369 | |
| 3370 } | |
| 3371 return this; // Lint noise | |
| 3372 } | |
| 3373 | |
| 3374 //------------------------------xdual------------------------------------------ | |
| 3375 // Dual: compute field-by-field dual | |
| 3376 const Type *TypeAryPtr::xdual() const { | |
| 223 | 3377 return new TypeAryPtr( dual_ptr(), _const_oop, _ary->dual()->is_ary(),_klass, _klass_is_exact, dual_offset(), dual_instance_id() ); |
| 0 | 3378 } |
| 3379 | |
| 3380 //------------------------------dump2------------------------------------------ | |
| 3381 #ifndef PRODUCT | |
| 3382 void TypeAryPtr::dump2( Dict &d, uint depth, outputStream *st ) const { | |
| 3383 _ary->dump2(d,depth,st); | |
| 3384 switch( _ptr ) { | |
| 3385 case Constant: | |
| 3386 const_oop()->print(st); | |
| 3387 break; | |
| 3388 case BotPTR: | |
| 3389 if (!WizardMode && !Verbose) { | |
| 3390 if( _klass_is_exact ) st->print(":exact"); | |
| 3391 break; | |
| 3392 } | |
| 3393 case TopPTR: | |
| 3394 case AnyNull: | |
| 3395 case NotNull: | |
| 3396 st->print(":%s", ptr_msg[_ptr]); | |
| 3397 if( _klass_is_exact ) st->print(":exact"); | |
| 3398 break; | |
| 3399 } | |
| 3400 | |
|
64
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3401 if( _offset != 0 ) { |
|
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3402 int header_size = objArrayOopDesc::header_size() * wordSize; |
|
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3403 if( _offset == OffsetTop ) st->print("+undefined"); |
|
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3404 else if( _offset == OffsetBot ) st->print("+any"); |
|
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3405 else if( _offset < header_size ) st->print("+%d", _offset); |
|
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3406 else { |
|
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3407 BasicType basic_elem_type = elem()->basic_type(); |
|
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3408 int array_base = arrayOopDesc::base_offset_in_bytes(basic_elem_type); |
|
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3409 int elem_size = type2aelembytes(basic_elem_type); |
|
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3410 st->print("[%d]", (_offset - array_base)/elem_size); |
|
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3411 } |
|
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3412 } |
|
b8f5ba577b02
6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents:
0
diff
changeset
|
3413 st->print(" *"); |
| 223 | 3414 if (_instance_id == InstanceTop) |
| 3415 st->print(",iid=top"); | |
| 3416 else if (_instance_id != InstanceBot) | |
| 0 | 3417 st->print(",iid=%d",_instance_id); |
| 3418 } | |
| 3419 #endif | |
| 3420 | |
| 3421 bool TypeAryPtr::empty(void) const { | |
| 3422 if (_ary->empty()) return true; | |
| 3423 return TypeOopPtr::empty(); | |
| 3424 } | |
| 3425 | |
| 3426 //------------------------------add_offset------------------------------------- | |
|
306
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
3427 const TypePtr *TypeAryPtr::add_offset( intptr_t offset ) const { |
| 0 | 3428 return make( _ptr, _const_oop, _ary, _klass, _klass_is_exact, xadd_offset(offset), _instance_id ); |
| 3429 } | |
| 3430 | |
| 3431 | |
| 3432 //============================================================================= | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3433 const TypeNarrowOop *TypeNarrowOop::BOTTOM; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3434 const TypeNarrowOop *TypeNarrowOop::NULL_PTR; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3435 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3436 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3437 const TypeNarrowOop* TypeNarrowOop::make(const TypePtr* type) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3438 return (const TypeNarrowOop*)(new TypeNarrowOop(type))->hashcons(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3439 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3440 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3441 //------------------------------hash------------------------------------------- |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3442 // Type-specific hashing function. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3443 int TypeNarrowOop::hash(void) const { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3444 return _ooptype->hash() + 7; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3445 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3446 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3447 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3448 bool TypeNarrowOop::eq( const Type *t ) const { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3449 const TypeNarrowOop* tc = t->isa_narrowoop(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3450 if (tc != NULL) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3451 if (_ooptype->base() != tc->_ooptype->base()) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3452 return false; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3453 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3454 return tc->_ooptype->eq(_ooptype); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3455 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3456 return false; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3457 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3458 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3459 bool TypeNarrowOop::singleton(void) const { // TRUE if type is a singleton |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3460 return _ooptype->singleton(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3461 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3462 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3463 bool TypeNarrowOop::empty(void) const { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3464 return _ooptype->empty(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3465 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3466 |
|
293
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
247
diff
changeset
|
3467 //------------------------------xmeet------------------------------------------ |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3468 // Compute the MEET of two types. It returns a new Type object. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3469 const Type *TypeNarrowOop::xmeet( const Type *t ) const { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3470 // Perform a fast test for common case; meeting the same types together. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3471 if( this == t ) return this; // Meeting same type-rep? |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3472 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3473 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3474 // Current "this->_base" is OopPtr |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3475 switch (t->base()) { // switch on original type |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3476 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3477 case Int: // Mixing ints & oops happens when javac |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3478 case Long: // reuses local variables |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3479 case FloatTop: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3480 case FloatCon: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3481 case FloatBot: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3482 case DoubleTop: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3483 case DoubleCon: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3484 case DoubleBot: |
|
293
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
247
diff
changeset
|
3485 case AnyPtr: |
|
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
247
diff
changeset
|
3486 case RawPtr: |
|
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
247
diff
changeset
|
3487 case OopPtr: |
|
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
247
diff
changeset
|
3488 case InstPtr: |
|
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
247
diff
changeset
|
3489 case KlassPtr: |
|
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
247
diff
changeset
|
3490 case AryPtr: |
|
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
247
diff
changeset
|
3491 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3492 case Bottom: // Ye Olde Default |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3493 return Type::BOTTOM; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3494 case Top: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3495 return this; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3496 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3497 case NarrowOop: { |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
183
diff
changeset
|
3498 const Type* result = _ooptype->xmeet(t->make_ptr()); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3499 if (result->isa_ptr()) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3500 return TypeNarrowOop::make(result->is_ptr()); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3501 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3502 return result; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3503 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3504 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3505 default: // All else is a mistake |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3506 typerr(t); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3507 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3508 } // End of switch |
|
293
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
247
diff
changeset
|
3509 |
|
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
247
diff
changeset
|
3510 return this; |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3511 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3512 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3513 const Type *TypeNarrowOop::xdual() const { // Compute dual right now. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3514 const TypePtr* odual = _ooptype->dual()->is_ptr(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3515 return new TypeNarrowOop(odual); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3516 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3517 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3518 const Type *TypeNarrowOop::filter( const Type *kills ) const { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3519 if (kills->isa_narrowoop()) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3520 const Type* ft =_ooptype->filter(kills->is_narrowoop()->_ooptype); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3521 if (ft->empty()) |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3522 return Type::TOP; // Canonical empty value |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3523 if (ft->isa_ptr()) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3524 return make(ft->isa_ptr()); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3525 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3526 return ft; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3527 } else if (kills->isa_ptr()) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3528 const Type* ft = _ooptype->join(kills); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3529 if (ft->empty()) |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3530 return Type::TOP; // Canonical empty value |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3531 return ft; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3532 } else { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3533 return Type::TOP; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3534 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3535 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3536 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3537 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3538 intptr_t TypeNarrowOop::get_con() const { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3539 return _ooptype->get_con(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3540 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3541 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3542 #ifndef PRODUCT |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3543 void TypeNarrowOop::dump2( Dict & d, uint depth, outputStream *st ) const { |
| 417 | 3544 st->print("narrowoop: "); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3545 _ooptype->dump2(d, depth, st); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3546 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3547 #endif |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3548 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3549 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3550 //============================================================================= |
| 0 | 3551 // Convenience common pre-built types. |
| 3552 | |
| 3553 // Not-null object klass or below | |
| 3554 const TypeKlassPtr *TypeKlassPtr::OBJECT; | |
| 3555 const TypeKlassPtr *TypeKlassPtr::OBJECT_OR_NULL; | |
| 3556 | |
| 3557 //------------------------------TypeKlasPtr------------------------------------ | |
| 3558 TypeKlassPtr::TypeKlassPtr( PTR ptr, ciKlass* klass, int offset ) | |
| 3559 : TypeOopPtr(KlassPtr, ptr, klass, (ptr==Constant), (ptr==Constant ? klass : NULL), offset, 0) { | |
| 3560 } | |
| 3561 | |
| 3562 //------------------------------make------------------------------------------- | |
| 3563 // ptr to klass 'k', if Constant, or possibly to a sub-klass if not a Constant | |
| 3564 const TypeKlassPtr *TypeKlassPtr::make( PTR ptr, ciKlass* k, int offset ) { | |
| 3565 assert( k != NULL, "Expect a non-NULL klass"); | |
| 3566 assert(k->is_instance_klass() || k->is_array_klass() || | |
| 3567 k->is_method_klass(), "Incorrect type of klass oop"); | |
| 3568 TypeKlassPtr *r = | |
| 3569 (TypeKlassPtr*)(new TypeKlassPtr(ptr, k, offset))->hashcons(); | |
| 3570 | |
| 3571 return r; | |
| 3572 } | |
| 3573 | |
| 3574 //------------------------------eq--------------------------------------------- | |
| 3575 // Structural equality check for Type representations | |
| 3576 bool TypeKlassPtr::eq( const Type *t ) const { | |
| 3577 const TypeKlassPtr *p = t->is_klassptr(); | |
| 3578 return | |
| 3579 klass()->equals(p->klass()) && | |
| 3580 TypeOopPtr::eq(p); | |
| 3581 } | |
| 3582 | |
| 3583 //------------------------------hash------------------------------------------- | |
| 3584 // Type-specific hashing function. | |
| 3585 int TypeKlassPtr::hash(void) const { | |
| 3586 return klass()->hash() + TypeOopPtr::hash(); | |
| 3587 } | |
| 3588 | |
| 3589 | |
| 3590 //------------------------------klass------------------------------------------ | |
| 3591 // Return the defining klass for this class | |
| 3592 ciKlass* TypeAryPtr::klass() const { | |
| 3593 if( _klass ) return _klass; // Return cached value, if possible | |
| 3594 | |
| 3595 // Oops, need to compute _klass and cache it | |
| 3596 ciKlass* k_ary = NULL; | |
| 3597 const TypeInstPtr *tinst; | |
| 3598 const TypeAryPtr *tary; | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3599 const Type* el = elem(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3600 if (el->isa_narrowoop()) { |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
183
diff
changeset
|
3601 el = el->make_ptr(); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3602 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3603 |
| 0 | 3604 // Get element klass |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3605 if ((tinst = el->isa_instptr()) != NULL) { |
| 0 | 3606 // Compute array klass from element klass |
| 3607 k_ary = ciObjArrayKlass::make(tinst->klass()); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3608 } else if ((tary = el->isa_aryptr()) != NULL) { |
| 0 | 3609 // Compute array klass from element klass |
| 3610 ciKlass* k_elem = tary->klass(); | |
| 3611 // If element type is something like bottom[], k_elem will be null. | |
| 3612 if (k_elem != NULL) | |
| 3613 k_ary = ciObjArrayKlass::make(k_elem); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3614 } else if ((el->base() == Type::Top) || |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3615 (el->base() == Type::Bottom)) { |
| 0 | 3616 // element type of Bottom occurs from meet of basic type |
| 3617 // and object; Top occurs when doing join on Bottom. | |
| 3618 // Leave k_ary at NULL. | |
| 3619 } else { | |
| 3620 // Cannot compute array klass directly from basic type, | |
| 3621 // since subtypes of TypeInt all have basic type T_INT. | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3622 assert(!el->isa_int(), |
| 0 | 3623 "integral arrays must be pre-equipped with a class"); |
| 3624 // Compute array klass directly from basic type | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3625 k_ary = ciTypeArrayKlass::make(el->basic_type()); |
| 0 | 3626 } |
| 3627 | |
| 163 | 3628 if( this != TypeAryPtr::OOPS ) { |
| 0 | 3629 // The _klass field acts as a cache of the underlying |
| 3630 // ciKlass for this array type. In order to set the field, | |
| 3631 // we need to cast away const-ness. | |
| 3632 // | |
| 3633 // IMPORTANT NOTE: we *never* set the _klass field for the | |
| 3634 // type TypeAryPtr::OOPS. This Type is shared between all | |
| 3635 // active compilations. However, the ciKlass which represents | |
| 3636 // this Type is *not* shared between compilations, so caching | |
| 3637 // this value would result in fetching a dangling pointer. | |
| 3638 // | |
| 3639 // Recomputing the underlying ciKlass for each request is | |
| 3640 // a bit less efficient than caching, but calls to | |
| 3641 // TypeAryPtr::OOPS->klass() are not common enough to matter. | |
| 3642 ((TypeAryPtr*)this)->_klass = k_ary; | |
| 163 | 3643 if (UseCompressedOops && k_ary != NULL && k_ary->is_obj_array_klass() && |
| 3644 _offset != 0 && _offset != arrayOopDesc::length_offset_in_bytes()) { | |
| 3645 ((TypeAryPtr*)this)->_is_ptr_to_narrowoop = true; | |
| 3646 } | |
| 3647 } | |
| 0 | 3648 return k_ary; |
| 3649 } | |
| 3650 | |
| 3651 | |
| 3652 //------------------------------add_offset------------------------------------- | |
| 3653 // Access internals of klass object | |
|
306
af945ba2e739
6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents:
293
diff
changeset
|
3654 const TypePtr *TypeKlassPtr::add_offset( intptr_t offset ) const { |
| 0 | 3655 return make( _ptr, klass(), xadd_offset(offset) ); |
| 3656 } | |
| 3657 | |
| 3658 //------------------------------cast_to_ptr_type------------------------------- | |
| 3659 const Type *TypeKlassPtr::cast_to_ptr_type(PTR ptr) const { | |
| 3660 assert(_base == OopPtr, "subclass must override cast_to_ptr_type"); | |
| 3661 if( ptr == _ptr ) return this; | |
| 3662 return make(ptr, _klass, _offset); | |
| 3663 } | |
| 3664 | |
| 3665 | |
| 3666 //-----------------------------cast_to_exactness------------------------------- | |
| 3667 const Type *TypeKlassPtr::cast_to_exactness(bool klass_is_exact) const { | |
| 3668 if( klass_is_exact == _klass_is_exact ) return this; | |
| 3669 if (!UseExactTypes) return this; | |
| 3670 return make(klass_is_exact ? Constant : NotNull, _klass, _offset); | |
| 3671 } | |
| 3672 | |
| 3673 | |
| 3674 //-----------------------------as_instance_type-------------------------------- | |
| 3675 // Corresponding type for an instance of the given class. | |
| 3676 // It will be NotNull, and exact if and only if the klass type is exact. | |
| 3677 const TypeOopPtr* TypeKlassPtr::as_instance_type() const { | |
| 3678 ciKlass* k = klass(); | |
| 3679 bool xk = klass_is_exact(); | |
| 3680 //return TypeInstPtr::make(TypePtr::NotNull, k, xk, NULL, 0); | |
| 3681 const TypeOopPtr* toop = TypeOopPtr::make_from_klass_raw(k); | |
| 3682 toop = toop->cast_to_ptr_type(TypePtr::NotNull)->is_oopptr(); | |
| 3683 return toop->cast_to_exactness(xk)->is_oopptr(); | |
| 3684 } | |
| 3685 | |
| 3686 | |
| 3687 //------------------------------xmeet------------------------------------------ | |
| 3688 // Compute the MEET of two types, return a new Type object. | |
| 3689 const Type *TypeKlassPtr::xmeet( const Type *t ) const { | |
| 3690 // Perform a fast test for common case; meeting the same types together. | |
| 3691 if( this == t ) return this; // Meeting same type-rep? | |
| 3692 | |
| 3693 // Current "this->_base" is Pointer | |
| 3694 switch (t->base()) { // switch on original type | |
| 3695 | |
| 3696 case Int: // Mixing ints & oops happens when javac | |
| 3697 case Long: // reuses local variables | |
| 3698 case FloatTop: | |
| 3699 case FloatCon: | |
| 3700 case FloatBot: | |
| 3701 case DoubleTop: | |
| 3702 case DoubleCon: | |
| 3703 case DoubleBot: | |
|
293
c3e045194476
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
247
diff
changeset
|
3704 case NarrowOop: |
| 0 | 3705 case Bottom: // Ye Olde Default |
| 3706 return Type::BOTTOM; | |
| 3707 case Top: | |
| 3708 return this; | |
| 3709 | |
| 3710 default: // All else is a mistake | |
| 3711 typerr(t); | |
| 3712 | |
| 3713 case RawPtr: return TypePtr::BOTTOM; | |
| 3714 | |
| 3715 case OopPtr: { // Meeting to OopPtrs | |
| 3716 // Found a OopPtr type vs self-KlassPtr type | |
| 3717 const TypePtr *tp = t->is_oopptr(); | |
| 3718 int offset = meet_offset(tp->offset()); | |
| 3719 PTR ptr = meet_ptr(tp->ptr()); | |
| 3720 switch (tp->ptr()) { | |
| 3721 case TopPTR: | |
| 3722 case AnyNull: | |
| 3723 return make(ptr, klass(), offset); | |
| 3724 case BotPTR: | |
| 3725 case NotNull: | |
| 3726 return TypePtr::make(AnyPtr, ptr, offset); | |
| 3727 default: typerr(t); | |
| 3728 } | |
| 3729 } | |
| 3730 | |
| 3731 case AnyPtr: { // Meeting to AnyPtrs | |
| 3732 // Found an AnyPtr type vs self-KlassPtr type | |
| 3733 const TypePtr *tp = t->is_ptr(); | |
| 3734 int offset = meet_offset(tp->offset()); | |
| 3735 PTR ptr = meet_ptr(tp->ptr()); | |
| 3736 switch (tp->ptr()) { | |
| 3737 case TopPTR: | |
| 3738 return this; | |
| 3739 case Null: | |
| 3740 if( ptr == Null ) return TypePtr::make( AnyPtr, ptr, offset ); | |
| 3741 case AnyNull: | |
| 3742 return make( ptr, klass(), offset ); | |
| 3743 case BotPTR: | |
| 3744 case NotNull: | |
| 3745 return TypePtr::make(AnyPtr, ptr, offset); | |
| 3746 default: typerr(t); | |
| 3747 } | |
| 3748 } | |
| 3749 | |
| 3750 case AryPtr: // Meet with AryPtr | |
| 3751 case InstPtr: // Meet with InstPtr | |
| 3752 return TypeInstPtr::BOTTOM; | |
| 3753 | |
| 3754 // | |
| 3755 // A-top } | |
| 3756 // / | \ } Tops | |
| 3757 // B-top A-any C-top } | |
| 3758 // | / | \ | } Any-nulls | |
| 3759 // B-any | C-any } | |
| 3760 // | | | | |
| 3761 // B-con A-con C-con } constants; not comparable across classes | |
| 3762 // | | | | |
| 3763 // B-not | C-not } | |
| 3764 // | \ | / | } not-nulls | |
| 3765 // B-bot A-not C-bot } | |
| 3766 // \ | / } Bottoms | |
| 3767 // A-bot } | |
| 3768 // | |
| 3769 | |
| 3770 case KlassPtr: { // Meet two KlassPtr types | |
| 3771 const TypeKlassPtr *tkls = t->is_klassptr(); | |
| 3772 int off = meet_offset(tkls->offset()); | |
| 3773 PTR ptr = meet_ptr(tkls->ptr()); | |
| 3774 | |
| 3775 // Check for easy case; klasses are equal (and perhaps not loaded!) | |
| 3776 // If we have constants, then we created oops so classes are loaded | |
| 3777 // and we can handle the constants further down. This case handles | |
| 3778 // not-loaded classes | |
| 3779 if( ptr != Constant && tkls->klass()->equals(klass()) ) { | |
| 3780 return make( ptr, klass(), off ); | |
| 3781 } | |
| 3782 | |
| 3783 // Classes require inspection in the Java klass hierarchy. Must be loaded. | |
| 3784 ciKlass* tkls_klass = tkls->klass(); | |
| 3785 ciKlass* this_klass = this->klass(); | |
| 3786 assert( tkls_klass->is_loaded(), "This class should have been loaded."); | |
| 3787 assert( this_klass->is_loaded(), "This class should have been loaded."); | |
| 3788 | |
| 3789 // If 'this' type is above the centerline and is a superclass of the | |
| 3790 // other, we can treat 'this' as having the same type as the other. | |
| 3791 if ((above_centerline(this->ptr())) && | |
| 3792 tkls_klass->is_subtype_of(this_klass)) { | |
| 3793 this_klass = tkls_klass; | |
| 3794 } | |
| 3795 // If 'tinst' type is above the centerline and is a superclass of the | |
| 3796 // other, we can treat 'tinst' as having the same type as the other. | |
| 3797 if ((above_centerline(tkls->ptr())) && | |
| 3798 this_klass->is_subtype_of(tkls_klass)) { | |
| 3799 tkls_klass = this_klass; | |
| 3800 } | |
| 3801 | |
| 3802 // Check for classes now being equal | |
| 3803 if (tkls_klass->equals(this_klass)) { | |
| 3804 // If the klasses are equal, the constants may still differ. Fall to | |
| 3805 // NotNull if they do (neither constant is NULL; that is a special case | |
| 3806 // handled elsewhere). | |
| 3807 ciObject* o = NULL; // Assume not constant when done | |
| 3808 ciObject* this_oop = const_oop(); | |
| 3809 ciObject* tkls_oop = tkls->const_oop(); | |
| 3810 if( ptr == Constant ) { | |
| 3811 if (this_oop != NULL && tkls_oop != NULL && | |
| 3812 this_oop->equals(tkls_oop) ) | |
| 3813 o = this_oop; | |
| 3814 else if (above_centerline(this->ptr())) | |
| 3815 o = tkls_oop; | |
| 3816 else if (above_centerline(tkls->ptr())) | |
| 3817 o = this_oop; | |
| 3818 else | |
| 3819 ptr = NotNull; | |
| 3820 } | |
| 3821 return make( ptr, this_klass, off ); | |
| 3822 } // Else classes are not equal | |
| 3823 | |
| 3824 // Since klasses are different, we require the LCA in the Java | |
| 3825 // class hierarchy - which means we have to fall to at least NotNull. | |
| 3826 if( ptr == TopPTR || ptr == AnyNull || ptr == Constant ) | |
| 3827 ptr = NotNull; | |
| 3828 // Now we find the LCA of Java classes | |
| 3829 ciKlass* k = this_klass->least_common_ancestor(tkls_klass); | |
| 3830 return make( ptr, k, off ); | |
| 3831 } // End of case KlassPtr | |
| 3832 | |
| 3833 } // End of switch | |
| 3834 return this; // Return the double constant | |
| 3835 } | |
| 3836 | |
| 3837 //------------------------------xdual------------------------------------------ | |
| 3838 // Dual: compute field-by-field dual | |
| 3839 const Type *TypeKlassPtr::xdual() const { | |
| 3840 return new TypeKlassPtr( dual_ptr(), klass(), dual_offset() ); | |
| 3841 } | |
| 3842 | |
| 3843 //------------------------------dump2------------------------------------------ | |
| 3844 // Dump Klass Type | |
| 3845 #ifndef PRODUCT | |
| 3846 void TypeKlassPtr::dump2( Dict & d, uint depth, outputStream *st ) const { | |
| 3847 switch( _ptr ) { | |
| 3848 case Constant: | |
| 3849 st->print("precise "); | |
| 3850 case NotNull: | |
| 3851 { | |
| 3852 const char *name = klass()->name()->as_utf8(); | |
| 3853 if( name ) { | |
| 3854 st->print("klass %s: " INTPTR_FORMAT, name, klass()); | |
| 3855 } else { | |
| 3856 ShouldNotReachHere(); | |
| 3857 } | |
| 3858 } | |
| 3859 case BotPTR: | |
| 3860 if( !WizardMode && !Verbose && !_klass_is_exact ) break; | |
| 3861 case TopPTR: | |
| 3862 case AnyNull: | |
| 3863 st->print(":%s", ptr_msg[_ptr]); | |
| 3864 if( _klass_is_exact ) st->print(":exact"); | |
| 3865 break; | |
| 3866 } | |
| 3867 | |
| 3868 if( _offset ) { // Dump offset, if any | |
| 3869 if( _offset == OffsetBot ) { st->print("+any"); } | |
| 3870 else if( _offset == OffsetTop ) { st->print("+unknown"); } | |
| 3871 else { st->print("+%d", _offset); } | |
| 3872 } | |
| 3873 | |
| 3874 st->print(" *"); | |
| 3875 } | |
| 3876 #endif | |
| 3877 | |
| 3878 | |
| 3879 | |
| 3880 //============================================================================= | |
| 3881 // Convenience common pre-built types. | |
| 3882 | |
| 3883 //------------------------------make------------------------------------------- | |
| 3884 const TypeFunc *TypeFunc::make( const TypeTuple *domain, const TypeTuple *range ) { | |
| 3885 return (TypeFunc*)(new TypeFunc(domain,range))->hashcons(); | |
| 3886 } | |
| 3887 | |
| 3888 //------------------------------make------------------------------------------- | |
| 3889 const TypeFunc *TypeFunc::make(ciMethod* method) { | |
| 3890 Compile* C = Compile::current(); | |
| 3891 const TypeFunc* tf = C->last_tf(method); // check cache | |
| 3892 if (tf != NULL) return tf; // The hit rate here is almost 50%. | |
| 3893 const TypeTuple *domain; | |
| 3894 if (method->flags().is_static()) { | |
| 3895 domain = TypeTuple::make_domain(NULL, method->signature()); | |
| 3896 } else { | |
| 3897 domain = TypeTuple::make_domain(method->holder(), method->signature()); | |
| 3898 } | |
| 3899 const TypeTuple *range = TypeTuple::make_range(method->signature()); | |
| 3900 tf = TypeFunc::make(domain, range); | |
| 3901 C->set_last_tf(method, tf); // fill cache | |
| 3902 return tf; | |
| 3903 } | |
| 3904 | |
| 3905 //------------------------------meet------------------------------------------- | |
| 3906 // Compute the MEET of two types. It returns a new Type object. | |
| 3907 const Type *TypeFunc::xmeet( const Type *t ) const { | |
| 3908 // Perform a fast test for common case; meeting the same types together. | |
| 3909 if( this == t ) return this; // Meeting same type-rep? | |
| 3910 | |
| 3911 // Current "this->_base" is Func | |
| 3912 switch (t->base()) { // switch on original type | |
| 3913 | |
| 3914 case Bottom: // Ye Olde Default | |
| 3915 return t; | |
| 3916 | |
| 3917 default: // All else is a mistake | |
| 3918 typerr(t); | |
| 3919 | |
| 3920 case Top: | |
| 3921 break; | |
| 3922 } | |
| 3923 return this; // Return the double constant | |
| 3924 } | |
| 3925 | |
| 3926 //------------------------------xdual------------------------------------------ | |
| 3927 // Dual: compute field-by-field dual | |
| 3928 const Type *TypeFunc::xdual() const { | |
| 3929 return this; | |
| 3930 } | |
| 3931 | |
| 3932 //------------------------------eq--------------------------------------------- | |
| 3933 // Structural equality check for Type representations | |
| 3934 bool TypeFunc::eq( const Type *t ) const { | |
| 3935 const TypeFunc *a = (const TypeFunc*)t; | |
| 3936 return _domain == a->_domain && | |
| 3937 _range == a->_range; | |
| 3938 } | |
| 3939 | |
| 3940 //------------------------------hash------------------------------------------- | |
| 3941 // Type-specific hashing function. | |
| 3942 int TypeFunc::hash(void) const { | |
| 3943 return (intptr_t)_domain + (intptr_t)_range; | |
| 3944 } | |
| 3945 | |
| 3946 //------------------------------dump2------------------------------------------ | |
| 3947 // Dump Function Type | |
| 3948 #ifndef PRODUCT | |
| 3949 void TypeFunc::dump2( Dict &d, uint depth, outputStream *st ) const { | |
| 3950 if( _range->_cnt <= Parms ) | |
| 3951 st->print("void"); | |
| 3952 else { | |
| 3953 uint i; | |
| 3954 for (i = Parms; i < _range->_cnt-1; i++) { | |
| 3955 _range->field_at(i)->dump2(d,depth,st); | |
| 3956 st->print("/"); | |
| 3957 } | |
| 3958 _range->field_at(i)->dump2(d,depth,st); | |
| 3959 } | |
| 3960 st->print(" "); | |
| 3961 st->print("( "); | |
| 3962 if( !depth || d[this] ) { // Check for recursive dump | |
| 3963 st->print("...)"); | |
| 3964 return; | |
| 3965 } | |
| 3966 d.Insert((void*)this,(void*)this); // Stop recursion | |
| 3967 if (Parms < _domain->_cnt) | |
| 3968 _domain->field_at(Parms)->dump2(d,depth-1,st); | |
| 3969 for (uint i = Parms+1; i < _domain->_cnt; i++) { | |
| 3970 st->print(", "); | |
| 3971 _domain->field_at(i)->dump2(d,depth-1,st); | |
| 3972 } | |
| 3973 st->print(" )"); | |
| 3974 } | |
| 3975 | |
| 3976 //------------------------------print_flattened-------------------------------- | |
| 3977 // Print a 'flattened' signature | |
| 3978 static const char * const flat_type_msg[Type::lastype] = { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
64
diff
changeset
|
3979 "bad","control","top","int","long","_", "narrowoop", |
| 0 | 3980 "tuple:", "array:", |
| 3981 "ptr", "rawptr", "ptr", "ptr", "ptr", "ptr", | |
| 3982 "func", "abIO", "return_address", "mem", | |
| 3983 "float_top", "ftcon:", "flt", | |
| 3984 "double_top", "dblcon:", "dbl", | |
| 3985 "bottom" | |
| 3986 }; | |
| 3987 | |
| 3988 void TypeFunc::print_flattened() const { | |
| 3989 if( _range->_cnt <= Parms ) | |
| 3990 tty->print("void"); | |
| 3991 else { | |
| 3992 uint i; | |
| 3993 for (i = Parms; i < _range->_cnt-1; i++) | |
| 3994 tty->print("%s/",flat_type_msg[_range->field_at(i)->base()]); | |
| 3995 tty->print("%s",flat_type_msg[_range->field_at(i)->base()]); | |
| 3996 } | |
| 3997 tty->print(" ( "); | |
| 3998 if (Parms < _domain->_cnt) | |
| 3999 tty->print("%s",flat_type_msg[_domain->field_at(Parms)->base()]); | |
| 4000 for (uint i = Parms+1; i < _domain->_cnt; i++) | |
| 4001 tty->print(", %s",flat_type_msg[_domain->field_at(i)->base()]); | |
| 4002 tty->print(" )"); | |
| 4003 } | |
| 4004 #endif | |
| 4005 | |
| 4006 //------------------------------singleton-------------------------------------- | |
| 4007 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple | |
| 4008 // constants (Ldi nodes). Singletons are integer, float or double constants | |
| 4009 // or a single symbol. | |
| 4010 bool TypeFunc::singleton(void) const { | |
| 4011 return false; // Never a singleton | |
| 4012 } | |
| 4013 | |
| 4014 bool TypeFunc::empty(void) const { | |
| 4015 return false; // Never empty | |
| 4016 } | |
| 4017 | |
| 4018 | |
| 4019 BasicType TypeFunc::return_type() const{ | |
| 4020 if (range()->cnt() == TypeFunc::Parms) { | |
| 4021 return T_VOID; | |
| 4022 } | |
| 4023 return range()->field_at(TypeFunc::Parms)->basic_type(); | |
| 4024 } |