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