rev 1082 : [mq]: indy.compiler.patch

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