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