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