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