1 /* 2 * Copyright (c) 1997, 2026, 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 "ci/ciField.hpp" 26 #include "ci/ciFlatArray.hpp" 27 #include "ci/ciFlatArrayKlass.hpp" 28 #include "ci/ciInlineKlass.hpp" 29 #include "ci/ciMethodData.hpp" 30 #include "ci/ciObjArrayKlass.hpp" 31 #include "ci/ciTypeFlow.hpp" 32 #include "classfile/javaClasses.hpp" 33 #include "classfile/symbolTable.hpp" 34 #include "classfile/vmSymbols.hpp" 35 #include "compiler/compileLog.hpp" 36 #include "libadt/dict.hpp" 37 #include "memory/oopFactory.hpp" 38 #include "memory/resourceArea.hpp" 39 #include "oops/instanceKlass.hpp" 40 #include "oops/instanceMirrorKlass.hpp" 41 #include "oops/objArrayKlass.hpp" 42 #include "oops/typeArrayKlass.hpp" 43 #include "opto/arraycopynode.hpp" 44 #include "opto/callnode.hpp" 45 #include "opto/matcher.hpp" 46 #include "opto/node.hpp" 47 #include "opto/opcodes.hpp" 48 #include "opto/rangeinference.hpp" 49 #include "opto/runtime.hpp" 50 #include "opto/type.hpp" 51 #include "runtime/globals.hpp" 52 #include "runtime/stubRoutines.hpp" 53 #include "utilities/checkedCast.hpp" 54 #include "utilities/debug.hpp" 55 #include "utilities/globalDefinitions.hpp" 56 #include "utilities/ostream.hpp" 57 #include "utilities/powerOfTwo.hpp" 58 #include "utilities/stringUtils.hpp" 59 60 // Portions of code courtesy of Clifford Click 61 62 // Optimization - Graph Style 63 64 // Dictionary of types shared among compilations. 65 Dict* Type::_shared_type_dict = nullptr; 66 const Type::Offset Type::Offset::top(Type::OffsetTop); 67 const Type::Offset Type::Offset::bottom(Type::OffsetBot); 68 69 const Type::Offset Type::Offset::meet(const Type::Offset other) const { 70 // Either is 'TOP' offset? Return the other offset! 71 if (_offset == OffsetTop) return other; 72 if (other._offset == OffsetTop) return *this; 73 // If either is different, return 'BOTTOM' offset 74 if (_offset != other._offset) return bottom; 75 return Offset(_offset); 76 } 77 78 const Type::Offset Type::Offset::dual() const { 79 if (_offset == OffsetTop) return bottom;// Map 'TOP' into 'BOTTOM' 80 if (_offset == OffsetBot) return top;// Map 'BOTTOM' into 'TOP' 81 return Offset(_offset); // Map everything else into self 82 } 83 84 const Type::Offset Type::Offset::add(intptr_t offset) const { 85 // Adding to 'TOP' offset? Return 'TOP'! 86 if (_offset == OffsetTop || offset == OffsetTop) return top; 87 // Adding to 'BOTTOM' offset? Return 'BOTTOM'! 88 if (_offset == OffsetBot || offset == OffsetBot) return bottom; 89 // Addition overflows or "accidentally" equals to OffsetTop? Return 'BOTTOM'! 90 offset += (intptr_t)_offset; 91 if (offset != (int)offset || offset == OffsetTop) return bottom; 92 93 // assert( _offset >= 0 && _offset+offset >= 0, "" ); 94 // It is possible to construct a negative offset during PhaseCCP 95 96 return Offset((int)offset); // Sum valid offsets 97 } 98 99 void Type::Offset::dump2(outputStream *st) const { 100 if (_offset == 0) { 101 return; 102 } else if (_offset == OffsetTop) { 103 st->print("+top"); 104 } 105 else if (_offset == OffsetBot) { 106 st->print("+bot"); 107 } else if (_offset) { 108 st->print("+%d", _offset); 109 } 110 } 111 112 // Array which maps compiler types to Basic Types 113 const Type::TypeInfo Type::_type_info[Type::lastype] = { 114 { Bad, T_ILLEGAL, "bad", false, Node::NotAMachineReg, relocInfo::none }, // Bad 115 { Control, T_ILLEGAL, "control", false, 0, relocInfo::none }, // Control 116 { Bottom, T_VOID, "top", false, 0, relocInfo::none }, // Top 117 { Bad, T_INT, "int:", false, Op_RegI, relocInfo::none }, // Int 118 { Bad, T_LONG, "long:", false, Op_RegL, relocInfo::none }, // Long 119 { Half, T_VOID, "half", false, 0, relocInfo::none }, // Half 120 { Bad, T_NARROWOOP, "narrowoop:", false, Op_RegN, relocInfo::none }, // NarrowOop 121 { Bad, T_NARROWKLASS,"narrowklass:", false, Op_RegN, relocInfo::none }, // NarrowKlass 122 { Bad, T_ILLEGAL, "tuple:", false, Node::NotAMachineReg, relocInfo::none }, // Tuple 123 { Bad, T_ARRAY, "array:", false, Node::NotAMachineReg, relocInfo::none }, // Array 124 { Bad, T_ARRAY, "interfaces:", false, Node::NotAMachineReg, relocInfo::none }, // Interfaces 125 126 #if defined(PPC64) 127 { Bad, T_ILLEGAL, "vectormask:", false, Op_RegVectMask, relocInfo::none }, // VectorMask. 128 { Bad, T_ILLEGAL, "vectora:", false, Op_VecA, relocInfo::none }, // VectorA. 129 { Bad, T_ILLEGAL, "vectors:", false, 0, relocInfo::none }, // VectorS 130 { Bad, T_ILLEGAL, "vectord:", false, Op_RegL, relocInfo::none }, // VectorD 131 { Bad, T_ILLEGAL, "vectorx:", false, Op_VecX, relocInfo::none }, // VectorX 132 { Bad, T_ILLEGAL, "vectory:", false, 0, relocInfo::none }, // VectorY 133 { Bad, T_ILLEGAL, "vectorz:", false, 0, relocInfo::none }, // VectorZ 134 #elif defined(S390) 135 { Bad, T_ILLEGAL, "vectormask:", false, Op_RegVectMask, relocInfo::none }, // VectorMask. 136 { Bad, T_ILLEGAL, "vectora:", false, Op_VecA, relocInfo::none }, // VectorA. 137 { Bad, T_ILLEGAL, "vectors:", false, 0, relocInfo::none }, // VectorS 138 { Bad, T_ILLEGAL, "vectord:", false, Op_RegL, relocInfo::none }, // VectorD 139 { Bad, T_ILLEGAL, "vectorx:", false, Op_VecX, relocInfo::none }, // VectorX 140 { Bad, T_ILLEGAL, "vectory:", false, 0, relocInfo::none }, // VectorY 141 { Bad, T_ILLEGAL, "vectorz:", false, 0, relocInfo::none }, // VectorZ 142 #else // all other 143 { Bad, T_ILLEGAL, "vectormask:", false, Op_RegVectMask, relocInfo::none }, // VectorMask. 144 { Bad, T_ILLEGAL, "vectora:", false, Op_VecA, relocInfo::none }, // VectorA. 145 { Bad, T_ILLEGAL, "vectors:", false, Op_VecS, relocInfo::none }, // VectorS 146 { Bad, T_ILLEGAL, "vectord:", false, Op_VecD, relocInfo::none }, // VectorD 147 { Bad, T_ILLEGAL, "vectorx:", false, Op_VecX, relocInfo::none }, // VectorX 148 { Bad, T_ILLEGAL, "vectory:", false, Op_VecY, relocInfo::none }, // VectorY 149 { Bad, T_ILLEGAL, "vectorz:", false, Op_VecZ, relocInfo::none }, // VectorZ 150 #endif 151 { Bad, T_ADDRESS, "anyptr:", false, Op_RegP, relocInfo::none }, // AnyPtr 152 { Bad, T_ADDRESS, "rawptr:", false, Op_RegP, relocInfo::none }, // RawPtr 153 { Bad, T_OBJECT, "oop:", true, Op_RegP, relocInfo::oop_type }, // OopPtr 154 { Bad, T_OBJECT, "inst:", true, Op_RegP, relocInfo::oop_type }, // InstPtr 155 { Bad, T_OBJECT, "ary:", true, Op_RegP, relocInfo::oop_type }, // AryPtr 156 { Bad, T_METADATA, "metadata:", false, Op_RegP, relocInfo::metadata_type }, // MetadataPtr 157 { Bad, T_METADATA, "klass:", false, Op_RegP, relocInfo::metadata_type }, // KlassPtr 158 { Bad, T_METADATA, "instklass:", false, Op_RegP, relocInfo::metadata_type }, // InstKlassPtr 159 { Bad, T_METADATA, "aryklass:", false, Op_RegP, relocInfo::metadata_type }, // AryKlassPtr 160 { Bad, T_OBJECT, "func", false, 0, relocInfo::none }, // Function 161 { Abio, T_ILLEGAL, "abIO", false, 0, relocInfo::none }, // Abio 162 { Return_Address, T_ADDRESS, "return_address",false, Op_RegP, relocInfo::none }, // Return_Address 163 { Memory, T_ILLEGAL, "memory", false, 0, relocInfo::none }, // Memory 164 { HalfFloatBot, T_SHORT, "halffloat_top", false, Op_RegF, relocInfo::none }, // HalfFloatTop 165 { HalfFloatCon, T_SHORT, "hfcon:", false, Op_RegF, relocInfo::none }, // HalfFloatCon 166 { HalfFloatTop, T_SHORT, "short", false, Op_RegF, relocInfo::none }, // HalfFloatBot 167 { FloatBot, T_FLOAT, "float_top", false, Op_RegF, relocInfo::none }, // FloatTop 168 { FloatCon, T_FLOAT, "ftcon:", false, Op_RegF, relocInfo::none }, // FloatCon 169 { FloatTop, T_FLOAT, "float", false, Op_RegF, relocInfo::none }, // FloatBot 170 { DoubleBot, T_DOUBLE, "double_top", false, Op_RegD, relocInfo::none }, // DoubleTop 171 { DoubleCon, T_DOUBLE, "dblcon:", false, Op_RegD, relocInfo::none }, // DoubleCon 172 { DoubleTop, T_DOUBLE, "double", false, Op_RegD, relocInfo::none }, // DoubleBot 173 { Top, T_ILLEGAL, "bottom", false, 0, relocInfo::none } // Bottom 174 }; 175 176 // Map ideal registers (machine types) to ideal types 177 const Type *Type::mreg2type[_last_machine_leaf]; 178 179 // Map basic types to canonical Type* pointers. 180 const Type* Type:: _const_basic_type[T_CONFLICT+1]; 181 182 // Map basic types to constant-zero Types. 183 const Type* Type:: _zero_type[T_CONFLICT+1]; 184 185 // Map basic types to array-body alias types. 186 const TypeAryPtr* TypeAryPtr::_array_body_type[T_CONFLICT+1]; 187 const TypeInterfaces* TypeAryPtr::_array_interfaces = nullptr; 188 const TypeInterfaces* TypeAryKlassPtr::_array_interfaces = nullptr; 189 190 //============================================================================= 191 // Convenience common pre-built types. 192 const Type *Type::ABIO; // State-of-machine only 193 const Type *Type::BOTTOM; // All values 194 const Type *Type::CONTROL; // Control only 195 const Type *Type::DOUBLE; // All doubles 196 const Type *Type::HALF_FLOAT; // All half floats 197 const Type *Type::FLOAT; // All floats 198 const Type *Type::HALF; // Placeholder half of doublewide type 199 const Type *Type::MEMORY; // Abstract store only 200 const Type *Type::RETURN_ADDRESS; 201 const Type *Type::TOP; // No values in set 202 203 //------------------------------get_const_type--------------------------- 204 const Type* Type::get_const_type(ciType* type, InterfaceHandling interface_handling) { 205 if (type == nullptr) { 206 return nullptr; 207 } else if (type->is_primitive_type()) { 208 return get_const_basic_type(type->basic_type()); 209 } else { 210 return TypeOopPtr::make_from_klass(type->as_klass(), interface_handling); 211 } 212 } 213 214 //---------------------------array_element_basic_type--------------------------------- 215 // Mapping to the array element's basic type. 216 BasicType Type::array_element_basic_type() const { 217 BasicType bt = basic_type(); 218 if (bt == T_INT) { 219 if (this == TypeInt::INT) return T_INT; 220 if (this == TypeInt::CHAR) return T_CHAR; 221 if (this == TypeInt::BYTE) return T_BYTE; 222 if (this == TypeInt::BOOL) return T_BOOLEAN; 223 if (this == TypeInt::SHORT) return T_SHORT; 224 return T_VOID; 225 } 226 return bt; 227 } 228 229 // For two instance arrays of same dimension, return the base element types. 230 // Otherwise or if the arrays have different dimensions, return null. 231 void Type::get_arrays_base_elements(const Type *a1, const Type *a2, 232 const TypeInstPtr **e1, const TypeInstPtr **e2) { 233 234 if (e1) *e1 = nullptr; 235 if (e2) *e2 = nullptr; 236 const TypeAryPtr* a1tap = (a1 == nullptr) ? nullptr : a1->isa_aryptr(); 237 const TypeAryPtr* a2tap = (a2 == nullptr) ? nullptr : a2->isa_aryptr(); 238 239 if (a1tap != nullptr && a2tap != nullptr) { 240 // Handle multidimensional arrays 241 const TypePtr* a1tp = a1tap->elem()->make_ptr(); 242 const TypePtr* a2tp = a2tap->elem()->make_ptr(); 243 while (a1tp && a1tp->isa_aryptr() && a2tp && a2tp->isa_aryptr()) { 244 a1tap = a1tp->is_aryptr(); 245 a2tap = a2tp->is_aryptr(); 246 a1tp = a1tap->elem()->make_ptr(); 247 a2tp = a2tap->elem()->make_ptr(); 248 } 249 if (a1tp && a1tp->isa_instptr() && a2tp && a2tp->isa_instptr()) { 250 if (e1) *e1 = a1tp->is_instptr(); 251 if (e2) *e2 = a2tp->is_instptr(); 252 } 253 } 254 } 255 256 //---------------------------get_typeflow_type--------------------------------- 257 // Import a type produced by ciTypeFlow. 258 const Type* Type::get_typeflow_type(ciType* type) { 259 switch (type->basic_type()) { 260 261 case ciTypeFlow::StateVector::T_BOTTOM: 262 assert(type == ciTypeFlow::StateVector::bottom_type(), ""); 263 return Type::BOTTOM; 264 265 case ciTypeFlow::StateVector::T_TOP: 266 assert(type == ciTypeFlow::StateVector::top_type(), ""); 267 return Type::TOP; 268 269 case ciTypeFlow::StateVector::T_NULL: 270 assert(type == ciTypeFlow::StateVector::null_type(), ""); 271 return TypePtr::NULL_PTR; 272 273 case ciTypeFlow::StateVector::T_LONG2: 274 // The ciTypeFlow pass pushes a long, then the half. 275 // We do the same. 276 assert(type == ciTypeFlow::StateVector::long2_type(), ""); 277 return TypeInt::TOP; 278 279 case ciTypeFlow::StateVector::T_DOUBLE2: 280 // The ciTypeFlow pass pushes double, then the half. 281 // Our convention is the same. 282 assert(type == ciTypeFlow::StateVector::double2_type(), ""); 283 return Type::TOP; 284 285 case T_ADDRESS: 286 assert(type->is_return_address(), ""); 287 return TypeRawPtr::make((address)(intptr_t)type->as_return_address()->bci()); 288 289 case T_OBJECT: 290 return Type::get_const_type(type->unwrap())->join_speculative(type->is_null_free() ? TypePtr::NOTNULL : TypePtr::BOTTOM); 291 292 default: 293 // make sure we did not mix up the cases: 294 assert(type != ciTypeFlow::StateVector::bottom_type(), ""); 295 assert(type != ciTypeFlow::StateVector::top_type(), ""); 296 assert(type != ciTypeFlow::StateVector::null_type(), ""); 297 assert(type != ciTypeFlow::StateVector::long2_type(), ""); 298 assert(type != ciTypeFlow::StateVector::double2_type(), ""); 299 assert(!type->is_return_address(), ""); 300 301 return Type::get_const_type(type); 302 } 303 } 304 305 306 //-----------------------make_from_constant------------------------------------ 307 const Type* Type::make_from_constant(ciConstant constant, bool require_constant, 308 int stable_dimension, bool is_narrow_oop, 309 bool is_autobox_cache) { 310 switch (constant.basic_type()) { 311 case T_BOOLEAN: return TypeInt::make(constant.as_boolean()); 312 case T_CHAR: return TypeInt::make(constant.as_char()); 313 case T_BYTE: return TypeInt::make(constant.as_byte()); 314 case T_SHORT: return TypeInt::make(constant.as_short()); 315 case T_INT: return TypeInt::make(constant.as_int()); 316 case T_LONG: return TypeLong::make(constant.as_long()); 317 case T_FLOAT: return TypeF::make(constant.as_float()); 318 case T_DOUBLE: return TypeD::make(constant.as_double()); 319 case T_ARRAY: 320 case T_OBJECT: { 321 const Type* con_type = nullptr; 322 ciObject* oop_constant = constant.as_object(); 323 if (oop_constant->is_null_object()) { 324 con_type = Type::get_zero_type(T_OBJECT); 325 } else { 326 guarantee(require_constant || oop_constant->should_be_constant(), "con_type must get computed"); 327 con_type = TypeOopPtr::make_from_constant(oop_constant, require_constant); 328 if (Compile::current()->eliminate_boxing() && is_autobox_cache) { 329 con_type = con_type->is_aryptr()->cast_to_autobox_cache(); 330 } 331 if (stable_dimension > 0) { 332 assert(FoldStableValues, "sanity"); 333 assert(!con_type->is_zero_type(), "default value for stable field"); 334 con_type = con_type->is_aryptr()->cast_to_stable(true, stable_dimension); 335 } 336 } 337 if (is_narrow_oop) { 338 con_type = con_type->make_narrowoop(); 339 } 340 return con_type; 341 } 342 case T_ILLEGAL: 343 // Invalid ciConstant returned due to OutOfMemoryError in the CI 344 assert(Compile::current()->env()->failing(), "otherwise should not see this"); 345 return nullptr; 346 default: 347 // Fall through to failure 348 return nullptr; 349 } 350 } 351 352 static ciConstant check_mismatched_access(ciConstant con, BasicType loadbt, bool is_unsigned) { 353 BasicType conbt = con.basic_type(); 354 switch (conbt) { 355 case T_BOOLEAN: conbt = T_BYTE; break; 356 case T_ARRAY: conbt = T_OBJECT; break; 357 default: break; 358 } 359 switch (loadbt) { 360 case T_BOOLEAN: loadbt = T_BYTE; break; 361 case T_NARROWOOP: loadbt = T_OBJECT; break; 362 case T_ARRAY: loadbt = T_OBJECT; break; 363 case T_ADDRESS: loadbt = T_OBJECT; break; 364 default: break; 365 } 366 if (conbt == loadbt) { 367 if (is_unsigned && conbt == T_BYTE) { 368 // LoadB (T_BYTE) with a small mask (<=8-bit) is converted to LoadUB (T_BYTE). 369 return ciConstant(T_INT, con.as_int() & 0xFF); 370 } else { 371 return con; 372 } 373 } 374 if (conbt == T_SHORT && loadbt == T_CHAR) { 375 // LoadS (T_SHORT) with a small mask (<=16-bit) is converted to LoadUS (T_CHAR). 376 return ciConstant(T_INT, con.as_int() & 0xFFFF); 377 } 378 return ciConstant(); // T_ILLEGAL 379 } 380 381 static const Type* make_constant_from_non_flat_array_element(ciArray* array, int off, int stable_dimension, 382 BasicType loadbt, bool is_unsigned_load) { 383 // Decode the results of GraphKit::array_element_address. 384 ciConstant element_value = array->element_value_by_offset(off); 385 if (element_value.basic_type() == T_ILLEGAL) { 386 return nullptr; // wrong offset 387 } 388 ciConstant con = check_mismatched_access(element_value, loadbt, is_unsigned_load); 389 390 assert(con.basic_type() != T_ILLEGAL, "elembt=%s; loadbt=%s; unsigned=%d", 391 type2name(element_value.basic_type()), type2name(loadbt), is_unsigned_load); 392 393 if (con.is_valid() && // not a mismatched access 394 !con.is_null_or_zero()) { // not a default value 395 bool is_narrow_oop = (loadbt == T_NARROWOOP); 396 return Type::make_from_constant(con, /*require_constant=*/true, stable_dimension, is_narrow_oop, /*is_autobox_cache=*/false); 397 } 398 return nullptr; 399 } 400 401 static const Type* make_constant_from_flat_array_element(ciFlatArray* array, int off, int field_offset, int stable_dimension, 402 BasicType loadbt, bool is_unsigned_load) { 403 // Decode the results of GraphKit::array_element_address. 404 ciConstant element_value = array->field_value_by_offset(off + field_offset); 405 if (element_value.basic_type() == T_ILLEGAL) { 406 return nullptr; // wrong offset 407 } 408 ciConstant con = check_mismatched_access(element_value, loadbt, is_unsigned_load); 409 410 assert(con.basic_type() != T_ILLEGAL, "elembt=%s; loadbt=%s; unsigned=%d", 411 type2name(element_value.basic_type()), type2name(loadbt), is_unsigned_load); 412 413 if (con.is_valid() && // not a mismatched access 414 !con.is_null_or_zero()) { // not a default value 415 bool is_narrow_oop = (loadbt == T_NARROWOOP); 416 return Type::make_from_constant(con, /*require_constant=*/true, stable_dimension, is_narrow_oop, /*is_autobox_cache=*/false); 417 } 418 return nullptr; 419 } 420 421 // Try to constant-fold a stable array element. 422 const Type* Type::make_constant_from_array_element(ciArray* array, int off, int field_offset, int stable_dimension, 423 BasicType loadbt, bool is_unsigned_load) { 424 if (array->is_flat()) { 425 return make_constant_from_flat_array_element(array->as_flat_array(), off, field_offset, stable_dimension, loadbt, is_unsigned_load); 426 } 427 return make_constant_from_non_flat_array_element(array, off, stable_dimension, loadbt, is_unsigned_load); 428 } 429 430 const Type* Type::make_constant_from_field(ciInstance* holder, int off, bool is_unsigned_load, BasicType loadbt) { 431 ciField* field; 432 ciType* type = holder->java_mirror_type(); 433 if (type != nullptr && type->is_instance_klass() && off >= InstanceMirrorKlass::offset_of_static_fields()) { 434 // Static field 435 field = type->as_instance_klass()->get_field_by_offset(off, /*is_static=*/true); 436 } else { 437 // Instance field 438 field = holder->klass()->as_instance_klass()->get_field_by_offset(off, /*is_static=*/false); 439 } 440 if (field == nullptr) { 441 return nullptr; // Wrong offset 442 } 443 return Type::make_constant_from_field(field, holder, loadbt, is_unsigned_load); 444 } 445 446 const Type* Type::make_constant_from_field(ciField* field, ciInstance* holder, 447 BasicType loadbt, bool is_unsigned_load) { 448 if (!field->is_constant()) { 449 return nullptr; // Non-constant field 450 } 451 ciConstant field_value; 452 if (field->is_static()) { 453 // final static field 454 field_value = field->constant_value(); 455 } else if (holder != nullptr) { 456 // final or stable non-static field 457 // Treat final non-static fields of trusted classes (classes in 458 // java.lang.invoke and sun.invoke packages and subpackages) as 459 // compile time constants. 460 field_value = field->constant_value_of(holder); 461 } 462 if (!field_value.is_valid()) { 463 return nullptr; // Not a constant 464 } 465 466 ciConstant con = check_mismatched_access(field_value, loadbt, is_unsigned_load); 467 468 assert(con.is_valid(), "elembt=%s; loadbt=%s; unsigned=%d", 469 type2name(field_value.basic_type()), type2name(loadbt), is_unsigned_load); 470 471 bool is_stable_array = FoldStableValues && field->is_stable() && field->type()->is_array_klass(); 472 int stable_dimension = (is_stable_array ? field->type()->as_array_klass()->dimension() : 0); 473 bool is_narrow_oop = (loadbt == T_NARROWOOP); 474 475 const Type* con_type = make_from_constant(con, /*require_constant=*/ true, 476 stable_dimension, is_narrow_oop, 477 field->is_autobox_cache()); 478 if (con_type != nullptr && field->is_call_site_target()) { 479 ciCallSite* call_site = holder->as_call_site(); 480 if (!call_site->is_fully_initialized_constant_call_site()) { 481 ciMethodHandle* target = con.as_object()->as_method_handle(); 482 Compile::current()->dependencies()->assert_call_site_target_value(call_site, target); 483 } 484 } 485 return con_type; 486 } 487 488 //------------------------------make------------------------------------------- 489 // Create a simple Type, with default empty symbol sets. Then hashcons it 490 // and look for an existing copy in the type dictionary. 491 const Type *Type::make( enum TYPES t ) { 492 return (new Type(t))->hashcons(); 493 } 494 495 //------------------------------cmp-------------------------------------------- 496 bool Type::equals(const Type* t1, const Type* t2) { 497 if (t1->_base != t2->_base) { 498 return false; // Missed badly 499 } 500 501 assert(t1 != t2 || t1->eq(t2), "eq must be reflexive"); 502 return t1->eq(t2); 503 } 504 505 const Type* Type::maybe_remove_speculative(bool include_speculative) const { 506 if (!include_speculative) { 507 return remove_speculative(); 508 } 509 return this; 510 } 511 512 //------------------------------hash------------------------------------------- 513 int Type::uhash( const Type *const t ) { 514 return (int)t->hash(); 515 } 516 517 #define POSITIVE_INFINITE_F 0x7f800000 // hex representation for IEEE 754 single precision positive infinite 518 #define POSITIVE_INFINITE_D 0x7ff0000000000000 // hex representation for IEEE 754 double precision positive infinite 519 520 //--------------------------Initialize_shared---------------------------------- 521 void Type::Initialize_shared(Compile* current) { 522 // This method does not need to be locked because the first system 523 // compilations (stub compilations) occur serially. If they are 524 // changed to proceed in parallel, then this section will need 525 // locking. 526 527 Arena* save = current->type_arena(); 528 Arena* shared_type_arena = new (mtCompiler)Arena(mtCompiler, Arena::Tag::tag_type); 529 530 current->set_type_arena(shared_type_arena); 531 532 // Map the boolean result of Type::equals into a comparator result that CmpKey expects. 533 CmpKey type_cmp = [](const void* t1, const void* t2) -> int32_t { 534 return Type::equals((Type*) t1, (Type*) t2) ? 0 : 1; 535 }; 536 537 _shared_type_dict = new (shared_type_arena) Dict(type_cmp, (Hash) Type::uhash, shared_type_arena, 128); 538 current->set_type_dict(_shared_type_dict); 539 540 // Make shared pre-built types. 541 CONTROL = make(Control); // Control only 542 TOP = make(Top); // No values in set 543 MEMORY = make(Memory); // Abstract store only 544 ABIO = make(Abio); // State-of-machine only 545 RETURN_ADDRESS=make(Return_Address); 546 FLOAT = make(FloatBot); // All floats 547 HALF_FLOAT = make(HalfFloatBot); // All half floats 548 DOUBLE = make(DoubleBot); // All doubles 549 BOTTOM = make(Bottom); // Everything 550 HALF = make(Half); // Placeholder half of doublewide type 551 552 TypeF::MAX = TypeF::make(max_jfloat); // Float MAX 553 TypeF::MIN = TypeF::make(min_jfloat); // Float MIN 554 TypeF::ZERO = TypeF::make(0.0); // Float 0 (positive zero) 555 TypeF::ONE = TypeF::make(1.0); // Float 1 556 TypeF::POS_INF = TypeF::make(jfloat_cast(POSITIVE_INFINITE_F)); 557 TypeF::NEG_INF = TypeF::make(-jfloat_cast(POSITIVE_INFINITE_F)); 558 559 TypeH::MAX = TypeH::make(max_jfloat16); // HalfFloat MAX 560 TypeH::MIN = TypeH::make(min_jfloat16); // HalfFloat MIN 561 TypeH::ZERO = TypeH::make((jshort)0); // HalfFloat 0 (positive zero) 562 TypeH::ONE = TypeH::make(one_jfloat16); // HalfFloat 1 563 TypeH::POS_INF = TypeH::make(pos_inf_jfloat16); 564 TypeH::NEG_INF = TypeH::make(neg_inf_jfloat16); 565 566 TypeD::MAX = TypeD::make(max_jdouble); // Double MAX 567 TypeD::MIN = TypeD::make(min_jdouble); // Double MIN 568 TypeD::ZERO = TypeD::make(0.0); // Double 0 (positive zero) 569 TypeD::ONE = TypeD::make(1.0); // Double 1 570 TypeD::POS_INF = TypeD::make(jdouble_cast(POSITIVE_INFINITE_D)); 571 TypeD::NEG_INF = TypeD::make(-jdouble_cast(POSITIVE_INFINITE_D)); 572 573 TypeInt::MAX = TypeInt::make(max_jint); // Int MAX 574 TypeInt::MIN = TypeInt::make(min_jint); // Int MIN 575 TypeInt::MINUS_1 = TypeInt::make(-1); // -1 576 TypeInt::ZERO = TypeInt::make( 0); // 0 577 TypeInt::ONE = TypeInt::make( 1); // 1 578 TypeInt::BOOL = TypeInt::make( 0, 1, WidenMin); // 0 or 1, FALSE or TRUE. 579 TypeInt::CC = TypeInt::make(-1, 1, WidenMin); // -1, 0 or 1, condition codes 580 TypeInt::CC_LT = TypeInt::make(-1,-1, WidenMin); // == TypeInt::MINUS_1 581 TypeInt::CC_GT = TypeInt::make( 1, 1, WidenMin); // == TypeInt::ONE 582 TypeInt::CC_EQ = TypeInt::make( 0, 0, WidenMin); // == TypeInt::ZERO 583 TypeInt::CC_NE = TypeInt::make_or_top(TypeIntPrototype<jint, juint>{{-1, 1}, {1, max_juint}, {0, 1}}, WidenMin)->is_int(); 584 TypeInt::CC_LE = TypeInt::make(-1, 0, WidenMin); 585 TypeInt::CC_GE = TypeInt::make( 0, 1, WidenMin); // == TypeInt::BOOL 586 TypeInt::BYTE = TypeInt::make(-128, 127, WidenMin); // Bytes 587 TypeInt::UBYTE = TypeInt::make(0, 255, WidenMin); // Unsigned Bytes 588 TypeInt::CHAR = TypeInt::make(0, 65535, WidenMin); // Java chars 589 TypeInt::SHORT = TypeInt::make(-32768, 32767, WidenMin); // Java shorts 590 TypeInt::NON_ZERO = TypeInt::make_or_top(TypeIntPrototype<jint, juint>{{min_jint, max_jint}, {1, max_juint}, {0, 0}}, WidenMin)->is_int(); 591 TypeInt::POS = TypeInt::make(0, max_jint, WidenMin); // Non-neg values 592 TypeInt::POS1 = TypeInt::make(1, max_jint, WidenMin); // Positive values 593 TypeInt::INT = TypeInt::make(min_jint, max_jint, WidenMax); // 32-bit integers 594 TypeInt::SYMINT = TypeInt::make(-max_jint, max_jint, WidenMin); // symmetric range 595 TypeInt::TYPE_DOMAIN = TypeInt::INT; 596 // CmpL is overloaded both as the bytecode computation returning 597 // a trinary (-1, 0, +1) integer result AND as an efficient long 598 // compare returning optimizer ideal-type flags. 599 assert(TypeInt::CC_LT == TypeInt::MINUS_1, "types must match for CmpL to work" ); 600 assert(TypeInt::CC_GT == TypeInt::ONE, "types must match for CmpL to work" ); 601 assert(TypeInt::CC_EQ == TypeInt::ZERO, "types must match for CmpL to work" ); 602 assert(TypeInt::CC_GE == TypeInt::BOOL, "types must match for CmpL to work" ); 603 604 TypeLong::MAX = TypeLong::make(max_jlong); // Long MAX 605 TypeLong::MIN = TypeLong::make(min_jlong); // Long MIN 606 TypeLong::MINUS_1 = TypeLong::make(-1); // -1 607 TypeLong::ZERO = TypeLong::make( 0); // 0 608 TypeLong::ONE = TypeLong::make( 1); // 1 609 TypeLong::NON_ZERO = TypeLong::make_or_top(TypeIntPrototype<jlong, julong>{{min_jlong, max_jlong}, {1, max_julong}, {0, 0}}, WidenMin)->is_long(); 610 TypeLong::POS = TypeLong::make(0, max_jlong, WidenMin); // Non-neg values 611 TypeLong::NEG = TypeLong::make(min_jlong, -1, WidenMin); 612 TypeLong::LONG = TypeLong::make(min_jlong, max_jlong, WidenMax); // 64-bit integers 613 TypeLong::INT = TypeLong::make((jlong)min_jint, (jlong)max_jint,WidenMin); 614 TypeLong::UINT = TypeLong::make(0, (jlong)max_juint, WidenMin); 615 TypeLong::TYPE_DOMAIN = TypeLong::LONG; 616 617 const Type **fboth =(const Type**)shared_type_arena->AmallocWords(2*sizeof(Type*)); 618 fboth[0] = Type::CONTROL; 619 fboth[1] = Type::CONTROL; 620 TypeTuple::IFBOTH = TypeTuple::make( 2, fboth ); 621 622 const Type **ffalse =(const Type**)shared_type_arena->AmallocWords(2*sizeof(Type*)); 623 ffalse[0] = Type::CONTROL; 624 ffalse[1] = Type::TOP; 625 TypeTuple::IFFALSE = TypeTuple::make( 2, ffalse ); 626 627 const Type **fneither =(const Type**)shared_type_arena->AmallocWords(2*sizeof(Type*)); 628 fneither[0] = Type::TOP; 629 fneither[1] = Type::TOP; 630 TypeTuple::IFNEITHER = TypeTuple::make( 2, fneither ); 631 632 const Type **ftrue =(const Type**)shared_type_arena->AmallocWords(2*sizeof(Type*)); 633 ftrue[0] = Type::TOP; 634 ftrue[1] = Type::CONTROL; 635 TypeTuple::IFTRUE = TypeTuple::make( 2, ftrue ); 636 637 const Type **floop =(const Type**)shared_type_arena->AmallocWords(2*sizeof(Type*)); 638 floop[0] = Type::CONTROL; 639 floop[1] = TypeInt::INT; 640 TypeTuple::LOOPBODY = TypeTuple::make( 2, floop ); 641 642 TypePtr::NULL_PTR= TypePtr::make(AnyPtr, TypePtr::Null, Offset(0)); 643 TypePtr::NOTNULL = TypePtr::make(AnyPtr, TypePtr::NotNull, Offset::bottom); 644 TypePtr::BOTTOM = TypePtr::make(AnyPtr, TypePtr::BotPTR, Offset::bottom); 645 646 TypeRawPtr::BOTTOM = TypeRawPtr::make( TypePtr::BotPTR ); 647 TypeRawPtr::NOTNULL= TypeRawPtr::make( TypePtr::NotNull ); 648 649 const Type **fmembar = TypeTuple::fields(0); 650 TypeTuple::MEMBAR = TypeTuple::make(TypeFunc::Parms+0, fmembar); 651 652 const Type **fsc = (const Type**)shared_type_arena->AmallocWords(2*sizeof(Type*)); 653 fsc[0] = TypeInt::CC; 654 fsc[1] = Type::MEMORY; 655 TypeTuple::STORECONDITIONAL = TypeTuple::make(2, fsc); 656 657 TypeInstPtr::NOTNULL = TypeInstPtr::make(TypePtr::NotNull, current->env()->Object_klass()); 658 TypeInstPtr::BOTTOM = TypeInstPtr::make(TypePtr::BotPTR, current->env()->Object_klass()); 659 TypeInstPtr::MIRROR = TypeInstPtr::make(TypePtr::NotNull, current->env()->Class_klass()); 660 TypeInstPtr::MARK = TypeInstPtr::make(TypePtr::BotPTR, current->env()->Object_klass(), 661 false, nullptr, Offset(oopDesc::mark_offset_in_bytes())); 662 TypeInstPtr::KLASS = TypeInstPtr::make(TypePtr::BotPTR, current->env()->Object_klass(), 663 false, nullptr, Offset(oopDesc::klass_offset_in_bytes())); 664 TypeOopPtr::BOTTOM = TypeOopPtr::make(TypePtr::BotPTR, Offset::bottom, TypeOopPtr::InstanceBot); 665 666 TypeMetadataPtr::BOTTOM = TypeMetadataPtr::make(TypePtr::BotPTR, nullptr, Offset::bottom); 667 668 TypeNarrowOop::NULL_PTR = TypeNarrowOop::make( TypePtr::NULL_PTR ); 669 TypeNarrowOop::BOTTOM = TypeNarrowOop::make( TypeInstPtr::BOTTOM ); 670 671 TypeNarrowKlass::NULL_PTR = TypeNarrowKlass::make( TypePtr::NULL_PTR ); 672 673 mreg2type[Op_Node] = Type::BOTTOM; 674 mreg2type[Op_Set ] = nullptr; 675 mreg2type[Op_RegN] = TypeNarrowOop::BOTTOM; 676 mreg2type[Op_RegI] = TypeInt::INT; 677 mreg2type[Op_RegP] = TypePtr::BOTTOM; 678 mreg2type[Op_RegF] = Type::FLOAT; 679 mreg2type[Op_RegD] = Type::DOUBLE; 680 mreg2type[Op_RegL] = TypeLong::LONG; 681 mreg2type[Op_RegFlags] = TypeInt::CC; 682 683 GrowableArray<ciInstanceKlass*> array_interfaces; 684 array_interfaces.push(current->env()->Cloneable_klass()); 685 array_interfaces.push(current->env()->Serializable_klass()); 686 TypeAryPtr::_array_interfaces = TypeInterfaces::make(&array_interfaces); 687 TypeAryKlassPtr::_array_interfaces = TypeAryPtr::_array_interfaces; 688 689 TypeAryPtr::BOTTOM = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(Type::BOTTOM, TypeInt::POS, false, false, false, false, false), nullptr, false, Offset::bottom); 690 TypeAryPtr::RANGE = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(Type::BOTTOM,TypeInt::POS, false, false, false, false, false), nullptr /* current->env()->Object_klass() */, false, Offset(arrayOopDesc::length_offset_in_bytes())); 691 692 TypeAryPtr::NARROWOOPS = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeNarrowOop::BOTTOM, TypeInt::POS, false, false, false, false, false), nullptr /*ciArrayKlass::make(o)*/, false, Offset::bottom); 693 694 #ifdef _LP64 695 if (UseCompressedOops) { 696 assert(TypeAryPtr::NARROWOOPS->is_ptr_to_narrowoop(), "array of narrow oops must be ptr to narrow oop"); 697 TypeAryPtr::OOPS = TypeAryPtr::NARROWOOPS; 698 } else 699 #endif 700 { 701 // There is no shared klass for Object[]. See note in TypeAryPtr::klass(). 702 TypeAryPtr::OOPS = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeInstPtr::BOTTOM,TypeInt::POS, false, false, false, false, false), nullptr /*ciArrayKlass::make(o)*/, false, Offset::bottom); 703 } 704 TypeAryPtr::BYTES = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeInt::BYTE ,TypeInt::POS, false, false, true, true, true), ciTypeArrayKlass::make(T_BYTE), true, Offset::bottom); 705 TypeAryPtr::SHORTS = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeInt::SHORT ,TypeInt::POS, false, false, true, true, true), ciTypeArrayKlass::make(T_SHORT), true, Offset::bottom); 706 TypeAryPtr::CHARS = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeInt::CHAR ,TypeInt::POS, false, false, true, true, true), ciTypeArrayKlass::make(T_CHAR), true, Offset::bottom); 707 TypeAryPtr::INTS = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeInt::INT ,TypeInt::POS, false, false, true, true, true), ciTypeArrayKlass::make(T_INT), true, Offset::bottom); 708 TypeAryPtr::LONGS = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeLong::LONG ,TypeInt::POS, false, false, true, true, true), ciTypeArrayKlass::make(T_LONG), true, Offset::bottom); 709 TypeAryPtr::FLOATS = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(Type::FLOAT ,TypeInt::POS, false, false, true, true, true), ciTypeArrayKlass::make(T_FLOAT), true, Offset::bottom); 710 TypeAryPtr::DOUBLES = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(Type::DOUBLE ,TypeInt::POS, false, false, true, true, true), ciTypeArrayKlass::make(T_DOUBLE), true, Offset::bottom); 711 TypeAryPtr::INLINES = TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(TypeInstPtr::BOTTOM,TypeInt::POS, /* stable= */ false, /* flat= */ true, false, false, false), nullptr, false, Offset::bottom); 712 713 // Nobody should ask _array_body_type[T_NARROWOOP]. Use null as assert. 714 TypeAryPtr::_array_body_type[T_NARROWOOP] = nullptr; 715 TypeAryPtr::_array_body_type[T_OBJECT] = TypeAryPtr::OOPS; 716 TypeAryPtr::_array_body_type[T_FLAT_ELEMENT] = TypeAryPtr::OOPS; 717 TypeAryPtr::_array_body_type[T_ARRAY] = TypeAryPtr::OOPS; // arrays are stored in oop arrays 718 TypeAryPtr::_array_body_type[T_BYTE] = TypeAryPtr::BYTES; 719 TypeAryPtr::_array_body_type[T_BOOLEAN] = TypeAryPtr::BYTES; // boolean[] is a byte array 720 TypeAryPtr::_array_body_type[T_SHORT] = TypeAryPtr::SHORTS; 721 TypeAryPtr::_array_body_type[T_CHAR] = TypeAryPtr::CHARS; 722 TypeAryPtr::_array_body_type[T_INT] = TypeAryPtr::INTS; 723 TypeAryPtr::_array_body_type[T_LONG] = TypeAryPtr::LONGS; 724 TypeAryPtr::_array_body_type[T_FLOAT] = TypeAryPtr::FLOATS; 725 TypeAryPtr::_array_body_type[T_DOUBLE] = TypeAryPtr::DOUBLES; 726 727 TypeInstKlassPtr::OBJECT = TypeInstKlassPtr::make(TypePtr::NotNull, current->env()->Object_klass(), Offset(0)); 728 TypeInstKlassPtr::OBJECT_OR_NULL = TypeInstKlassPtr::make(TypePtr::BotPTR, current->env()->Object_klass(), Offset(0)); 729 730 const Type **fi2c = TypeTuple::fields(2); 731 fi2c[TypeFunc::Parms+0] = TypeInstPtr::BOTTOM; // Method* 732 fi2c[TypeFunc::Parms+1] = TypeRawPtr::BOTTOM; // argument pointer 733 TypeTuple::START_I2C = TypeTuple::make(TypeFunc::Parms+2, fi2c); 734 735 const Type **intpair = TypeTuple::fields(2); 736 intpair[0] = TypeInt::INT; 737 intpair[1] = TypeInt::INT; 738 TypeTuple::INT_PAIR = TypeTuple::make(2, intpair); 739 740 const Type **longpair = TypeTuple::fields(2); 741 longpair[0] = TypeLong::LONG; 742 longpair[1] = TypeLong::LONG; 743 TypeTuple::LONG_PAIR = TypeTuple::make(2, longpair); 744 745 const Type **intccpair = TypeTuple::fields(2); 746 intccpair[0] = TypeInt::INT; 747 intccpair[1] = TypeInt::CC; 748 TypeTuple::INT_CC_PAIR = TypeTuple::make(2, intccpair); 749 750 const Type **longccpair = TypeTuple::fields(2); 751 longccpair[0] = TypeLong::LONG; 752 longccpair[1] = TypeInt::CC; 753 TypeTuple::LONG_CC_PAIR = TypeTuple::make(2, longccpair); 754 755 _const_basic_type[T_NARROWOOP] = TypeNarrowOop::BOTTOM; 756 _const_basic_type[T_NARROWKLASS] = Type::BOTTOM; 757 _const_basic_type[T_BOOLEAN] = TypeInt::BOOL; 758 _const_basic_type[T_CHAR] = TypeInt::CHAR; 759 _const_basic_type[T_BYTE] = TypeInt::BYTE; 760 _const_basic_type[T_SHORT] = TypeInt::SHORT; 761 _const_basic_type[T_INT] = TypeInt::INT; 762 _const_basic_type[T_LONG] = TypeLong::LONG; 763 _const_basic_type[T_FLOAT] = Type::FLOAT; 764 _const_basic_type[T_DOUBLE] = Type::DOUBLE; 765 _const_basic_type[T_OBJECT] = TypeInstPtr::BOTTOM; 766 _const_basic_type[T_ARRAY] = TypeInstPtr::BOTTOM; // there is no separate bottom for arrays 767 _const_basic_type[T_FLAT_ELEMENT] = TypeInstPtr::BOTTOM; 768 _const_basic_type[T_VOID] = TypePtr::NULL_PTR; // reflection represents void this way 769 _const_basic_type[T_ADDRESS] = TypeRawPtr::BOTTOM; // both interpreter return addresses & random raw ptrs 770 _const_basic_type[T_CONFLICT] = Type::BOTTOM; // why not? 771 772 _zero_type[T_NARROWOOP] = TypeNarrowOop::NULL_PTR; 773 _zero_type[T_NARROWKLASS] = TypeNarrowKlass::NULL_PTR; 774 _zero_type[T_BOOLEAN] = TypeInt::ZERO; // false == 0 775 _zero_type[T_CHAR] = TypeInt::ZERO; // '\0' == 0 776 _zero_type[T_BYTE] = TypeInt::ZERO; // 0x00 == 0 777 _zero_type[T_SHORT] = TypeInt::ZERO; // 0x0000 == 0 778 _zero_type[T_INT] = TypeInt::ZERO; 779 _zero_type[T_LONG] = TypeLong::ZERO; 780 _zero_type[T_FLOAT] = TypeF::ZERO; 781 _zero_type[T_DOUBLE] = TypeD::ZERO; 782 _zero_type[T_OBJECT] = TypePtr::NULL_PTR; 783 _zero_type[T_ARRAY] = TypePtr::NULL_PTR; // null array is null oop 784 _zero_type[T_FLAT_ELEMENT] = TypePtr::NULL_PTR; 785 _zero_type[T_ADDRESS] = TypePtr::NULL_PTR; // raw pointers use the same null 786 _zero_type[T_VOID] = Type::TOP; // the only void value is no value at all 787 788 // get_zero_type() should not happen for T_CONFLICT 789 _zero_type[T_CONFLICT]= nullptr; 790 791 TypeVect::VECTMASK = (TypeVect*)(new TypeVectMask(T_BOOLEAN, MaxVectorSize))->hashcons(); 792 mreg2type[Op_RegVectMask] = TypeVect::VECTMASK; 793 794 if (Matcher::supports_scalable_vector()) { 795 TypeVect::VECTA = TypeVect::make(T_BYTE, Matcher::scalable_vector_reg_size(T_BYTE)); 796 } 797 798 // Vector predefined types, it needs initialized _const_basic_type[]. 799 if (Matcher::vector_size_supported(T_BYTE, 4)) { 800 TypeVect::VECTS = TypeVect::make(T_BYTE, 4); 801 } 802 if (Matcher::vector_size_supported(T_FLOAT, 2)) { 803 TypeVect::VECTD = TypeVect::make(T_FLOAT, 2); 804 } 805 if (Matcher::vector_size_supported(T_FLOAT, 4)) { 806 TypeVect::VECTX = TypeVect::make(T_FLOAT, 4); 807 } 808 if (Matcher::vector_size_supported(T_FLOAT, 8)) { 809 TypeVect::VECTY = TypeVect::make(T_FLOAT, 8); 810 } 811 if (Matcher::vector_size_supported(T_FLOAT, 16)) { 812 TypeVect::VECTZ = TypeVect::make(T_FLOAT, 16); 813 } 814 815 mreg2type[Op_VecA] = TypeVect::VECTA; 816 mreg2type[Op_VecS] = TypeVect::VECTS; 817 mreg2type[Op_VecD] = TypeVect::VECTD; 818 mreg2type[Op_VecX] = TypeVect::VECTX; 819 mreg2type[Op_VecY] = TypeVect::VECTY; 820 mreg2type[Op_VecZ] = TypeVect::VECTZ; 821 822 LockNode::initialize_lock_Type(); 823 ArrayCopyNode::initialize_arraycopy_Type(); 824 OptoRuntime::initialize_types(); 825 826 // Restore working type arena. 827 current->set_type_arena(save); 828 current->set_type_dict(nullptr); 829 } 830 831 //------------------------------Initialize------------------------------------- 832 void Type::Initialize(Compile* current) { 833 assert(current->type_arena() != nullptr, "must have created type arena"); 834 835 if (_shared_type_dict == nullptr) { 836 Initialize_shared(current); 837 } 838 839 Arena* type_arena = current->type_arena(); 840 841 // Create the hash-cons'ing dictionary with top-level storage allocation 842 Dict *tdic = new (type_arena) Dict(*_shared_type_dict, type_arena); 843 current->set_type_dict(tdic); 844 } 845 846 //------------------------------hashcons--------------------------------------- 847 // Do the hash-cons trick. If the Type already exists in the type table, 848 // delete the current Type and return the existing Type. Otherwise stick the 849 // current Type in the Type table. 850 const Type *Type::hashcons(void) { 851 DEBUG_ONLY(base()); // Check the assertion in Type::base(). 852 // Look up the Type in the Type dictionary 853 Dict *tdic = type_dict(); 854 Type* old = (Type*)(tdic->Insert(this, this, false)); 855 if( old ) { // Pre-existing Type? 856 if( old != this ) // Yes, this guy is not the pre-existing? 857 delete this; // Yes, Nuke this guy 858 assert( old->_dual, "" ); 859 return old; // Return pre-existing 860 } 861 862 // Every type has a dual (to make my lattice symmetric). 863 // Since we just discovered a new Type, compute its dual right now. 864 assert( !_dual, "" ); // No dual yet 865 _dual = xdual(); // Compute the dual 866 if (equals(this, _dual)) { // Handle self-symmetric 867 if (_dual != this) { 868 delete _dual; 869 _dual = this; 870 } 871 return this; 872 } 873 assert( !_dual->_dual, "" ); // No reverse dual yet 874 assert( !(*tdic)[_dual], "" ); // Dual not in type system either 875 // New Type, insert into Type table 876 tdic->Insert((void*)_dual,(void*)_dual); 877 ((Type*)_dual)->_dual = this; // Finish up being symmetric 878 #ifdef ASSERT 879 Type *dual_dual = (Type*)_dual->xdual(); 880 assert( eq(dual_dual), "xdual(xdual()) should be identity" ); 881 delete dual_dual; 882 #endif 883 return this; // Return new Type 884 } 885 886 //------------------------------eq--------------------------------------------- 887 // Structural equality check for Type representations 888 bool Type::eq( const Type * ) const { 889 return true; // Nothing else can go wrong 890 } 891 892 //------------------------------hash------------------------------------------- 893 // Type-specific hashing function. 894 uint Type::hash(void) const { 895 return _base; 896 } 897 898 //------------------------------is_finite-------------------------------------- 899 // Has a finite value 900 bool Type::is_finite() const { 901 return false; 902 } 903 904 //------------------------------is_nan----------------------------------------- 905 // Is not a number (NaN) 906 bool Type::is_nan() const { 907 return false; 908 } 909 910 #ifdef ASSERT 911 class VerifyMeet; 912 class VerifyMeetResult : public ArenaObj { 913 friend class VerifyMeet; 914 friend class Type; 915 private: 916 class VerifyMeetResultEntry { 917 private: 918 const Type* _in1; 919 const Type* _in2; 920 const Type* _res; 921 public: 922 VerifyMeetResultEntry(const Type* in1, const Type* in2, const Type* res): 923 _in1(in1), _in2(in2), _res(res) { 924 } 925 VerifyMeetResultEntry(): 926 _in1(nullptr), _in2(nullptr), _res(nullptr) { 927 } 928 929 bool operator==(const VerifyMeetResultEntry& rhs) const { 930 return _in1 == rhs._in1 && 931 _in2 == rhs._in2 && 932 _res == rhs._res; 933 } 934 935 bool operator!=(const VerifyMeetResultEntry& rhs) const { 936 return !(rhs == *this); 937 } 938 939 static int compare(const VerifyMeetResultEntry& v1, const VerifyMeetResultEntry& v2) { 940 if ((intptr_t) v1._in1 < (intptr_t) v2._in1) { 941 return -1; 942 } else if (v1._in1 == v2._in1) { 943 if ((intptr_t) v1._in2 < (intptr_t) v2._in2) { 944 return -1; 945 } else if (v1._in2 == v2._in2) { 946 assert(v1._res == v2._res || v1._res == nullptr || v2._res == nullptr, "same inputs should lead to same result"); 947 return 0; 948 } 949 return 1; 950 } 951 return 1; 952 } 953 const Type* res() const { return _res; } 954 }; 955 uint _depth; 956 GrowableArray<VerifyMeetResultEntry> _cache; 957 958 // With verification code, the meet of A and B causes the computation of: 959 // 1- meet(A, B) 960 // 2- meet(B, A) 961 // 3- meet(dual(meet(A, B)), dual(A)) 962 // 4- meet(dual(meet(A, B)), dual(B)) 963 // 5- meet(dual(A), dual(B)) 964 // 6- meet(dual(B), dual(A)) 965 // 7- meet(dual(meet(dual(A), dual(B))), A) 966 // 8- meet(dual(meet(dual(A), dual(B))), B) 967 // 968 // In addition the meet of A[] and B[] requires the computation of the meet of A and B. 969 // 970 // The meet of A[] and B[] triggers the computation of: 971 // 1- meet(A[], B[][) 972 // 1.1- meet(A, B) 973 // 1.2- meet(B, A) 974 // 1.3- meet(dual(meet(A, B)), dual(A)) 975 // 1.4- meet(dual(meet(A, B)), dual(B)) 976 // 1.5- meet(dual(A), dual(B)) 977 // 1.6- meet(dual(B), dual(A)) 978 // 1.7- meet(dual(meet(dual(A), dual(B))), A) 979 // 1.8- meet(dual(meet(dual(A), dual(B))), B) 980 // 2- meet(B[], A[]) 981 // 2.1- meet(B, A) = 1.2 982 // 2.2- meet(A, B) = 1.1 983 // 2.3- meet(dual(meet(B, A)), dual(B)) = 1.4 984 // 2.4- meet(dual(meet(B, A)), dual(A)) = 1.3 985 // 2.5- meet(dual(B), dual(A)) = 1.6 986 // 2.6- meet(dual(A), dual(B)) = 1.5 987 // 2.7- meet(dual(meet(dual(B), dual(A))), B) = 1.8 988 // 2.8- meet(dual(meet(dual(B), dual(A))), B) = 1.7 989 // etc. 990 // The number of meet operations performed grows exponentially with the number of dimensions of the arrays but the number 991 // of different meet operations is linear in the number of dimensions. The function below caches meet results for the 992 // duration of the meet at the root of the recursive calls. 993 // 994 const Type* meet(const Type* t1, const Type* t2) { 995 bool found = false; 996 const VerifyMeetResultEntry meet(t1, t2, nullptr); 997 int pos = _cache.find_sorted<VerifyMeetResultEntry, VerifyMeetResultEntry::compare>(meet, found); 998 const Type* res = nullptr; 999 if (found) { 1000 res = _cache.at(pos).res(); 1001 } else { 1002 res = t1->xmeet(t2); 1003 _cache.insert_sorted<VerifyMeetResultEntry::compare>(VerifyMeetResultEntry(t1, t2, res)); 1004 found = false; 1005 _cache.find_sorted<VerifyMeetResultEntry, VerifyMeetResultEntry::compare>(meet, found); 1006 assert(found, "should be in table after it's added"); 1007 } 1008 return res; 1009 } 1010 1011 void add(const Type* t1, const Type* t2, const Type* res) { 1012 _cache.insert_sorted<VerifyMeetResultEntry::compare>(VerifyMeetResultEntry(t1, t2, res)); 1013 } 1014 1015 bool empty_cache() const { 1016 return _cache.length() == 0; 1017 } 1018 public: 1019 VerifyMeetResult(Compile* C) : 1020 _depth(0), _cache(C->comp_arena(), 2, 0, VerifyMeetResultEntry()) { 1021 } 1022 }; 1023 1024 void Type::assert_type_verify_empty() const { 1025 assert(Compile::current()->_type_verify == nullptr || Compile::current()->_type_verify->empty_cache(), "cache should have been discarded"); 1026 } 1027 1028 class VerifyMeet { 1029 private: 1030 Compile* _C; 1031 public: 1032 VerifyMeet(Compile* C) : _C(C) { 1033 if (C->_type_verify == nullptr) { 1034 C->_type_verify = new (C->comp_arena())VerifyMeetResult(C); 1035 } 1036 _C->_type_verify->_depth++; 1037 } 1038 1039 ~VerifyMeet() { 1040 assert(_C->_type_verify->_depth != 0, ""); 1041 _C->_type_verify->_depth--; 1042 if (_C->_type_verify->_depth == 0) { 1043 _C->_type_verify->_cache.trunc_to(0); 1044 } 1045 } 1046 1047 const Type* meet(const Type* t1, const Type* t2) const { 1048 return _C->_type_verify->meet(t1, t2); 1049 } 1050 1051 void add(const Type* t1, const Type* t2, const Type* res) const { 1052 _C->_type_verify->add(t1, t2, res); 1053 } 1054 }; 1055 1056 void Type::check_symmetrical(const Type* t, const Type* mt, const VerifyMeet& verify) const { 1057 Compile* C = Compile::current(); 1058 const Type* mt2 = verify.meet(t, this); 1059 1060 // Verify that: 1061 // this meet t == t meet this 1062 if (mt != mt2) { 1063 tty->print_cr("=== Meet Not Commutative ==="); 1064 tty->print("t = "); t->dump(); tty->cr(); 1065 tty->print("this = "); dump(); tty->cr(); 1066 tty->print("t meet this = "); mt2->dump(); tty->cr(); 1067 tty->print("this meet t = "); mt->dump(); tty->cr(); 1068 fatal("meet not commutative"); 1069 } 1070 const Type* dual_join = mt->_dual; 1071 const Type* t2t = verify.meet(dual_join,t->_dual); 1072 const Type* t2this = verify.meet(dual_join,this->_dual); 1073 1074 // Interface meet Oop is Not Symmetric: 1075 // Interface:AnyNull meet Oop:AnyNull == Interface:AnyNull 1076 // Interface:NotNull meet Oop:NotNull == java/lang/Object:NotNull 1077 1078 // Verify that: 1079 // 1) mt_dual meet t_dual == t_dual 1080 // which corresponds to 1081 // !(t meet this) meet !t == 1082 // (!t join !this) meet !t == !t 1083 // 2) mt_dual meet this_dual == this_dual 1084 // which corresponds to 1085 // !(t meet this) meet !this == 1086 // (!t join !this) meet !this == !this 1087 if (t2t != t->_dual || t2this != this->_dual) { 1088 tty->print_cr("=== Meet Not Symmetric ==="); 1089 tty->print("t = "); t->dump(); tty->cr(); 1090 tty->print("this= "); dump(); tty->cr(); 1091 tty->print("mt=(t meet this)= "); mt->dump(); tty->cr(); 1092 1093 tty->print("t_dual= "); t->_dual->dump(); tty->cr(); 1094 tty->print("this_dual= "); _dual->dump(); tty->cr(); 1095 tty->print("mt_dual= "); mt->_dual->dump(); tty->cr(); 1096 1097 // 1) 1098 tty->print("mt_dual meet t_dual= "); t2t ->dump(); tty->cr(); 1099 // 2) 1100 tty->print("mt_dual meet this_dual= "); t2this ->dump(); tty->cr(); 1101 tty->cr(); 1102 tty->print_cr("Fail: "); 1103 if (t2t != t->_dual) { 1104 tty->print_cr("- mt_dual meet t_dual != t_dual"); 1105 } 1106 if (t2this != this->_dual) { 1107 tty->print_cr("- mt_dual meet this_dual != this_dual"); 1108 } 1109 tty->cr(); 1110 1111 fatal("meet not symmetric"); 1112 } 1113 } 1114 #endif 1115 1116 //------------------------------meet------------------------------------------- 1117 // Compute the MEET of two types. NOT virtual. It enforces that meet is 1118 // commutative and the lattice is symmetric. 1119 const Type *Type::meet_helper(const Type *t, bool include_speculative) const { 1120 if (isa_narrowoop() && t->isa_narrowoop()) { 1121 const Type* result = make_ptr()->meet_helper(t->make_ptr(), include_speculative); 1122 return result->make_narrowoop(); 1123 } 1124 if (isa_narrowklass() && t->isa_narrowklass()) { 1125 const Type* result = make_ptr()->meet_helper(t->make_ptr(), include_speculative); 1126 return result->make_narrowklass(); 1127 } 1128 1129 #ifdef ASSERT 1130 Compile* C = Compile::current(); 1131 VerifyMeet verify(C); 1132 #endif 1133 1134 const Type *this_t = maybe_remove_speculative(include_speculative); 1135 t = t->maybe_remove_speculative(include_speculative); 1136 1137 const Type *mt = this_t->xmeet(t); 1138 #ifdef ASSERT 1139 verify.add(this_t, t, mt); 1140 if (isa_narrowoop() || t->isa_narrowoop()) { 1141 return mt; 1142 } 1143 if (isa_narrowklass() || t->isa_narrowklass()) { 1144 return mt; 1145 } 1146 // TODO 8350865 This currently triggers a verification failure, the code around "// Even though MyValue is final" needs adjustments 1147 if ((this_t->isa_ptr() && this_t->is_ptr()->is_not_flat()) || 1148 (this_t->_dual->isa_ptr() && this_t->_dual->is_ptr()->is_not_flat())) return mt; 1149 this_t->check_symmetrical(t, mt, verify); 1150 const Type *mt_dual = verify.meet(this_t->_dual, t->_dual); 1151 this_t->_dual->check_symmetrical(t->_dual, mt_dual, verify); 1152 #endif 1153 return mt; 1154 } 1155 1156 //------------------------------xmeet------------------------------------------ 1157 // Compute the MEET of two types. It returns a new Type object. 1158 const Type *Type::xmeet( const Type *t ) const { 1159 // Perform a fast test for common case; meeting the same types together. 1160 if( this == t ) return this; // Meeting same type-rep? 1161 1162 // Meeting TOP with anything? 1163 if( _base == Top ) return t; 1164 1165 // Meeting BOTTOM with anything? 1166 if( _base == Bottom ) return BOTTOM; 1167 1168 // Current "this->_base" is one of: Bad, Multi, Control, Top, 1169 // Abio, Abstore, Floatxxx, Doublexxx, Bottom, lastype. 1170 switch (t->base()) { // Switch on original type 1171 1172 // Cut in half the number of cases I must handle. Only need cases for when 1173 // the given enum "t->type" is less than or equal to the local enum "type". 1174 case HalfFloatCon: 1175 case FloatCon: 1176 case DoubleCon: 1177 case Int: 1178 case Long: 1179 return t->xmeet(this); 1180 1181 case OopPtr: 1182 return t->xmeet(this); 1183 1184 case InstPtr: 1185 return t->xmeet(this); 1186 1187 case MetadataPtr: 1188 case KlassPtr: 1189 case InstKlassPtr: 1190 case AryKlassPtr: 1191 return t->xmeet(this); 1192 1193 case AryPtr: 1194 return t->xmeet(this); 1195 1196 case NarrowOop: 1197 return t->xmeet(this); 1198 1199 case NarrowKlass: 1200 return t->xmeet(this); 1201 1202 case Bad: // Type check 1203 default: // Bogus type not in lattice 1204 typerr(t); 1205 return Type::BOTTOM; 1206 1207 case Bottom: // Ye Olde Default 1208 return t; 1209 1210 case HalfFloatTop: 1211 if (_base == HalfFloatTop) { return this; } 1212 case HalfFloatBot: // Half Float 1213 if (_base == HalfFloatBot || _base == HalfFloatTop) { return HALF_FLOAT; } 1214 if (_base == FloatBot || _base == FloatTop) { return Type::BOTTOM; } 1215 if (_base == DoubleTop || _base == DoubleBot) { return Type::BOTTOM; } 1216 typerr(t); 1217 return Type::BOTTOM; 1218 1219 case FloatTop: 1220 if (_base == FloatTop ) { return this; } 1221 case FloatBot: // Float 1222 if (_base == FloatBot || _base == FloatTop) { return FLOAT; } 1223 if (_base == HalfFloatTop || _base == HalfFloatBot) { return Type::BOTTOM; } 1224 if (_base == DoubleTop || _base == DoubleBot) { return Type::BOTTOM; } 1225 typerr(t); 1226 return Type::BOTTOM; 1227 1228 case DoubleTop: 1229 if (_base == DoubleTop) { return this; } 1230 case DoubleBot: // Double 1231 if (_base == DoubleBot || _base == DoubleTop) { return DOUBLE; } 1232 if (_base == HalfFloatTop || _base == HalfFloatBot) { return Type::BOTTOM; } 1233 if (_base == FloatTop || _base == FloatBot) { return Type::BOTTOM; } 1234 typerr(t); 1235 return Type::BOTTOM; 1236 1237 // These next few cases must match exactly or it is a compile-time error. 1238 case Control: // Control of code 1239 case Abio: // State of world outside of program 1240 case Memory: 1241 if (_base == t->_base) { return this; } 1242 typerr(t); 1243 return Type::BOTTOM; 1244 1245 case Top: // Top of the lattice 1246 return this; 1247 } 1248 1249 // The type is unchanged 1250 return this; 1251 } 1252 1253 //-----------------------------filter------------------------------------------ 1254 const Type *Type::filter_helper(const Type *kills, bool include_speculative) const { 1255 const Type* ft = join_helper(kills, include_speculative); 1256 if (ft->empty()) 1257 return Type::TOP; // Canonical empty value 1258 return ft; 1259 } 1260 1261 //------------------------------xdual------------------------------------------ 1262 const Type *Type::xdual() const { 1263 // Note: the base() accessor asserts the sanity of _base. 1264 assert(_type_info[base()].dual_type != Bad, "implement with v-call"); 1265 return new Type(_type_info[_base].dual_type); 1266 } 1267 1268 //------------------------------has_memory------------------------------------- 1269 bool Type::has_memory() const { 1270 Type::TYPES tx = base(); 1271 if (tx == Memory) return true; 1272 if (tx == Tuple) { 1273 const TypeTuple *t = is_tuple(); 1274 for (uint i=0; i < t->cnt(); i++) { 1275 tx = t->field_at(i)->base(); 1276 if (tx == Memory) return true; 1277 } 1278 } 1279 return false; 1280 } 1281 1282 #ifndef PRODUCT 1283 //------------------------------dump2------------------------------------------ 1284 void Type::dump2( Dict &d, uint depth, outputStream *st ) const { 1285 st->print("%s", _type_info[_base].msg); 1286 } 1287 1288 //------------------------------dump------------------------------------------- 1289 void Type::dump_on(outputStream *st) const { 1290 ResourceMark rm; 1291 Dict d(cmpkey,hashkey); // Stop recursive type dumping 1292 dump2(d,1, st); 1293 if (is_ptr_to_narrowoop()) { 1294 st->print(" [narrow]"); 1295 } else if (is_ptr_to_narrowklass()) { 1296 st->print(" [narrowklass]"); 1297 } 1298 } 1299 1300 //----------------------------------------------------------------------------- 1301 const char* Type::str(const Type* t) { 1302 stringStream ss; 1303 t->dump_on(&ss); 1304 return ss.as_string(); 1305 } 1306 #endif 1307 1308 //------------------------------singleton-------------------------------------- 1309 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple 1310 // constants (Ldi nodes). Singletons are integer, float or double constants. 1311 bool Type::singleton(void) const { 1312 return _base == Top || _base == Half; 1313 } 1314 1315 //------------------------------empty------------------------------------------ 1316 // TRUE if Type is a type with no values, FALSE otherwise. 1317 bool Type::empty(void) const { 1318 switch (_base) { 1319 case DoubleTop: 1320 case FloatTop: 1321 case HalfFloatTop: 1322 case Top: 1323 return true; 1324 1325 case Half: 1326 case Abio: 1327 case Return_Address: 1328 case Memory: 1329 case Bottom: 1330 case HalfFloatBot: 1331 case FloatBot: 1332 case DoubleBot: 1333 return false; // never a singleton, therefore never empty 1334 1335 default: 1336 ShouldNotReachHere(); 1337 return false; 1338 } 1339 } 1340 1341 //------------------------------dump_stats------------------------------------- 1342 // Dump collected statistics to stderr 1343 #ifndef PRODUCT 1344 void Type::dump_stats() { 1345 tty->print("Types made: %d\n", type_dict()->Size()); 1346 } 1347 #endif 1348 1349 //------------------------------category--------------------------------------- 1350 #ifndef PRODUCT 1351 Type::Category Type::category() const { 1352 const TypeTuple* tuple; 1353 switch (base()) { 1354 case Type::Int: 1355 case Type::Long: 1356 case Type::Half: 1357 case Type::NarrowOop: 1358 case Type::NarrowKlass: 1359 case Type::Array: 1360 case Type::VectorA: 1361 case Type::VectorS: 1362 case Type::VectorD: 1363 case Type::VectorX: 1364 case Type::VectorY: 1365 case Type::VectorZ: 1366 case Type::VectorMask: 1367 case Type::AnyPtr: 1368 case Type::RawPtr: 1369 case Type::OopPtr: 1370 case Type::InstPtr: 1371 case Type::AryPtr: 1372 case Type::MetadataPtr: 1373 case Type::KlassPtr: 1374 case Type::InstKlassPtr: 1375 case Type::AryKlassPtr: 1376 case Type::Function: 1377 case Type::Return_Address: 1378 case Type::HalfFloatTop: 1379 case Type::HalfFloatCon: 1380 case Type::HalfFloatBot: 1381 case Type::FloatTop: 1382 case Type::FloatCon: 1383 case Type::FloatBot: 1384 case Type::DoubleTop: 1385 case Type::DoubleCon: 1386 case Type::DoubleBot: 1387 return Category::Data; 1388 case Type::Memory: 1389 return Category::Memory; 1390 case Type::Control: 1391 return Category::Control; 1392 case Type::Top: 1393 case Type::Abio: 1394 case Type::Bottom: 1395 return Category::Other; 1396 case Type::Bad: 1397 case Type::lastype: 1398 return Category::Undef; 1399 case Type::Tuple: 1400 // Recursive case. Return CatMixed if the tuple contains types of 1401 // different categories (e.g. CallStaticJavaNode's type), or the specific 1402 // category if all types are of the same category (e.g. IfNode's type). 1403 tuple = is_tuple(); 1404 if (tuple->cnt() == 0) { 1405 return Category::Undef; 1406 } else { 1407 Category first = tuple->field_at(0)->category(); 1408 for (uint i = 1; i < tuple->cnt(); i++) { 1409 if (tuple->field_at(i)->category() != first) { 1410 return Category::Mixed; 1411 } 1412 } 1413 return first; 1414 } 1415 default: 1416 assert(false, "unmatched base type: all base types must be categorized"); 1417 } 1418 return Category::Undef; 1419 } 1420 1421 bool Type::has_category(Type::Category cat) const { 1422 if (category() == cat) { 1423 return true; 1424 } 1425 if (category() == Category::Mixed) { 1426 const TypeTuple* tuple = is_tuple(); 1427 for (uint i = 0; i < tuple->cnt(); i++) { 1428 if (tuple->field_at(i)->has_category(cat)) { 1429 return true; 1430 } 1431 } 1432 } 1433 return false; 1434 } 1435 #endif 1436 1437 //------------------------------typerr----------------------------------------- 1438 void Type::typerr( const Type *t ) const { 1439 #ifndef PRODUCT 1440 tty->print("\nError mixing types: "); 1441 dump(); 1442 tty->print(" and "); 1443 t->dump(); 1444 tty->print("\n"); 1445 #endif 1446 ShouldNotReachHere(); 1447 } 1448 1449 1450 //============================================================================= 1451 // Convenience common pre-built types. 1452 const TypeF *TypeF::MAX; // Floating point max 1453 const TypeF *TypeF::MIN; // Floating point min 1454 const TypeF *TypeF::ZERO; // Floating point zero 1455 const TypeF *TypeF::ONE; // Floating point one 1456 const TypeF *TypeF::POS_INF; // Floating point positive infinity 1457 const TypeF *TypeF::NEG_INF; // Floating point negative infinity 1458 1459 //------------------------------make------------------------------------------- 1460 // Create a float constant 1461 const TypeF *TypeF::make(float f) { 1462 return (TypeF*)(new TypeF(f))->hashcons(); 1463 } 1464 1465 //------------------------------meet------------------------------------------- 1466 // Compute the MEET of two types. It returns a new Type object. 1467 const Type *TypeF::xmeet( const Type *t ) const { 1468 // Perform a fast test for common case; meeting the same types together. 1469 if( this == t ) return this; // Meeting same type-rep? 1470 1471 // Current "this->_base" is FloatCon 1472 switch (t->base()) { // Switch on original type 1473 case AnyPtr: // Mixing with oops happens when javac 1474 case RawPtr: // reuses local variables 1475 case OopPtr: 1476 case InstPtr: 1477 case AryPtr: 1478 case MetadataPtr: 1479 case KlassPtr: 1480 case InstKlassPtr: 1481 case AryKlassPtr: 1482 case NarrowOop: 1483 case NarrowKlass: 1484 case Int: 1485 case Long: 1486 case HalfFloatTop: 1487 case HalfFloatCon: 1488 case HalfFloatBot: 1489 case DoubleTop: 1490 case DoubleCon: 1491 case DoubleBot: 1492 case Bottom: // Ye Olde Default 1493 return Type::BOTTOM; 1494 1495 case FloatBot: 1496 return t; 1497 1498 default: // All else is a mistake 1499 typerr(t); 1500 1501 case FloatCon: // Float-constant vs Float-constant? 1502 if( jint_cast(_f) != jint_cast(t->getf()) ) // unequal constants? 1503 // must compare bitwise as positive zero, negative zero and NaN have 1504 // all the same representation in C++ 1505 return FLOAT; // Return generic float 1506 // Equal constants 1507 case Top: 1508 case FloatTop: 1509 break; // Return the float constant 1510 } 1511 return this; // Return the float constant 1512 } 1513 1514 //------------------------------xdual------------------------------------------ 1515 // Dual: symmetric 1516 const Type *TypeF::xdual() const { 1517 return this; 1518 } 1519 1520 //------------------------------eq--------------------------------------------- 1521 // Structural equality check for Type representations 1522 bool TypeF::eq(const Type *t) const { 1523 // Bitwise comparison to distinguish between +/-0. These values must be treated 1524 // as different to be consistent with C1 and the interpreter. 1525 return (jint_cast(_f) == jint_cast(t->getf())); 1526 } 1527 1528 //------------------------------hash------------------------------------------- 1529 // Type-specific hashing function. 1530 uint TypeF::hash(void) const { 1531 return *(uint*)(&_f); 1532 } 1533 1534 //------------------------------is_finite-------------------------------------- 1535 // Has a finite value 1536 bool TypeF::is_finite() const { 1537 return g_isfinite(getf()) != 0; 1538 } 1539 1540 //------------------------------is_nan----------------------------------------- 1541 // Is not a number (NaN) 1542 bool TypeF::is_nan() const { 1543 return g_isnan(getf()) != 0; 1544 } 1545 1546 //------------------------------dump2------------------------------------------ 1547 // Dump float constant Type 1548 #ifndef PRODUCT 1549 void TypeF::dump2( Dict &d, uint depth, outputStream *st ) const { 1550 Type::dump2(d,depth, st); 1551 st->print("%f", _f); 1552 } 1553 #endif 1554 1555 //------------------------------singleton-------------------------------------- 1556 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple 1557 // constants (Ldi nodes). Singletons are integer, float or double constants 1558 // or a single symbol. 1559 bool TypeF::singleton(void) const { 1560 return true; // Always a singleton 1561 } 1562 1563 bool TypeF::empty(void) const { 1564 return false; // always exactly a singleton 1565 } 1566 1567 //============================================================================= 1568 // Convenience common pre-built types. 1569 const TypeH* TypeH::MAX; // Half float max 1570 const TypeH* TypeH::MIN; // Half float min 1571 const TypeH* TypeH::ZERO; // Half float zero 1572 const TypeH* TypeH::ONE; // Half float one 1573 const TypeH* TypeH::POS_INF; // Half float positive infinity 1574 const TypeH* TypeH::NEG_INF; // Half float negative infinity 1575 1576 //------------------------------make------------------------------------------- 1577 // Create a halffloat constant 1578 const TypeH* TypeH::make(short f) { 1579 return (TypeH*)(new TypeH(f))->hashcons(); 1580 } 1581 1582 const TypeH* TypeH::make(float f) { 1583 assert(StubRoutines::f2hf_adr() != nullptr, ""); 1584 short hf = StubRoutines::f2hf(f); 1585 return (TypeH*)(new TypeH(hf))->hashcons(); 1586 } 1587 1588 //------------------------------xmeet------------------------------------------- 1589 // Compute the MEET of two types. It returns a new Type object. 1590 const Type* TypeH::xmeet(const Type* t) const { 1591 // Perform a fast test for common case; meeting the same types together. 1592 if (this == t) return this; // Meeting same type-rep? 1593 1594 // Current "this->_base" is FloatCon 1595 switch (t->base()) { // Switch on original type 1596 case AnyPtr: // Mixing with oops happens when javac 1597 case RawPtr: // reuses local variables 1598 case OopPtr: 1599 case InstPtr: 1600 case AryPtr: 1601 case MetadataPtr: 1602 case KlassPtr: 1603 case InstKlassPtr: 1604 case AryKlassPtr: 1605 case NarrowOop: 1606 case NarrowKlass: 1607 case Int: 1608 case Long: 1609 case FloatTop: 1610 case FloatCon: 1611 case FloatBot: 1612 case DoubleTop: 1613 case DoubleCon: 1614 case DoubleBot: 1615 case Bottom: // Ye Olde Default 1616 return Type::BOTTOM; 1617 1618 case HalfFloatBot: 1619 return t; 1620 1621 default: // All else is a mistake 1622 typerr(t); 1623 1624 case HalfFloatCon: // Half float-constant vs Half float-constant? 1625 if (_f != t->geth()) { // unequal constants? 1626 // must compare bitwise as positive zero, negative zero and NaN have 1627 // all the same representation in C++ 1628 return HALF_FLOAT; // Return generic float 1629 } // Equal constants 1630 case Top: 1631 case HalfFloatTop: 1632 break; // Return the Half float constant 1633 } 1634 return this; // Return the Half float constant 1635 } 1636 1637 //------------------------------xdual------------------------------------------ 1638 // Dual: symmetric 1639 const Type* TypeH::xdual() const { 1640 return this; 1641 } 1642 1643 //------------------------------eq--------------------------------------------- 1644 // Structural equality check for Type representations 1645 bool TypeH::eq(const Type* t) const { 1646 // Bitwise comparison to distinguish between +/-0. These values must be treated 1647 // as different to be consistent with C1 and the interpreter. 1648 return (_f == t->geth()); 1649 } 1650 1651 //------------------------------hash------------------------------------------- 1652 // Type-specific hashing function. 1653 uint TypeH::hash(void) const { 1654 return *(jshort*)(&_f); 1655 } 1656 1657 //------------------------------is_finite-------------------------------------- 1658 // Has a finite value 1659 bool TypeH::is_finite() const { 1660 assert(StubRoutines::hf2f_adr() != nullptr, ""); 1661 float f = StubRoutines::hf2f(geth()); 1662 return g_isfinite(f) != 0; 1663 } 1664 1665 float TypeH::getf() const { 1666 assert(StubRoutines::hf2f_adr() != nullptr, ""); 1667 return StubRoutines::hf2f(geth()); 1668 } 1669 1670 //------------------------------is_nan----------------------------------------- 1671 // Is not a number (NaN) 1672 bool TypeH::is_nan() const { 1673 assert(StubRoutines::hf2f_adr() != nullptr, ""); 1674 float f = StubRoutines::hf2f(geth()); 1675 return g_isnan(f) != 0; 1676 } 1677 1678 //------------------------------dump2------------------------------------------ 1679 // Dump float constant Type 1680 #ifndef PRODUCT 1681 void TypeH::dump2(Dict &d, uint depth, outputStream* st) const { 1682 Type::dump2(d,depth, st); 1683 st->print("%f", getf()); 1684 } 1685 #endif 1686 1687 //------------------------------singleton-------------------------------------- 1688 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple 1689 // constants (Ldi nodes). Singletons are integer, half float, float or double constants 1690 // or a single symbol. 1691 bool TypeH::singleton(void) const { 1692 return true; // Always a singleton 1693 } 1694 1695 bool TypeH::empty(void) const { 1696 return false; // always exactly a singleton 1697 } 1698 1699 //============================================================================= 1700 // Convenience common pre-built types. 1701 const TypeD *TypeD::MAX; // Floating point max 1702 const TypeD *TypeD::MIN; // Floating point min 1703 const TypeD *TypeD::ZERO; // Floating point zero 1704 const TypeD *TypeD::ONE; // Floating point one 1705 const TypeD *TypeD::POS_INF; // Floating point positive infinity 1706 const TypeD *TypeD::NEG_INF; // Floating point negative infinity 1707 1708 //------------------------------make------------------------------------------- 1709 const TypeD *TypeD::make(double d) { 1710 return (TypeD*)(new TypeD(d))->hashcons(); 1711 } 1712 1713 //------------------------------meet------------------------------------------- 1714 // Compute the MEET of two types. It returns a new Type object. 1715 const Type *TypeD::xmeet( const Type *t ) const { 1716 // Perform a fast test for common case; meeting the same types together. 1717 if( this == t ) return this; // Meeting same type-rep? 1718 1719 // Current "this->_base" is DoubleCon 1720 switch (t->base()) { // Switch on original type 1721 case AnyPtr: // Mixing with oops happens when javac 1722 case RawPtr: // reuses local variables 1723 case OopPtr: 1724 case InstPtr: 1725 case AryPtr: 1726 case MetadataPtr: 1727 case KlassPtr: 1728 case InstKlassPtr: 1729 case AryKlassPtr: 1730 case NarrowOop: 1731 case NarrowKlass: 1732 case Int: 1733 case Long: 1734 case HalfFloatTop: 1735 case HalfFloatCon: 1736 case HalfFloatBot: 1737 case FloatTop: 1738 case FloatCon: 1739 case FloatBot: 1740 case Bottom: // Ye Olde Default 1741 return Type::BOTTOM; 1742 1743 case DoubleBot: 1744 return t; 1745 1746 default: // All else is a mistake 1747 typerr(t); 1748 1749 case DoubleCon: // Double-constant vs Double-constant? 1750 if( jlong_cast(_d) != jlong_cast(t->getd()) ) // unequal constants? (see comment in TypeF::xmeet) 1751 return DOUBLE; // Return generic double 1752 case Top: 1753 case DoubleTop: 1754 break; 1755 } 1756 return this; // Return the double constant 1757 } 1758 1759 //------------------------------xdual------------------------------------------ 1760 // Dual: symmetric 1761 const Type *TypeD::xdual() const { 1762 return this; 1763 } 1764 1765 //------------------------------eq--------------------------------------------- 1766 // Structural equality check for Type representations 1767 bool TypeD::eq(const Type *t) const { 1768 // Bitwise comparison to distinguish between +/-0. These values must be treated 1769 // as different to be consistent with C1 and the interpreter. 1770 return (jlong_cast(_d) == jlong_cast(t->getd())); 1771 } 1772 1773 //------------------------------hash------------------------------------------- 1774 // Type-specific hashing function. 1775 uint TypeD::hash(void) const { 1776 return *(uint*)(&_d); 1777 } 1778 1779 //------------------------------is_finite-------------------------------------- 1780 // Has a finite value 1781 bool TypeD::is_finite() const { 1782 return g_isfinite(getd()) != 0; 1783 } 1784 1785 //------------------------------is_nan----------------------------------------- 1786 // Is not a number (NaN) 1787 bool TypeD::is_nan() const { 1788 return g_isnan(getd()) != 0; 1789 } 1790 1791 //------------------------------dump2------------------------------------------ 1792 // Dump double constant Type 1793 #ifndef PRODUCT 1794 void TypeD::dump2( Dict &d, uint depth, outputStream *st ) const { 1795 Type::dump2(d,depth,st); 1796 st->print("%f", _d); 1797 } 1798 #endif 1799 1800 //------------------------------singleton-------------------------------------- 1801 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple 1802 // constants (Ldi nodes). Singletons are integer, float or double constants 1803 // or a single symbol. 1804 bool TypeD::singleton(void) const { 1805 return true; // Always a singleton 1806 } 1807 1808 bool TypeD::empty(void) const { 1809 return false; // always exactly a singleton 1810 } 1811 1812 const TypeInteger* TypeInteger::make(jlong lo, jlong hi, int w, BasicType bt) { 1813 if (bt == T_INT) { 1814 return TypeInt::make(checked_cast<jint>(lo), checked_cast<jint>(hi), w); 1815 } 1816 assert(bt == T_LONG, "basic type not an int or long"); 1817 return TypeLong::make(lo, hi, w); 1818 } 1819 1820 const TypeInteger* TypeInteger::make(jlong con, BasicType bt) { 1821 return make(con, con, WidenMin, bt); 1822 } 1823 1824 jlong TypeInteger::get_con_as_long(BasicType bt) const { 1825 if (bt == T_INT) { 1826 return is_int()->get_con(); 1827 } 1828 assert(bt == T_LONG, "basic type not an int or long"); 1829 return is_long()->get_con(); 1830 } 1831 1832 const TypeInteger* TypeInteger::bottom(BasicType bt) { 1833 if (bt == T_INT) { 1834 return TypeInt::INT; 1835 } 1836 assert(bt == T_LONG, "basic type not an int or long"); 1837 return TypeLong::LONG; 1838 } 1839 1840 const TypeInteger* TypeInteger::zero(BasicType bt) { 1841 if (bt == T_INT) { 1842 return TypeInt::ZERO; 1843 } 1844 assert(bt == T_LONG, "basic type not an int or long"); 1845 return TypeLong::ZERO; 1846 } 1847 1848 const TypeInteger* TypeInteger::one(BasicType bt) { 1849 if (bt == T_INT) { 1850 return TypeInt::ONE; 1851 } 1852 assert(bt == T_LONG, "basic type not an int or long"); 1853 return TypeLong::ONE; 1854 } 1855 1856 const TypeInteger* TypeInteger::minus_1(BasicType bt) { 1857 if (bt == T_INT) { 1858 return TypeInt::MINUS_1; 1859 } 1860 assert(bt == T_LONG, "basic type not an int or long"); 1861 return TypeLong::MINUS_1; 1862 } 1863 1864 //============================================================================= 1865 // Convenience common pre-built types. 1866 const TypeInt* TypeInt::MAX; // INT_MAX 1867 const TypeInt* TypeInt::MIN; // INT_MIN 1868 const TypeInt* TypeInt::MINUS_1;// -1 1869 const TypeInt* TypeInt::ZERO; // 0 1870 const TypeInt* TypeInt::ONE; // 1 1871 const TypeInt* TypeInt::BOOL; // 0 or 1, FALSE or TRUE. 1872 const TypeInt* TypeInt::CC; // -1,0 or 1, condition codes 1873 const TypeInt* TypeInt::CC_LT; // [-1] == MINUS_1 1874 const TypeInt* TypeInt::CC_GT; // [1] == ONE 1875 const TypeInt* TypeInt::CC_EQ; // [0] == ZERO 1876 const TypeInt* TypeInt::CC_NE; 1877 const TypeInt* TypeInt::CC_LE; // [-1,0] 1878 const TypeInt* TypeInt::CC_GE; // [0,1] == BOOL (!) 1879 const TypeInt* TypeInt::BYTE; // Bytes, -128 to 127 1880 const TypeInt* TypeInt::UBYTE; // Unsigned Bytes, 0 to 255 1881 const TypeInt* TypeInt::CHAR; // Java chars, 0-65535 1882 const TypeInt* TypeInt::SHORT; // Java shorts, -32768-32767 1883 const TypeInt* TypeInt::NON_ZERO; 1884 const TypeInt* TypeInt::POS; // Positive 32-bit integers or zero 1885 const TypeInt* TypeInt::POS1; // Positive 32-bit integers 1886 const TypeInt* TypeInt::INT; // 32-bit integers 1887 const TypeInt* TypeInt::SYMINT; // symmetric range [-max_jint..max_jint] 1888 const TypeInt* TypeInt::TYPE_DOMAIN; // alias for TypeInt::INT 1889 1890 TypeInt::TypeInt(const TypeIntPrototype<jint, juint>& t, int widen, bool dual) 1891 : TypeInteger(Int, t.normalize_widen(widen), dual), _lo(t._srange._lo), _hi(t._srange._hi), 1892 _ulo(t._urange._lo), _uhi(t._urange._hi), _bits(t._bits) { 1893 DEBUG_ONLY(t.verify_constraints()); 1894 } 1895 1896 const Type* TypeInt::make_or_top(const TypeIntPrototype<jint, juint>& t, int widen, bool dual) { 1897 auto canonicalized_t = t.canonicalize_constraints(); 1898 if (canonicalized_t.empty()) { 1899 return dual ? Type::BOTTOM : Type::TOP; 1900 } 1901 return (new TypeInt(canonicalized_t._data, widen, dual))->hashcons()->is_int(); 1902 } 1903 1904 const TypeInt* TypeInt::make(jint con) { 1905 juint ucon = con; 1906 return (new TypeInt(TypeIntPrototype<jint, juint>{{con, con}, {ucon, ucon}, {~ucon, ucon}}, 1907 WidenMin, false))->hashcons()->is_int(); 1908 } 1909 1910 const TypeInt* TypeInt::make(jint lo, jint hi, int widen) { 1911 assert(lo <= hi, "must be legal bounds"); 1912 return make_or_top(TypeIntPrototype<jint, juint>{{lo, hi}, {0, max_juint}, {0, 0}}, widen)->is_int(); 1913 } 1914 1915 const Type* TypeInt::make_or_top(const TypeIntPrototype<jint, juint>& t, int widen) { 1916 return make_or_top(t, widen, false); 1917 } 1918 1919 bool TypeInt::contains(jint i) const { 1920 assert(!_is_dual, "dual types should only be used for join calculation"); 1921 juint u = i; 1922 return i >= _lo && i <= _hi && 1923 u >= _ulo && u <= _uhi && 1924 _bits.is_satisfied_by(u); 1925 } 1926 1927 bool TypeInt::contains(const TypeInt* t) const { 1928 assert(!_is_dual && !t->_is_dual, "dual types should only be used for join calculation"); 1929 return TypeIntHelper::int_type_is_subset(this, t); 1930 } 1931 1932 #ifdef ASSERT 1933 bool TypeInt::strictly_contains(const TypeInt* t) const { 1934 assert(!_is_dual && !t->_is_dual, "dual types should only be used for join calculation"); 1935 return TypeIntHelper::int_type_is_subset(this, t) && !TypeIntHelper::int_type_is_equal(this, t); 1936 } 1937 #endif // ASSERT 1938 1939 const Type* TypeInt::xmeet(const Type* t) const { 1940 return TypeIntHelper::int_type_xmeet(this, t); 1941 } 1942 1943 const Type* TypeInt::xdual() const { 1944 return new TypeInt(TypeIntPrototype<jint, juint>{{_lo, _hi}, {_ulo, _uhi}, _bits}, 1945 _widen, !_is_dual); 1946 } 1947 1948 const Type* TypeInt::widen(const Type* old, const Type* limit) const { 1949 assert(!_is_dual, "dual types should only be used for join calculation"); 1950 return TypeIntHelper::int_type_widen(this, old->isa_int(), limit->isa_int()); 1951 } 1952 1953 const Type* TypeInt::narrow(const Type* old) const { 1954 assert(!_is_dual, "dual types should only be used for join calculation"); 1955 if (old == nullptr) { 1956 return this; 1957 } 1958 1959 return TypeIntHelper::int_type_narrow(this, old->isa_int()); 1960 } 1961 1962 //-----------------------------filter------------------------------------------ 1963 const Type* TypeInt::filter_helper(const Type* kills, bool include_speculative) const { 1964 assert(!_is_dual, "dual types should only be used for join calculation"); 1965 const TypeInt* ft = join_helper(kills, include_speculative)->isa_int(); 1966 if (ft == nullptr) { 1967 return Type::TOP; // Canonical empty value 1968 } 1969 assert(!ft->_is_dual, "dual types should only be used for join calculation"); 1970 if (ft->_widen < this->_widen) { 1971 // Do not allow the value of kill->_widen to affect the outcome. 1972 // The widen bits must be allowed to run freely through the graph. 1973 return (new TypeInt(TypeIntPrototype<jint, juint>{{ft->_lo, ft->_hi}, {ft->_ulo, ft->_uhi}, ft->_bits}, 1974 this->_widen, false))->hashcons(); 1975 } 1976 return ft; 1977 } 1978 1979 //------------------------------eq--------------------------------------------- 1980 // Structural equality check for Type representations 1981 bool TypeInt::eq(const Type* t) const { 1982 const TypeInt* r = t->is_int(); 1983 return TypeIntHelper::int_type_is_equal(this, r) && _widen == r->_widen && _is_dual == r->_is_dual; 1984 } 1985 1986 //------------------------------hash------------------------------------------- 1987 // Type-specific hashing function. 1988 uint TypeInt::hash(void) const { 1989 return (uint)_lo + (uint)_hi + (uint)_ulo + (uint)_uhi + 1990 (uint)_bits._zeros + (uint)_bits._ones + (uint)_widen + (uint)_is_dual + (uint)Type::Int; 1991 } 1992 1993 //------------------------------is_finite-------------------------------------- 1994 // Has a finite value 1995 bool TypeInt::is_finite() const { 1996 return true; 1997 } 1998 1999 //------------------------------singleton-------------------------------------- 2000 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple 2001 // constants. 2002 bool TypeInt::singleton(void) const { 2003 return _lo == _hi; 2004 } 2005 2006 bool TypeInt::empty(void) const { 2007 return false; 2008 } 2009 2010 //============================================================================= 2011 // Convenience common pre-built types. 2012 const TypeLong* TypeLong::MAX; 2013 const TypeLong* TypeLong::MIN; 2014 const TypeLong* TypeLong::MINUS_1;// -1 2015 const TypeLong* TypeLong::ZERO; // 0 2016 const TypeLong* TypeLong::ONE; // 1 2017 const TypeLong* TypeLong::NON_ZERO; 2018 const TypeLong* TypeLong::POS; // >=0 2019 const TypeLong* TypeLong::NEG; 2020 const TypeLong* TypeLong::LONG; // 64-bit integers 2021 const TypeLong* TypeLong::INT; // 32-bit subrange 2022 const TypeLong* TypeLong::UINT; // 32-bit unsigned subrange 2023 const TypeLong* TypeLong::TYPE_DOMAIN; // alias for TypeLong::LONG 2024 2025 TypeLong::TypeLong(const TypeIntPrototype<jlong, julong>& t, int widen, bool dual) 2026 : TypeInteger(Long, t.normalize_widen(widen), dual), _lo(t._srange._lo), _hi(t._srange._hi), 2027 _ulo(t._urange._lo), _uhi(t._urange._hi), _bits(t._bits) { 2028 DEBUG_ONLY(t.verify_constraints()); 2029 } 2030 2031 const Type* TypeLong::make_or_top(const TypeIntPrototype<jlong, julong>& t, int widen, bool dual) { 2032 auto canonicalized_t = t.canonicalize_constraints(); 2033 if (canonicalized_t.empty()) { 2034 return dual ? Type::BOTTOM : Type::TOP; 2035 } 2036 return (new TypeLong(canonicalized_t._data, widen, dual))->hashcons()->is_long(); 2037 } 2038 2039 const TypeLong* TypeLong::make(jlong con) { 2040 julong ucon = con; 2041 return (new TypeLong(TypeIntPrototype<jlong, julong>{{con, con}, {ucon, ucon}, {~ucon, ucon}}, 2042 WidenMin, false))->hashcons()->is_long(); 2043 } 2044 2045 const TypeLong* TypeLong::make(jlong lo, jlong hi, int widen) { 2046 assert(lo <= hi, "must be legal bounds"); 2047 return make_or_top(TypeIntPrototype<jlong, julong>{{lo, hi}, {0, max_julong}, {0, 0}}, widen)->is_long(); 2048 } 2049 2050 const Type* TypeLong::make_or_top(const TypeIntPrototype<jlong, julong>& t, int widen) { 2051 return make_or_top(t, widen, false); 2052 } 2053 2054 bool TypeLong::contains(jlong i) const { 2055 assert(!_is_dual, "dual types should only be used for join calculation"); 2056 julong u = i; 2057 return i >= _lo && i <= _hi && 2058 u >= _ulo && u <= _uhi && 2059 _bits.is_satisfied_by(u); 2060 } 2061 2062 bool TypeLong::contains(const TypeLong* t) const { 2063 assert(!_is_dual && !t->_is_dual, "dual types should only be used for join calculation"); 2064 return TypeIntHelper::int_type_is_subset(this, t); 2065 } 2066 2067 #ifdef ASSERT 2068 bool TypeLong::strictly_contains(const TypeLong* t) const { 2069 assert(!_is_dual && !t->_is_dual, "dual types should only be used for join calculation"); 2070 return TypeIntHelper::int_type_is_subset(this, t) && !TypeIntHelper::int_type_is_equal(this, t); 2071 } 2072 #endif // ASSERT 2073 2074 const Type* TypeLong::xmeet(const Type* t) const { 2075 return TypeIntHelper::int_type_xmeet(this, t); 2076 } 2077 2078 const Type* TypeLong::xdual() const { 2079 return new TypeLong(TypeIntPrototype<jlong, julong>{{_lo, _hi}, {_ulo, _uhi}, _bits}, 2080 _widen, !_is_dual); 2081 } 2082 2083 const Type* TypeLong::widen(const Type* old, const Type* limit) const { 2084 assert(!_is_dual, "dual types should only be used for join calculation"); 2085 return TypeIntHelper::int_type_widen(this, old->isa_long(), limit->isa_long()); 2086 } 2087 2088 const Type* TypeLong::narrow(const Type* old) const { 2089 assert(!_is_dual, "dual types should only be used for join calculation"); 2090 if (old == nullptr) { 2091 return this; 2092 } 2093 2094 return TypeIntHelper::int_type_narrow(this, old->isa_long()); 2095 } 2096 2097 //-----------------------------filter------------------------------------------ 2098 const Type* TypeLong::filter_helper(const Type* kills, bool include_speculative) const { 2099 assert(!_is_dual, "dual types should only be used for join calculation"); 2100 const TypeLong* ft = join_helper(kills, include_speculative)->isa_long(); 2101 if (ft == nullptr) { 2102 return Type::TOP; // Canonical empty value 2103 } 2104 assert(!ft->_is_dual, "dual types should only be used for join calculation"); 2105 if (ft->_widen < this->_widen) { 2106 // Do not allow the value of kill->_widen to affect the outcome. 2107 // The widen bits must be allowed to run freely through the graph. 2108 return (new TypeLong(TypeIntPrototype<jlong, julong>{{ft->_lo, ft->_hi}, {ft->_ulo, ft->_uhi}, ft->_bits}, 2109 this->_widen, false))->hashcons(); 2110 } 2111 return ft; 2112 } 2113 2114 //------------------------------eq--------------------------------------------- 2115 // Structural equality check for Type representations 2116 bool TypeLong::eq(const Type* t) const { 2117 const TypeLong* r = t->is_long(); 2118 return TypeIntHelper::int_type_is_equal(this, r) && _widen == r->_widen && _is_dual == r->_is_dual; 2119 } 2120 2121 //------------------------------hash------------------------------------------- 2122 // Type-specific hashing function. 2123 uint TypeLong::hash(void) const { 2124 return (uint)_lo + (uint)_hi + (uint)_ulo + (uint)_uhi + 2125 (uint)_bits._zeros + (uint)_bits._ones + (uint)_widen + (uint)_is_dual + (uint)Type::Long; 2126 } 2127 2128 //------------------------------is_finite-------------------------------------- 2129 // Has a finite value 2130 bool TypeLong::is_finite() const { 2131 return true; 2132 } 2133 2134 //------------------------------singleton-------------------------------------- 2135 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple 2136 // constants 2137 bool TypeLong::singleton(void) const { 2138 return _lo == _hi; 2139 } 2140 2141 bool TypeLong::empty(void) const { 2142 return false; 2143 } 2144 2145 //------------------------------dump2------------------------------------------ 2146 #ifndef PRODUCT 2147 void TypeInt::dump2(Dict& d, uint depth, outputStream* st) const { 2148 TypeIntHelper::int_type_dump(this, st, false); 2149 } 2150 2151 void TypeInt::dump_verbose() const { 2152 TypeIntHelper::int_type_dump(this, tty, true); 2153 } 2154 2155 void TypeLong::dump2(Dict& d, uint depth, outputStream* st) const { 2156 TypeIntHelper::int_type_dump(this, st, false); 2157 } 2158 2159 void TypeLong::dump_verbose() const { 2160 TypeIntHelper::int_type_dump(this, tty, true); 2161 } 2162 #endif 2163 2164 //============================================================================= 2165 // Convenience common pre-built types. 2166 const TypeTuple *TypeTuple::IFBOTH; // Return both arms of IF as reachable 2167 const TypeTuple *TypeTuple::IFFALSE; 2168 const TypeTuple *TypeTuple::IFTRUE; 2169 const TypeTuple *TypeTuple::IFNEITHER; 2170 const TypeTuple *TypeTuple::LOOPBODY; 2171 const TypeTuple *TypeTuple::MEMBAR; 2172 const TypeTuple *TypeTuple::STORECONDITIONAL; 2173 const TypeTuple *TypeTuple::START_I2C; 2174 const TypeTuple *TypeTuple::INT_PAIR; 2175 const TypeTuple *TypeTuple::LONG_PAIR; 2176 const TypeTuple *TypeTuple::INT_CC_PAIR; 2177 const TypeTuple *TypeTuple::LONG_CC_PAIR; 2178 2179 static void collect_inline_fields(ciInlineKlass* vk, const Type** field_array, uint& pos) { 2180 for (int i = 0; i < vk->nof_declared_nonstatic_fields(); i++) { 2181 ciField* field = vk->declared_nonstatic_field_at(i); 2182 if (field->is_flat()) { 2183 collect_inline_fields(field->type()->as_inline_klass(), field_array, pos); 2184 if (!field->is_null_free()) { 2185 // Use T_INT instead of T_BOOLEAN here because the upper bits can contain garbage if the holder 2186 // is null and C2 will only zero them for T_INT assuming that T_BOOLEAN is already canonicalized. 2187 field_array[pos++] = Type::get_const_basic_type(T_INT); 2188 } 2189 } else { 2190 BasicType bt = field->type()->basic_type(); 2191 const Type* ft = Type::get_const_type(field->type()); 2192 field_array[pos++] = ft; 2193 if (type2size[bt] == 2) { 2194 field_array[pos++] = Type::HALF; 2195 } 2196 } 2197 } 2198 } 2199 2200 //------------------------------make------------------------------------------- 2201 // Make a TypeTuple from the range of a method signature 2202 const TypeTuple *TypeTuple::make_range(ciSignature* sig, InterfaceHandling interface_handling, bool ret_vt_fields) { 2203 ciType* return_type = sig->return_type(); 2204 uint arg_cnt = return_type->size(); 2205 if (ret_vt_fields) { 2206 arg_cnt = return_type->as_inline_klass()->inline_arg_slots() + 1; 2207 // InlineTypeNode::NullMarker field used for null checking 2208 arg_cnt++; 2209 } 2210 const Type **field_array = fields(arg_cnt); 2211 switch (return_type->basic_type()) { 2212 case T_LONG: 2213 field_array[TypeFunc::Parms] = TypeLong::LONG; 2214 field_array[TypeFunc::Parms+1] = Type::HALF; 2215 break; 2216 case T_DOUBLE: 2217 field_array[TypeFunc::Parms] = Type::DOUBLE; 2218 field_array[TypeFunc::Parms+1] = Type::HALF; 2219 break; 2220 case T_OBJECT: 2221 if (return_type->is_inlinetype() && ret_vt_fields) { 2222 uint pos = TypeFunc::Parms; 2223 field_array[pos++] = get_const_type(return_type); // Oop might be null when returning as fields 2224 collect_inline_fields(return_type->as_inline_klass(), field_array, pos); 2225 // InlineTypeNode::NullMarker field used for null checking 2226 field_array[pos++] = get_const_basic_type(T_BOOLEAN); 2227 assert(pos == (TypeFunc::Parms + arg_cnt), "out of bounds"); 2228 break; 2229 } else { 2230 field_array[TypeFunc::Parms] = get_const_type(return_type, interface_handling)->join_speculative(TypePtr::BOTTOM); 2231 } 2232 break; 2233 case T_ARRAY: 2234 case T_BOOLEAN: 2235 case T_CHAR: 2236 case T_FLOAT: 2237 case T_BYTE: 2238 case T_SHORT: 2239 case T_INT: 2240 field_array[TypeFunc::Parms] = get_const_type(return_type, interface_handling); 2241 break; 2242 case T_VOID: 2243 break; 2244 default: 2245 ShouldNotReachHere(); 2246 } 2247 return (TypeTuple*)(new TypeTuple(TypeFunc::Parms + arg_cnt, field_array))->hashcons(); 2248 } 2249 2250 // Make a TypeTuple from the domain of a method signature 2251 const TypeTuple *TypeTuple::make_domain(ciMethod* method, InterfaceHandling interface_handling, bool vt_fields_as_args) { 2252 ciSignature* sig = method->signature(); 2253 uint arg_cnt = sig->size() + (method->is_static() ? 0 : 1); 2254 if (vt_fields_as_args) { 2255 arg_cnt = 0; 2256 assert(method->get_sig_cc() != nullptr, "Should have scalarized signature"); 2257 for (ExtendedSignature sig_cc = ExtendedSignature(method->get_sig_cc(), SigEntryFilter()); !sig_cc.at_end(); ++sig_cc) { 2258 arg_cnt += type2size[(*sig_cc)._bt]; 2259 } 2260 } 2261 2262 uint pos = TypeFunc::Parms; 2263 const Type** field_array = fields(arg_cnt); 2264 if (!method->is_static()) { 2265 ciInstanceKlass* recv = method->holder(); 2266 if (vt_fields_as_args && recv->is_inlinetype() && recv->as_inline_klass()->can_be_passed_as_fields() && method->is_scalarized_arg(0)) { 2267 collect_inline_fields(recv->as_inline_klass(), field_array, pos); 2268 } else { 2269 field_array[pos++] = get_const_type(recv, interface_handling)->join_speculative(TypePtr::NOTNULL); 2270 } 2271 } 2272 2273 int i = 0; 2274 while (pos < TypeFunc::Parms + arg_cnt) { 2275 ciType* type = sig->type_at(i); 2276 BasicType bt = type->basic_type(); 2277 2278 switch (bt) { 2279 case T_LONG: 2280 field_array[pos++] = TypeLong::LONG; 2281 field_array[pos++] = Type::HALF; 2282 break; 2283 case T_DOUBLE: 2284 field_array[pos++] = Type::DOUBLE; 2285 field_array[pos++] = Type::HALF; 2286 break; 2287 case T_OBJECT: 2288 if (type->is_inlinetype() && vt_fields_as_args && method->is_scalarized_arg(i + (method->is_static() ? 0 : 1))) { 2289 // InlineTypeNode::NullMarker field used for null checking 2290 field_array[pos++] = get_const_basic_type(T_BOOLEAN); 2291 collect_inline_fields(type->as_inline_klass(), field_array, pos); 2292 } else { 2293 field_array[pos++] = get_const_type(type, interface_handling); 2294 } 2295 break; 2296 case T_ARRAY: 2297 case T_FLOAT: 2298 case T_INT: 2299 field_array[pos++] = get_const_type(type, interface_handling); 2300 break; 2301 case T_BOOLEAN: 2302 case T_CHAR: 2303 case T_BYTE: 2304 case T_SHORT: 2305 field_array[pos++] = TypeInt::INT; 2306 break; 2307 default: 2308 ShouldNotReachHere(); 2309 } 2310 i++; 2311 } 2312 assert(pos == TypeFunc::Parms + arg_cnt, "wrong number of arguments"); 2313 2314 return (TypeTuple*)(new TypeTuple(TypeFunc::Parms + arg_cnt, field_array))->hashcons(); 2315 } 2316 2317 const TypeTuple *TypeTuple::make( uint cnt, const Type **fields ) { 2318 return (TypeTuple*)(new TypeTuple(cnt,fields))->hashcons(); 2319 } 2320 2321 //------------------------------fields----------------------------------------- 2322 // Subroutine call type with space allocated for argument types 2323 // Memory for Control, I_O, Memory, FramePtr, and ReturnAdr is allocated implicitly 2324 const Type **TypeTuple::fields( uint arg_cnt ) { 2325 const Type **flds = (const Type **)(Compile::current()->type_arena()->AmallocWords((TypeFunc::Parms+arg_cnt)*sizeof(Type*) )); 2326 flds[TypeFunc::Control ] = Type::CONTROL; 2327 flds[TypeFunc::I_O ] = Type::ABIO; 2328 flds[TypeFunc::Memory ] = Type::MEMORY; 2329 flds[TypeFunc::FramePtr ] = TypeRawPtr::BOTTOM; 2330 flds[TypeFunc::ReturnAdr] = Type::RETURN_ADDRESS; 2331 2332 return flds; 2333 } 2334 2335 //------------------------------meet------------------------------------------- 2336 // Compute the MEET of two types. It returns a new Type object. 2337 const Type *TypeTuple::xmeet( const Type *t ) const { 2338 // Perform a fast test for common case; meeting the same types together. 2339 if( this == t ) return this; // Meeting same type-rep? 2340 2341 // Current "this->_base" is Tuple 2342 switch (t->base()) { // switch on original type 2343 2344 case Bottom: // Ye Olde Default 2345 return t; 2346 2347 default: // All else is a mistake 2348 typerr(t); 2349 2350 case Tuple: { // Meeting 2 signatures? 2351 const TypeTuple *x = t->is_tuple(); 2352 assert( _cnt == x->_cnt, "" ); 2353 const Type **fields = (const Type **)(Compile::current()->type_arena()->AmallocWords( _cnt*sizeof(Type*) )); 2354 for( uint i=0; i<_cnt; i++ ) 2355 fields[i] = field_at(i)->xmeet( x->field_at(i) ); 2356 return TypeTuple::make(_cnt,fields); 2357 } 2358 case Top: 2359 break; 2360 } 2361 return this; // Return the double constant 2362 } 2363 2364 //------------------------------xdual------------------------------------------ 2365 // Dual: compute field-by-field dual 2366 const Type *TypeTuple::xdual() const { 2367 const Type **fields = (const Type **)(Compile::current()->type_arena()->AmallocWords( _cnt*sizeof(Type*) )); 2368 for( uint i=0; i<_cnt; i++ ) 2369 fields[i] = _fields[i]->dual(); 2370 return new TypeTuple(_cnt,fields); 2371 } 2372 2373 //------------------------------eq--------------------------------------------- 2374 // Structural equality check for Type representations 2375 bool TypeTuple::eq( const Type *t ) const { 2376 const TypeTuple *s = (const TypeTuple *)t; 2377 if (_cnt != s->_cnt) return false; // Unequal field counts 2378 for (uint i = 0; i < _cnt; i++) 2379 if (field_at(i) != s->field_at(i)) // POINTER COMPARE! NO RECURSION! 2380 return false; // Missed 2381 return true; 2382 } 2383 2384 //------------------------------hash------------------------------------------- 2385 // Type-specific hashing function. 2386 uint TypeTuple::hash(void) const { 2387 uintptr_t sum = _cnt; 2388 for( uint i=0; i<_cnt; i++ ) 2389 sum += (uintptr_t)_fields[i]; // Hash on pointers directly 2390 return (uint)sum; 2391 } 2392 2393 //------------------------------dump2------------------------------------------ 2394 // Dump signature Type 2395 #ifndef PRODUCT 2396 void TypeTuple::dump2( Dict &d, uint depth, outputStream *st ) const { 2397 st->print("{"); 2398 if( !depth || d[this] ) { // Check for recursive print 2399 st->print("...}"); 2400 return; 2401 } 2402 d.Insert((void*)this, (void*)this); // Stop recursion 2403 if( _cnt ) { 2404 uint i; 2405 for( i=0; i<_cnt-1; i++ ) { 2406 st->print("%d:", i); 2407 _fields[i]->dump2(d, depth-1, st); 2408 st->print(", "); 2409 } 2410 st->print("%d:", i); 2411 _fields[i]->dump2(d, depth-1, st); 2412 } 2413 st->print("}"); 2414 } 2415 #endif 2416 2417 //------------------------------singleton-------------------------------------- 2418 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple 2419 // constants (Ldi nodes). Singletons are integer, float or double constants 2420 // or a single symbol. 2421 bool TypeTuple::singleton(void) const { 2422 return false; // Never a singleton 2423 } 2424 2425 bool TypeTuple::empty(void) const { 2426 for( uint i=0; i<_cnt; i++ ) { 2427 if (_fields[i]->empty()) return true; 2428 } 2429 return false; 2430 } 2431 2432 //============================================================================= 2433 // Convenience common pre-built types. 2434 2435 inline const TypeInt* normalize_array_size(const TypeInt* size) { 2436 // Certain normalizations keep us sane when comparing types. 2437 // We do not want arrayOop variables to differ only by the wideness 2438 // of their index types. Pick minimum wideness, since that is the 2439 // forced wideness of small ranges anyway. 2440 if (size->_widen != Type::WidenMin) 2441 return TypeInt::make(size->_lo, size->_hi, Type::WidenMin); 2442 else 2443 return size; 2444 } 2445 2446 //------------------------------make------------------------------------------- 2447 const TypeAry* TypeAry::make(const Type* elem, const TypeInt* size, bool stable, 2448 bool flat, bool not_flat, bool not_null_free, bool atomic) { 2449 if (UseCompressedOops && elem->isa_oopptr()) { 2450 elem = elem->make_narrowoop(); 2451 } 2452 size = normalize_array_size(size); 2453 return (TypeAry*)(new TypeAry(elem, size, stable, flat, not_flat, not_null_free, atomic))->hashcons(); 2454 } 2455 2456 //------------------------------meet------------------------------------------- 2457 // Compute the MEET of two types. It returns a new Type object. 2458 const Type *TypeAry::xmeet( const Type *t ) const { 2459 // Perform a fast test for common case; meeting the same types together. 2460 if( this == t ) return this; // Meeting same type-rep? 2461 2462 // Current "this->_base" is Ary 2463 switch (t->base()) { // switch on original type 2464 2465 case Bottom: // Ye Olde Default 2466 return t; 2467 2468 default: // All else is a mistake 2469 typerr(t); 2470 2471 case Array: { // Meeting 2 arrays? 2472 const TypeAry* a = t->is_ary(); 2473 const Type* size = _size->xmeet(a->_size); 2474 const TypeInt* isize = size->isa_int(); 2475 if (isize == nullptr) { 2476 assert(size == Type::TOP || size == Type::BOTTOM, ""); 2477 return size; 2478 } 2479 return TypeAry::make(_elem->meet_speculative(a->_elem), 2480 isize, _stable && a->_stable, 2481 _flat && a->_flat, 2482 _not_flat && a->_not_flat, 2483 _not_null_free && a->_not_null_free, 2484 _atomic && a->_atomic); 2485 } 2486 case Top: 2487 break; 2488 } 2489 return this; // Return the double constant 2490 } 2491 2492 //------------------------------xdual------------------------------------------ 2493 // Dual: compute field-by-field dual 2494 const Type *TypeAry::xdual() const { 2495 const TypeInt* size_dual = _size->dual()->is_int(); 2496 size_dual = normalize_array_size(size_dual); 2497 return new TypeAry(_elem->dual(), size_dual, !_stable, !_flat, !_not_flat, !_not_null_free, !_atomic); 2498 } 2499 2500 //------------------------------eq--------------------------------------------- 2501 // Structural equality check for Type representations 2502 bool TypeAry::eq( const Type *t ) const { 2503 const TypeAry *a = (const TypeAry*)t; 2504 return _elem == a->_elem && 2505 _stable == a->_stable && 2506 _size == a->_size && 2507 _flat == a->_flat && 2508 _not_flat == a->_not_flat && 2509 _not_null_free == a->_not_null_free && 2510 _atomic == a->_atomic; 2511 2512 } 2513 2514 //------------------------------hash------------------------------------------- 2515 // Type-specific hashing function. 2516 uint TypeAry::hash(void) const { 2517 return (uint)(uintptr_t)_elem + (uint)(uintptr_t)_size + (uint)(_stable ? 43 : 0) + 2518 (uint)(_flat ? 44 : 0) + (uint)(_not_flat ? 45 : 0) + (uint)(_not_null_free ? 46 : 0) + (uint)(_atomic ? 47 : 0); 2519 } 2520 2521 /** 2522 * Return same type without a speculative part in the element 2523 */ 2524 const TypeAry* TypeAry::remove_speculative() const { 2525 return make(_elem->remove_speculative(), _size, _stable, _flat, _not_flat, _not_null_free, _atomic); 2526 } 2527 2528 /** 2529 * Return same type with cleaned up speculative part of element 2530 */ 2531 const Type* TypeAry::cleanup_speculative() const { 2532 return make(_elem->cleanup_speculative(), _size, _stable, _flat, _not_flat, _not_null_free, _atomic); 2533 } 2534 2535 /** 2536 * Return same type but with a different inline depth (used for speculation) 2537 * 2538 * @param depth depth to meet with 2539 */ 2540 const TypePtr* TypePtr::with_inline_depth(int depth) const { 2541 if (!UseInlineDepthForSpeculativeTypes) { 2542 return this; 2543 } 2544 return make(AnyPtr, _ptr, _offset, _speculative, depth); 2545 } 2546 2547 //------------------------------dump2------------------------------------------ 2548 #ifndef PRODUCT 2549 void TypeAry::dump2( Dict &d, uint depth, outputStream *st ) const { 2550 if (_stable) st->print("stable:"); 2551 if (_flat) st->print("flat:"); 2552 if (Verbose) { 2553 if (_not_flat) st->print("not flat:"); 2554 if (_not_null_free) st->print("not null free:"); 2555 } 2556 if (_atomic) st->print("atomic:"); 2557 _elem->dump2(d, depth, st); 2558 st->print("["); 2559 _size->dump2(d, depth, st); 2560 st->print("]"); 2561 } 2562 #endif 2563 2564 //------------------------------singleton-------------------------------------- 2565 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple 2566 // constants (Ldi nodes). Singletons are integer, float or double constants 2567 // or a single symbol. 2568 bool TypeAry::singleton(void) const { 2569 return false; // Never a singleton 2570 } 2571 2572 bool TypeAry::empty(void) const { 2573 return _elem->empty() || _size->empty(); 2574 } 2575 2576 //--------------------------ary_must_be_exact---------------------------------- 2577 bool TypeAry::ary_must_be_exact() const { 2578 // This logic looks at the element type of an array, and returns true 2579 // if the element type is either a primitive or a final instance class. 2580 // In such cases, an array built on this ary must have no subclasses. 2581 if (_elem == BOTTOM) return false; // general array not exact 2582 if (_elem == TOP ) return false; // inverted general array not exact 2583 const TypeOopPtr* toop = nullptr; 2584 if (UseCompressedOops && _elem->isa_narrowoop()) { 2585 toop = _elem->make_ptr()->isa_oopptr(); 2586 } else { 2587 toop = _elem->isa_oopptr(); 2588 } 2589 if (!toop) return true; // a primitive type, like int 2590 if (!toop->is_loaded()) return false; // unloaded class 2591 const TypeInstPtr* tinst; 2592 if (_elem->isa_narrowoop()) 2593 tinst = _elem->make_ptr()->isa_instptr(); 2594 else 2595 tinst = _elem->isa_instptr(); 2596 if (tinst) { 2597 if (tinst->instance_klass()->is_final()) { 2598 // Even though MyValue is final, [LMyValue is only exact if the array 2599 // is (not) null-free due to null-free [LMyValue <: null-able [LMyValue. 2600 // TODO 8350865 If we know that the array can't be null-free, it's allowed to be exact, right? 2601 // If so, we should add '&& !_not_null_free' 2602 if (tinst->is_inlinetypeptr() && (tinst->ptr() != TypePtr::NotNull)) { 2603 return false; 2604 } 2605 return true; 2606 } 2607 return false; 2608 } 2609 const TypeAryPtr* tap; 2610 if (_elem->isa_narrowoop()) 2611 tap = _elem->make_ptr()->isa_aryptr(); 2612 else 2613 tap = _elem->isa_aryptr(); 2614 if (tap) 2615 return tap->ary()->ary_must_be_exact(); 2616 return false; 2617 } 2618 2619 //==============================TypeVect======================================= 2620 // Convenience common pre-built types. 2621 const TypeVect* TypeVect::VECTA = nullptr; // vector length agnostic 2622 const TypeVect* TypeVect::VECTS = nullptr; // 32-bit vectors 2623 const TypeVect* TypeVect::VECTD = nullptr; // 64-bit vectors 2624 const TypeVect* TypeVect::VECTX = nullptr; // 128-bit vectors 2625 const TypeVect* TypeVect::VECTY = nullptr; // 256-bit vectors 2626 const TypeVect* TypeVect::VECTZ = nullptr; // 512-bit vectors 2627 const TypeVect* TypeVect::VECTMASK = nullptr; // predicate/mask vector 2628 2629 //------------------------------make------------------------------------------- 2630 const TypeVect* TypeVect::make(BasicType elem_bt, uint length, bool is_mask) { 2631 if (is_mask) { 2632 return makemask(elem_bt, length); 2633 } 2634 assert(is_java_primitive(elem_bt), "only primitive types in vector"); 2635 assert(Matcher::vector_size_supported(elem_bt, length), "length in range"); 2636 int size = length * type2aelembytes(elem_bt); 2637 switch (Matcher::vector_ideal_reg(size)) { 2638 case Op_VecA: 2639 return (TypeVect*)(new TypeVectA(elem_bt, length))->hashcons(); 2640 case Op_VecS: 2641 return (TypeVect*)(new TypeVectS(elem_bt, length))->hashcons(); 2642 case Op_RegL: 2643 case Op_VecD: 2644 case Op_RegD: 2645 return (TypeVect*)(new TypeVectD(elem_bt, length))->hashcons(); 2646 case Op_VecX: 2647 return (TypeVect*)(new TypeVectX(elem_bt, length))->hashcons(); 2648 case Op_VecY: 2649 return (TypeVect*)(new TypeVectY(elem_bt, length))->hashcons(); 2650 case Op_VecZ: 2651 return (TypeVect*)(new TypeVectZ(elem_bt, length))->hashcons(); 2652 } 2653 ShouldNotReachHere(); 2654 return nullptr; 2655 } 2656 2657 // Create a vector mask type with the given element basic type and length. 2658 // - Returns "TypeVectMask" (PVectMask) for platforms that support the predicate 2659 // feature and it is implemented properly in the backend, allowing the mask to 2660 // be stored in a predicate/mask register. 2661 // - Returns a normal vector type "TypeVectA ~ TypeVectZ" (NVectMask) otherwise, 2662 // where the vector mask is stored in a vector register. 2663 const TypeVect* TypeVect::makemask(BasicType elem_bt, uint length) { 2664 if (Matcher::has_predicated_vectors() && 2665 Matcher::match_rule_supported_vector_masked(Op_VectorLoadMask, length, elem_bt)) { 2666 return TypeVectMask::make(elem_bt, length); 2667 } else { 2668 return make(elem_bt, length); 2669 } 2670 } 2671 2672 //------------------------------meet------------------------------------------- 2673 // Compute the MEET of two types. Since each TypeVect is the only instance of 2674 // its species, meeting often returns itself 2675 const Type* TypeVect::xmeet(const Type* t) const { 2676 // Perform a fast test for common case; meeting the same types together. 2677 if (this == t) { 2678 return this; 2679 } 2680 2681 // Current "this->_base" is Vector 2682 switch (t->base()) { // switch on original type 2683 2684 case Bottom: // Ye Olde Default 2685 return t; 2686 2687 default: // All else is a mistake 2688 typerr(t); 2689 case VectorMask: 2690 case VectorA: 2691 case VectorS: 2692 case VectorD: 2693 case VectorX: 2694 case VectorY: 2695 case VectorZ: { // Meeting 2 vectors? 2696 const TypeVect* v = t->is_vect(); 2697 assert(base() == v->base(), ""); 2698 assert(length() == v->length(), ""); 2699 assert(element_basic_type() == v->element_basic_type(), ""); 2700 return this; 2701 } 2702 case Top: 2703 break; 2704 } 2705 return this; 2706 } 2707 2708 //------------------------------xdual------------------------------------------ 2709 // Since each TypeVect is the only instance of its species, it is self-dual 2710 const Type* TypeVect::xdual() const { 2711 return this; 2712 } 2713 2714 //------------------------------eq--------------------------------------------- 2715 // Structural equality check for Type representations 2716 bool TypeVect::eq(const Type* t) const { 2717 const TypeVect* v = t->is_vect(); 2718 return (element_basic_type() == v->element_basic_type()) && (length() == v->length()); 2719 } 2720 2721 //------------------------------hash------------------------------------------- 2722 // Type-specific hashing function. 2723 uint TypeVect::hash(void) const { 2724 return (uint)base() + (uint)(uintptr_t)_elem_bt + (uint)(uintptr_t)_length; 2725 } 2726 2727 //------------------------------singleton-------------------------------------- 2728 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple 2729 // constants (Ldi nodes). Vector is singleton if all elements are the same 2730 // constant value (when vector is created with Replicate code). 2731 bool TypeVect::singleton(void) const { 2732 // There is no Con node for vectors yet. 2733 // return _elem->singleton(); 2734 return false; 2735 } 2736 2737 bool TypeVect::empty(void) const { 2738 return false; 2739 } 2740 2741 //------------------------------dump2------------------------------------------ 2742 #ifndef PRODUCT 2743 void TypeVect::dump2(Dict& d, uint depth, outputStream* st) const { 2744 switch (base()) { 2745 case VectorA: 2746 st->print("vectora"); break; 2747 case VectorS: 2748 st->print("vectors"); break; 2749 case VectorD: 2750 st->print("vectord"); break; 2751 case VectorX: 2752 st->print("vectorx"); break; 2753 case VectorY: 2754 st->print("vectory"); break; 2755 case VectorZ: 2756 st->print("vectorz"); break; 2757 case VectorMask: 2758 st->print("vectormask"); break; 2759 default: 2760 ShouldNotReachHere(); 2761 } 2762 st->print("<%c,%u>", type2char(element_basic_type()), length()); 2763 } 2764 #endif 2765 2766 const TypeVectMask* TypeVectMask::make(const BasicType elem_bt, uint length) { 2767 return (TypeVectMask*) (new TypeVectMask(elem_bt, length))->hashcons(); 2768 } 2769 2770 //============================================================================= 2771 // Convenience common pre-built types. 2772 const TypePtr *TypePtr::NULL_PTR; 2773 const TypePtr *TypePtr::NOTNULL; 2774 const TypePtr *TypePtr::BOTTOM; 2775 2776 //------------------------------meet------------------------------------------- 2777 // Meet over the PTR enum 2778 const TypePtr::PTR TypePtr::ptr_meet[TypePtr::lastPTR][TypePtr::lastPTR] = { 2779 // TopPTR, AnyNull, Constant, Null, NotNull, BotPTR, 2780 { /* Top */ TopPTR, AnyNull, Constant, Null, NotNull, BotPTR,}, 2781 { /* AnyNull */ AnyNull, AnyNull, Constant, BotPTR, NotNull, BotPTR,}, 2782 { /* Constant*/ Constant, Constant, Constant, BotPTR, NotNull, BotPTR,}, 2783 { /* Null */ Null, BotPTR, BotPTR, Null, BotPTR, BotPTR,}, 2784 { /* NotNull */ NotNull, NotNull, NotNull, BotPTR, NotNull, BotPTR,}, 2785 { /* BotPTR */ BotPTR, BotPTR, BotPTR, BotPTR, BotPTR, BotPTR,} 2786 }; 2787 2788 //------------------------------make------------------------------------------- 2789 const TypePtr* TypePtr::make(TYPES t, enum PTR ptr, Offset offset, const TypePtr* speculative, int inline_depth) { 2790 return (TypePtr*)(new TypePtr(t,ptr,offset, speculative, inline_depth))->hashcons(); 2791 } 2792 2793 //------------------------------cast_to_ptr_type------------------------------- 2794 const TypePtr* TypePtr::cast_to_ptr_type(PTR ptr) const { 2795 assert(_base == AnyPtr, "subclass must override cast_to_ptr_type"); 2796 if( ptr == _ptr ) return this; 2797 return make(_base, ptr, _offset, _speculative, _inline_depth); 2798 } 2799 2800 //------------------------------get_con---------------------------------------- 2801 intptr_t TypePtr::get_con() const { 2802 assert( _ptr == Null, "" ); 2803 return offset(); 2804 } 2805 2806 //------------------------------meet------------------------------------------- 2807 // Compute the MEET of two types. It returns a new Type object. 2808 const Type *TypePtr::xmeet(const Type *t) const { 2809 const Type* res = xmeet_helper(t); 2810 if (res->isa_ptr() == nullptr) { 2811 return res; 2812 } 2813 2814 const TypePtr* res_ptr = res->is_ptr(); 2815 if (res_ptr->speculative() != nullptr) { 2816 // type->speculative() is null means that speculation is no better 2817 // than type, i.e. type->speculative() == type. So there are 2 2818 // ways to represent the fact that we have no useful speculative 2819 // data and we should use a single one to be able to test for 2820 // equality between types. Check whether type->speculative() == 2821 // type and set speculative to null if it is the case. 2822 if (res_ptr->remove_speculative() == res_ptr->speculative()) { 2823 return res_ptr->remove_speculative(); 2824 } 2825 } 2826 2827 return res; 2828 } 2829 2830 const Type *TypePtr::xmeet_helper(const Type *t) const { 2831 // Perform a fast test for common case; meeting the same types together. 2832 if( this == t ) return this; // Meeting same type-rep? 2833 2834 // Current "this->_base" is AnyPtr 2835 switch (t->base()) { // switch on original type 2836 case Int: // Mixing ints & oops happens when javac 2837 case Long: // reuses local variables 2838 case HalfFloatTop: 2839 case HalfFloatCon: 2840 case HalfFloatBot: 2841 case FloatTop: 2842 case FloatCon: 2843 case FloatBot: 2844 case DoubleTop: 2845 case DoubleCon: 2846 case DoubleBot: 2847 case NarrowOop: 2848 case NarrowKlass: 2849 case Bottom: // Ye Olde Default 2850 return Type::BOTTOM; 2851 case Top: 2852 return this; 2853 2854 case AnyPtr: { // Meeting to AnyPtrs 2855 const TypePtr *tp = t->is_ptr(); 2856 const TypePtr* speculative = xmeet_speculative(tp); 2857 int depth = meet_inline_depth(tp->inline_depth()); 2858 return make(AnyPtr, meet_ptr(tp->ptr()), meet_offset(tp->offset()), speculative, depth); 2859 } 2860 case RawPtr: // For these, flip the call around to cut down 2861 case OopPtr: 2862 case InstPtr: // on the cases I have to handle. 2863 case AryPtr: 2864 case MetadataPtr: 2865 case KlassPtr: 2866 case InstKlassPtr: 2867 case AryKlassPtr: 2868 return t->xmeet(this); // Call in reverse direction 2869 default: // All else is a mistake 2870 typerr(t); 2871 2872 } 2873 return this; 2874 } 2875 2876 //------------------------------meet_offset------------------------------------ 2877 Type::Offset TypePtr::meet_offset(int offset) const { 2878 return _offset.meet(Offset(offset)); 2879 } 2880 2881 //------------------------------dual_offset------------------------------------ 2882 Type::Offset TypePtr::dual_offset() const { 2883 return _offset.dual(); 2884 } 2885 2886 //------------------------------xdual------------------------------------------ 2887 // Dual: compute field-by-field dual 2888 const TypePtr::PTR TypePtr::ptr_dual[TypePtr::lastPTR] = { 2889 BotPTR, NotNull, Constant, Null, AnyNull, TopPTR 2890 }; 2891 2892 const TypePtr::FlatInArray TypePtr::flat_in_array_dual[Uninitialized] = { 2893 /* TopFlat -> */ MaybeFlat, 2894 /* Flat -> */ NotFlat, 2895 /* NotFlat -> */ Flat, 2896 /* MaybeFlat -> */ TopFlat 2897 }; 2898 2899 const char* const TypePtr::flat_in_array_msg[Uninitialized] = { 2900 "TOP flat in array", "flat in array", "not flat in array", "maybe flat in array" 2901 }; 2902 2903 const Type *TypePtr::xdual() const { 2904 return new TypePtr(AnyPtr, dual_ptr(), dual_offset(), dual_speculative(), dual_inline_depth()); 2905 } 2906 2907 //------------------------------xadd_offset------------------------------------ 2908 Type::Offset TypePtr::xadd_offset(intptr_t offset) const { 2909 return _offset.add(offset); 2910 } 2911 2912 //------------------------------add_offset------------------------------------- 2913 const TypePtr *TypePtr::add_offset( intptr_t offset ) const { 2914 return make(AnyPtr, _ptr, xadd_offset(offset), _speculative, _inline_depth); 2915 } 2916 2917 const TypePtr *TypePtr::with_offset(intptr_t offset) const { 2918 return make(AnyPtr, _ptr, Offset(offset), _speculative, _inline_depth); 2919 } 2920 2921 //------------------------------eq--------------------------------------------- 2922 // Structural equality check for Type representations 2923 bool TypePtr::eq( const Type *t ) const { 2924 const TypePtr *a = (const TypePtr*)t; 2925 return _ptr == a->ptr() && _offset == a->_offset && eq_speculative(a) && _inline_depth == a->_inline_depth; 2926 } 2927 2928 //------------------------------hash------------------------------------------- 2929 // Type-specific hashing function. 2930 uint TypePtr::hash(void) const { 2931 return (uint)_ptr + (uint)offset() + (uint)hash_speculative() + (uint)_inline_depth; 2932 } 2933 2934 /** 2935 * Return same type without a speculative part 2936 */ 2937 const TypePtr* TypePtr::remove_speculative() const { 2938 if (_speculative == nullptr) { 2939 return this; 2940 } 2941 assert(_inline_depth == InlineDepthTop || _inline_depth == InlineDepthBottom, "non speculative type shouldn't have inline depth"); 2942 return make(AnyPtr, _ptr, _offset, nullptr, _inline_depth); 2943 } 2944 2945 /** 2946 * Return same type but drop speculative part if we know we won't use 2947 * it 2948 */ 2949 const Type* TypePtr::cleanup_speculative() const { 2950 if (speculative() == nullptr) { 2951 return this; 2952 } 2953 const Type* no_spec = remove_speculative(); 2954 // If this is NULL_PTR then we don't need the speculative type 2955 // (with_inline_depth in case the current type inline depth is 2956 // InlineDepthTop) 2957 if (no_spec == NULL_PTR->with_inline_depth(inline_depth())) { 2958 return no_spec; 2959 } 2960 if (above_centerline(speculative()->ptr())) { 2961 return no_spec; 2962 } 2963 const TypeOopPtr* spec_oopptr = speculative()->isa_oopptr(); 2964 // If the speculative may be null and is an inexact klass then it 2965 // doesn't help 2966 if (speculative() != TypePtr::NULL_PTR && speculative()->maybe_null() && 2967 (spec_oopptr == nullptr || !spec_oopptr->klass_is_exact())) { 2968 return no_spec; 2969 } 2970 return this; 2971 } 2972 2973 /** 2974 * dual of the speculative part of the type 2975 */ 2976 const TypePtr* TypePtr::dual_speculative() const { 2977 if (_speculative == nullptr) { 2978 return nullptr; 2979 } 2980 return _speculative->dual()->is_ptr(); 2981 } 2982 2983 /** 2984 * meet of the speculative parts of 2 types 2985 * 2986 * @param other type to meet with 2987 */ 2988 const TypePtr* TypePtr::xmeet_speculative(const TypePtr* other) const { 2989 bool this_has_spec = (_speculative != nullptr); 2990 bool other_has_spec = (other->speculative() != nullptr); 2991 2992 if (!this_has_spec && !other_has_spec) { 2993 return nullptr; 2994 } 2995 2996 // If we are at a point where control flow meets and one branch has 2997 // a speculative type and the other has not, we meet the speculative 2998 // type of one branch with the actual type of the other. If the 2999 // actual type is exact and the speculative is as well, then the 3000 // result is a speculative type which is exact and we can continue 3001 // speculation further. 3002 const TypePtr* this_spec = _speculative; 3003 const TypePtr* other_spec = other->speculative(); 3004 3005 if (!this_has_spec) { 3006 this_spec = this; 3007 } 3008 3009 if (!other_has_spec) { 3010 other_spec = other; 3011 } 3012 3013 return this_spec->meet(other_spec)->is_ptr(); 3014 } 3015 3016 /** 3017 * dual of the inline depth for this type (used for speculation) 3018 */ 3019 int TypePtr::dual_inline_depth() const { 3020 return -inline_depth(); 3021 } 3022 3023 /** 3024 * meet of 2 inline depths (used for speculation) 3025 * 3026 * @param depth depth to meet with 3027 */ 3028 int TypePtr::meet_inline_depth(int depth) const { 3029 return MAX2(inline_depth(), depth); 3030 } 3031 3032 /** 3033 * Are the speculative parts of 2 types equal? 3034 * 3035 * @param other type to compare this one to 3036 */ 3037 bool TypePtr::eq_speculative(const TypePtr* other) const { 3038 if (_speculative == nullptr || other->speculative() == nullptr) { 3039 return _speculative == other->speculative(); 3040 } 3041 3042 if (_speculative->base() != other->speculative()->base()) { 3043 return false; 3044 } 3045 3046 return _speculative->eq(other->speculative()); 3047 } 3048 3049 /** 3050 * Hash of the speculative part of the type 3051 */ 3052 int TypePtr::hash_speculative() const { 3053 if (_speculative == nullptr) { 3054 return 0; 3055 } 3056 3057 return _speculative->hash(); 3058 } 3059 3060 /** 3061 * add offset to the speculative part of the type 3062 * 3063 * @param offset offset to add 3064 */ 3065 const TypePtr* TypePtr::add_offset_speculative(intptr_t offset) const { 3066 if (_speculative == nullptr) { 3067 return nullptr; 3068 } 3069 return _speculative->add_offset(offset)->is_ptr(); 3070 } 3071 3072 const TypePtr* TypePtr::with_offset_speculative(intptr_t offset) const { 3073 if (_speculative == nullptr) { 3074 return nullptr; 3075 } 3076 return _speculative->with_offset(offset)->is_ptr(); 3077 } 3078 3079 /** 3080 * return exact klass from the speculative type if there's one 3081 */ 3082 ciKlass* TypePtr::speculative_type() const { 3083 if (_speculative != nullptr && _speculative->isa_oopptr()) { 3084 const TypeOopPtr* speculative = _speculative->join(this)->is_oopptr(); 3085 if (speculative->klass_is_exact()) { 3086 return speculative->exact_klass(); 3087 } 3088 } 3089 return nullptr; 3090 } 3091 3092 /** 3093 * return true if speculative type may be null 3094 */ 3095 bool TypePtr::speculative_maybe_null() const { 3096 if (_speculative != nullptr) { 3097 const TypePtr* speculative = _speculative->join(this)->is_ptr(); 3098 return speculative->maybe_null(); 3099 } 3100 return true; 3101 } 3102 3103 bool TypePtr::speculative_always_null() const { 3104 if (_speculative != nullptr) { 3105 const TypePtr* speculative = _speculative->join(this)->is_ptr(); 3106 return speculative == TypePtr::NULL_PTR; 3107 } 3108 return false; 3109 } 3110 3111 /** 3112 * Same as TypePtr::speculative_type() but return the klass only if 3113 * the speculative tells us is not null 3114 */ 3115 ciKlass* TypePtr::speculative_type_not_null() const { 3116 if (speculative_maybe_null()) { 3117 return nullptr; 3118 } 3119 return speculative_type(); 3120 } 3121 3122 /** 3123 * Check whether new profiling would improve speculative type 3124 * 3125 * @param exact_kls class from profiling 3126 * @param inline_depth inlining depth of profile point 3127 * 3128 * @return true if type profile is valuable 3129 */ 3130 bool TypePtr::would_improve_type(ciKlass* exact_kls, int inline_depth) const { 3131 // no profiling? 3132 if (exact_kls == nullptr) { 3133 return false; 3134 } 3135 if (speculative() == TypePtr::NULL_PTR) { 3136 return false; 3137 } 3138 // no speculative type or non exact speculative type? 3139 if (speculative_type() == nullptr) { 3140 return true; 3141 } 3142 // If the node already has an exact speculative type keep it, 3143 // unless it was provided by profiling that is at a deeper 3144 // inlining level. Profiling at a higher inlining depth is 3145 // expected to be less accurate. 3146 if (_speculative->inline_depth() == InlineDepthBottom) { 3147 return false; 3148 } 3149 assert(_speculative->inline_depth() != InlineDepthTop, "can't do the comparison"); 3150 return inline_depth < _speculative->inline_depth(); 3151 } 3152 3153 /** 3154 * Check whether new profiling would improve ptr (= tells us it is non 3155 * null) 3156 * 3157 * @param ptr_kind always null or not null? 3158 * 3159 * @return true if ptr profile is valuable 3160 */ 3161 bool TypePtr::would_improve_ptr(ProfilePtrKind ptr_kind) const { 3162 // profiling doesn't tell us anything useful 3163 if (ptr_kind != ProfileAlwaysNull && ptr_kind != ProfileNeverNull) { 3164 return false; 3165 } 3166 // We already know this is not null 3167 if (!this->maybe_null()) { 3168 return false; 3169 } 3170 // We already know the speculative type cannot be null 3171 if (!speculative_maybe_null()) { 3172 return false; 3173 } 3174 // We already know this is always null 3175 if (this == TypePtr::NULL_PTR) { 3176 return false; 3177 } 3178 // We already know the speculative type is always null 3179 if (speculative_always_null()) { 3180 return false; 3181 } 3182 if (ptr_kind == ProfileAlwaysNull && speculative() != nullptr && speculative()->isa_oopptr()) { 3183 return false; 3184 } 3185 return true; 3186 } 3187 3188 TypePtr::FlatInArray TypePtr::compute_flat_in_array(ciInstanceKlass* instance_klass, bool is_exact) { 3189 if (!instance_klass->can_be_inline_klass(is_exact)) { 3190 // Definitely not a value class and thus never flat in an array. 3191 return NotFlat; 3192 } 3193 if (instance_klass->is_inlinetype() && instance_klass->as_inline_klass()->is_always_flat_in_array()) { 3194 return Flat; 3195 } 3196 // We don't know. 3197 return MaybeFlat; 3198 } 3199 3200 // Compute flat in array property if we don't know anything about it (i.e. old_flat_in_array == MaybeFlat). 3201 TypePtr::FlatInArray TypePtr::compute_flat_in_array_if_unknown(ciInstanceKlass* instance_klass, bool is_exact, 3202 FlatInArray old_flat_in_array) const { 3203 switch (old_flat_in_array) { 3204 case Flat: 3205 assert(can_be_inline_type(), "only value objects can be flat in array"); 3206 assert(!instance_klass->is_inlinetype() || instance_klass->as_inline_klass()->is_always_flat_in_array(), 3207 "a value object is only marked flat in array if it's proven to be always flat in array"); 3208 break; 3209 case NotFlat: 3210 assert(!instance_klass->maybe_flat_in_array(), "cannot be flat"); 3211 break; 3212 case MaybeFlat: 3213 return compute_flat_in_array(instance_klass, is_exact); 3214 break; 3215 default: 3216 break; 3217 } 3218 return old_flat_in_array; 3219 } 3220 3221 //------------------------------dump2------------------------------------------ 3222 const char *const TypePtr::ptr_msg[TypePtr::lastPTR] = { 3223 "TopPTR","AnyNull","Constant","null","NotNull","BotPTR" 3224 }; 3225 3226 #ifndef PRODUCT 3227 void TypePtr::dump2( Dict &d, uint depth, outputStream *st ) const { 3228 st->print("ptr:%s", ptr_msg[_ptr]); 3229 dump_offset(st); 3230 dump_inline_depth(st); 3231 dump_speculative(st); 3232 } 3233 3234 void TypePtr::dump_offset(outputStream* st) const { 3235 _offset.dump2(st); 3236 } 3237 3238 /** 3239 *dump the speculative part of the type 3240 */ 3241 void TypePtr::dump_speculative(outputStream *st) const { 3242 if (_speculative != nullptr) { 3243 st->print(" (speculative="); 3244 _speculative->dump_on(st); 3245 st->print(")"); 3246 } 3247 } 3248 3249 /** 3250 *dump the inline depth of the type 3251 */ 3252 void TypePtr::dump_inline_depth(outputStream *st) const { 3253 if (_inline_depth != InlineDepthBottom) { 3254 if (_inline_depth == InlineDepthTop) { 3255 st->print(" (inline_depth=InlineDepthTop)"); 3256 } else { 3257 st->print(" (inline_depth=%d)", _inline_depth); 3258 } 3259 } 3260 } 3261 3262 void TypePtr::dump_flat_in_array(FlatInArray flat_in_array, outputStream* st) { 3263 switch (flat_in_array) { 3264 case MaybeFlat: 3265 case NotFlat: 3266 if (!Verbose) { 3267 break; 3268 } 3269 case TopFlat: 3270 case Flat: 3271 st->print(" (%s)", flat_in_array_msg[flat_in_array]); 3272 break; 3273 default: 3274 ShouldNotReachHere(); 3275 } 3276 } 3277 #endif 3278 3279 //------------------------------singleton-------------------------------------- 3280 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple 3281 // constants 3282 bool TypePtr::singleton(void) const { 3283 // TopPTR, Null, AnyNull, Constant are all singletons 3284 return (_offset != Offset::bottom) && !below_centerline(_ptr); 3285 } 3286 3287 bool TypePtr::empty(void) const { 3288 return (_offset == Offset::top) || above_centerline(_ptr); 3289 } 3290 3291 //============================================================================= 3292 // Convenience common pre-built types. 3293 const TypeRawPtr *TypeRawPtr::BOTTOM; 3294 const TypeRawPtr *TypeRawPtr::NOTNULL; 3295 3296 //------------------------------make------------------------------------------- 3297 const TypeRawPtr *TypeRawPtr::make( enum PTR ptr ) { 3298 assert( ptr != Constant, "what is the constant?" ); 3299 assert( ptr != Null, "Use TypePtr for null" ); 3300 return (TypeRawPtr*)(new TypeRawPtr(ptr,nullptr))->hashcons(); 3301 } 3302 3303 const TypeRawPtr *TypeRawPtr::make(address bits) { 3304 assert(bits != nullptr, "Use TypePtr for null"); 3305 return (TypeRawPtr*)(new TypeRawPtr(Constant,bits))->hashcons(); 3306 } 3307 3308 //------------------------------cast_to_ptr_type------------------------------- 3309 const TypeRawPtr* TypeRawPtr::cast_to_ptr_type(PTR ptr) const { 3310 assert( ptr != Constant, "what is the constant?" ); 3311 assert( ptr != Null, "Use TypePtr for null" ); 3312 assert( _bits == nullptr, "Why cast a constant address?"); 3313 if( ptr == _ptr ) return this; 3314 return make(ptr); 3315 } 3316 3317 //------------------------------get_con---------------------------------------- 3318 intptr_t TypeRawPtr::get_con() const { 3319 assert( _ptr == Null || _ptr == Constant, "" ); 3320 return (intptr_t)_bits; 3321 } 3322 3323 //------------------------------meet------------------------------------------- 3324 // Compute the MEET of two types. It returns a new Type object. 3325 const Type *TypeRawPtr::xmeet( const Type *t ) const { 3326 // Perform a fast test for common case; meeting the same types together. 3327 if( this == t ) return this; // Meeting same type-rep? 3328 3329 // Current "this->_base" is RawPtr 3330 switch( t->base() ) { // switch on original type 3331 case Bottom: // Ye Olde Default 3332 return t; 3333 case Top: 3334 return this; 3335 case AnyPtr: // Meeting to AnyPtrs 3336 break; 3337 case RawPtr: { // might be top, bot, any/not or constant 3338 enum PTR tptr = t->is_ptr()->ptr(); 3339 enum PTR ptr = meet_ptr( tptr ); 3340 if( ptr == Constant ) { // Cannot be equal constants, so... 3341 if( tptr == Constant && _ptr != Constant) return t; 3342 if( _ptr == Constant && tptr != Constant) return this; 3343 ptr = NotNull; // Fall down in lattice 3344 } 3345 return make( ptr ); 3346 } 3347 3348 case OopPtr: 3349 case InstPtr: 3350 case AryPtr: 3351 case MetadataPtr: 3352 case KlassPtr: 3353 case InstKlassPtr: 3354 case AryKlassPtr: 3355 return TypePtr::BOTTOM; // Oop meet raw is not well defined 3356 default: // All else is a mistake 3357 typerr(t); 3358 } 3359 3360 // Found an AnyPtr type vs self-RawPtr type 3361 const TypePtr *tp = t->is_ptr(); 3362 switch (tp->ptr()) { 3363 case TypePtr::TopPTR: return this; 3364 case TypePtr::BotPTR: return t; 3365 case TypePtr::Null: 3366 if( _ptr == TypePtr::TopPTR ) return t; 3367 return TypeRawPtr::BOTTOM; 3368 case TypePtr::NotNull: return TypePtr::make(AnyPtr, meet_ptr(TypePtr::NotNull), tp->meet_offset(0), tp->speculative(), tp->inline_depth()); 3369 case TypePtr::AnyNull: 3370 if( _ptr == TypePtr::Constant) return this; 3371 return make( meet_ptr(TypePtr::AnyNull) ); 3372 default: ShouldNotReachHere(); 3373 } 3374 return this; 3375 } 3376 3377 //------------------------------xdual------------------------------------------ 3378 // Dual: compute field-by-field dual 3379 const Type *TypeRawPtr::xdual() const { 3380 return new TypeRawPtr( dual_ptr(), _bits ); 3381 } 3382 3383 //------------------------------add_offset------------------------------------- 3384 const TypePtr* TypeRawPtr::add_offset(intptr_t offset) const { 3385 if( offset == OffsetTop ) return BOTTOM; // Undefined offset-> undefined pointer 3386 if( offset == OffsetBot ) return BOTTOM; // Unknown offset-> unknown pointer 3387 if( offset == 0 ) return this; // No change 3388 switch (_ptr) { 3389 case TypePtr::TopPTR: 3390 case TypePtr::BotPTR: 3391 case TypePtr::NotNull: 3392 return this; 3393 case TypePtr::Constant: { 3394 uintptr_t bits = (uintptr_t)_bits; 3395 uintptr_t sum = bits + offset; 3396 if (( offset < 0 ) 3397 ? ( sum > bits ) // Underflow? 3398 : ( sum < bits )) { // Overflow? 3399 return BOTTOM; 3400 } else if ( sum == 0 ) { 3401 return TypePtr::NULL_PTR; 3402 } else { 3403 return make( (address)sum ); 3404 } 3405 } 3406 default: ShouldNotReachHere(); 3407 } 3408 } 3409 3410 //------------------------------eq--------------------------------------------- 3411 // Structural equality check for Type representations 3412 bool TypeRawPtr::eq( const Type *t ) const { 3413 const TypeRawPtr *a = (const TypeRawPtr*)t; 3414 return _bits == a->_bits && TypePtr::eq(t); 3415 } 3416 3417 //------------------------------hash------------------------------------------- 3418 // Type-specific hashing function. 3419 uint TypeRawPtr::hash(void) const { 3420 return (uint)(uintptr_t)_bits + (uint)TypePtr::hash(); 3421 } 3422 3423 //------------------------------dump2------------------------------------------ 3424 #ifndef PRODUCT 3425 void TypeRawPtr::dump2(Dict& d, uint depth, outputStream* st) const { 3426 if (_ptr == Constant) { 3427 st->print("rawptr:Constant:" INTPTR_FORMAT, p2i(_bits)); 3428 } else { 3429 st->print("rawptr:%s", ptr_msg[_ptr]); 3430 } 3431 } 3432 #endif 3433 3434 //============================================================================= 3435 // Convenience common pre-built type. 3436 const TypeOopPtr *TypeOopPtr::BOTTOM; 3437 3438 TypeInterfaces::TypeInterfaces(ciInstanceKlass** interfaces_base, int nb_interfaces) 3439 : Type(Interfaces), _interfaces(interfaces_base, nb_interfaces), 3440 _hash(0), _exact_klass(nullptr) { 3441 _interfaces.sort(compare); 3442 initialize(); 3443 } 3444 3445 const TypeInterfaces* TypeInterfaces::make(GrowableArray<ciInstanceKlass*>* interfaces) { 3446 // hashcons() can only delete the last thing that was allocated: to 3447 // make sure all memory for the newly created TypeInterfaces can be 3448 // freed if an identical one exists, allocate space for the array of 3449 // interfaces right after the TypeInterfaces object so that they 3450 // form a contiguous piece of memory. 3451 int nb_interfaces = interfaces == nullptr ? 0 : interfaces->length(); 3452 size_t total_size = sizeof(TypeInterfaces) + nb_interfaces * sizeof(ciInstanceKlass*); 3453 3454 void* allocated_mem = operator new(total_size); 3455 ciInstanceKlass** interfaces_base = (ciInstanceKlass**)((char*)allocated_mem + sizeof(TypeInterfaces)); 3456 for (int i = 0; i < nb_interfaces; ++i) { 3457 interfaces_base[i] = interfaces->at(i); 3458 } 3459 TypeInterfaces* result = ::new (allocated_mem) TypeInterfaces(interfaces_base, nb_interfaces); 3460 return (const TypeInterfaces*)result->hashcons(); 3461 } 3462 3463 void TypeInterfaces::initialize() { 3464 compute_hash(); 3465 compute_exact_klass(); 3466 DEBUG_ONLY(_initialized = true;) 3467 } 3468 3469 int TypeInterfaces::compare(ciInstanceKlass* const& k1, ciInstanceKlass* const& k2) { 3470 if ((intptr_t)k1 < (intptr_t)k2) { 3471 return -1; 3472 } else if ((intptr_t)k1 > (intptr_t)k2) { 3473 return 1; 3474 } 3475 return 0; 3476 } 3477 3478 int TypeInterfaces::compare(ciInstanceKlass** k1, ciInstanceKlass** k2) { 3479 return compare(*k1, *k2); 3480 } 3481 3482 bool TypeInterfaces::eq(const Type* t) const { 3483 const TypeInterfaces* other = (const TypeInterfaces*)t; 3484 if (_interfaces.length() != other->_interfaces.length()) { 3485 return false; 3486 } 3487 for (int i = 0; i < _interfaces.length(); i++) { 3488 ciKlass* k1 = _interfaces.at(i); 3489 ciKlass* k2 = other->_interfaces.at(i); 3490 if (!k1->equals(k2)) { 3491 return false; 3492 } 3493 } 3494 return true; 3495 } 3496 3497 bool TypeInterfaces::eq(ciInstanceKlass* k) const { 3498 assert(k->is_loaded(), "should be loaded"); 3499 GrowableArray<ciInstanceKlass *>* interfaces = k->transitive_interfaces(); 3500 if (_interfaces.length() != interfaces->length()) { 3501 return false; 3502 } 3503 for (int i = 0; i < interfaces->length(); i++) { 3504 bool found = false; 3505 _interfaces.find_sorted<ciInstanceKlass*, compare>(interfaces->at(i), found); 3506 if (!found) { 3507 return false; 3508 } 3509 } 3510 return true; 3511 } 3512 3513 3514 uint TypeInterfaces::hash() const { 3515 assert(_initialized, "must be"); 3516 return _hash; 3517 } 3518 3519 const Type* TypeInterfaces::xdual() const { 3520 return this; 3521 } 3522 3523 void TypeInterfaces::compute_hash() { 3524 uint hash = 0; 3525 for (int i = 0; i < _interfaces.length(); i++) { 3526 ciKlass* k = _interfaces.at(i); 3527 hash += k->hash(); 3528 } 3529 _hash = hash; 3530 } 3531 3532 static int compare_interfaces(ciInstanceKlass** k1, ciInstanceKlass** k2) { 3533 return (int)((*k1)->ident() - (*k2)->ident()); 3534 } 3535 3536 void TypeInterfaces::dump(outputStream* st) const { 3537 if (_interfaces.length() == 0) { 3538 return; 3539 } 3540 ResourceMark rm; 3541 st->print(" ("); 3542 GrowableArray<ciInstanceKlass*> interfaces; 3543 interfaces.appendAll(&_interfaces); 3544 // Sort the interfaces so they are listed in the same order from one run to the other of the same compilation 3545 interfaces.sort(compare_interfaces); 3546 for (int i = 0; i < interfaces.length(); i++) { 3547 if (i > 0) { 3548 st->print(","); 3549 } 3550 ciKlass* k = interfaces.at(i); 3551 k->print_name_on(st); 3552 } 3553 st->print(")"); 3554 } 3555 3556 #ifdef ASSERT 3557 void TypeInterfaces::verify() const { 3558 for (int i = 1; i < _interfaces.length(); i++) { 3559 ciInstanceKlass* k1 = _interfaces.at(i-1); 3560 ciInstanceKlass* k2 = _interfaces.at(i); 3561 assert(compare(k2, k1) > 0, "should be ordered"); 3562 assert(k1 != k2, "no duplicate"); 3563 } 3564 } 3565 #endif 3566 3567 const TypeInterfaces* TypeInterfaces::union_with(const TypeInterfaces* other) const { 3568 GrowableArray<ciInstanceKlass*> result_list; 3569 int i = 0; 3570 int j = 0; 3571 while (i < _interfaces.length() || j < other->_interfaces.length()) { 3572 while (i < _interfaces.length() && 3573 (j >= other->_interfaces.length() || 3574 compare(_interfaces.at(i), other->_interfaces.at(j)) < 0)) { 3575 result_list.push(_interfaces.at(i)); 3576 i++; 3577 } 3578 while (j < other->_interfaces.length() && 3579 (i >= _interfaces.length() || 3580 compare(other->_interfaces.at(j), _interfaces.at(i)) < 0)) { 3581 result_list.push(other->_interfaces.at(j)); 3582 j++; 3583 } 3584 if (i < _interfaces.length() && 3585 j < other->_interfaces.length() && 3586 _interfaces.at(i) == other->_interfaces.at(j)) { 3587 result_list.push(_interfaces.at(i)); 3588 i++; 3589 j++; 3590 } 3591 } 3592 const TypeInterfaces* result = TypeInterfaces::make(&result_list); 3593 #ifdef ASSERT 3594 result->verify(); 3595 for (int i = 0; i < _interfaces.length(); i++) { 3596 assert(result->_interfaces.contains(_interfaces.at(i)), "missing"); 3597 } 3598 for (int i = 0; i < other->_interfaces.length(); i++) { 3599 assert(result->_interfaces.contains(other->_interfaces.at(i)), "missing"); 3600 } 3601 for (int i = 0; i < result->_interfaces.length(); i++) { 3602 assert(_interfaces.contains(result->_interfaces.at(i)) || other->_interfaces.contains(result->_interfaces.at(i)), "missing"); 3603 } 3604 #endif 3605 return result; 3606 } 3607 3608 const TypeInterfaces* TypeInterfaces::intersection_with(const TypeInterfaces* other) const { 3609 GrowableArray<ciInstanceKlass*> result_list; 3610 int i = 0; 3611 int j = 0; 3612 while (i < _interfaces.length() || j < other->_interfaces.length()) { 3613 while (i < _interfaces.length() && 3614 (j >= other->_interfaces.length() || 3615 compare(_interfaces.at(i), other->_interfaces.at(j)) < 0)) { 3616 i++; 3617 } 3618 while (j < other->_interfaces.length() && 3619 (i >= _interfaces.length() || 3620 compare(other->_interfaces.at(j), _interfaces.at(i)) < 0)) { 3621 j++; 3622 } 3623 if (i < _interfaces.length() && 3624 j < other->_interfaces.length() && 3625 _interfaces.at(i) == other->_interfaces.at(j)) { 3626 result_list.push(_interfaces.at(i)); 3627 i++; 3628 j++; 3629 } 3630 } 3631 const TypeInterfaces* result = TypeInterfaces::make(&result_list); 3632 #ifdef ASSERT 3633 result->verify(); 3634 for (int i = 0; i < _interfaces.length(); i++) { 3635 assert(!other->_interfaces.contains(_interfaces.at(i)) || result->_interfaces.contains(_interfaces.at(i)), "missing"); 3636 } 3637 for (int i = 0; i < other->_interfaces.length(); i++) { 3638 assert(!_interfaces.contains(other->_interfaces.at(i)) || result->_interfaces.contains(other->_interfaces.at(i)), "missing"); 3639 } 3640 for (int i = 0; i < result->_interfaces.length(); i++) { 3641 assert(_interfaces.contains(result->_interfaces.at(i)) && other->_interfaces.contains(result->_interfaces.at(i)), "missing"); 3642 } 3643 #endif 3644 return result; 3645 } 3646 3647 // Is there a single ciKlass* that can represent the interface set? 3648 ciInstanceKlass* TypeInterfaces::exact_klass() const { 3649 assert(_initialized, "must be"); 3650 return _exact_klass; 3651 } 3652 3653 void TypeInterfaces::compute_exact_klass() { 3654 if (_interfaces.length() == 0) { 3655 _exact_klass = nullptr; 3656 return; 3657 } 3658 ciInstanceKlass* res = nullptr; 3659 for (int i = 0; i < _interfaces.length(); i++) { 3660 ciInstanceKlass* interface = _interfaces.at(i); 3661 if (eq(interface)) { 3662 assert(res == nullptr, ""); 3663 res = interface; 3664 } 3665 } 3666 _exact_klass = res; 3667 } 3668 3669 #ifdef ASSERT 3670 void TypeInterfaces::verify_is_loaded() const { 3671 for (int i = 0; i < _interfaces.length(); i++) { 3672 ciKlass* interface = _interfaces.at(i); 3673 assert(interface->is_loaded(), "Interface not loaded"); 3674 } 3675 } 3676 #endif 3677 3678 // Can't be implemented because there's no way to know if the type is above or below the center line. 3679 const Type* TypeInterfaces::xmeet(const Type* t) const { 3680 ShouldNotReachHere(); 3681 return Type::xmeet(t); 3682 } 3683 3684 bool TypeInterfaces::singleton(void) const { 3685 ShouldNotReachHere(); 3686 return Type::singleton(); 3687 } 3688 3689 bool TypeInterfaces::has_non_array_interface() const { 3690 assert(TypeAryPtr::_array_interfaces != nullptr, "How come Type::Initialize_shared wasn't called yet?"); 3691 3692 return !TypeAryPtr::_array_interfaces->contains(this); 3693 } 3694 3695 //------------------------------TypeOopPtr------------------------------------- 3696 TypeOopPtr::TypeOopPtr(TYPES t, PTR ptr, ciKlass* k, const TypeInterfaces* interfaces, bool xk, ciObject* o, Offset offset, Offset field_offset, 3697 int instance_id, const TypePtr* speculative, int inline_depth) 3698 : TypePtr(t, ptr, offset, speculative, inline_depth), 3699 _const_oop(o), _klass(k), 3700 _interfaces(interfaces), 3701 _klass_is_exact(xk), 3702 _is_ptr_to_narrowoop(false), 3703 _is_ptr_to_narrowklass(false), 3704 _is_ptr_to_boxed_value(false), 3705 _is_ptr_to_strict_final_field(false), 3706 _instance_id(instance_id) { 3707 #ifdef ASSERT 3708 if (klass() != nullptr && klass()->is_loaded()) { 3709 interfaces->verify_is_loaded(); 3710 } 3711 #endif 3712 if (Compile::current()->eliminate_boxing() && (t == InstPtr) && 3713 (offset.get() > 0) && xk && (k != nullptr) && k->is_instance_klass()) { 3714 _is_ptr_to_boxed_value = k->as_instance_klass()->is_boxed_value_offset(offset.get()); 3715 _is_ptr_to_strict_final_field = _is_ptr_to_boxed_value; 3716 } 3717 3718 if (klass() != nullptr && klass()->is_instance_klass() && klass()->is_loaded() && 3719 this->offset() != Type::OffsetBot && this->offset() != Type::OffsetTop) { 3720 ciField* field = klass()->as_instance_klass()->get_field_by_offset(this->offset(), false); 3721 if (field != nullptr && field->is_strict() && field->is_final()) { 3722 _is_ptr_to_strict_final_field = true; 3723 } 3724 } 3725 3726 #ifdef _LP64 3727 if (this->offset() > 0 || this->offset() == Type::OffsetTop || this->offset() == Type::OffsetBot) { 3728 if (this->offset() == oopDesc::klass_offset_in_bytes()) { 3729 _is_ptr_to_narrowklass = UseCompressedClassPointers; 3730 } else if (klass() == nullptr) { 3731 // Array with unknown body type 3732 assert(this->isa_aryptr(), "only arrays without klass"); 3733 _is_ptr_to_narrowoop = UseCompressedOops; 3734 } else if (UseCompressedOops && this->isa_aryptr() && this->offset() != arrayOopDesc::length_offset_in_bytes()) { 3735 if (klass()->is_flat_array_klass() && field_offset != Offset::top && field_offset != Offset::bottom) { 3736 // Check if the field of the inline type array element contains oops 3737 ciInlineKlass* vk = klass()->as_flat_array_klass()->element_klass()->as_inline_klass(); 3738 int foffset = field_offset.get() + vk->payload_offset(); 3739 BasicType field_bt; 3740 ciField* field = vk->get_field_by_offset(foffset, false); 3741 if (field != nullptr) { 3742 field_bt = field->layout_type(); 3743 } else { 3744 assert(field_offset.get() == vk->null_marker_offset_in_payload(), "no field or null marker of %s at offset %d", vk->name()->as_utf8(), foffset); 3745 field_bt = T_BOOLEAN; 3746 } 3747 _is_ptr_to_narrowoop = ::is_reference_type(field_bt); 3748 } else if (klass()->is_obj_array_klass()) { 3749 _is_ptr_to_narrowoop = true; 3750 } 3751 } else if (klass()->is_instance_klass()) { 3752 if (this->isa_klassptr()) { 3753 // Perm objects don't use compressed references 3754 } else if (_offset == Offset::bottom || _offset == Offset::top) { 3755 // unsafe access 3756 _is_ptr_to_narrowoop = UseCompressedOops; 3757 } else { 3758 assert(this->isa_instptr(), "must be an instance ptr."); 3759 if (klass() == ciEnv::current()->Class_klass() && 3760 (this->offset() == java_lang_Class::klass_offset() || 3761 this->offset() == java_lang_Class::array_klass_offset())) { 3762 // Special hidden fields from the Class. 3763 assert(this->isa_instptr(), "must be an instance ptr."); 3764 _is_ptr_to_narrowoop = false; 3765 } else if (klass() == ciEnv::current()->Class_klass() && 3766 this->offset() >= InstanceMirrorKlass::offset_of_static_fields()) { 3767 // Static fields 3768 BasicType basic_elem_type = T_ILLEGAL; 3769 if (const_oop() != nullptr) { 3770 ciInstanceKlass* k = const_oop()->as_instance()->java_lang_Class_klass()->as_instance_klass(); 3771 basic_elem_type = k->get_field_type_by_offset(this->offset(), true); 3772 } 3773 if (basic_elem_type != T_ILLEGAL) { 3774 _is_ptr_to_narrowoop = UseCompressedOops && ::is_reference_type(basic_elem_type); 3775 } else { 3776 // unsafe access 3777 _is_ptr_to_narrowoop = UseCompressedOops; 3778 } 3779 } else { 3780 // Instance fields which contains a compressed oop references. 3781 ciInstanceKlass* ik = klass()->as_instance_klass(); 3782 BasicType basic_elem_type = ik->get_field_type_by_offset(this->offset(), false); 3783 if (basic_elem_type != T_ILLEGAL) { 3784 _is_ptr_to_narrowoop = UseCompressedOops && ::is_reference_type(basic_elem_type); 3785 } else if (klass()->equals(ciEnv::current()->Object_klass())) { 3786 // Compile::find_alias_type() cast exactness on all types to verify 3787 // that it does not affect alias type. 3788 _is_ptr_to_narrowoop = UseCompressedOops; 3789 } else { 3790 // Type for the copy start in LibraryCallKit::inline_native_clone(). 3791 _is_ptr_to_narrowoop = UseCompressedOops; 3792 } 3793 } 3794 } 3795 } 3796 } 3797 #endif // _LP64 3798 } 3799 3800 //------------------------------make------------------------------------------- 3801 const TypeOopPtr *TypeOopPtr::make(PTR ptr, Offset offset, int instance_id, 3802 const TypePtr* speculative, int inline_depth) { 3803 assert(ptr != Constant, "no constant generic pointers"); 3804 ciKlass* k = Compile::current()->env()->Object_klass(); 3805 bool xk = false; 3806 ciObject* o = nullptr; 3807 const TypeInterfaces* interfaces = TypeInterfaces::make(); 3808 return (TypeOopPtr*)(new TypeOopPtr(OopPtr, ptr, k, interfaces, xk, o, offset, Offset::bottom, instance_id, speculative, inline_depth))->hashcons(); 3809 } 3810 3811 3812 //------------------------------cast_to_ptr_type------------------------------- 3813 const TypeOopPtr* TypeOopPtr::cast_to_ptr_type(PTR ptr) const { 3814 assert(_base == OopPtr, "subclass must override cast_to_ptr_type"); 3815 if( ptr == _ptr ) return this; 3816 return make(ptr, _offset, _instance_id, _speculative, _inline_depth); 3817 } 3818 3819 //-----------------------------cast_to_instance_id---------------------------- 3820 const TypeOopPtr *TypeOopPtr::cast_to_instance_id(int instance_id) const { 3821 // There are no instances of a general oop. 3822 // Return self unchanged. 3823 return this; 3824 } 3825 3826 //-----------------------------cast_to_exactness------------------------------- 3827 const TypeOopPtr* TypeOopPtr::cast_to_exactness(bool klass_is_exact) const { 3828 // There is no such thing as an exact general oop. 3829 // Return self unchanged. 3830 return this; 3831 } 3832 3833 //------------------------------as_klass_type---------------------------------- 3834 // Return the klass type corresponding to this instance or array type. 3835 // It is the type that is loaded from an object of this type. 3836 const TypeKlassPtr* TypeOopPtr::as_klass_type(bool try_for_exact) const { 3837 ShouldNotReachHere(); 3838 return nullptr; 3839 } 3840 3841 //------------------------------meet------------------------------------------- 3842 // Compute the MEET of two types. It returns a new Type object. 3843 const Type *TypeOopPtr::xmeet_helper(const Type *t) const { 3844 // Perform a fast test for common case; meeting the same types together. 3845 if( this == t ) return this; // Meeting same type-rep? 3846 3847 // Current "this->_base" is OopPtr 3848 switch (t->base()) { // switch on original type 3849 3850 case Int: // Mixing ints & oops happens when javac 3851 case Long: // reuses local variables 3852 case HalfFloatTop: 3853 case HalfFloatCon: 3854 case HalfFloatBot: 3855 case FloatTop: 3856 case FloatCon: 3857 case FloatBot: 3858 case DoubleTop: 3859 case DoubleCon: 3860 case DoubleBot: 3861 case NarrowOop: 3862 case NarrowKlass: 3863 case Bottom: // Ye Olde Default 3864 return Type::BOTTOM; 3865 case Top: 3866 return this; 3867 3868 default: // All else is a mistake 3869 typerr(t); 3870 3871 case RawPtr: 3872 case MetadataPtr: 3873 case KlassPtr: 3874 case InstKlassPtr: 3875 case AryKlassPtr: 3876 return TypePtr::BOTTOM; // Oop meet raw is not well defined 3877 3878 case AnyPtr: { 3879 // Found an AnyPtr type vs self-OopPtr type 3880 const TypePtr *tp = t->is_ptr(); 3881 Offset offset = meet_offset(tp->offset()); 3882 PTR ptr = meet_ptr(tp->ptr()); 3883 const TypePtr* speculative = xmeet_speculative(tp); 3884 int depth = meet_inline_depth(tp->inline_depth()); 3885 switch (tp->ptr()) { 3886 case Null: 3887 if (ptr == Null) return TypePtr::make(AnyPtr, ptr, offset, speculative, depth); 3888 // else fall through: 3889 case TopPTR: 3890 case AnyNull: { 3891 int instance_id = meet_instance_id(InstanceTop); 3892 return make(ptr, offset, instance_id, speculative, depth); 3893 } 3894 case BotPTR: 3895 case NotNull: 3896 return TypePtr::make(AnyPtr, ptr, offset, speculative, depth); 3897 default: typerr(t); 3898 } 3899 } 3900 3901 case OopPtr: { // Meeting to other OopPtrs 3902 const TypeOopPtr *tp = t->is_oopptr(); 3903 int instance_id = meet_instance_id(tp->instance_id()); 3904 const TypePtr* speculative = xmeet_speculative(tp); 3905 int depth = meet_inline_depth(tp->inline_depth()); 3906 return make(meet_ptr(tp->ptr()), meet_offset(tp->offset()), instance_id, speculative, depth); 3907 } 3908 3909 case InstPtr: // For these, flip the call around to cut down 3910 case AryPtr: 3911 return t->xmeet(this); // Call in reverse direction 3912 3913 } // End of switch 3914 return this; // Return the double constant 3915 } 3916 3917 3918 //------------------------------xdual------------------------------------------ 3919 // Dual of a pure heap pointer. No relevant klass or oop information. 3920 const Type *TypeOopPtr::xdual() const { 3921 assert(klass() == Compile::current()->env()->Object_klass(), "no klasses here"); 3922 assert(const_oop() == nullptr, "no constants here"); 3923 return new TypeOopPtr(_base, dual_ptr(), klass(), _interfaces, klass_is_exact(), const_oop(), dual_offset(), Offset::bottom, dual_instance_id(), dual_speculative(), dual_inline_depth()); 3924 } 3925 3926 //--------------------------make_from_klass_common----------------------------- 3927 // Computes the element-type given a klass. 3928 const TypeOopPtr* TypeOopPtr::make_from_klass_common(ciKlass *klass, bool klass_change, bool try_for_exact, InterfaceHandling interface_handling) { 3929 if (klass->is_instance_klass() || klass->is_inlinetype()) { 3930 Compile* C = Compile::current(); 3931 Dependencies* deps = C->dependencies(); 3932 assert((deps != nullptr) == (C->method() != nullptr && C->method()->code_size() > 0), "sanity"); 3933 // Element is an instance 3934 bool klass_is_exact = false; 3935 ciInstanceKlass* ik = klass->as_instance_klass(); 3936 if (klass->is_loaded()) { 3937 // Try to set klass_is_exact. 3938 klass_is_exact = ik->is_final(); 3939 if (!klass_is_exact && klass_change 3940 && deps != nullptr && UseUniqueSubclasses) { 3941 ciInstanceKlass* sub = ik->unique_concrete_subklass(); 3942 if (sub != nullptr) { 3943 deps->assert_abstract_with_unique_concrete_subtype(ik, sub); 3944 klass = ik = sub; 3945 klass_is_exact = sub->is_final(); 3946 } 3947 } 3948 if (!klass_is_exact && try_for_exact && deps != nullptr && 3949 !ik->is_interface() && !ik->has_subklass()) { 3950 // Add a dependence; if concrete subclass added we need to recompile 3951 deps->assert_leaf_type(ik); 3952 klass_is_exact = true; 3953 } 3954 } 3955 FlatInArray flat_in_array = compute_flat_in_array(ik, klass_is_exact); 3956 const TypeInterfaces* interfaces = TypePtr::interfaces(klass, true, true, false, interface_handling); 3957 return TypeInstPtr::make(TypePtr::BotPTR, klass, interfaces, klass_is_exact, nullptr, Offset(0), flat_in_array); 3958 } else if (klass->is_obj_array_klass()) { 3959 // Element is an object or inline type array. Recursively call ourself. 3960 ciObjArrayKlass* array_klass = klass->as_obj_array_klass(); 3961 const TypeOopPtr* etype = TypeOopPtr::make_from_klass_common(array_klass->element_klass(), /* klass_change= */ false, try_for_exact, interface_handling); 3962 bool xk = array_klass->is_loaded() && array_klass->is_refined(); 3963 3964 // Determine null-free/flat properties 3965 bool flat; 3966 bool not_flat; 3967 bool is_null_free; 3968 bool not_null_free; 3969 bool atomic; 3970 if (xk) { 3971 flat = array_klass->is_flat_array_klass(); 3972 not_flat = !flat; 3973 is_null_free = array_klass->is_elem_null_free(); 3974 not_null_free = !is_null_free; 3975 atomic = array_klass->is_elem_atomic(); 3976 3977 if (is_null_free) { 3978 etype = etype->join_speculative(NOTNULL)->is_oopptr(); 3979 } 3980 } else { 3981 const TypeOopPtr* exact_etype = etype; 3982 if (etype->can_be_inline_type()) { 3983 // Use exact type if element can be an inline type 3984 exact_etype = TypeOopPtr::make_from_klass_common(klass->as_array_klass()->element_klass(), /* klass_change= */ true, /* try_for_exact= */ true, interface_handling); 3985 } 3986 3987 flat = false; 3988 bool not_inline = !exact_etype->can_be_inline_type(); 3989 not_null_free = not_inline; 3990 not_flat = !UseArrayFlattening || not_inline || (exact_etype->is_inlinetypeptr() && !exact_etype->inline_klass()->maybe_flat_in_array()); 3991 atomic = not_flat; 3992 } 3993 3994 const TypeAry* arr0 = TypeAry::make(etype, TypeInt::POS, /* stable= */ false, flat, not_flat, not_null_free, atomic); 3995 // We used to pass NotNull in here, asserting that the sub-arrays 3996 // are all not-null. This is not true in generally, as code can 3997 // slam nullptrs down in the subarrays. 3998 const TypeAryPtr* arr = TypeAryPtr::make(TypePtr::BotPTR, arr0, nullptr, xk, Offset(0)); 3999 return arr; 4000 } else if (klass->is_type_array_klass()) { 4001 // Element is an typeArray 4002 const Type* etype = get_const_basic_type(klass->as_type_array_klass()->element_type()); 4003 const TypeAry* arr0 = TypeAry::make(etype, TypeInt::POS, 4004 /* stable= */ false, /* flat= */ false, /* not_flat= */ true, /* not_null_free= */ true, true); 4005 // We used to pass NotNull in here, asserting that the array pointer 4006 // is not-null. That was not true in general. 4007 const TypeAryPtr* arr = TypeAryPtr::make(TypePtr::BotPTR, arr0, klass, true, Offset(0)); 4008 return arr; 4009 } else { 4010 ShouldNotReachHere(); 4011 return nullptr; 4012 } 4013 } 4014 4015 //------------------------------make_from_constant----------------------------- 4016 // Make a java pointer from an oop constant 4017 const TypeOopPtr* TypeOopPtr::make_from_constant(ciObject* o, bool require_constant) { 4018 assert(!o->is_null_object(), "null object not yet handled here."); 4019 4020 const bool make_constant = require_constant || o->should_be_constant(); 4021 4022 ciKlass* klass = o->klass(); 4023 if (klass->is_instance_klass() || klass->is_inlinetype()) { 4024 // Element is an instance or inline type 4025 if (make_constant) { 4026 return TypeInstPtr::make(o); 4027 } else { 4028 return TypeInstPtr::make(TypePtr::NotNull, klass, true, nullptr, Offset(0)); 4029 } 4030 } else if (klass->is_obj_array_klass()) { 4031 // Element is an object array. Recursively call ourself. 4032 const TypeOopPtr* etype = TypeOopPtr::make_from_klass_raw(klass->as_array_klass()->element_klass(), trust_interfaces); 4033 bool is_flat = o->as_array()->is_flat(); 4034 bool is_null_free = o->as_array()->is_null_free(); 4035 if (is_null_free) { 4036 etype = etype->join_speculative(TypePtr::NOTNULL)->is_oopptr(); 4037 } 4038 bool is_atomic = o->as_array()->is_atomic(); 4039 const TypeAry* arr0 = TypeAry::make(etype, TypeInt::make(o->as_array()->length()), /* stable= */ false, /* flat= */ is_flat, 4040 /* not_flat= */ !is_flat, /* not_null_free= */ !is_null_free, /* atomic= */ is_atomic); 4041 // We used to pass NotNull in here, asserting that the sub-arrays 4042 // are all not-null. This is not true in generally, as code can 4043 // slam nulls down in the subarrays. 4044 if (make_constant) { 4045 return TypeAryPtr::make(TypePtr::Constant, o, arr0, klass, true, Offset(0)); 4046 } else { 4047 return TypeAryPtr::make(TypePtr::NotNull, arr0, klass, true, Offset(0)); 4048 } 4049 } else if (klass->is_type_array_klass()) { 4050 // Element is an typeArray 4051 const Type* etype = (Type*)get_const_basic_type(klass->as_type_array_klass()->element_type()); 4052 const TypeAry* arr0 = TypeAry::make(etype, TypeInt::make(o->as_array()->length()), /* stable= */ false, /* flat= */ false, 4053 /* not_flat= */ true, /* not_null_free= */ true, true); 4054 // We used to pass NotNull in here, asserting that the array pointer 4055 // is not-null. That was not true in general. 4056 if (make_constant) { 4057 return TypeAryPtr::make(TypePtr::Constant, o, arr0, klass, true, Offset(0)); 4058 } else { 4059 return TypeAryPtr::make(TypePtr::NotNull, arr0, klass, true, Offset(0)); 4060 } 4061 } 4062 4063 fatal("unhandled object type"); 4064 return nullptr; 4065 } 4066 4067 //------------------------------get_con---------------------------------------- 4068 intptr_t TypeOopPtr::get_con() const { 4069 assert( _ptr == Null || _ptr == Constant, "" ); 4070 assert(offset() >= 0, ""); 4071 4072 if (offset() != 0) { 4073 // After being ported to the compiler interface, the compiler no longer 4074 // directly manipulates the addresses of oops. Rather, it only has a pointer 4075 // to a handle at compile time. This handle is embedded in the generated 4076 // code and dereferenced at the time the nmethod is made. Until that time, 4077 // it is not reasonable to do arithmetic with the addresses of oops (we don't 4078 // have access to the addresses!). This does not seem to currently happen, 4079 // but this assertion here is to help prevent its occurrence. 4080 tty->print_cr("Found oop constant with non-zero offset"); 4081 ShouldNotReachHere(); 4082 } 4083 4084 return (intptr_t)const_oop()->constant_encoding(); 4085 } 4086 4087 4088 //-----------------------------filter------------------------------------------ 4089 // Do not allow interface-vs.-noninterface joins to collapse to top. 4090 const Type *TypeOopPtr::filter_helper(const Type *kills, bool include_speculative) const { 4091 4092 const Type* ft = join_helper(kills, include_speculative); 4093 4094 if (ft->empty()) { 4095 return Type::TOP; // Canonical empty value 4096 } 4097 4098 return ft; 4099 } 4100 4101 //------------------------------eq--------------------------------------------- 4102 // Structural equality check for Type representations 4103 bool TypeOopPtr::eq( const Type *t ) const { 4104 const TypeOopPtr *a = (const TypeOopPtr*)t; 4105 if (_klass_is_exact != a->_klass_is_exact || 4106 _instance_id != a->_instance_id) return false; 4107 ciObject* one = const_oop(); 4108 ciObject* two = a->const_oop(); 4109 if (one == nullptr || two == nullptr) { 4110 return (one == two) && TypePtr::eq(t); 4111 } else { 4112 return one->equals(two) && TypePtr::eq(t); 4113 } 4114 } 4115 4116 //------------------------------hash------------------------------------------- 4117 // Type-specific hashing function. 4118 uint TypeOopPtr::hash(void) const { 4119 return 4120 (uint)(const_oop() ? const_oop()->hash() : 0) + 4121 (uint)_klass_is_exact + 4122 (uint)_instance_id + TypePtr::hash(); 4123 } 4124 4125 //------------------------------dump2------------------------------------------ 4126 #ifndef PRODUCT 4127 void TypeOopPtr::dump2(Dict& d, uint depth, outputStream* st) const { 4128 st->print("oopptr:%s", ptr_msg[_ptr]); 4129 if (_klass_is_exact) { 4130 st->print(":exact"); 4131 } 4132 if (const_oop() != nullptr) { 4133 st->print(":" INTPTR_FORMAT, p2i(const_oop())); 4134 } 4135 dump_offset(st); 4136 dump_instance_id(st); 4137 dump_inline_depth(st); 4138 dump_speculative(st); 4139 } 4140 4141 void TypeOopPtr::dump_instance_id(outputStream* st) const { 4142 if (_instance_id == InstanceTop) { 4143 st->print(",iid=top"); 4144 } else if (_instance_id == InstanceBot) { 4145 st->print(",iid=bot"); 4146 } else { 4147 st->print(",iid=%d", _instance_id); 4148 } 4149 } 4150 #endif 4151 4152 //------------------------------singleton-------------------------------------- 4153 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple 4154 // constants 4155 bool TypeOopPtr::singleton(void) const { 4156 // detune optimizer to not generate constant oop + constant offset as a constant! 4157 // TopPTR, Null, AnyNull, Constant are all singletons 4158 return (offset() == 0) && !below_centerline(_ptr); 4159 } 4160 4161 //------------------------------add_offset------------------------------------- 4162 const TypePtr* TypeOopPtr::add_offset(intptr_t offset) const { 4163 return make(_ptr, xadd_offset(offset), _instance_id, add_offset_speculative(offset), _inline_depth); 4164 } 4165 4166 const TypeOopPtr* TypeOopPtr::with_offset(intptr_t offset) const { 4167 return make(_ptr, Offset(offset), _instance_id, with_offset_speculative(offset), _inline_depth); 4168 } 4169 4170 /** 4171 * Return same type without a speculative part 4172 */ 4173 const TypeOopPtr* TypeOopPtr::remove_speculative() const { 4174 if (_speculative == nullptr) { 4175 return this; 4176 } 4177 assert(_inline_depth == InlineDepthTop || _inline_depth == InlineDepthBottom, "non speculative type shouldn't have inline depth"); 4178 return make(_ptr, _offset, _instance_id, nullptr, _inline_depth); 4179 } 4180 4181 /** 4182 * Return same type but drop speculative part if we know we won't use 4183 * it 4184 */ 4185 const Type* TypeOopPtr::cleanup_speculative() const { 4186 // If the klass is exact and the ptr is not null then there's 4187 // nothing that the speculative type can help us with 4188 if (klass_is_exact() && !maybe_null()) { 4189 return remove_speculative(); 4190 } 4191 return TypePtr::cleanup_speculative(); 4192 } 4193 4194 /** 4195 * Return same type but with a different inline depth (used for speculation) 4196 * 4197 * @param depth depth to meet with 4198 */ 4199 const TypePtr* TypeOopPtr::with_inline_depth(int depth) const { 4200 if (!UseInlineDepthForSpeculativeTypes) { 4201 return this; 4202 } 4203 return make(_ptr, _offset, _instance_id, _speculative, depth); 4204 } 4205 4206 //------------------------------with_instance_id-------------------------------- 4207 const TypePtr* TypeOopPtr::with_instance_id(int instance_id) const { 4208 assert(_instance_id != -1, "should be known"); 4209 return make(_ptr, _offset, instance_id, _speculative, _inline_depth); 4210 } 4211 4212 //------------------------------meet_instance_id-------------------------------- 4213 int TypeOopPtr::meet_instance_id( int instance_id ) const { 4214 // Either is 'TOP' instance? Return the other instance! 4215 if( _instance_id == InstanceTop ) return instance_id; 4216 if( instance_id == InstanceTop ) return _instance_id; 4217 // If either is different, return 'BOTTOM' instance 4218 if( _instance_id != instance_id ) return InstanceBot; 4219 return _instance_id; 4220 } 4221 4222 //------------------------------dual_instance_id-------------------------------- 4223 int TypeOopPtr::dual_instance_id( ) const { 4224 if( _instance_id == InstanceTop ) return InstanceBot; // Map TOP into BOTTOM 4225 if( _instance_id == InstanceBot ) return InstanceTop; // Map BOTTOM into TOP 4226 return _instance_id; // Map everything else into self 4227 } 4228 4229 4230 const TypeInterfaces* TypeOopPtr::meet_interfaces(const TypeOopPtr* other) const { 4231 if (above_centerline(_ptr) && above_centerline(other->_ptr)) { 4232 return _interfaces->union_with(other->_interfaces); 4233 } else if (above_centerline(_ptr) && !above_centerline(other->_ptr)) { 4234 return other->_interfaces; 4235 } else if (above_centerline(other->_ptr) && !above_centerline(_ptr)) { 4236 return _interfaces; 4237 } 4238 return _interfaces->intersection_with(other->_interfaces); 4239 } 4240 4241 /** 4242 * Check whether new profiling would improve speculative type 4243 * 4244 * @param exact_kls class from profiling 4245 * @param inline_depth inlining depth of profile point 4246 * 4247 * @return true if type profile is valuable 4248 */ 4249 bool TypeOopPtr::would_improve_type(ciKlass* exact_kls, int inline_depth) const { 4250 // no way to improve an already exact type 4251 if (klass_is_exact()) { 4252 return false; 4253 } 4254 return TypePtr::would_improve_type(exact_kls, inline_depth); 4255 } 4256 4257 //============================================================================= 4258 // Convenience common pre-built types. 4259 const TypeInstPtr *TypeInstPtr::NOTNULL; 4260 const TypeInstPtr *TypeInstPtr::BOTTOM; 4261 const TypeInstPtr *TypeInstPtr::MIRROR; 4262 const TypeInstPtr *TypeInstPtr::MARK; 4263 const TypeInstPtr *TypeInstPtr::KLASS; 4264 4265 // Is there a single ciKlass* that can represent that type? 4266 ciKlass* TypeInstPtr::exact_klass_helper() const { 4267 if (_interfaces->empty()) { 4268 return _klass; 4269 } 4270 if (_klass != ciEnv::current()->Object_klass()) { 4271 if (_interfaces->eq(_klass->as_instance_klass())) { 4272 return _klass; 4273 } 4274 return nullptr; 4275 } 4276 return _interfaces->exact_klass(); 4277 } 4278 4279 //------------------------------TypeInstPtr------------------------------------- 4280 TypeInstPtr::TypeInstPtr(PTR ptr, ciKlass* k, const TypeInterfaces* interfaces, bool xk, ciObject* o, Offset off, 4281 FlatInArray flat_in_array, int instance_id, const TypePtr* speculative, int inline_depth) 4282 : TypeOopPtr(InstPtr, ptr, k, interfaces, xk, o, off, Offset::bottom, instance_id, speculative, inline_depth), 4283 _flat_in_array(flat_in_array) { 4284 4285 assert(flat_in_array != Uninitialized, "must be set now"); 4286 assert(k == nullptr || !k->is_loaded() || !k->is_interface(), "no interface here"); 4287 assert(k != nullptr && 4288 (k->is_loaded() || o == nullptr), 4289 "cannot have constants with non-loaded klass"); 4290 }; 4291 4292 //------------------------------make------------------------------------------- 4293 const TypeInstPtr *TypeInstPtr::make(PTR ptr, 4294 ciKlass* k, 4295 const TypeInterfaces* interfaces, 4296 bool xk, 4297 ciObject* o, 4298 Offset offset, 4299 FlatInArray flat_in_array, 4300 int instance_id, 4301 const TypePtr* speculative, 4302 int inline_depth) { 4303 assert( !k->is_loaded() || k->is_instance_klass(), "Must be for instance"); 4304 // Either const_oop() is null or else ptr is Constant 4305 assert( (!o && ptr != Constant) || (o && ptr == Constant), 4306 "constant pointers must have a value supplied" ); 4307 // Ptr is never Null 4308 assert( ptr != Null, "null pointers are not typed" ); 4309 4310 assert(instance_id <= 0 || xk, "instances are always exactly typed"); 4311 ciInstanceKlass* ik = k->as_instance_klass(); 4312 if (ptr == Constant) { 4313 // Note: This case includes meta-object constants, such as methods. 4314 xk = true; 4315 } else if (k->is_loaded()) { 4316 if (!xk && ik->is_final()) xk = true; // no inexact final klass 4317 assert(!ik->is_interface(), "no interface here"); 4318 if (xk && ik->is_interface()) xk = false; // no exact interface 4319 } 4320 4321 if (flat_in_array == Uninitialized) { 4322 flat_in_array = compute_flat_in_array(ik, xk); 4323 } 4324 // Now hash this baby 4325 TypeInstPtr *result = 4326 (TypeInstPtr*)(new TypeInstPtr(ptr, k, interfaces, xk, o, offset, flat_in_array, instance_id, speculative, inline_depth))->hashcons(); 4327 4328 return result; 4329 } 4330 4331 const TypeInterfaces* TypePtr::interfaces(ciKlass*& k, bool klass, bool interface, bool array, InterfaceHandling interface_handling) { 4332 if (k->is_instance_klass()) { 4333 if (k->is_loaded()) { 4334 if (k->is_interface() && interface_handling == ignore_interfaces) { 4335 assert(interface, "no interface expected"); 4336 k = ciEnv::current()->Object_klass(); 4337 const TypeInterfaces* interfaces = TypeInterfaces::make(); 4338 return interfaces; 4339 } 4340 GrowableArray<ciInstanceKlass *>* k_interfaces = k->as_instance_klass()->transitive_interfaces(); 4341 const TypeInterfaces* interfaces = TypeInterfaces::make(k_interfaces); 4342 if (k->is_interface()) { 4343 assert(interface, "no interface expected"); 4344 k = ciEnv::current()->Object_klass(); 4345 } else { 4346 assert(klass, "no instance klass expected"); 4347 } 4348 return interfaces; 4349 } 4350 const TypeInterfaces* interfaces = TypeInterfaces::make(); 4351 return interfaces; 4352 } 4353 assert(array, "no array expected"); 4354 assert(k->is_array_klass(), "Not an array?"); 4355 ciType* e = k->as_array_klass()->base_element_type(); 4356 if (e->is_loaded() && e->is_instance_klass() && e->as_instance_klass()->is_interface()) { 4357 if (interface_handling == ignore_interfaces) { 4358 k = ciObjArrayKlass::make(ciEnv::current()->Object_klass(), k->as_array_klass()->dimension()); 4359 } 4360 } 4361 return TypeAryPtr::_array_interfaces; 4362 } 4363 4364 /** 4365 * Create constant type for a constant boxed value 4366 */ 4367 const Type* TypeInstPtr::get_const_boxed_value() const { 4368 assert(is_ptr_to_boxed_value(), "should be called only for boxed value"); 4369 assert((const_oop() != nullptr), "should be called only for constant object"); 4370 ciConstant constant = const_oop()->as_instance()->field_value_by_offset(offset()); 4371 BasicType bt = constant.basic_type(); 4372 switch (bt) { 4373 case T_BOOLEAN: return TypeInt::make(constant.as_boolean()); 4374 case T_INT: return TypeInt::make(constant.as_int()); 4375 case T_CHAR: return TypeInt::make(constant.as_char()); 4376 case T_BYTE: return TypeInt::make(constant.as_byte()); 4377 case T_SHORT: return TypeInt::make(constant.as_short()); 4378 case T_FLOAT: return TypeF::make(constant.as_float()); 4379 case T_DOUBLE: return TypeD::make(constant.as_double()); 4380 case T_LONG: return TypeLong::make(constant.as_long()); 4381 default: break; 4382 } 4383 fatal("Invalid boxed value type '%s'", type2name(bt)); 4384 return nullptr; 4385 } 4386 4387 //------------------------------cast_to_ptr_type------------------------------- 4388 const TypeInstPtr* TypeInstPtr::cast_to_ptr_type(PTR ptr) const { 4389 if( ptr == _ptr ) return this; 4390 // Reconstruct _sig info here since not a problem with later lazy 4391 // construction, _sig will show up on demand. 4392 return make(ptr, klass(), _interfaces, klass_is_exact(), ptr == Constant ? const_oop() : nullptr, _offset, _flat_in_array, _instance_id, _speculative, _inline_depth); 4393 } 4394 4395 4396 //-----------------------------cast_to_exactness------------------------------- 4397 const TypeInstPtr* TypeInstPtr::cast_to_exactness(bool klass_is_exact) const { 4398 if( klass_is_exact == _klass_is_exact ) return this; 4399 if (!_klass->is_loaded()) return this; 4400 ciInstanceKlass* ik = _klass->as_instance_klass(); 4401 if( (ik->is_final() || _const_oop) ) return this; // cannot clear xk 4402 assert(!ik->is_interface(), "no interface here"); 4403 FlatInArray flat_in_array = compute_flat_in_array(ik, klass_is_exact); 4404 return make(ptr(), klass(), _interfaces, klass_is_exact, const_oop(), _offset, flat_in_array, _instance_id, _speculative, _inline_depth); 4405 } 4406 4407 //-----------------------------cast_to_instance_id---------------------------- 4408 const TypeInstPtr* TypeInstPtr::cast_to_instance_id(int instance_id) const { 4409 if( instance_id == _instance_id ) return this; 4410 return make(_ptr, klass(), _interfaces, _klass_is_exact, const_oop(), _offset, _flat_in_array, instance_id, _speculative, _inline_depth); 4411 } 4412 4413 //------------------------------xmeet_unloaded--------------------------------- 4414 // Compute the MEET of two InstPtrs when at least one is unloaded. 4415 // Assume classes are different since called after check for same name/class-loader 4416 const TypeInstPtr *TypeInstPtr::xmeet_unloaded(const TypeInstPtr *tinst, const TypeInterfaces* interfaces) const { 4417 Offset off = meet_offset(tinst->offset()); 4418 PTR ptr = meet_ptr(tinst->ptr()); 4419 int instance_id = meet_instance_id(tinst->instance_id()); 4420 const TypePtr* speculative = xmeet_speculative(tinst); 4421 int depth = meet_inline_depth(tinst->inline_depth()); 4422 4423 const TypeInstPtr *loaded = is_loaded() ? this : tinst; 4424 const TypeInstPtr *unloaded = is_loaded() ? tinst : this; 4425 if( loaded->klass()->equals(ciEnv::current()->Object_klass()) ) { 4426 // 4427 // Meet unloaded class with java/lang/Object 4428 // 4429 // Meet 4430 // | Unloaded Class 4431 // Object | TOP | AnyNull | Constant | NotNull | BOTTOM | 4432 // =================================================================== 4433 // TOP | ..........................Unloaded......................| 4434 // AnyNull | U-AN |................Unloaded......................| 4435 // Constant | ... O-NN .................................. | O-BOT | 4436 // NotNull | ... O-NN .................................. | O-BOT | 4437 // BOTTOM | ........................Object-BOTTOM ..................| 4438 // 4439 assert(loaded->ptr() != TypePtr::Null, "insanity check"); 4440 // 4441 if (loaded->ptr() == TypePtr::TopPTR) { return unloaded->with_speculative(speculative); } 4442 else if (loaded->ptr() == TypePtr::AnyNull) { 4443 FlatInArray flat_in_array = meet_flat_in_array(_flat_in_array, tinst->flat_in_array()); 4444 return make(ptr, unloaded->klass(), interfaces, false, nullptr, off, flat_in_array, instance_id, 4445 speculative, depth); 4446 } 4447 else if (loaded->ptr() == TypePtr::BotPTR) { return TypeInstPtr::BOTTOM->with_speculative(speculative); } 4448 else if (loaded->ptr() == TypePtr::Constant || loaded->ptr() == TypePtr::NotNull) { 4449 if (unloaded->ptr() == TypePtr::BotPTR) { return TypeInstPtr::BOTTOM->with_speculative(speculative); } 4450 else { return TypeInstPtr::NOTNULL->with_speculative(speculative); } 4451 } 4452 else if (unloaded->ptr() == TypePtr::TopPTR) { return unloaded->with_speculative(speculative); } 4453 4454 return unloaded->cast_to_ptr_type(TypePtr::AnyNull)->is_instptr()->with_speculative(speculative); 4455 } 4456 4457 // Both are unloaded, not the same class, not Object 4458 // Or meet unloaded with a different loaded class, not java/lang/Object 4459 if (ptr != TypePtr::BotPTR) { 4460 return TypeInstPtr::NOTNULL->with_speculative(speculative); 4461 } 4462 return TypeInstPtr::BOTTOM->with_speculative(speculative); 4463 } 4464 4465 4466 //------------------------------meet------------------------------------------- 4467 // Compute the MEET of two types. It returns a new Type object. 4468 const Type *TypeInstPtr::xmeet_helper(const Type *t) const { 4469 // Perform a fast test for common case; meeting the same types together. 4470 if( this == t ) return this; // Meeting same type-rep? 4471 4472 // Current "this->_base" is Pointer 4473 switch (t->base()) { // switch on original type 4474 4475 case Int: // Mixing ints & oops happens when javac 4476 case Long: // reuses local variables 4477 case HalfFloatTop: 4478 case HalfFloatCon: 4479 case HalfFloatBot: 4480 case FloatTop: 4481 case FloatCon: 4482 case FloatBot: 4483 case DoubleTop: 4484 case DoubleCon: 4485 case DoubleBot: 4486 case NarrowOop: 4487 case NarrowKlass: 4488 case Bottom: // Ye Olde Default 4489 return Type::BOTTOM; 4490 case Top: 4491 return this; 4492 4493 default: // All else is a mistake 4494 typerr(t); 4495 4496 case MetadataPtr: 4497 case KlassPtr: 4498 case InstKlassPtr: 4499 case AryKlassPtr: 4500 case RawPtr: return TypePtr::BOTTOM; 4501 4502 case AryPtr: { // All arrays inherit from Object class 4503 // Call in reverse direction to avoid duplication 4504 return t->is_aryptr()->xmeet_helper(this); 4505 } 4506 4507 case OopPtr: { // Meeting to OopPtrs 4508 // Found a OopPtr type vs self-InstPtr type 4509 const TypeOopPtr *tp = t->is_oopptr(); 4510 Offset offset = meet_offset(tp->offset()); 4511 PTR ptr = meet_ptr(tp->ptr()); 4512 switch (tp->ptr()) { 4513 case TopPTR: 4514 case AnyNull: { 4515 int instance_id = meet_instance_id(InstanceTop); 4516 const TypePtr* speculative = xmeet_speculative(tp); 4517 int depth = meet_inline_depth(tp->inline_depth()); 4518 return make(ptr, klass(), _interfaces, klass_is_exact(), 4519 (ptr == Constant ? const_oop() : nullptr), offset, flat_in_array(), instance_id, speculative, depth); 4520 } 4521 case NotNull: 4522 case BotPTR: { 4523 int instance_id = meet_instance_id(tp->instance_id()); 4524 const TypePtr* speculative = xmeet_speculative(tp); 4525 int depth = meet_inline_depth(tp->inline_depth()); 4526 return TypeOopPtr::make(ptr, offset, instance_id, speculative, depth); 4527 } 4528 default: typerr(t); 4529 } 4530 } 4531 4532 case AnyPtr: { // Meeting to AnyPtrs 4533 // Found an AnyPtr type vs self-InstPtr type 4534 const TypePtr *tp = t->is_ptr(); 4535 Offset offset = meet_offset(tp->offset()); 4536 PTR ptr = meet_ptr(tp->ptr()); 4537 int instance_id = meet_instance_id(InstanceTop); 4538 const TypePtr* speculative = xmeet_speculative(tp); 4539 int depth = meet_inline_depth(tp->inline_depth()); 4540 switch (tp->ptr()) { 4541 case Null: 4542 if( ptr == Null ) return TypePtr::make(AnyPtr, ptr, offset, speculative, depth); 4543 // else fall through to AnyNull 4544 case TopPTR: 4545 case AnyNull: { 4546 return make(ptr, klass(), _interfaces, klass_is_exact(), 4547 (ptr == Constant ? const_oop() : nullptr), offset, flat_in_array(), instance_id, speculative, depth); 4548 } 4549 case NotNull: 4550 case BotPTR: 4551 return TypePtr::make(AnyPtr, ptr, offset, speculative,depth); 4552 default: typerr(t); 4553 } 4554 } 4555 4556 /* 4557 A-top } 4558 / | \ } Tops 4559 B-top A-any C-top } 4560 | / | \ | } Any-nulls 4561 B-any | C-any } 4562 | | | 4563 B-con A-con C-con } constants; not comparable across classes 4564 | | | 4565 B-not | C-not } 4566 | \ | / | } not-nulls 4567 B-bot A-not C-bot } 4568 \ | / } Bottoms 4569 A-bot } 4570 */ 4571 4572 case InstPtr: { // Meeting 2 Oops? 4573 // Found an InstPtr sub-type vs self-InstPtr type 4574 const TypeInstPtr *tinst = t->is_instptr(); 4575 Offset off = meet_offset(tinst->offset()); 4576 PTR ptr = meet_ptr(tinst->ptr()); 4577 int instance_id = meet_instance_id(tinst->instance_id()); 4578 const TypePtr* speculative = xmeet_speculative(tinst); 4579 int depth = meet_inline_depth(tinst->inline_depth()); 4580 const TypeInterfaces* interfaces = meet_interfaces(tinst); 4581 4582 ciKlass* tinst_klass = tinst->klass(); 4583 ciKlass* this_klass = klass(); 4584 4585 ciKlass* res_klass = nullptr; 4586 bool res_xk = false; 4587 const Type* res; 4588 MeetResult kind = meet_instptr(ptr, interfaces, this, tinst, res_klass, res_xk); 4589 4590 if (kind == UNLOADED) { 4591 // One of these classes has not been loaded 4592 const TypeInstPtr* unloaded_meet = xmeet_unloaded(tinst, interfaces); 4593 #ifndef PRODUCT 4594 if (PrintOpto && Verbose) { 4595 tty->print("meet of unloaded classes resulted in: "); 4596 unloaded_meet->dump(); 4597 tty->cr(); 4598 tty->print(" this == "); 4599 dump(); 4600 tty->cr(); 4601 tty->print(" tinst == "); 4602 tinst->dump(); 4603 tty->cr(); 4604 } 4605 #endif 4606 res = unloaded_meet; 4607 } else { 4608 FlatInArray flat_in_array = meet_flat_in_array(_flat_in_array, tinst->flat_in_array()); 4609 if (kind == NOT_SUBTYPE && instance_id > 0) { 4610 instance_id = InstanceBot; 4611 } else if (kind == LCA) { 4612 instance_id = InstanceBot; 4613 } 4614 ciObject* o = nullptr; // Assume not constant when done 4615 ciObject* this_oop = const_oop(); 4616 ciObject* tinst_oop = tinst->const_oop(); 4617 if (ptr == Constant) { 4618 if (this_oop != nullptr && tinst_oop != nullptr && 4619 this_oop->equals(tinst_oop)) 4620 o = this_oop; 4621 else if (above_centerline(_ptr)) { 4622 assert(!tinst_klass->is_interface(), ""); 4623 o = tinst_oop; 4624 } else if (above_centerline(tinst->_ptr)) { 4625 assert(!this_klass->is_interface(), ""); 4626 o = this_oop; 4627 } else 4628 ptr = NotNull; 4629 } 4630 res = make(ptr, res_klass, interfaces, res_xk, o, off, flat_in_array, instance_id, speculative, depth); 4631 } 4632 4633 return res; 4634 4635 } // End of case InstPtr 4636 4637 } // End of switch 4638 return this; // Return the double constant 4639 } 4640 4641 template<class T> TypePtr::MeetResult TypePtr::meet_instptr(PTR& ptr, const TypeInterfaces*& interfaces, const T* this_type, const T* other_type, 4642 ciKlass*& res_klass, bool& res_xk) { 4643 ciKlass* this_klass = this_type->klass(); 4644 ciKlass* other_klass = other_type->klass(); 4645 4646 bool this_xk = this_type->klass_is_exact(); 4647 bool other_xk = other_type->klass_is_exact(); 4648 PTR this_ptr = this_type->ptr(); 4649 PTR other_ptr = other_type->ptr(); 4650 const TypeInterfaces* this_interfaces = this_type->interfaces(); 4651 const TypeInterfaces* other_interfaces = other_type->interfaces(); 4652 // Check for easy case; klasses are equal (and perhaps not loaded!) 4653 // If we have constants, then we created oops so classes are loaded 4654 // and we can handle the constants further down. This case handles 4655 // both-not-loaded or both-loaded classes 4656 if (ptr != Constant && this_klass->equals(other_klass) && this_xk == other_xk) { 4657 res_klass = this_klass; 4658 res_xk = this_xk; 4659 return QUICK; 4660 } 4661 4662 // Classes require inspection in the Java klass hierarchy. Must be loaded. 4663 if (!other_klass->is_loaded() || !this_klass->is_loaded()) { 4664 return UNLOADED; 4665 } 4666 4667 // !!! Here's how the symmetry requirement breaks down into invariants: 4668 // If we split one up & one down AND they subtype, take the down man. 4669 // If we split one up & one down AND they do NOT subtype, "fall hard". 4670 // If both are up and they subtype, take the subtype class. 4671 // If both are up and they do NOT subtype, "fall hard". 4672 // If both are down and they subtype, take the supertype class. 4673 // If both are down and they do NOT subtype, "fall hard". 4674 // Constants treated as down. 4675 4676 // Now, reorder the above list; observe that both-down+subtype is also 4677 // "fall hard"; "fall hard" becomes the default case: 4678 // If we split one up & one down AND they subtype, take the down man. 4679 // If both are up and they subtype, take the subtype class. 4680 4681 // If both are down and they subtype, "fall hard". 4682 // If both are down and they do NOT subtype, "fall hard". 4683 // If both are up and they do NOT subtype, "fall hard". 4684 // If we split one up & one down AND they do NOT subtype, "fall hard". 4685 4686 // If a proper subtype is exact, and we return it, we return it exactly. 4687 // If a proper supertype is exact, there can be no subtyping relationship! 4688 // If both types are equal to the subtype, exactness is and-ed below the 4689 // centerline and or-ed above it. (N.B. Constants are always exact.) 4690 4691 const T* subtype = nullptr; 4692 bool subtype_exact = false; 4693 if (this_type->is_same_java_type_as(other_type)) { 4694 // Same klass 4695 subtype = this_type; 4696 subtype_exact = below_centerline(ptr) ? (this_xk && other_xk) : (this_xk || other_xk); 4697 } else if (!other_xk && this_type->is_meet_subtype_of(other_type)) { 4698 subtype = this_type; // Pick subtyping class 4699 subtype_exact = this_xk; 4700 } else if (!this_xk && other_type->is_meet_subtype_of(this_type)) { 4701 subtype = other_type; // Pick subtyping class 4702 subtype_exact = other_xk; 4703 } 4704 4705 if (subtype != nullptr) { 4706 if (above_centerline(ptr)) { 4707 // Both types are empty. 4708 this_type = other_type = subtype; 4709 this_xk = other_xk = subtype_exact; 4710 } else if (above_centerline(this_ptr) && !above_centerline(other_ptr)) { 4711 // this_type is empty while other_type is not. Take other_type. 4712 this_type = other_type; 4713 this_xk = other_xk; 4714 } else if (above_centerline(other_ptr) && !above_centerline(this_ptr)) { 4715 // other_type is empty while this_type is not. Take this_type. 4716 other_type = this_type; // this is down; keep down man 4717 } else { 4718 // this_type and other_type are both non-empty. 4719 this_xk = subtype_exact; // either they are equal, or we'll do an LCA 4720 } 4721 } 4722 4723 // Check for classes now being equal 4724 if (this_type->is_same_java_type_as(other_type)) { 4725 // If the klasses are equal, the constants may still differ. Fall to 4726 // NotNull if they do (neither constant is null; that is a special case 4727 // handled elsewhere). 4728 res_klass = this_type->klass(); 4729 res_xk = this_xk; 4730 return SUBTYPE; 4731 } // Else classes are not equal 4732 4733 // Since klasses are different, we require a LCA in the Java 4734 // class hierarchy - which means we have to fall to at least NotNull. 4735 if (ptr == TopPTR || ptr == AnyNull || ptr == Constant) { 4736 ptr = NotNull; 4737 } 4738 4739 interfaces = this_interfaces->intersection_with(other_interfaces); 4740 4741 // Now we find the LCA of Java classes 4742 ciKlass* k = this_klass->least_common_ancestor(other_klass); 4743 4744 res_klass = k; 4745 res_xk = false; 4746 return LCA; 4747 } 4748 4749 // Top-Flat Flat Not-Flat Maybe-Flat 4750 // ------------------------------------------------------------- 4751 // Top-Flat Top-Flat Flat Not-Flat Maybe-Flat 4752 // Flat Flat Flat Maybe-Flat Maybe-Flat 4753 // Not-Flat Not-Flat Maybe-Flat Not-Flat Maybe-Flat 4754 // Maybe-Flat Maybe-Flat Maybe-Flat Maybe-Flat Maybe-flat 4755 TypePtr::FlatInArray TypePtr::meet_flat_in_array(const FlatInArray left, const FlatInArray right) { 4756 if (left == TopFlat) { 4757 return right; 4758 } 4759 if (right == TopFlat) { 4760 return left; 4761 } 4762 if (left == MaybeFlat || right == MaybeFlat) { 4763 return MaybeFlat; 4764 } 4765 4766 switch (left) { 4767 case Flat: 4768 if (right == Flat) { 4769 return Flat; 4770 } 4771 return MaybeFlat; 4772 case NotFlat: 4773 if (right == NotFlat) { 4774 return NotFlat; 4775 } 4776 return MaybeFlat; 4777 default: 4778 ShouldNotReachHere(); 4779 return Uninitialized; 4780 } 4781 } 4782 4783 //------------------------java_mirror_type-------------------------------------- 4784 ciType* TypeInstPtr::java_mirror_type() const { 4785 // must be a singleton type 4786 if( const_oop() == nullptr ) return nullptr; 4787 4788 // must be of type java.lang.Class 4789 if( klass() != ciEnv::current()->Class_klass() ) return nullptr; 4790 return const_oop()->as_instance()->java_mirror_type(); 4791 } 4792 4793 4794 //------------------------------xdual------------------------------------------ 4795 // Dual: do NOT dual on klasses. This means I do NOT understand the Java 4796 // inheritance mechanism. 4797 const Type* TypeInstPtr::xdual() const { 4798 return new TypeInstPtr(dual_ptr(), klass(), _interfaces, klass_is_exact(), const_oop(), dual_offset(), 4799 dual_flat_in_array(), dual_instance_id(), dual_speculative(), dual_inline_depth()); 4800 } 4801 4802 //------------------------------eq--------------------------------------------- 4803 // Structural equality check for Type representations 4804 bool TypeInstPtr::eq( const Type *t ) const { 4805 const TypeInstPtr *p = t->is_instptr(); 4806 return 4807 klass()->equals(p->klass()) && 4808 _flat_in_array == p->_flat_in_array && 4809 _interfaces->eq(p->_interfaces) && 4810 TypeOopPtr::eq(p); // Check sub-type stuff 4811 } 4812 4813 //------------------------------hash------------------------------------------- 4814 // Type-specific hashing function. 4815 uint TypeInstPtr::hash() const { 4816 return klass()->hash() + TypeOopPtr::hash() + _interfaces->hash() + static_cast<uint>(_flat_in_array); 4817 } 4818 4819 bool TypeInstPtr::is_java_subtype_of_helper(const TypeOopPtr* other, bool this_exact, bool other_exact) const { 4820 return TypePtr::is_java_subtype_of_helper_for_instance(this, other, this_exact, other_exact); 4821 } 4822 4823 4824 bool TypeInstPtr::is_same_java_type_as_helper(const TypeOopPtr* other) const { 4825 return TypePtr::is_same_java_type_as_helper_for_instance(this, other); 4826 } 4827 4828 bool TypeInstPtr::maybe_java_subtype_of_helper(const TypeOopPtr* other, bool this_exact, bool other_exact) const { 4829 return TypePtr::maybe_java_subtype_of_helper_for_instance(this, other, this_exact, other_exact); 4830 } 4831 4832 4833 //------------------------------dump2------------------------------------------ 4834 // Dump oop Type 4835 #ifndef PRODUCT 4836 void TypeInstPtr::dump2(Dict &d, uint depth, outputStream* st) const { 4837 // Print the name of the klass. 4838 st->print("instptr:"); 4839 klass()->print_name_on(st); 4840 _interfaces->dump(st); 4841 4842 if (_ptr == Constant && (WizardMode || Verbose)) { 4843 ResourceMark rm; 4844 stringStream ss; 4845 4846 st->print(" "); 4847 const_oop()->print_oop(&ss); 4848 // 'const_oop->print_oop()' may emit newlines('\n') into ss. 4849 // suppress newlines from it so -XX:+Verbose -XX:+PrintIdeal dumps one-liner for each node. 4850 char* buf = ss.as_string(/* c_heap= */false); 4851 StringUtils::replace_no_expand(buf, "\n", ""); 4852 st->print_raw(buf); 4853 } 4854 4855 st->print(":%s", ptr_msg[_ptr]); 4856 if (_klass_is_exact) { 4857 st->print(":exact"); 4858 } 4859 4860 st->print(" *"); 4861 4862 dump_offset(st); 4863 dump_instance_id(st); 4864 dump_inline_depth(st); 4865 dump_speculative(st); 4866 dump_flat_in_array(_flat_in_array, st); 4867 } 4868 #endif 4869 4870 bool TypeInstPtr::empty() const { 4871 if (_flat_in_array == TopFlat) { 4872 return true; 4873 } 4874 return TypeOopPtr::empty(); 4875 } 4876 4877 //------------------------------add_offset------------------------------------- 4878 const TypePtr* TypeInstPtr::add_offset(intptr_t offset) const { 4879 return make(_ptr, klass(), _interfaces, klass_is_exact(), const_oop(), xadd_offset(offset), _flat_in_array, 4880 _instance_id, add_offset_speculative(offset), _inline_depth); 4881 } 4882 4883 const TypeInstPtr* TypeInstPtr::with_offset(intptr_t offset) const { 4884 return make(_ptr, klass(), _interfaces, klass_is_exact(), const_oop(), Offset(offset), _flat_in_array, 4885 _instance_id, with_offset_speculative(offset), _inline_depth); 4886 } 4887 4888 const TypeInstPtr* TypeInstPtr::remove_speculative() const { 4889 if (_speculative == nullptr) { 4890 return this; 4891 } 4892 assert(_inline_depth == InlineDepthTop || _inline_depth == InlineDepthBottom, "non speculative type shouldn't have inline depth"); 4893 return make(_ptr, klass(), _interfaces, klass_is_exact(), const_oop(), _offset, _flat_in_array, 4894 _instance_id, nullptr, _inline_depth); 4895 } 4896 4897 const TypeInstPtr* TypeInstPtr::with_speculative(const TypePtr* speculative) const { 4898 return make(_ptr, klass(), _interfaces, klass_is_exact(), const_oop(), _offset, _flat_in_array, _instance_id, speculative, _inline_depth); 4899 } 4900 4901 const TypePtr* TypeInstPtr::with_inline_depth(int depth) const { 4902 if (!UseInlineDepthForSpeculativeTypes) { 4903 return this; 4904 } 4905 return make(_ptr, klass(), _interfaces, klass_is_exact(), const_oop(), _offset, _flat_in_array, _instance_id, _speculative, depth); 4906 } 4907 4908 const TypePtr* TypeInstPtr::with_instance_id(int instance_id) const { 4909 assert(is_known_instance(), "should be known"); 4910 return make(_ptr, klass(), _interfaces, klass_is_exact(), const_oop(), _offset, _flat_in_array, instance_id, _speculative, _inline_depth); 4911 } 4912 4913 const TypeInstPtr *TypeInstPtr::cast_to_flat_in_array() const { 4914 return make(_ptr, klass(), _interfaces, klass_is_exact(), const_oop(), _offset, Flat, _instance_id, _speculative, _inline_depth); 4915 } 4916 4917 const TypeInstPtr *TypeInstPtr::cast_to_maybe_flat_in_array() const { 4918 return make(_ptr, klass(), _interfaces, klass_is_exact(), const_oop(), _offset, MaybeFlat, _instance_id, _speculative, _inline_depth); 4919 } 4920 4921 const TypeKlassPtr* TypeInstPtr::as_klass_type(bool try_for_exact) const { 4922 bool xk = klass_is_exact(); 4923 ciInstanceKlass* ik = klass()->as_instance_klass(); 4924 if (try_for_exact && !xk && !ik->has_subklass() && !ik->is_final()) { 4925 if (_interfaces->eq(ik)) { 4926 Compile* C = Compile::current(); 4927 Dependencies* deps = C->dependencies(); 4928 deps->assert_leaf_type(ik); 4929 xk = true; 4930 } 4931 } 4932 FlatInArray flat_in_array = compute_flat_in_array_if_unknown(ik, xk, _flat_in_array); 4933 return TypeInstKlassPtr::make(xk ? TypePtr::Constant : TypePtr::NotNull, klass(), _interfaces, Offset(0), flat_in_array); 4934 } 4935 4936 template <class T1, class T2> bool TypePtr::is_meet_subtype_of_helper_for_instance(const T1* this_one, const T2* other, bool this_xk, bool other_xk) { 4937 static_assert(std::is_base_of<T2, T1>::value, ""); 4938 4939 if (!this_one->is_instance_type(other)) { 4940 return false; 4941 } 4942 4943 if (other->klass() == ciEnv::current()->Object_klass() && other->_interfaces->empty()) { 4944 return true; 4945 } 4946 4947 return this_one->klass()->is_subtype_of(other->klass()) && 4948 (!this_xk || this_one->_interfaces->contains(other->_interfaces)); 4949 } 4950 4951 4952 bool TypeInstPtr::is_meet_subtype_of_helper(const TypeOopPtr *other, bool this_xk, bool other_xk) const { 4953 return TypePtr::is_meet_subtype_of_helper_for_instance(this, other, this_xk, other_xk); 4954 } 4955 4956 template <class T1, class T2> bool TypePtr::is_meet_subtype_of_helper_for_array(const T1* this_one, const T2* other, bool this_xk, bool other_xk) { 4957 static_assert(std::is_base_of<T2, T1>::value, ""); 4958 if (other->klass() == ciEnv::current()->Object_klass() && other->_interfaces->empty()) { 4959 return true; 4960 } 4961 4962 if (this_one->is_instance_type(other)) { 4963 return other->klass() == ciEnv::current()->Object_klass() && this_one->_interfaces->contains(other->_interfaces); 4964 } 4965 4966 int dummy; 4967 bool this_top_or_bottom = (this_one->base_element_type(dummy) == Type::TOP || this_one->base_element_type(dummy) == Type::BOTTOM); 4968 if (this_top_or_bottom) { 4969 return false; 4970 } 4971 4972 const T1* other_ary = this_one->is_array_type(other); 4973 const TypePtr* other_elem = other_ary->elem()->make_ptr(); 4974 const TypePtr* this_elem = this_one->elem()->make_ptr(); 4975 if (other_elem != nullptr && this_elem != nullptr) { 4976 return this_one->is_reference_type(this_elem)->is_meet_subtype_of_helper(this_one->is_reference_type(other_elem), this_xk, other_xk); 4977 } 4978 if (other_elem == nullptr && this_elem == nullptr) { 4979 return this_one->klass()->is_subtype_of(other->klass()); 4980 } 4981 4982 return false; 4983 } 4984 4985 bool TypeAryPtr::is_meet_subtype_of_helper(const TypeOopPtr *other, bool this_xk, bool other_xk) const { 4986 return TypePtr::is_meet_subtype_of_helper_for_array(this, other, this_xk, other_xk); 4987 } 4988 4989 bool TypeInstKlassPtr::is_meet_subtype_of_helper(const TypeKlassPtr *other, bool this_xk, bool other_xk) const { 4990 return TypePtr::is_meet_subtype_of_helper_for_instance(this, other, this_xk, other_xk); 4991 } 4992 4993 bool TypeAryKlassPtr::is_meet_subtype_of_helper(const TypeKlassPtr *other, bool this_xk, bool other_xk) const { 4994 return TypePtr::is_meet_subtype_of_helper_for_array(this, other, this_xk, other_xk); 4995 } 4996 4997 //============================================================================= 4998 // Convenience common pre-built types. 4999 const TypeAryPtr* TypeAryPtr::BOTTOM; 5000 const TypeAryPtr *TypeAryPtr::RANGE; 5001 const TypeAryPtr *TypeAryPtr::OOPS; 5002 const TypeAryPtr *TypeAryPtr::NARROWOOPS; 5003 const TypeAryPtr *TypeAryPtr::BYTES; 5004 const TypeAryPtr *TypeAryPtr::SHORTS; 5005 const TypeAryPtr *TypeAryPtr::CHARS; 5006 const TypeAryPtr *TypeAryPtr::INTS; 5007 const TypeAryPtr *TypeAryPtr::LONGS; 5008 const TypeAryPtr *TypeAryPtr::FLOATS; 5009 const TypeAryPtr *TypeAryPtr::DOUBLES; 5010 const TypeAryPtr *TypeAryPtr::INLINES; 5011 5012 //------------------------------make------------------------------------------- 5013 const TypeAryPtr* TypeAryPtr::make(PTR ptr, const TypeAry *ary, ciKlass* k, bool xk, Offset offset, Offset field_offset, 5014 int instance_id, const TypePtr* speculative, int inline_depth) { 5015 assert(!(k == nullptr && ary->_elem->isa_int()), 5016 "integral arrays must be pre-equipped with a class"); 5017 if (!xk) xk = ary->ary_must_be_exact(); 5018 assert(instance_id <= 0 || xk, "instances are always exactly typed"); 5019 if (k != nullptr && k->is_loaded() && k->is_obj_array_klass() && 5020 k->as_obj_array_klass()->base_element_klass()->is_interface()) { 5021 k = nullptr; 5022 } 5023 return (TypeAryPtr*)(new TypeAryPtr(ptr, nullptr, ary, k, xk, offset, field_offset, instance_id, false, speculative, inline_depth))->hashcons(); 5024 } 5025 5026 //------------------------------make------------------------------------------- 5027 const TypeAryPtr* TypeAryPtr::make(PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk, Offset offset, Offset field_offset, 5028 int instance_id, const TypePtr* speculative, int inline_depth, 5029 bool is_autobox_cache) { 5030 assert(!(k == nullptr && ary->_elem->isa_int()), 5031 "integral arrays must be pre-equipped with a class"); 5032 assert( (ptr==Constant && o) || (ptr!=Constant && !o), "" ); 5033 if (!xk) xk = (o != nullptr) || ary->ary_must_be_exact(); 5034 assert(instance_id <= 0 || xk, "instances are always exactly typed"); 5035 if (k != nullptr && k->is_loaded() && k->is_obj_array_klass() && 5036 k->as_obj_array_klass()->base_element_klass()->is_interface()) { 5037 k = nullptr; 5038 } 5039 return (TypeAryPtr*)(new TypeAryPtr(ptr, o, ary, k, xk, offset, field_offset, instance_id, is_autobox_cache, speculative, inline_depth))->hashcons(); 5040 } 5041 5042 //------------------------------cast_to_ptr_type------------------------------- 5043 const TypeAryPtr* TypeAryPtr::cast_to_ptr_type(PTR ptr) const { 5044 if( ptr == _ptr ) return this; 5045 return make(ptr, ptr == Constant ? const_oop() : nullptr, _ary, klass(), klass_is_exact(), _offset, _field_offset, _instance_id, _speculative, _inline_depth, _is_autobox_cache); 5046 } 5047 5048 5049 //-----------------------------cast_to_exactness------------------------------- 5050 const TypeAryPtr* TypeAryPtr::cast_to_exactness(bool klass_is_exact) const { 5051 if( klass_is_exact == _klass_is_exact ) return this; 5052 if (_ary->ary_must_be_exact()) return this; // cannot clear xk 5053 return make(ptr(), const_oop(), _ary, klass(), klass_is_exact, _offset, _field_offset, _instance_id, _speculative, _inline_depth, _is_autobox_cache); 5054 } 5055 5056 //-----------------------------cast_to_instance_id---------------------------- 5057 const TypeAryPtr* TypeAryPtr::cast_to_instance_id(int instance_id) const { 5058 if( instance_id == _instance_id ) return this; 5059 return make(_ptr, const_oop(), _ary, klass(), _klass_is_exact, _offset, _field_offset, instance_id, _speculative, _inline_depth, _is_autobox_cache); 5060 } 5061 5062 5063 //-----------------------------max_array_length------------------------------- 5064 // A wrapper around arrayOopDesc::max_array_length(etype) with some input normalization. 5065 jint TypeAryPtr::max_array_length(BasicType etype) { 5066 if (!is_java_primitive(etype) && !::is_reference_type(etype)) { 5067 if (etype == T_NARROWOOP) { 5068 etype = T_OBJECT; 5069 } else if (etype == T_ILLEGAL) { // bottom[] 5070 etype = T_BYTE; // will produce conservatively high value 5071 } else { 5072 fatal("not an element type: %s", type2name(etype)); 5073 } 5074 } 5075 return arrayOopDesc::max_array_length(etype); 5076 } 5077 5078 //-----------------------------narrow_size_type------------------------------- 5079 // Narrow the given size type to the index range for the given array base type. 5080 // Return null if the resulting int type becomes empty. 5081 const TypeInt* TypeAryPtr::narrow_size_type(const TypeInt* size) const { 5082 jint hi = size->_hi; 5083 jint lo = size->_lo; 5084 jint min_lo = 0; 5085 jint max_hi = max_array_length(elem()->array_element_basic_type()); 5086 //if (index_not_size) --max_hi; // type of a valid array index, FTR 5087 bool chg = false; 5088 if (lo < min_lo) { 5089 lo = min_lo; 5090 if (size->is_con()) { 5091 hi = lo; 5092 } 5093 chg = true; 5094 } 5095 if (hi > max_hi) { 5096 hi = max_hi; 5097 if (size->is_con()) { 5098 lo = hi; 5099 } 5100 chg = true; 5101 } 5102 // Negative length arrays will produce weird intermediate dead fast-path code 5103 if (lo > hi) { 5104 return TypeInt::ZERO; 5105 } 5106 if (!chg) { 5107 return size; 5108 } 5109 return TypeInt::make(lo, hi, Type::WidenMin); 5110 } 5111 5112 //-------------------------------cast_to_size---------------------------------- 5113 const TypeAryPtr* TypeAryPtr::cast_to_size(const TypeInt* new_size) const { 5114 assert(new_size != nullptr, ""); 5115 new_size = narrow_size_type(new_size); 5116 if (new_size == size()) return this; 5117 const TypeAry* new_ary = TypeAry::make(elem(), new_size, is_stable(), is_flat(), is_not_flat(), is_not_null_free(), is_atomic()); 5118 return make(ptr(), const_oop(), new_ary, klass(), klass_is_exact(), _offset, _field_offset, _instance_id, _speculative, _inline_depth, _is_autobox_cache); 5119 } 5120 5121 const TypeAryPtr* TypeAryPtr::cast_to_flat(bool flat) const { 5122 if (flat == is_flat()) { 5123 return this; 5124 } 5125 assert(!flat || !is_not_flat(), "inconsistency"); 5126 const TypeAry* new_ary = TypeAry::make(elem(), size(), is_stable(), flat, is_not_flat(), is_not_null_free(), is_atomic()); 5127 const TypeAryPtr* res = make(ptr(), const_oop(), new_ary, klass(), klass_is_exact(), _offset, _field_offset, _instance_id, _speculative, _inline_depth, _is_autobox_cache); 5128 if (res->speculative() == res->remove_speculative()) { 5129 return res->remove_speculative(); 5130 } 5131 return res; 5132 } 5133 5134 //-------------------------------cast_to_not_flat------------------------------ 5135 const TypeAryPtr* TypeAryPtr::cast_to_not_flat(bool not_flat) const { 5136 if (not_flat == is_not_flat()) { 5137 return this; 5138 } 5139 assert(!not_flat || !is_flat(), "inconsistency"); 5140 const TypeAry* new_ary = TypeAry::make(elem(), size(), is_stable(), is_flat(), not_flat, is_not_null_free(), is_atomic()); 5141 const TypeAryPtr* res = make(ptr(), const_oop(), new_ary, klass(), klass_is_exact(), _offset, _field_offset, _instance_id, _speculative, _inline_depth, _is_autobox_cache); 5142 // We keep the speculative part if it contains information about flat-/nullability. 5143 // Make sure it's removed if it's not better than the non-speculative type anymore. 5144 if (res->speculative() == res->remove_speculative()) { 5145 return res->remove_speculative(); 5146 } 5147 return res; 5148 } 5149 5150 const TypeAryPtr* TypeAryPtr::cast_to_null_free(bool null_free) const { 5151 if (null_free == is_null_free()) { 5152 return this; 5153 } 5154 assert(!null_free || !is_not_null_free(), "inconsistency"); 5155 const Type* elem = this->elem(); 5156 const Type* new_elem = elem->make_ptr(); 5157 if (null_free) { 5158 new_elem = new_elem->join_speculative(TypePtr::NOTNULL); 5159 } else { 5160 new_elem = new_elem->meet_speculative(TypePtr::NULL_PTR); 5161 } 5162 new_elem = elem->isa_narrowoop() ? new_elem->make_narrowoop() : new_elem; 5163 const TypeAry* new_ary = TypeAry::make(new_elem, size(), is_stable(), is_flat(), is_not_flat(), is_not_null_free(), is_atomic()); 5164 const TypeAryPtr* res = make(ptr(), const_oop(), new_ary, klass(), klass_is_exact(), _offset, _field_offset, _instance_id, _speculative, _inline_depth, _is_autobox_cache); 5165 if (res->speculative() == res->remove_speculative()) { 5166 return res->remove_speculative(); 5167 } 5168 return res; 5169 } 5170 5171 //-------------------------------cast_to_not_null_free------------------------- 5172 const TypeAryPtr* TypeAryPtr::cast_to_not_null_free(bool not_null_free) const { 5173 if (not_null_free == is_not_null_free()) { 5174 return this; 5175 } 5176 assert(!not_null_free || !is_null_free(), "inconsistency"); 5177 const TypeAry* new_ary = TypeAry::make(elem(), size(), is_stable(), is_flat(), is_not_flat(), not_null_free, is_atomic()); 5178 const TypeAryPtr* res = make(ptr(), const_oop(), new_ary, klass(), klass_is_exact(), _offset, _field_offset, 5179 _instance_id, _speculative, _inline_depth, _is_autobox_cache); 5180 // We keep the speculative part if it contains information about flat-/nullability. 5181 // Make sure it's removed if it's not better than the non-speculative type anymore. 5182 if (res->speculative() == res->remove_speculative()) { 5183 return res->remove_speculative(); 5184 } 5185 return res; 5186 } 5187 5188 //---------------------------------update_properties--------------------------- 5189 const TypeAryPtr* TypeAryPtr::update_properties(const TypeAryPtr* from) const { 5190 if ((from->is_flat() && is_not_flat()) || 5191 (from->is_not_flat() && is_flat()) || 5192 (from->is_null_free() && is_not_null_free()) || 5193 (from->is_not_null_free() && is_null_free())) { 5194 return nullptr; // Inconsistent properties 5195 } 5196 const TypeAryPtr* res = this; 5197 if (from->is_not_null_free()) { 5198 res = res->cast_to_not_null_free(); 5199 } 5200 if (from->is_not_flat()) { 5201 res = res->cast_to_not_flat(); 5202 } 5203 return res; 5204 } 5205 5206 jint TypeAryPtr::flat_layout_helper() const { 5207 return exact_klass()->as_flat_array_klass()->layout_helper(); 5208 } 5209 5210 int TypeAryPtr::flat_elem_size() const { 5211 return exact_klass()->as_flat_array_klass()->element_byte_size(); 5212 } 5213 5214 int TypeAryPtr::flat_log_elem_size() const { 5215 return exact_klass()->as_flat_array_klass()->log2_element_size(); 5216 } 5217 5218 //------------------------------cast_to_stable--------------------------------- 5219 const TypeAryPtr* TypeAryPtr::cast_to_stable(bool stable, int stable_dimension) const { 5220 if (stable_dimension <= 0 || (stable_dimension == 1 && stable == this->is_stable())) 5221 return this; 5222 5223 const Type* elem = this->elem(); 5224 const TypePtr* elem_ptr = elem->make_ptr(); 5225 5226 if (stable_dimension > 1 && elem_ptr != nullptr && elem_ptr->isa_aryptr()) { 5227 // If this is widened from a narrow oop, TypeAry::make will re-narrow it. 5228 elem = elem_ptr = elem_ptr->is_aryptr()->cast_to_stable(stable, stable_dimension - 1); 5229 } 5230 5231 const TypeAry* new_ary = TypeAry::make(elem, size(), stable, is_flat(), is_not_flat(), is_not_null_free(), is_atomic()); 5232 5233 return make(ptr(), const_oop(), new_ary, klass(), klass_is_exact(), _offset, _field_offset, _instance_id, _speculative, _inline_depth, _is_autobox_cache); 5234 } 5235 5236 //-----------------------------stable_dimension-------------------------------- 5237 int TypeAryPtr::stable_dimension() const { 5238 if (!is_stable()) return 0; 5239 int dim = 1; 5240 const TypePtr* elem_ptr = elem()->make_ptr(); 5241 if (elem_ptr != nullptr && elem_ptr->isa_aryptr()) 5242 dim += elem_ptr->is_aryptr()->stable_dimension(); 5243 return dim; 5244 } 5245 5246 //----------------------cast_to_autobox_cache----------------------------------- 5247 const TypeAryPtr* TypeAryPtr::cast_to_autobox_cache() const { 5248 if (is_autobox_cache()) return this; 5249 const TypeOopPtr* etype = elem()->make_oopptr(); 5250 if (etype == nullptr) return this; 5251 // The pointers in the autobox arrays are always non-null. 5252 etype = etype->cast_to_ptr_type(TypePtr::NotNull)->is_oopptr(); 5253 const TypeAry* new_ary = TypeAry::make(etype, size(), is_stable(), is_flat(), is_not_flat(), is_not_null_free(), is_atomic()); 5254 return make(ptr(), const_oop(), new_ary, klass(), klass_is_exact(), _offset, _field_offset, _instance_id, _speculative, _inline_depth, /*is_autobox_cache=*/true); 5255 } 5256 5257 //------------------------------eq--------------------------------------------- 5258 // Structural equality check for Type representations 5259 bool TypeAryPtr::eq( const Type *t ) const { 5260 const TypeAryPtr *p = t->is_aryptr(); 5261 return 5262 _ary == p->_ary && // Check array 5263 TypeOopPtr::eq(p) &&// Check sub-parts 5264 _field_offset == p->_field_offset; 5265 } 5266 5267 //------------------------------hash------------------------------------------- 5268 // Type-specific hashing function. 5269 uint TypeAryPtr::hash(void) const { 5270 return (uint)(uintptr_t)_ary + TypeOopPtr::hash() + _field_offset.get(); 5271 } 5272 5273 bool TypeAryPtr::is_java_subtype_of_helper(const TypeOopPtr* other, bool this_exact, bool other_exact) const { 5274 return TypePtr::is_java_subtype_of_helper_for_array(this, other, this_exact, other_exact); 5275 } 5276 5277 bool TypeAryPtr::is_same_java_type_as_helper(const TypeOopPtr* other) const { 5278 return TypePtr::is_same_java_type_as_helper_for_array(this, other); 5279 } 5280 5281 bool TypeAryPtr::maybe_java_subtype_of_helper(const TypeOopPtr* other, bool this_exact, bool other_exact) const { 5282 return TypePtr::maybe_java_subtype_of_helper_for_array(this, other, this_exact, other_exact); 5283 } 5284 //------------------------------meet------------------------------------------- 5285 // Compute the MEET of two types. It returns a new Type object. 5286 const Type *TypeAryPtr::xmeet_helper(const Type *t) const { 5287 // Perform a fast test for common case; meeting the same types together. 5288 if( this == t ) return this; // Meeting same type-rep? 5289 // Current "this->_base" is Pointer 5290 switch (t->base()) { // switch on original type 5291 5292 // Mixing ints & oops happens when javac reuses local variables 5293 case Int: 5294 case Long: 5295 case HalfFloatTop: 5296 case HalfFloatCon: 5297 case HalfFloatBot: 5298 case FloatTop: 5299 case FloatCon: 5300 case FloatBot: 5301 case DoubleTop: 5302 case DoubleCon: 5303 case DoubleBot: 5304 case NarrowOop: 5305 case NarrowKlass: 5306 case Bottom: // Ye Olde Default 5307 return Type::BOTTOM; 5308 case Top: 5309 return this; 5310 5311 default: // All else is a mistake 5312 typerr(t); 5313 5314 case OopPtr: { // Meeting to OopPtrs 5315 // Found a OopPtr type vs self-AryPtr type 5316 const TypeOopPtr *tp = t->is_oopptr(); 5317 Offset offset = meet_offset(tp->offset()); 5318 PTR ptr = meet_ptr(tp->ptr()); 5319 int depth = meet_inline_depth(tp->inline_depth()); 5320 const TypePtr* speculative = xmeet_speculative(tp); 5321 switch (tp->ptr()) { 5322 case TopPTR: 5323 case AnyNull: { 5324 int instance_id = meet_instance_id(InstanceTop); 5325 return make(ptr, (ptr == Constant ? const_oop() : nullptr), 5326 _ary, _klass, _klass_is_exact, offset, _field_offset, instance_id, speculative, depth); 5327 } 5328 case BotPTR: 5329 case NotNull: { 5330 int instance_id = meet_instance_id(tp->instance_id()); 5331 return TypeOopPtr::make(ptr, offset, instance_id, speculative, depth); 5332 } 5333 default: ShouldNotReachHere(); 5334 } 5335 } 5336 5337 case AnyPtr: { // Meeting two AnyPtrs 5338 // Found an AnyPtr type vs self-AryPtr type 5339 const TypePtr *tp = t->is_ptr(); 5340 Offset offset = meet_offset(tp->offset()); 5341 PTR ptr = meet_ptr(tp->ptr()); 5342 const TypePtr* speculative = xmeet_speculative(tp); 5343 int depth = meet_inline_depth(tp->inline_depth()); 5344 switch (tp->ptr()) { 5345 case TopPTR: 5346 return this; 5347 case BotPTR: 5348 case NotNull: 5349 return TypePtr::make(AnyPtr, ptr, offset, speculative, depth); 5350 case Null: 5351 if( ptr == Null ) return TypePtr::make(AnyPtr, ptr, offset, speculative, depth); 5352 // else fall through to AnyNull 5353 case AnyNull: { 5354 int instance_id = meet_instance_id(InstanceTop); 5355 return make(ptr, (ptr == Constant ? const_oop() : nullptr), 5356 _ary, _klass, _klass_is_exact, offset, _field_offset, instance_id, speculative, depth); 5357 } 5358 default: ShouldNotReachHere(); 5359 } 5360 } 5361 5362 case MetadataPtr: 5363 case KlassPtr: 5364 case InstKlassPtr: 5365 case AryKlassPtr: 5366 case RawPtr: return TypePtr::BOTTOM; 5367 5368 case AryPtr: { // Meeting 2 references? 5369 const TypeAryPtr *tap = t->is_aryptr(); 5370 Offset off = meet_offset(tap->offset()); 5371 Offset field_off = meet_field_offset(tap->field_offset()); 5372 const Type* tm = _ary->meet_speculative(tap->_ary); 5373 const TypeAry* tary = tm->isa_ary(); 5374 if (tary == nullptr) { 5375 assert(tm == Type::TOP || tm == Type::BOTTOM, ""); 5376 return tm; 5377 } 5378 PTR ptr = meet_ptr(tap->ptr()); 5379 int instance_id = meet_instance_id(tap->instance_id()); 5380 const TypePtr* speculative = xmeet_speculative(tap); 5381 int depth = meet_inline_depth(tap->inline_depth()); 5382 5383 ciKlass* res_klass = nullptr; 5384 bool res_xk = false; 5385 bool res_flat = false; 5386 bool res_not_flat = false; 5387 bool res_not_null_free = false; 5388 bool res_atomic = false; 5389 const Type* elem = tary->_elem; 5390 if (meet_aryptr(ptr, elem, this, tap, res_klass, res_xk, res_flat, res_not_flat, res_not_null_free, res_atomic) == NOT_SUBTYPE) { 5391 instance_id = InstanceBot; 5392 } else if (this->is_flat() != tap->is_flat()) { 5393 // Meeting flat inline type array with non-flat array. Adjust (field) offset accordingly. 5394 if (tary->_flat) { 5395 // Result is in a flat representation 5396 off = Offset(is_flat() ? offset() : tap->offset()); 5397 field_off = is_flat() ? field_offset() : tap->field_offset(); 5398 } else if (below_centerline(ptr)) { 5399 // Result is in a non-flat representation 5400 off = Offset(flat_offset()).meet(Offset(tap->flat_offset())); 5401 field_off = (field_off == Offset::top) ? Offset::top : Offset::bottom; 5402 } else if (flat_offset() == tap->flat_offset()) { 5403 off = Offset(!is_flat() ? offset() : tap->offset()); 5404 field_off = !is_flat() ? field_offset() : tap->field_offset(); 5405 } 5406 } 5407 5408 ciObject* o = nullptr; // Assume not constant when done 5409 ciObject* this_oop = const_oop(); 5410 ciObject* tap_oop = tap->const_oop(); 5411 if (ptr == Constant) { 5412 if (this_oop != nullptr && tap_oop != nullptr && 5413 this_oop->equals(tap_oop)) { 5414 o = tap_oop; 5415 } else if (above_centerline(_ptr)) { 5416 o = tap_oop; 5417 } else if (above_centerline(tap->_ptr)) { 5418 o = this_oop; 5419 } else { 5420 ptr = NotNull; 5421 } 5422 } 5423 return make(ptr, o, TypeAry::make(elem, tary->_size, tary->_stable, res_flat, res_not_flat, res_not_null_free, res_atomic), res_klass, res_xk, off, field_off, instance_id, speculative, depth); 5424 } 5425 5426 // All arrays inherit from Object class 5427 case InstPtr: { 5428 const TypeInstPtr *tp = t->is_instptr(); 5429 Offset offset = meet_offset(tp->offset()); 5430 PTR ptr = meet_ptr(tp->ptr()); 5431 int instance_id = meet_instance_id(tp->instance_id()); 5432 const TypePtr* speculative = xmeet_speculative(tp); 5433 int depth = meet_inline_depth(tp->inline_depth()); 5434 const TypeInterfaces* interfaces = meet_interfaces(tp); 5435 const TypeInterfaces* tp_interfaces = tp->_interfaces; 5436 const TypeInterfaces* this_interfaces = _interfaces; 5437 5438 switch (ptr) { 5439 case TopPTR: 5440 case AnyNull: // Fall 'down' to dual of object klass 5441 // For instances when a subclass meets a superclass we fall 5442 // below the centerline when the superclass is exact. We need to 5443 // do the same here. 5444 // 5445 // Flat in array: 5446 // We do 5447 // dual(TypeAryPtr) MEET dual(TypeInstPtr) 5448 // If TypeInstPtr is anything else than Object, then the result of the meet is bottom Object (i.e. we could have 5449 // instances or arrays). 5450 // If TypeInstPtr is an Object and either 5451 // - exact 5452 // - inexact AND flat in array == dual(not flat in array) (i.e. not an array type) 5453 // then the result of the meet is bottom Object (i.e. we could have instances or arrays). 5454 // Otherwise, we meet two array pointers and create a new TypeAryPtr. 5455 if (tp->klass()->equals(ciEnv::current()->Object_klass()) && this_interfaces->contains(tp_interfaces) && 5456 !tp->klass_is_exact() && !tp->is_not_flat_in_array()) { 5457 return TypeAryPtr::make(ptr, _ary, _klass, _klass_is_exact, offset, _field_offset, instance_id, speculative, depth); 5458 } else { 5459 // cannot subclass, so the meet has to fall badly below the centerline 5460 ptr = NotNull; 5461 instance_id = InstanceBot; 5462 interfaces = this_interfaces->intersection_with(tp_interfaces); 5463 FlatInArray flat_in_array = meet_flat_in_array(NotFlat, tp->flat_in_array()); 5464 return TypeInstPtr::make(ptr, ciEnv::current()->Object_klass(), interfaces, false, nullptr, offset, flat_in_array, instance_id, speculative, depth); 5465 } 5466 case Constant: 5467 case NotNull: 5468 case BotPTR: { // Fall down to object klass 5469 // LCA is object_klass, but if we subclass from the top we can do better 5470 if (above_centerline(tp->ptr())) { 5471 // If 'tp' is above the centerline and it is Object class 5472 // then we can subclass in the Java class hierarchy. 5473 // For instances when a subclass meets a superclass we fall 5474 // below the centerline when the superclass is exact. We need 5475 // to do the same here. 5476 5477 // Flat in array: We do TypeAryPtr MEET dual(TypeInstPtr), same applies as above in TopPTR/AnyNull case. 5478 if (tp->klass()->equals(ciEnv::current()->Object_klass()) && this_interfaces->contains(tp_interfaces) && 5479 !tp->klass_is_exact() && !tp->is_not_flat_in_array()) { 5480 // that is, my array type is a subtype of 'tp' klass 5481 return make(ptr, (ptr == Constant ? const_oop() : nullptr), 5482 _ary, _klass, _klass_is_exact, offset, _field_offset, instance_id, speculative, depth); 5483 } 5484 } 5485 // The other case cannot happen, since t cannot be a subtype of an array. 5486 // The meet falls down to Object class below centerline. 5487 if (ptr == Constant) { 5488 ptr = NotNull; 5489 } 5490 if (instance_id > 0) { 5491 instance_id = InstanceBot; 5492 } 5493 5494 FlatInArray flat_in_array = meet_flat_in_array(NotFlat, tp->flat_in_array()); 5495 interfaces = this_interfaces->intersection_with(tp_interfaces); 5496 return TypeInstPtr::make(ptr, ciEnv::current()->Object_klass(), interfaces, false, nullptr, offset, 5497 flat_in_array, instance_id, speculative, depth); 5498 } 5499 default: typerr(t); 5500 } 5501 } 5502 } 5503 return this; // Lint noise 5504 } 5505 5506 5507 template<class T> TypePtr::MeetResult TypePtr::meet_aryptr(PTR& ptr, const Type*& elem, const T* this_ary, const T* other_ary, 5508 ciKlass*& res_klass, bool& res_xk, bool &res_flat, bool& res_not_flat, bool& res_not_null_free, bool &res_atomic) { 5509 int dummy; 5510 bool this_top_or_bottom = (this_ary->base_element_type(dummy) == Type::TOP || this_ary->base_element_type(dummy) == Type::BOTTOM); 5511 bool other_top_or_bottom = (other_ary->base_element_type(dummy) == Type::TOP || other_ary->base_element_type(dummy) == Type::BOTTOM); 5512 ciKlass* this_klass = this_ary->klass(); 5513 ciKlass* other_klass = other_ary->klass(); 5514 bool this_xk = this_ary->klass_is_exact(); 5515 bool other_xk = other_ary->klass_is_exact(); 5516 PTR this_ptr = this_ary->ptr(); 5517 PTR other_ptr = other_ary->ptr(); 5518 bool this_flat = this_ary->is_flat(); 5519 bool this_not_flat = this_ary->is_not_flat(); 5520 bool other_flat = other_ary->is_flat(); 5521 bool other_not_flat = other_ary->is_not_flat(); 5522 bool this_not_null_free = this_ary->is_not_null_free(); 5523 bool other_not_null_free = other_ary->is_not_null_free(); 5524 bool this_atomic = this_ary->is_atomic(); 5525 bool other_atomic = other_ary->is_atomic(); 5526 const bool same_nullness = this_ary->is_null_free() == other_ary->is_null_free(); 5527 res_klass = nullptr; 5528 MeetResult result = SUBTYPE; 5529 res_flat = this_flat && other_flat; 5530 bool res_null_free = this_ary->is_null_free() && other_ary->is_null_free(); 5531 res_not_flat = this_not_flat && other_not_flat; 5532 res_not_null_free = this_not_null_free && other_not_null_free; 5533 res_atomic = this_atomic && other_atomic; 5534 5535 if (elem->isa_int()) { 5536 // Integral array element types have irrelevant lattice relations. 5537 // It is the klass that determines array layout, not the element type. 5538 if (this_top_or_bottom) { 5539 res_klass = other_klass; 5540 } else if (other_top_or_bottom || other_klass == this_klass) { 5541 res_klass = this_klass; 5542 } else { 5543 // Something like byte[int+] meets char[int+]. 5544 // This must fall to bottom, not (int[-128..65535])[int+]. 5545 // instance_id = InstanceBot; 5546 elem = Type::BOTTOM; 5547 result = NOT_SUBTYPE; 5548 if (above_centerline(ptr) || ptr == Constant) { 5549 ptr = NotNull; 5550 res_xk = false; 5551 return NOT_SUBTYPE; 5552 } 5553 } 5554 } else {// Non integral arrays. 5555 // Must fall to bottom if exact klasses in upper lattice 5556 // are not equal or super klass is exact. 5557 if ((above_centerline(ptr) || ptr == Constant) && !this_ary->is_same_java_type_as(other_ary) && 5558 // meet with top[] and bottom[] are processed further down: 5559 !this_top_or_bottom && !other_top_or_bottom && 5560 // both are exact and not equal: 5561 ((other_xk && this_xk) || 5562 // 'tap' is exact and super or unrelated: 5563 (other_xk && !other_ary->is_meet_subtype_of(this_ary)) || 5564 // 'this' is exact and super or unrelated: 5565 (this_xk && !this_ary->is_meet_subtype_of(other_ary)))) { 5566 if (above_centerline(ptr) || (elem->make_ptr() && above_centerline(elem->make_ptr()->_ptr))) { 5567 elem = Type::BOTTOM; 5568 } 5569 ptr = NotNull; 5570 res_xk = false; 5571 return NOT_SUBTYPE; 5572 } 5573 } 5574 5575 res_xk = false; 5576 switch (other_ptr) { 5577 case AnyNull: 5578 case TopPTR: 5579 // Compute new klass on demand, do not use tap->_klass 5580 if (below_centerline(this_ptr)) { 5581 res_xk = this_xk; 5582 if (this_ary->is_flat()) { 5583 elem = this_ary->elem(); 5584 } 5585 } else { 5586 res_xk = (other_xk || this_xk); 5587 } 5588 break; 5589 case Constant: { 5590 if (this_ptr == Constant && same_nullness) { 5591 // Only exact if same nullness since: 5592 // null-free [LMyValue <: nullable [LMyValue. 5593 res_xk = true; 5594 } else if (above_centerline(this_ptr)) { 5595 res_xk = true; 5596 } else { 5597 // Only precise for identical arrays 5598 res_xk = this_xk && (this_ary->is_same_java_type_as(other_ary) || (this_top_or_bottom && other_top_or_bottom)); 5599 // Even though MyValue is final, [LMyValue is only exact if the array 5600 // is (not) null-free due to null-free [LMyValue <: null-able [LMyValue. 5601 if (res_xk && !res_null_free && !res_not_null_free) { 5602 ptr = NotNull; 5603 res_xk = false; 5604 } 5605 } 5606 break; 5607 } 5608 case NotNull: 5609 case BotPTR: 5610 // Compute new klass on demand, do not use tap->_klass 5611 if (above_centerline(this_ptr)) { 5612 res_xk = other_xk; 5613 if (other_ary->is_flat()) { 5614 elem = other_ary->elem(); 5615 } 5616 } else { 5617 res_xk = (other_xk && this_xk) && 5618 (this_ary->is_same_java_type_as(other_ary) || (this_top_or_bottom && other_top_or_bottom)); // Only precise for identical arrays 5619 // Even though MyValue is final, [LMyValue is only exact if the array 5620 // is (not) null-free due to null-free [LMyValue <: null-able [LMyValue. 5621 if (res_xk && !res_null_free && !res_not_null_free) { 5622 ptr = NotNull; 5623 res_xk = false; 5624 } 5625 } 5626 break; 5627 default: { 5628 ShouldNotReachHere(); 5629 return result; 5630 } 5631 } 5632 return result; 5633 } 5634 5635 5636 //------------------------------xdual------------------------------------------ 5637 // Dual: compute field-by-field dual 5638 const Type *TypeAryPtr::xdual() const { 5639 bool xk = _klass_is_exact; 5640 return new TypeAryPtr(dual_ptr(), _const_oop, _ary->dual()->is_ary(), _klass, xk, dual_offset(), dual_field_offset(), dual_instance_id(), is_autobox_cache(), dual_speculative(), dual_inline_depth()); 5641 } 5642 5643 Type::Offset TypeAryPtr::meet_field_offset(const Type::Offset offset) const { 5644 return _field_offset.meet(offset); 5645 } 5646 5647 //------------------------------dual_offset------------------------------------ 5648 Type::Offset TypeAryPtr::dual_field_offset() const { 5649 return _field_offset.dual(); 5650 } 5651 5652 //------------------------------dump2------------------------------------------ 5653 #ifndef PRODUCT 5654 void TypeAryPtr::dump2( Dict &d, uint depth, outputStream *st ) const { 5655 st->print("aryptr:"); 5656 _ary->dump2(d, depth, st); 5657 _interfaces->dump(st); 5658 5659 if (_ptr == Constant) { 5660 const_oop()->print(st); 5661 } 5662 5663 st->print(":%s", ptr_msg[_ptr]); 5664 if (_klass_is_exact) { 5665 st->print(":exact"); 5666 } 5667 5668 if (is_flat()) { 5669 st->print(":flat"); 5670 st->print("("); 5671 _field_offset.dump2(st); 5672 st->print(")"); 5673 } else if (is_not_flat()) { 5674 st->print(":not_flat"); 5675 } 5676 if (is_null_free()) { 5677 st->print(":null free"); 5678 } 5679 if (is_atomic()) { 5680 st->print(":atomic"); 5681 } 5682 if (Verbose) { 5683 if (is_not_flat()) { 5684 st->print(":not flat"); 5685 } 5686 if (is_not_null_free()) { 5687 st->print(":nullable"); 5688 } 5689 } 5690 if (offset() != 0) { 5691 BasicType basic_elem_type = elem()->basic_type(); 5692 int header_size = arrayOopDesc::base_offset_in_bytes(basic_elem_type); 5693 if( _offset == Offset::top ) st->print("+undefined"); 5694 else if( _offset == Offset::bottom ) st->print("+any"); 5695 else if( offset() < header_size ) st->print("+%d", offset()); 5696 else { 5697 if (basic_elem_type == T_ILLEGAL) { 5698 st->print("+any"); 5699 } else { 5700 int elem_size = type2aelembytes(basic_elem_type); 5701 st->print("[%d]", (offset() - header_size)/elem_size); 5702 } 5703 } 5704 } 5705 5706 dump_instance_id(st); 5707 dump_inline_depth(st); 5708 dump_speculative(st); 5709 } 5710 #endif 5711 5712 bool TypeAryPtr::empty(void) const { 5713 if (_ary->empty()) return true; 5714 // FIXME: Does this belong here? Or in the meet code itself? 5715 if (is_flat() && is_not_flat()) { 5716 return true; 5717 } 5718 return TypeOopPtr::empty(); 5719 } 5720 5721 //------------------------------add_offset------------------------------------- 5722 const TypePtr* TypeAryPtr::add_offset(intptr_t offset) const { 5723 return make(_ptr, _const_oop, _ary, _klass, _klass_is_exact, xadd_offset(offset), _field_offset, _instance_id, add_offset_speculative(offset), _inline_depth, _is_autobox_cache); 5724 } 5725 5726 const TypeAryPtr* TypeAryPtr::with_offset(intptr_t offset) const { 5727 return make(_ptr, _const_oop, _ary, _klass, _klass_is_exact, Offset(offset), _field_offset, _instance_id, with_offset_speculative(offset), _inline_depth, _is_autobox_cache); 5728 } 5729 5730 const TypeAryPtr* TypeAryPtr::with_ary(const TypeAry* ary) const { 5731 return make(_ptr, _const_oop, ary, _klass, _klass_is_exact, _offset, _field_offset, _instance_id, _speculative, _inline_depth, _is_autobox_cache); 5732 } 5733 5734 const TypeAryPtr* TypeAryPtr::remove_speculative() const { 5735 if (_speculative == nullptr) { 5736 return this; 5737 } 5738 assert(_inline_depth == InlineDepthTop || _inline_depth == InlineDepthBottom, "non speculative type shouldn't have inline depth"); 5739 return make(_ptr, _const_oop, _ary->remove_speculative()->is_ary(), _klass, _klass_is_exact, _offset, _field_offset, _instance_id, nullptr, _inline_depth, _is_autobox_cache); 5740 } 5741 5742 const Type* TypeAryPtr::cleanup_speculative() const { 5743 if (speculative() == nullptr) { 5744 return this; 5745 } 5746 // Keep speculative part if it contains information about flat-/nullability 5747 const TypeAryPtr* spec_aryptr = speculative()->isa_aryptr(); 5748 if (spec_aryptr != nullptr && !above_centerline(spec_aryptr->ptr()) && 5749 (spec_aryptr->is_not_flat() || spec_aryptr->is_not_null_free())) { 5750 return this; 5751 } 5752 return TypeOopPtr::cleanup_speculative(); 5753 } 5754 5755 const TypePtr* TypeAryPtr::with_inline_depth(int depth) const { 5756 if (!UseInlineDepthForSpeculativeTypes) { 5757 return this; 5758 } 5759 return make(_ptr, _const_oop, _ary->remove_speculative()->is_ary(), _klass, _klass_is_exact, _offset, _field_offset, _instance_id, _speculative, depth, _is_autobox_cache); 5760 } 5761 5762 const TypeAryPtr* TypeAryPtr::with_field_offset(int offset) const { 5763 return make(_ptr, _const_oop, _ary->remove_speculative()->is_ary(), _klass, _klass_is_exact, _offset, Offset(offset), _instance_id, _speculative, _inline_depth, _is_autobox_cache); 5764 } 5765 5766 const TypePtr* TypeAryPtr::add_field_offset_and_offset(intptr_t offset) const { 5767 int adj = 0; 5768 if (is_flat() && klass_is_exact() && offset != Type::OffsetBot && offset != Type::OffsetTop) { 5769 if (_offset.get() != OffsetBot && _offset.get() != OffsetTop) { 5770 adj = _offset.get(); 5771 offset += _offset.get(); 5772 } 5773 uint header = arrayOopDesc::base_offset_in_bytes(T_FLAT_ELEMENT); 5774 if (_field_offset.get() != OffsetBot && _field_offset.get() != OffsetTop) { 5775 offset += _field_offset.get(); 5776 if (_offset.get() == OffsetBot || _offset.get() == OffsetTop) { 5777 offset += header; 5778 } 5779 } 5780 if (elem()->make_oopptr()->is_inlinetypeptr() && (offset >= (intptr_t)header || offset < 0)) { 5781 // Try to get the field of the inline type array element we are pointing to 5782 ciInlineKlass* vk = elem()->inline_klass(); 5783 int shift = flat_log_elem_size(); 5784 int mask = (1 << shift) - 1; 5785 intptr_t field_offset = ((offset - header) & mask); 5786 ciField* field = vk->get_field_by_offset(field_offset + vk->payload_offset(), false); 5787 if (field != nullptr || field_offset == vk->null_marker_offset_in_payload()) { 5788 return with_field_offset(field_offset)->add_offset(offset - field_offset - adj); 5789 } 5790 } 5791 } 5792 return add_offset(offset - adj); 5793 } 5794 5795 // Return offset incremented by field_offset for flat inline type arrays 5796 int TypeAryPtr::flat_offset() const { 5797 int offset = _offset.get(); 5798 if (offset != Type::OffsetBot && offset != Type::OffsetTop && 5799 _field_offset != Offset::bottom && _field_offset != Offset::top) { 5800 offset += _field_offset.get(); 5801 } 5802 return offset; 5803 } 5804 5805 const TypePtr* TypeAryPtr::with_instance_id(int instance_id) const { 5806 assert(is_known_instance(), "should be known"); 5807 return make(_ptr, _const_oop, _ary->remove_speculative()->is_ary(), _klass, _klass_is_exact, _offset, _field_offset, instance_id, _speculative, _inline_depth); 5808 } 5809 5810 //============================================================================= 5811 5812 5813 //------------------------------hash------------------------------------------- 5814 // Type-specific hashing function. 5815 uint TypeNarrowPtr::hash(void) const { 5816 return _ptrtype->hash() + 7; 5817 } 5818 5819 bool TypeNarrowPtr::singleton(void) const { // TRUE if type is a singleton 5820 return _ptrtype->singleton(); 5821 } 5822 5823 bool TypeNarrowPtr::empty(void) const { 5824 return _ptrtype->empty(); 5825 } 5826 5827 intptr_t TypeNarrowPtr::get_con() const { 5828 return _ptrtype->get_con(); 5829 } 5830 5831 bool TypeNarrowPtr::eq( const Type *t ) const { 5832 const TypeNarrowPtr* tc = isa_same_narrowptr(t); 5833 if (tc != nullptr) { 5834 if (_ptrtype->base() != tc->_ptrtype->base()) { 5835 return false; 5836 } 5837 return tc->_ptrtype->eq(_ptrtype); 5838 } 5839 return false; 5840 } 5841 5842 const Type *TypeNarrowPtr::xdual() const { // Compute dual right now. 5843 const TypePtr* odual = _ptrtype->dual()->is_ptr(); 5844 return make_same_narrowptr(odual); 5845 } 5846 5847 5848 const Type *TypeNarrowPtr::filter_helper(const Type *kills, bool include_speculative) const { 5849 if (isa_same_narrowptr(kills)) { 5850 const Type* ft =_ptrtype->filter_helper(is_same_narrowptr(kills)->_ptrtype, include_speculative); 5851 if (ft->empty()) 5852 return Type::TOP; // Canonical empty value 5853 if (ft->isa_ptr()) { 5854 return make_hash_same_narrowptr(ft->isa_ptr()); 5855 } 5856 return ft; 5857 } else if (kills->isa_ptr()) { 5858 const Type* ft = _ptrtype->join_helper(kills, include_speculative); 5859 if (ft->empty()) 5860 return Type::TOP; // Canonical empty value 5861 return ft; 5862 } else { 5863 return Type::TOP; 5864 } 5865 } 5866 5867 //------------------------------xmeet------------------------------------------ 5868 // Compute the MEET of two types. It returns a new Type object. 5869 const Type *TypeNarrowPtr::xmeet( const Type *t ) const { 5870 // Perform a fast test for common case; meeting the same types together. 5871 if( this == t ) return this; // Meeting same type-rep? 5872 5873 if (t->base() == base()) { 5874 const Type* result = _ptrtype->xmeet(t->make_ptr()); 5875 if (result->isa_ptr()) { 5876 return make_hash_same_narrowptr(result->is_ptr()); 5877 } 5878 return result; 5879 } 5880 5881 // Current "this->_base" is NarrowKlass or NarrowOop 5882 switch (t->base()) { // switch on original type 5883 5884 case Int: // Mixing ints & oops happens when javac 5885 case Long: // reuses local variables 5886 case HalfFloatTop: 5887 case HalfFloatCon: 5888 case HalfFloatBot: 5889 case FloatTop: 5890 case FloatCon: 5891 case FloatBot: 5892 case DoubleTop: 5893 case DoubleCon: 5894 case DoubleBot: 5895 case AnyPtr: 5896 case RawPtr: 5897 case OopPtr: 5898 case InstPtr: 5899 case AryPtr: 5900 case MetadataPtr: 5901 case KlassPtr: 5902 case InstKlassPtr: 5903 case AryKlassPtr: 5904 case NarrowOop: 5905 case NarrowKlass: 5906 case Bottom: // Ye Olde Default 5907 return Type::BOTTOM; 5908 case Top: 5909 return this; 5910 5911 default: // All else is a mistake 5912 typerr(t); 5913 5914 } // End of switch 5915 5916 return this; 5917 } 5918 5919 #ifndef PRODUCT 5920 void TypeNarrowPtr::dump2( Dict & d, uint depth, outputStream *st ) const { 5921 _ptrtype->dump2(d, depth, st); 5922 } 5923 #endif 5924 5925 const TypeNarrowOop *TypeNarrowOop::BOTTOM; 5926 const TypeNarrowOop *TypeNarrowOop::NULL_PTR; 5927 5928 5929 const TypeNarrowOop* TypeNarrowOop::make(const TypePtr* type) { 5930 return (const TypeNarrowOop*)(new TypeNarrowOop(type))->hashcons(); 5931 } 5932 5933 const TypeNarrowOop* TypeNarrowOop::remove_speculative() const { 5934 return make(_ptrtype->remove_speculative()->is_ptr()); 5935 } 5936 5937 const Type* TypeNarrowOop::cleanup_speculative() const { 5938 return make(_ptrtype->cleanup_speculative()->is_ptr()); 5939 } 5940 5941 #ifndef PRODUCT 5942 void TypeNarrowOop::dump2( Dict & d, uint depth, outputStream *st ) const { 5943 st->print("narrowoop: "); 5944 TypeNarrowPtr::dump2(d, depth, st); 5945 } 5946 #endif 5947 5948 const TypeNarrowKlass *TypeNarrowKlass::NULL_PTR; 5949 5950 const TypeNarrowKlass* TypeNarrowKlass::make(const TypePtr* type) { 5951 return (const TypeNarrowKlass*)(new TypeNarrowKlass(type))->hashcons(); 5952 } 5953 5954 #ifndef PRODUCT 5955 void TypeNarrowKlass::dump2( Dict & d, uint depth, outputStream *st ) const { 5956 st->print("narrowklass: "); 5957 TypeNarrowPtr::dump2(d, depth, st); 5958 } 5959 #endif 5960 5961 5962 //------------------------------eq--------------------------------------------- 5963 // Structural equality check for Type representations 5964 bool TypeMetadataPtr::eq( const Type *t ) const { 5965 const TypeMetadataPtr *a = (const TypeMetadataPtr*)t; 5966 ciMetadata* one = metadata(); 5967 ciMetadata* two = a->metadata(); 5968 if (one == nullptr || two == nullptr) { 5969 return (one == two) && TypePtr::eq(t); 5970 } else { 5971 return one->equals(two) && TypePtr::eq(t); 5972 } 5973 } 5974 5975 //------------------------------hash------------------------------------------- 5976 // Type-specific hashing function. 5977 uint TypeMetadataPtr::hash(void) const { 5978 return 5979 (metadata() ? metadata()->hash() : 0) + 5980 TypePtr::hash(); 5981 } 5982 5983 //------------------------------singleton-------------------------------------- 5984 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple 5985 // constants 5986 bool TypeMetadataPtr::singleton(void) const { 5987 // detune optimizer to not generate constant metadata + constant offset as a constant! 5988 // TopPTR, Null, AnyNull, Constant are all singletons 5989 return (offset() == 0) && !below_centerline(_ptr); 5990 } 5991 5992 //------------------------------add_offset------------------------------------- 5993 const TypePtr* TypeMetadataPtr::add_offset( intptr_t offset ) const { 5994 return make( _ptr, _metadata, xadd_offset(offset)); 5995 } 5996 5997 //-----------------------------filter------------------------------------------ 5998 // Do not allow interface-vs.-noninterface joins to collapse to top. 5999 const Type *TypeMetadataPtr::filter_helper(const Type *kills, bool include_speculative) const { 6000 const TypeMetadataPtr* ft = join_helper(kills, include_speculative)->isa_metadataptr(); 6001 if (ft == nullptr || ft->empty()) 6002 return Type::TOP; // Canonical empty value 6003 return ft; 6004 } 6005 6006 //------------------------------get_con---------------------------------------- 6007 intptr_t TypeMetadataPtr::get_con() const { 6008 assert( _ptr == Null || _ptr == Constant, "" ); 6009 assert(offset() >= 0, ""); 6010 6011 if (offset() != 0) { 6012 // After being ported to the compiler interface, the compiler no longer 6013 // directly manipulates the addresses of oops. Rather, it only has a pointer 6014 // to a handle at compile time. This handle is embedded in the generated 6015 // code and dereferenced at the time the nmethod is made. Until that time, 6016 // it is not reasonable to do arithmetic with the addresses of oops (we don't 6017 // have access to the addresses!). This does not seem to currently happen, 6018 // but this assertion here is to help prevent its occurrence. 6019 tty->print_cr("Found oop constant with non-zero offset"); 6020 ShouldNotReachHere(); 6021 } 6022 6023 return (intptr_t)metadata()->constant_encoding(); 6024 } 6025 6026 //------------------------------cast_to_ptr_type------------------------------- 6027 const TypeMetadataPtr* TypeMetadataPtr::cast_to_ptr_type(PTR ptr) const { 6028 if( ptr == _ptr ) return this; 6029 return make(ptr, metadata(), _offset); 6030 } 6031 6032 //------------------------------meet------------------------------------------- 6033 // Compute the MEET of two types. It returns a new Type object. 6034 const Type *TypeMetadataPtr::xmeet( const Type *t ) const { 6035 // Perform a fast test for common case; meeting the same types together. 6036 if( this == t ) return this; // Meeting same type-rep? 6037 6038 // Current "this->_base" is OopPtr 6039 switch (t->base()) { // switch on original type 6040 6041 case Int: // Mixing ints & oops happens when javac 6042 case Long: // reuses local variables 6043 case HalfFloatTop: 6044 case HalfFloatCon: 6045 case HalfFloatBot: 6046 case FloatTop: 6047 case FloatCon: 6048 case FloatBot: 6049 case DoubleTop: 6050 case DoubleCon: 6051 case DoubleBot: 6052 case NarrowOop: 6053 case NarrowKlass: 6054 case Bottom: // Ye Olde Default 6055 return Type::BOTTOM; 6056 case Top: 6057 return this; 6058 6059 default: // All else is a mistake 6060 typerr(t); 6061 6062 case AnyPtr: { 6063 // Found an AnyPtr type vs self-OopPtr type 6064 const TypePtr *tp = t->is_ptr(); 6065 Offset offset = meet_offset(tp->offset()); 6066 PTR ptr = meet_ptr(tp->ptr()); 6067 switch (tp->ptr()) { 6068 case Null: 6069 if (ptr == Null) return TypePtr::make(AnyPtr, ptr, offset, tp->speculative(), tp->inline_depth()); 6070 // else fall through: 6071 case TopPTR: 6072 case AnyNull: { 6073 return make(ptr, _metadata, offset); 6074 } 6075 case BotPTR: 6076 case NotNull: 6077 return TypePtr::make(AnyPtr, ptr, offset, tp->speculative(), tp->inline_depth()); 6078 default: typerr(t); 6079 } 6080 } 6081 6082 case RawPtr: 6083 case KlassPtr: 6084 case InstKlassPtr: 6085 case AryKlassPtr: 6086 case OopPtr: 6087 case InstPtr: 6088 case AryPtr: 6089 return TypePtr::BOTTOM; // Oop meet raw is not well defined 6090 6091 case MetadataPtr: { 6092 const TypeMetadataPtr *tp = t->is_metadataptr(); 6093 Offset offset = meet_offset(tp->offset()); 6094 PTR tptr = tp->ptr(); 6095 PTR ptr = meet_ptr(tptr); 6096 ciMetadata* md = (tptr == TopPTR) ? metadata() : tp->metadata(); 6097 if (tptr == TopPTR || _ptr == TopPTR || 6098 metadata()->equals(tp->metadata())) { 6099 return make(ptr, md, offset); 6100 } 6101 // metadata is different 6102 if( ptr == Constant ) { // Cannot be equal constants, so... 6103 if( tptr == Constant && _ptr != Constant) return t; 6104 if( _ptr == Constant && tptr != Constant) return this; 6105 ptr = NotNull; // Fall down in lattice 6106 } 6107 return make(ptr, nullptr, offset); 6108 break; 6109 } 6110 } // End of switch 6111 return this; // Return the double constant 6112 } 6113 6114 6115 //------------------------------xdual------------------------------------------ 6116 // Dual of a pure metadata pointer. 6117 const Type *TypeMetadataPtr::xdual() const { 6118 return new TypeMetadataPtr(dual_ptr(), metadata(), dual_offset()); 6119 } 6120 6121 //------------------------------dump2------------------------------------------ 6122 #ifndef PRODUCT 6123 void TypeMetadataPtr::dump2( Dict &d, uint depth, outputStream *st ) const { 6124 st->print("metadataptr:%s", ptr_msg[_ptr]); 6125 if (metadata() != nullptr) { 6126 st->print(":" INTPTR_FORMAT, p2i(metadata())); 6127 } 6128 dump_offset(st); 6129 } 6130 #endif 6131 6132 6133 //============================================================================= 6134 // Convenience common pre-built type. 6135 const TypeMetadataPtr *TypeMetadataPtr::BOTTOM; 6136 6137 TypeMetadataPtr::TypeMetadataPtr(PTR ptr, ciMetadata* metadata, Offset offset): 6138 TypePtr(MetadataPtr, ptr, offset), _metadata(metadata) { 6139 } 6140 6141 const TypeMetadataPtr* TypeMetadataPtr::make(ciMethod* m) { 6142 return make(Constant, m, Offset(0)); 6143 } 6144 const TypeMetadataPtr* TypeMetadataPtr::make(ciMethodData* m) { 6145 return make(Constant, m, Offset(0)); 6146 } 6147 6148 //------------------------------make------------------------------------------- 6149 // Create a meta data constant 6150 const TypeMetadataPtr* TypeMetadataPtr::make(PTR ptr, ciMetadata* m, Offset offset) { 6151 assert(m == nullptr || !m->is_klass(), "wrong type"); 6152 return (TypeMetadataPtr*)(new TypeMetadataPtr(ptr, m, offset))->hashcons(); 6153 } 6154 6155 6156 const TypeKlassPtr* TypeAryPtr::as_klass_type(bool try_for_exact) const { 6157 const Type* elem = _ary->_elem; 6158 bool xk = klass_is_exact(); 6159 bool is_refined = false; 6160 if (elem->make_oopptr() != nullptr) { 6161 is_refined = true; 6162 elem = elem->make_oopptr()->as_klass_type(try_for_exact); 6163 if (elem->isa_aryklassptr()) { 6164 const TypeAryKlassPtr* elem_klass = elem->is_aryklassptr(); 6165 if (elem_klass->is_refined_type()) { 6166 elem = elem_klass->cast_to_non_refined(); 6167 } 6168 } else { 6169 const TypeInstKlassPtr* elem_klass = elem->is_instklassptr(); 6170 if (try_for_exact && !xk && elem_klass->klass_is_exact() && 6171 !elem_klass->exact_klass()->as_instance_klass()->can_be_inline_klass()) { 6172 xk = true; 6173 } 6174 } 6175 } 6176 return TypeAryKlassPtr::make(xk ? TypePtr::Constant : TypePtr::NotNull, elem, klass(), Offset(0), is_not_flat(), is_not_null_free(), is_flat(), is_null_free(), is_atomic(), is_refined); 6177 } 6178 6179 const TypeKlassPtr* TypeKlassPtr::make(ciKlass* klass, InterfaceHandling interface_handling) { 6180 if (klass->is_instance_klass()) { 6181 return TypeInstKlassPtr::make(klass, interface_handling); 6182 } 6183 return TypeAryKlassPtr::make(klass, interface_handling); 6184 } 6185 6186 TypeKlassPtr::TypeKlassPtr(TYPES t, PTR ptr, ciKlass* klass, const TypeInterfaces* interfaces, Offset offset) 6187 : TypePtr(t, ptr, offset), _klass(klass), _interfaces(interfaces) { 6188 assert(klass == nullptr || !klass->is_loaded() || (klass->is_instance_klass() && !klass->is_interface()) || 6189 klass->is_type_array_klass() || klass->is_flat_array_klass() || !klass->as_obj_array_klass()->base_element_klass()->is_interface(), "no interface here"); 6190 } 6191 6192 // Is there a single ciKlass* that can represent that type? 6193 ciKlass* TypeKlassPtr::exact_klass_helper() const { 6194 assert(_klass->is_instance_klass() && !_klass->is_interface(), "No interface"); 6195 if (_interfaces->empty()) { 6196 return _klass; 6197 } 6198 if (_klass != ciEnv::current()->Object_klass()) { 6199 if (_interfaces->eq(_klass->as_instance_klass())) { 6200 return _klass; 6201 } 6202 return nullptr; 6203 } 6204 return _interfaces->exact_klass(); 6205 } 6206 6207 //------------------------------eq--------------------------------------------- 6208 // Structural equality check for Type representations 6209 bool TypeKlassPtr::eq(const Type *t) const { 6210 const TypeKlassPtr *p = t->is_klassptr(); 6211 return 6212 _interfaces->eq(p->_interfaces) && 6213 TypePtr::eq(p); 6214 } 6215 6216 //------------------------------hash------------------------------------------- 6217 // Type-specific hashing function. 6218 uint TypeKlassPtr::hash(void) const { 6219 return TypePtr::hash() + _interfaces->hash(); 6220 } 6221 6222 //------------------------------singleton-------------------------------------- 6223 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple 6224 // constants 6225 bool TypeKlassPtr::singleton(void) const { 6226 // detune optimizer to not generate constant klass + constant offset as a constant! 6227 // TopPTR, Null, AnyNull, Constant are all singletons 6228 return (offset() == 0) && !below_centerline(_ptr); 6229 } 6230 6231 // Do not allow interface-vs.-noninterface joins to collapse to top. 6232 const Type *TypeKlassPtr::filter_helper(const Type *kills, bool include_speculative) const { 6233 // logic here mirrors the one from TypeOopPtr::filter. See comments 6234 // there. 6235 const Type* ft = join_helper(kills, include_speculative); 6236 6237 if (ft->empty()) { 6238 return Type::TOP; // Canonical empty value 6239 } 6240 6241 return ft; 6242 } 6243 6244 const TypeInterfaces* TypeKlassPtr::meet_interfaces(const TypeKlassPtr* other) const { 6245 if (above_centerline(_ptr) && above_centerline(other->_ptr)) { 6246 return _interfaces->union_with(other->_interfaces); 6247 } else if (above_centerline(_ptr) && !above_centerline(other->_ptr)) { 6248 return other->_interfaces; 6249 } else if (above_centerline(other->_ptr) && !above_centerline(_ptr)) { 6250 return _interfaces; 6251 } 6252 return _interfaces->intersection_with(other->_interfaces); 6253 } 6254 6255 //------------------------------get_con---------------------------------------- 6256 intptr_t TypeKlassPtr::get_con() const { 6257 assert( _ptr == Null || _ptr == Constant, "" ); 6258 assert( offset() >= 0, "" ); 6259 6260 if (offset() != 0) { 6261 // After being ported to the compiler interface, the compiler no longer 6262 // directly manipulates the addresses of oops. Rather, it only has a pointer 6263 // to a handle at compile time. This handle is embedded in the generated 6264 // code and dereferenced at the time the nmethod is made. Until that time, 6265 // it is not reasonable to do arithmetic with the addresses of oops (we don't 6266 // have access to the addresses!). This does not seem to currently happen, 6267 // but this assertion here is to help prevent its occurrence. 6268 tty->print_cr("Found oop constant with non-zero offset"); 6269 ShouldNotReachHere(); 6270 } 6271 6272 ciKlass* k = exact_klass(); 6273 6274 return (intptr_t)k->constant_encoding(); 6275 } 6276 6277 //============================================================================= 6278 // Convenience common pre-built types. 6279 6280 // Not-null object klass or below 6281 const TypeInstKlassPtr *TypeInstKlassPtr::OBJECT; 6282 const TypeInstKlassPtr *TypeInstKlassPtr::OBJECT_OR_NULL; 6283 6284 bool TypeInstKlassPtr::eq(const Type *t) const { 6285 const TypeInstKlassPtr* p = t->is_instklassptr(); 6286 return 6287 klass()->equals(p->klass()) && 6288 _flat_in_array == p->_flat_in_array && 6289 TypeKlassPtr::eq(p); 6290 } 6291 6292 uint TypeInstKlassPtr::hash() const { 6293 return klass()->hash() + TypeKlassPtr::hash() + static_cast<uint>(_flat_in_array); 6294 } 6295 6296 const TypeInstKlassPtr *TypeInstKlassPtr::make(PTR ptr, ciKlass* k, const TypeInterfaces* interfaces, Offset offset, FlatInArray flat_in_array) { 6297 if (flat_in_array == Uninitialized) { 6298 flat_in_array = compute_flat_in_array(k->as_instance_klass(), ptr == Constant); 6299 } 6300 TypeInstKlassPtr *r = 6301 (TypeInstKlassPtr*)(new TypeInstKlassPtr(ptr, k, interfaces, offset, flat_in_array))->hashcons(); 6302 6303 return r; 6304 } 6305 6306 bool TypeInstKlassPtr::empty() const { 6307 if (_flat_in_array == TopFlat) { 6308 return true; 6309 } 6310 return TypeKlassPtr::empty(); 6311 } 6312 6313 //------------------------------add_offset------------------------------------- 6314 // Access internals of klass object 6315 const TypePtr *TypeInstKlassPtr::add_offset( intptr_t offset ) const { 6316 return make(_ptr, klass(), _interfaces, xadd_offset(offset), _flat_in_array); 6317 } 6318 6319 const TypeInstKlassPtr* TypeInstKlassPtr::with_offset(intptr_t offset) const { 6320 return make(_ptr, klass(), _interfaces, Offset(offset), _flat_in_array); 6321 } 6322 6323 //------------------------------cast_to_ptr_type------------------------------- 6324 const TypeInstKlassPtr* TypeInstKlassPtr::cast_to_ptr_type(PTR ptr) const { 6325 assert(_base == InstKlassPtr, "subclass must override cast_to_ptr_type"); 6326 if( ptr == _ptr ) return this; 6327 return make(ptr, _klass, _interfaces, _offset, _flat_in_array); 6328 } 6329 6330 6331 bool TypeInstKlassPtr::must_be_exact() const { 6332 if (!_klass->is_loaded()) return false; 6333 ciInstanceKlass* ik = _klass->as_instance_klass(); 6334 if (ik->is_final()) return true; // cannot clear xk 6335 return false; 6336 } 6337 6338 //-----------------------------cast_to_exactness------------------------------- 6339 const TypeKlassPtr* TypeInstKlassPtr::cast_to_exactness(bool klass_is_exact) const { 6340 if (klass_is_exact == (_ptr == Constant)) return this; 6341 if (must_be_exact()) return this; 6342 ciKlass* k = klass(); 6343 FlatInArray flat_in_array = compute_flat_in_array(k->as_instance_klass(), klass_is_exact); 6344 return make(klass_is_exact ? Constant : NotNull, k, _interfaces, _offset, flat_in_array); 6345 } 6346 6347 6348 //-----------------------------as_instance_type-------------------------------- 6349 // Corresponding type for an instance of the given class. 6350 // It will be NotNull, and exact if and only if the klass type is exact. 6351 const TypeOopPtr* TypeInstKlassPtr::as_instance_type(bool klass_change) const { 6352 ciKlass* k = klass(); 6353 bool xk = klass_is_exact(); 6354 Compile* C = Compile::current(); 6355 Dependencies* deps = C->dependencies(); 6356 assert((deps != nullptr) == (C->method() != nullptr && C->method()->code_size() > 0), "sanity"); 6357 // Element is an instance 6358 bool klass_is_exact = false; 6359 const TypeInterfaces* interfaces = _interfaces; 6360 ciInstanceKlass* ik = k->as_instance_klass(); 6361 if (k->is_loaded()) { 6362 // Try to set klass_is_exact. 6363 klass_is_exact = ik->is_final(); 6364 if (!klass_is_exact && klass_change 6365 && deps != nullptr && UseUniqueSubclasses) { 6366 ciInstanceKlass* sub = ik->unique_concrete_subklass(); 6367 if (sub != nullptr) { 6368 if (_interfaces->eq(sub)) { 6369 deps->assert_abstract_with_unique_concrete_subtype(ik, sub); 6370 k = ik = sub; 6371 xk = sub->is_final(); 6372 } 6373 } 6374 } 6375 } 6376 6377 FlatInArray flat_in_array = compute_flat_in_array_if_unknown(ik, xk, _flat_in_array); 6378 return TypeInstPtr::make(TypePtr::BotPTR, k, interfaces, xk, nullptr, Offset(0), flat_in_array); 6379 } 6380 6381 //------------------------------xmeet------------------------------------------ 6382 // Compute the MEET of two types, return a new Type object. 6383 const Type *TypeInstKlassPtr::xmeet( const Type *t ) const { 6384 // Perform a fast test for common case; meeting the same types together. 6385 if( this == t ) return this; // Meeting same type-rep? 6386 6387 // Current "this->_base" is Pointer 6388 switch (t->base()) { // switch on original type 6389 6390 case Int: // Mixing ints & oops happens when javac 6391 case Long: // reuses local variables 6392 case HalfFloatTop: 6393 case HalfFloatCon: 6394 case HalfFloatBot: 6395 case FloatTop: 6396 case FloatCon: 6397 case FloatBot: 6398 case DoubleTop: 6399 case DoubleCon: 6400 case DoubleBot: 6401 case NarrowOop: 6402 case NarrowKlass: 6403 case Bottom: // Ye Olde Default 6404 return Type::BOTTOM; 6405 case Top: 6406 return this; 6407 6408 default: // All else is a mistake 6409 typerr(t); 6410 6411 case AnyPtr: { // Meeting to AnyPtrs 6412 // Found an AnyPtr type vs self-KlassPtr type 6413 const TypePtr *tp = t->is_ptr(); 6414 Offset offset = meet_offset(tp->offset()); 6415 PTR ptr = meet_ptr(tp->ptr()); 6416 switch (tp->ptr()) { 6417 case TopPTR: 6418 return this; 6419 case Null: 6420 if( ptr == Null ) return TypePtr::make(AnyPtr, ptr, offset, tp->speculative(), tp->inline_depth()); 6421 case AnyNull: 6422 return make(ptr, klass(), _interfaces, offset, _flat_in_array); 6423 case BotPTR: 6424 case NotNull: 6425 return TypePtr::make(AnyPtr, ptr, offset, tp->speculative(), tp->inline_depth()); 6426 default: typerr(t); 6427 } 6428 } 6429 6430 case RawPtr: 6431 case MetadataPtr: 6432 case OopPtr: 6433 case AryPtr: // Meet with AryPtr 6434 case InstPtr: // Meet with InstPtr 6435 return TypePtr::BOTTOM; 6436 6437 // 6438 // A-top } 6439 // / | \ } Tops 6440 // B-top A-any C-top } 6441 // | / | \ | } Any-nulls 6442 // B-any | C-any } 6443 // | | | 6444 // B-con A-con C-con } constants; not comparable across classes 6445 // | | | 6446 // B-not | C-not } 6447 // | \ | / | } not-nulls 6448 // B-bot A-not C-bot } 6449 // \ | / } Bottoms 6450 // A-bot } 6451 // 6452 6453 case InstKlassPtr: { // Meet two KlassPtr types 6454 const TypeInstKlassPtr *tkls = t->is_instklassptr(); 6455 Offset off = meet_offset(tkls->offset()); 6456 PTR ptr = meet_ptr(tkls->ptr()); 6457 const TypeInterfaces* interfaces = meet_interfaces(tkls); 6458 6459 ciKlass* res_klass = nullptr; 6460 bool res_xk = false; 6461 const FlatInArray flat_in_array = meet_flat_in_array(_flat_in_array, tkls->flat_in_array()); 6462 switch (meet_instptr(ptr, interfaces, this, tkls, res_klass, res_xk)) { 6463 case UNLOADED: 6464 ShouldNotReachHere(); 6465 case SUBTYPE: 6466 case NOT_SUBTYPE: 6467 case LCA: 6468 case QUICK: { 6469 assert(res_xk == (ptr == Constant), ""); 6470 const Type* res = make(ptr, res_klass, interfaces, off, flat_in_array); 6471 return res; 6472 } 6473 default: 6474 ShouldNotReachHere(); 6475 } 6476 } // End of case KlassPtr 6477 case AryKlassPtr: { // All arrays inherit from Object class 6478 const TypeAryKlassPtr *tp = t->is_aryklassptr(); 6479 Offset offset = meet_offset(tp->offset()); 6480 PTR ptr = meet_ptr(tp->ptr()); 6481 const TypeInterfaces* interfaces = meet_interfaces(tp); 6482 const TypeInterfaces* tp_interfaces = tp->_interfaces; 6483 const TypeInterfaces* this_interfaces = _interfaces; 6484 6485 switch (ptr) { 6486 case TopPTR: 6487 case AnyNull: // Fall 'down' to dual of object klass 6488 // For instances when a subclass meets a superclass we fall 6489 // below the centerline when the superclass is exact. We need to 6490 // do the same here. 6491 // 6492 // Flat in array: See explanation for meet with TypeInstPtr in TypeAryPtr::xmeet_helper(). 6493 if (klass()->equals(ciEnv::current()->Object_klass()) && tp_interfaces->contains(this_interfaces) && 6494 !klass_is_exact() && !is_not_flat_in_array()) { 6495 return TypeAryKlassPtr::make(ptr, tp->elem(), tp->klass(), offset, tp->is_not_flat(), tp->is_not_null_free(), tp->is_flat(), tp->is_null_free(), tp->is_atomic(), tp->is_refined_type()); 6496 } else { 6497 // cannot subclass, so the meet has to fall badly below the centerline 6498 ptr = NotNull; 6499 interfaces = _interfaces->intersection_with(tp->_interfaces); 6500 FlatInArray flat_in_array = meet_flat_in_array(_flat_in_array, NotFlat); 6501 return make(ptr, ciEnv::current()->Object_klass(), interfaces, offset, flat_in_array); 6502 } 6503 case Constant: 6504 case NotNull: 6505 case BotPTR: { // Fall down to object klass 6506 // LCA is object_klass, but if we subclass from the top we can do better 6507 if( above_centerline(_ptr) ) { // if( _ptr == TopPTR || _ptr == AnyNull ) 6508 // If 'this' (InstPtr) is above the centerline and it is Object class 6509 // then we can subclass in the Java class hierarchy. 6510 // For instances when a subclass meets a superclass we fall 6511 // below the centerline when the superclass is exact. We need 6512 // to do the same here. 6513 // 6514 // Flat in array: See explanation for meet with TypeInstPtr in TypeAryPtr::xmeet_helper(). 6515 if (klass()->equals(ciEnv::current()->Object_klass()) && tp_interfaces->contains(this_interfaces) && 6516 !klass_is_exact() && !is_not_flat_in_array()) { 6517 // that is, tp's array type is a subtype of my klass 6518 return TypeAryKlassPtr::make(ptr, tp->elem(), tp->klass(), offset, tp->is_not_flat(), tp->is_not_null_free(), tp->is_flat(), tp->is_null_free(), tp->is_atomic(), tp->is_refined_type()); 6519 } 6520 } 6521 // The other case cannot happen, since I cannot be a subtype of an array. 6522 // The meet falls down to Object class below centerline. 6523 if( ptr == Constant ) 6524 ptr = NotNull; 6525 interfaces = this_interfaces->intersection_with(tp_interfaces); 6526 FlatInArray flat_in_array = meet_flat_in_array(_flat_in_array, NotFlat); 6527 return make(ptr, ciEnv::current()->Object_klass(), interfaces, offset, flat_in_array); 6528 } 6529 default: typerr(t); 6530 } 6531 } 6532 6533 } // End of switch 6534 return this; // Return the double constant 6535 } 6536 6537 //------------------------------xdual------------------------------------------ 6538 // Dual: compute field-by-field dual 6539 const Type* TypeInstKlassPtr::xdual() const { 6540 return new TypeInstKlassPtr(dual_ptr(), klass(), _interfaces, dual_offset(), dual_flat_in_array()); 6541 } 6542 6543 template <class T1, class T2> bool TypePtr::is_java_subtype_of_helper_for_instance(const T1* this_one, const T2* other, bool this_exact, bool other_exact) { 6544 static_assert(std::is_base_of<T2, T1>::value, ""); 6545 if (!this_one->is_loaded() || !other->is_loaded()) { 6546 return false; 6547 } 6548 if (!this_one->is_instance_type(other)) { 6549 return false; 6550 } 6551 6552 if (!other_exact) { 6553 return false; 6554 } 6555 6556 if (other->klass()->equals(ciEnv::current()->Object_klass()) && other->_interfaces->empty()) { 6557 return true; 6558 } 6559 6560 return this_one->klass()->is_subtype_of(other->klass()) && this_one->_interfaces->contains(other->_interfaces); 6561 } 6562 6563 bool TypeInstKlassPtr::might_be_an_array() const { 6564 if (!instance_klass()->is_java_lang_Object()) { 6565 // TypeInstKlassPtr can be an array only if it is java.lang.Object: the only supertype of array types. 6566 return false; 6567 } 6568 if (interfaces()->has_non_array_interface()) { 6569 // Arrays only implement Cloneable and Serializable. If we see any other interface, [this] cannot be an array. 6570 return false; 6571 } 6572 // Cannot prove it's not an array. 6573 return true; 6574 } 6575 6576 bool TypeInstKlassPtr::is_java_subtype_of_helper(const TypeKlassPtr* other, bool this_exact, bool other_exact) const { 6577 return TypePtr::is_java_subtype_of_helper_for_instance(this, other, this_exact, other_exact); 6578 } 6579 6580 template <class T1, class T2> bool TypePtr::is_same_java_type_as_helper_for_instance(const T1* this_one, const T2* other) { 6581 static_assert(std::is_base_of<T2, T1>::value, ""); 6582 if (!this_one->is_loaded() || !other->is_loaded()) { 6583 return false; 6584 } 6585 if (!this_one->is_instance_type(other)) { 6586 return false; 6587 } 6588 return this_one->klass()->equals(other->klass()) && this_one->_interfaces->eq(other->_interfaces); 6589 } 6590 6591 bool TypeInstKlassPtr::is_same_java_type_as_helper(const TypeKlassPtr* other) const { 6592 return TypePtr::is_same_java_type_as_helper_for_instance(this, other); 6593 } 6594 6595 template <class T1, class T2> bool TypePtr::maybe_java_subtype_of_helper_for_instance(const T1* this_one, const T2* other, bool this_exact, bool other_exact) { 6596 static_assert(std::is_base_of<T2, T1>::value, ""); 6597 if (!this_one->is_loaded() || !other->is_loaded()) { 6598 return true; 6599 } 6600 6601 if (this_one->is_array_type(other)) { 6602 return !this_exact && this_one->klass()->equals(ciEnv::current()->Object_klass()) && other->_interfaces->contains(this_one->_interfaces); 6603 } 6604 6605 assert(this_one->is_instance_type(other), "unsupported"); 6606 6607 if (this_exact && other_exact) { 6608 return this_one->is_java_subtype_of(other); 6609 } 6610 6611 if (!this_one->klass()->is_subtype_of(other->klass()) && !other->klass()->is_subtype_of(this_one->klass())) { 6612 return false; 6613 } 6614 6615 if (this_exact) { 6616 return this_one->klass()->is_subtype_of(other->klass()) && this_one->_interfaces->contains(other->_interfaces); 6617 } 6618 6619 return true; 6620 } 6621 6622 bool TypeInstKlassPtr::maybe_java_subtype_of_helper(const TypeKlassPtr* other, bool this_exact, bool other_exact) const { 6623 return TypePtr::maybe_java_subtype_of_helper_for_instance(this, other, this_exact, other_exact); 6624 } 6625 6626 const TypeKlassPtr* TypeInstKlassPtr::try_improve() const { 6627 if (!UseUniqueSubclasses) { 6628 return this; 6629 } 6630 ciKlass* k = klass(); 6631 Compile* C = Compile::current(); 6632 Dependencies* deps = C->dependencies(); 6633 assert((deps != nullptr) == (C->method() != nullptr && C->method()->code_size() > 0), "sanity"); 6634 if (k->is_loaded()) { 6635 ciInstanceKlass* ik = k->as_instance_klass(); 6636 if (deps != nullptr) { 6637 ciInstanceKlass* sub = ik->unique_concrete_subklass(); 6638 if (sub != nullptr) { 6639 bool improve_to_exact = sub->is_final() && _ptr == NotNull; 6640 const TypeInstKlassPtr* improved = TypeInstKlassPtr::make(improve_to_exact ? Constant : _ptr, sub, _offset); 6641 if (improved->_interfaces->contains(_interfaces)) { 6642 deps->assert_abstract_with_unique_concrete_subtype(ik, sub); 6643 return improved; 6644 } 6645 } 6646 } 6647 } 6648 return this; 6649 } 6650 6651 bool TypeInstKlassPtr::can_be_inline_array() const { 6652 return _klass->equals(ciEnv::current()->Object_klass()) && TypeAryKlassPtr::_array_interfaces->contains(_interfaces); 6653 } 6654 6655 #ifndef PRODUCT 6656 void TypeInstKlassPtr::dump2(Dict& d, uint depth, outputStream* st) const { 6657 st->print("instklassptr:"); 6658 klass()->print_name_on(st); 6659 _interfaces->dump(st); 6660 st->print(":%s", ptr_msg[_ptr]); 6661 dump_offset(st); 6662 dump_flat_in_array(_flat_in_array, st); 6663 } 6664 #endif // PRODUCT 6665 6666 bool TypeAryKlassPtr::can_be_inline_array() const { 6667 return _elem->isa_instklassptr() && _elem->is_instklassptr()->_klass->can_be_inline_klass(); 6668 } 6669 6670 bool TypeInstPtr::can_be_inline_array() const { 6671 return _klass->equals(ciEnv::current()->Object_klass()) && TypeAryPtr::_array_interfaces->contains(_interfaces); 6672 } 6673 6674 bool TypeAryPtr::can_be_inline_array() const { 6675 return elem()->make_ptr() && elem()->make_ptr()->isa_instptr() && elem()->make_ptr()->is_instptr()->_klass->can_be_inline_klass(); 6676 } 6677 6678 const TypeAryKlassPtr *TypeAryKlassPtr::make(PTR ptr, const Type* elem, ciKlass* k, Offset offset, bool not_flat, bool not_null_free, bool flat, bool null_free, bool atomic, bool refined_type) { 6679 return (TypeAryKlassPtr*)(new TypeAryKlassPtr(ptr, elem, k, offset, not_flat, not_null_free, flat, null_free, atomic, refined_type))->hashcons(); 6680 } 6681 6682 const TypeAryKlassPtr* TypeAryKlassPtr::make(PTR ptr, ciKlass* k, Offset offset, InterfaceHandling interface_handling, bool not_flat, bool not_null_free, bool flat, bool null_free, bool atomic, bool refined_type) { 6683 const Type* etype; 6684 if (k->is_obj_array_klass()) { 6685 // Element is an object array. Recursively call ourself. 6686 ciKlass* eklass = k->as_obj_array_klass()->element_klass(); 6687 etype = TypeKlassPtr::make(eklass, interface_handling)->cast_to_exactness(false); 6688 k = nullptr; 6689 } else if (k->is_type_array_klass()) { 6690 // Element is an typeArray 6691 etype = get_const_basic_type(k->as_type_array_klass()->element_type()); 6692 } else { 6693 ShouldNotReachHere(); 6694 } 6695 6696 return TypeAryKlassPtr::make(ptr, etype, k, offset, not_flat, not_null_free, flat, null_free, atomic, refined_type); 6697 } 6698 6699 const TypeAryKlassPtr* TypeAryKlassPtr::make(ciKlass* klass, InterfaceHandling interface_handling) { 6700 ciArrayKlass* k = klass->as_array_klass(); 6701 if (k->is_refined()) { 6702 return TypeAryKlassPtr::make(Constant, k, Offset(0), interface_handling, !k->is_flat_array_klass(), !k->is_elem_null_free(), 6703 k->is_flat_array_klass(), k->is_elem_null_free(), k->is_elem_atomic(), true); 6704 } else { 6705 // Use the default combination to canonicalize all non-refined klass pointers 6706 return TypeAryKlassPtr::make(Constant, k, Offset(0), interface_handling, true, true, false, false, true, false); 6707 } 6708 } 6709 6710 const TypeAryKlassPtr* TypeAryKlassPtr::cast_to_non_refined() const { 6711 assert(is_refined_type(), "must be a refined type"); 6712 PTR ptr = _ptr; 6713 // There can be multiple refined array types corresponding to a single unrefined type 6714 if (ptr == NotNull && elem()->is_klassptr()->klass_is_exact()) { 6715 ptr = Constant; 6716 } 6717 return make(ptr, elem(), nullptr, _offset, true, true, false, false, true, false); 6718 } 6719 6720 // Get the (non-)refined array klass ptr 6721 const TypeAryKlassPtr* TypeAryKlassPtr::cast_to_refined_array_klass_ptr(bool refined) const { 6722 if ((refined == is_refined_type()) || !klass_is_exact() || !exact_klass()->is_obj_array_klass()) { 6723 return this; 6724 } 6725 ciArrayKlass* k = exact_klass()->as_array_klass(); 6726 k = ciObjArrayKlass::make(k->element_klass(), refined); 6727 return make(k, trust_interfaces); 6728 } 6729 6730 //------------------------------eq--------------------------------------------- 6731 // Structural equality check for Type representations 6732 bool TypeAryKlassPtr::eq(const Type *t) const { 6733 const TypeAryKlassPtr *p = t->is_aryklassptr(); 6734 return 6735 _elem == p->_elem && // Check array 6736 _flat == p->_flat && 6737 _not_flat == p->_not_flat && 6738 _null_free == p->_null_free && 6739 _not_null_free == p->_not_null_free && 6740 _atomic == p->_atomic && 6741 _refined_type == p->_refined_type && 6742 TypeKlassPtr::eq(p); // Check sub-parts 6743 } 6744 6745 //------------------------------hash------------------------------------------- 6746 // Type-specific hashing function. 6747 uint TypeAryKlassPtr::hash(void) const { 6748 return (uint)(uintptr_t)_elem + TypeKlassPtr::hash() + (uint)(_not_flat ? 43 : 0) + 6749 (uint)(_not_null_free ? 44 : 0) + (uint)(_flat ? 45 : 0) + (uint)(_null_free ? 46 : 0) + (uint)(_atomic ? 47 : 0) + (uint)(_refined_type ? 48 : 0); 6750 } 6751 6752 //----------------------compute_klass------------------------------------------ 6753 // Compute the defining klass for this class 6754 ciKlass* TypeAryPtr::compute_klass() const { 6755 // Compute _klass based on element type. 6756 ciKlass* k_ary = nullptr; 6757 const TypeInstPtr *tinst; 6758 const TypeAryPtr *tary; 6759 const Type* el = elem(); 6760 if (el->isa_narrowoop()) { 6761 el = el->make_ptr(); 6762 } 6763 6764 // Get element klass 6765 if ((tinst = el->isa_instptr()) != nullptr) { 6766 // Leave k_ary at nullptr. 6767 } else if ((tary = el->isa_aryptr()) != nullptr) { 6768 // Leave k_ary at nullptr. 6769 } else if ((el->base() == Type::Top) || 6770 (el->base() == Type::Bottom)) { 6771 // element type of Bottom occurs from meet of basic type 6772 // and object; Top occurs when doing join on Bottom. 6773 // Leave k_ary at null. 6774 } else { 6775 assert(!el->isa_int(), "integral arrays must be pre-equipped with a class"); 6776 // Compute array klass directly from basic type 6777 k_ary = ciTypeArrayKlass::make(el->basic_type()); 6778 } 6779 return k_ary; 6780 } 6781 6782 //------------------------------klass------------------------------------------ 6783 // Return the defining klass for this class 6784 ciKlass* TypeAryPtr::klass() const { 6785 if( _klass ) return _klass; // Return cached value, if possible 6786 6787 // Oops, need to compute _klass and cache it 6788 ciKlass* k_ary = compute_klass(); 6789 6790 if( this != TypeAryPtr::OOPS && this->dual() != TypeAryPtr::OOPS ) { 6791 // The _klass field acts as a cache of the underlying 6792 // ciKlass for this array type. In order to set the field, 6793 // we need to cast away const-ness. 6794 // 6795 // IMPORTANT NOTE: we *never* set the _klass field for the 6796 // type TypeAryPtr::OOPS. This Type is shared between all 6797 // active compilations. However, the ciKlass which represents 6798 // this Type is *not* shared between compilations, so caching 6799 // this value would result in fetching a dangling pointer. 6800 // 6801 // Recomputing the underlying ciKlass for each request is 6802 // a bit less efficient than caching, but calls to 6803 // TypeAryPtr::OOPS->klass() are not common enough to matter. 6804 ((TypeAryPtr*)this)->_klass = k_ary; 6805 } 6806 return k_ary; 6807 } 6808 6809 // Is there a single ciKlass* that can represent that type? 6810 ciKlass* TypeAryPtr::exact_klass_helper() const { 6811 if (_ary->_elem->make_ptr() && _ary->_elem->make_ptr()->isa_oopptr()) { 6812 ciKlass* k = _ary->_elem->make_ptr()->is_oopptr()->exact_klass_helper(); 6813 if (k == nullptr) { 6814 return nullptr; 6815 } 6816 if (k->is_array_klass() && k->as_array_klass()->is_refined()) { 6817 // We have no mechanism to create an array of refined arrays 6818 k = ciObjArrayKlass::make(k->as_array_klass()->element_klass(), false); 6819 } 6820 if (klass_is_exact()) { 6821 return ciObjArrayKlass::make(k, true, is_null_free(), is_atomic()); 6822 } else { 6823 // We may reach here if called recursively, must be an unrefined type then 6824 return ciObjArrayKlass::make(k, false); 6825 } 6826 } 6827 6828 return klass(); 6829 } 6830 6831 const Type* TypeAryPtr::base_element_type(int& dims) const { 6832 const Type* elem = this->elem(); 6833 dims = 1; 6834 while (elem->make_ptr() && elem->make_ptr()->isa_aryptr()) { 6835 elem = elem->make_ptr()->is_aryptr()->elem(); 6836 dims++; 6837 } 6838 return elem; 6839 } 6840 6841 //------------------------------add_offset------------------------------------- 6842 // Access internals of klass object 6843 const TypePtr* TypeAryKlassPtr::add_offset(intptr_t offset) const { 6844 return make(_ptr, elem(), klass(), xadd_offset(offset), is_not_flat(), is_not_null_free(), _flat, _null_free, _atomic, _refined_type); 6845 } 6846 6847 const TypeAryKlassPtr* TypeAryKlassPtr::with_offset(intptr_t offset) const { 6848 return make(_ptr, elem(), klass(), Offset(offset), is_not_flat(), is_not_null_free(), _flat, _null_free, _atomic, _refined_type); 6849 } 6850 6851 //------------------------------cast_to_ptr_type------------------------------- 6852 const TypeAryKlassPtr* TypeAryKlassPtr::cast_to_ptr_type(PTR ptr) const { 6853 assert(_base == AryKlassPtr, "subclass must override cast_to_ptr_type"); 6854 if (ptr == _ptr) return this; 6855 return make(ptr, elem(), _klass, _offset, is_not_flat(), is_not_null_free(), _flat, _null_free, _atomic, _refined_type); 6856 } 6857 6858 bool TypeAryKlassPtr::must_be_exact() const { 6859 assert(klass_is_exact(), "precondition"); 6860 if (_elem == Type::BOTTOM || _elem == Type::TOP) { 6861 return false; 6862 } 6863 const TypeKlassPtr* elem = _elem->isa_klassptr(); 6864 if (elem == nullptr) { 6865 // primitive arrays 6866 return true; 6867 } 6868 6869 // refined types are final 6870 return _refined_type; 6871 } 6872 6873 //-----------------------------cast_to_exactness------------------------------- 6874 const TypeKlassPtr *TypeAryKlassPtr::cast_to_exactness(bool klass_is_exact) const { 6875 if (klass_is_exact == this->klass_is_exact()) { 6876 return this; 6877 } 6878 if (!klass_is_exact && must_be_exact()) { 6879 return this; 6880 } 6881 const Type* elem = this->elem(); 6882 if (elem->isa_klassptr() && !klass_is_exact) { 6883 elem = elem->is_klassptr()->cast_to_exactness(klass_is_exact); 6884 } 6885 6886 if (klass_is_exact) { 6887 // cast_to_exactness(true) really means get the LCA of all values represented by this 6888 // TypeAryKlassPtr. As a result, it must be an unrefined klass pointer. 6889 return make(Constant, elem, nullptr, _offset, true, true, false, false, true, false); 6890 } else { 6891 // cast_to_exactness(false) means get the TypeAryKlassPtr representing all values that subtype 6892 // this value 6893 bool not_inline = !_elem->isa_instklassptr() || !_elem->is_instklassptr()->instance_klass()->can_be_inline_klass(); 6894 bool not_flat = !UseArrayFlattening || not_inline || 6895 (_elem->isa_instklassptr() && _elem->is_instklassptr()->instance_klass()->is_inlinetype() && !_elem->is_instklassptr()->instance_klass()->maybe_flat_in_array()); 6896 bool not_null_free = not_inline; 6897 bool atomic = not_flat; 6898 return make(NotNull, elem, nullptr, _offset, not_flat, not_null_free, false, false, atomic, false); 6899 } 6900 } 6901 6902 //-----------------------------as_instance_type-------------------------------- 6903 // Corresponding type for an instance of the given class. 6904 // It will be NotNull, and exact if and only if the klass type is exact. 6905 const TypeOopPtr* TypeAryKlassPtr::as_instance_type(bool klass_change) const { 6906 ciKlass* k = klass(); 6907 bool xk = klass_is_exact(); 6908 const Type* el = nullptr; 6909 if (elem()->isa_klassptr()) { 6910 el = elem()->is_klassptr()->as_instance_type(false)->cast_to_exactness(false); 6911 k = nullptr; 6912 } else { 6913 el = elem(); 6914 } 6915 bool null_free = _null_free; 6916 if (null_free && el->isa_ptr()) { 6917 el = el->is_ptr()->join_speculative(TypePtr::NOTNULL); 6918 } 6919 return TypeAryPtr::make(TypePtr::BotPTR, TypeAry::make(el, TypeInt::POS, false, is_flat(), is_not_flat(), is_not_null_free(), is_atomic()), k, xk, Offset(0)); 6920 } 6921 6922 6923 //------------------------------xmeet------------------------------------------ 6924 // Compute the MEET of two types, return a new Type object. 6925 const Type *TypeAryKlassPtr::xmeet( const Type *t ) const { 6926 // Perform a fast test for common case; meeting the same types together. 6927 if( this == t ) return this; // Meeting same type-rep? 6928 6929 // Current "this->_base" is Pointer 6930 switch (t->base()) { // switch on original type 6931 6932 case Int: // Mixing ints & oops happens when javac 6933 case Long: // reuses local variables 6934 case HalfFloatTop: 6935 case HalfFloatCon: 6936 case HalfFloatBot: 6937 case FloatTop: 6938 case FloatCon: 6939 case FloatBot: 6940 case DoubleTop: 6941 case DoubleCon: 6942 case DoubleBot: 6943 case NarrowOop: 6944 case NarrowKlass: 6945 case Bottom: // Ye Olde Default 6946 return Type::BOTTOM; 6947 case Top: 6948 return this; 6949 6950 default: // All else is a mistake 6951 typerr(t); 6952 6953 case AnyPtr: { // Meeting to AnyPtrs 6954 // Found an AnyPtr type vs self-KlassPtr type 6955 const TypePtr *tp = t->is_ptr(); 6956 Offset offset = meet_offset(tp->offset()); 6957 PTR ptr = meet_ptr(tp->ptr()); 6958 switch (tp->ptr()) { 6959 case TopPTR: 6960 return this; 6961 case Null: 6962 if( ptr == Null ) return TypePtr::make(AnyPtr, ptr, offset, tp->speculative(), tp->inline_depth()); 6963 case AnyNull: 6964 return make(ptr, _elem, klass(), offset, is_not_flat(), is_not_null_free(), is_flat(), is_null_free(), is_atomic(), is_refined_type()); 6965 case BotPTR: 6966 case NotNull: 6967 return TypePtr::make(AnyPtr, ptr, offset, tp->speculative(), tp->inline_depth()); 6968 default: typerr(t); 6969 } 6970 } 6971 6972 case RawPtr: 6973 case MetadataPtr: 6974 case OopPtr: 6975 case AryPtr: // Meet with AryPtr 6976 case InstPtr: // Meet with InstPtr 6977 return TypePtr::BOTTOM; 6978 6979 // 6980 // A-top } 6981 // / | \ } Tops 6982 // B-top A-any C-top } 6983 // | / | \ | } Any-nulls 6984 // B-any | C-any } 6985 // | | | 6986 // B-con A-con C-con } constants; not comparable across classes 6987 // | | | 6988 // B-not | C-not } 6989 // | \ | / | } not-nulls 6990 // B-bot A-not C-bot } 6991 // \ | / } Bottoms 6992 // A-bot } 6993 // 6994 6995 case AryKlassPtr: { // Meet two KlassPtr types 6996 const TypeAryKlassPtr *tap = t->is_aryklassptr(); 6997 Offset off = meet_offset(tap->offset()); 6998 const Type* elem = _elem->meet(tap->_elem); 6999 PTR ptr = meet_ptr(tap->ptr()); 7000 ciKlass* res_klass = nullptr; 7001 bool res_xk = false; 7002 bool res_flat = false; 7003 bool res_not_flat = false; 7004 bool res_not_null_free = false; 7005 bool res_atomic = false; 7006 MeetResult res = meet_aryptr(ptr, elem, this, tap, 7007 res_klass, res_xk, res_flat, res_not_flat, res_not_null_free, res_atomic); 7008 assert(res_xk == (ptr == Constant), ""); 7009 bool flat = meet_flat(tap->_flat); 7010 bool null_free = meet_null_free(tap->_null_free); 7011 bool atomic = meet_atomic(tap->_atomic); 7012 bool refined_type = _refined_type && tap->_refined_type; 7013 if (res == NOT_SUBTYPE) { 7014 flat = false; 7015 null_free = false; 7016 atomic = false; 7017 refined_type = false; 7018 } else if (res == SUBTYPE) { 7019 if (above_centerline(tap->ptr()) && !above_centerline(this->ptr())) { 7020 flat = _flat; 7021 null_free = _null_free; 7022 atomic = _atomic; 7023 refined_type = _refined_type; 7024 } else if (above_centerline(this->ptr()) && !above_centerline(tap->ptr())) { 7025 flat = tap->_flat; 7026 null_free = tap->_null_free; 7027 atomic = tap->_atomic; 7028 refined_type = tap->_refined_type; 7029 } else if (above_centerline(this->ptr()) && above_centerline(tap->ptr())) { 7030 flat = _flat || tap->_flat; 7031 null_free = _null_free || tap->_null_free; 7032 atomic = _atomic || tap->_atomic; 7033 refined_type = _refined_type || tap->_refined_type; 7034 } else if (res_xk && _refined_type != tap->_refined_type) { 7035 // This can happen if the phi emitted by LibraryCallKit::load_default_refined_array_klass/load_non_refined_array_klass 7036 // is processed before the typeArray guard is folded. Both inputs are constant but the input corresponding to the 7037 // typeArray will go away. Don't constant fold it yet but wait for the control input to collapse. 7038 ptr = PTR::NotNull; 7039 } 7040 } 7041 return make(ptr, elem, res_klass, off, res_not_flat, res_not_null_free, flat, null_free, atomic, refined_type); 7042 } // End of case KlassPtr 7043 case InstKlassPtr: { 7044 const TypeInstKlassPtr *tp = t->is_instklassptr(); 7045 Offset offset = meet_offset(tp->offset()); 7046 PTR ptr = meet_ptr(tp->ptr()); 7047 const TypeInterfaces* interfaces = meet_interfaces(tp); 7048 const TypeInterfaces* tp_interfaces = tp->_interfaces; 7049 const TypeInterfaces* this_interfaces = _interfaces; 7050 7051 switch (ptr) { 7052 case TopPTR: 7053 case AnyNull: // Fall 'down' to dual of object klass 7054 // For instances when a subclass meets a superclass we fall 7055 // below the centerline when the superclass is exact. We need to 7056 // do the same here. 7057 // 7058 // Flat in array: See explanation for meet with TypeInstPtr in TypeAryPtr::xmeet_helper(). 7059 if (tp->klass()->equals(ciEnv::current()->Object_klass()) && this_interfaces->contains(tp_interfaces) && 7060 !tp->klass_is_exact() && !tp->is_not_flat_in_array()) { 7061 return TypeAryKlassPtr::make(ptr, _elem, _klass, offset, is_not_flat(), is_not_null_free(), is_flat(), is_null_free(), is_atomic(), is_refined_type()); 7062 } else { 7063 // cannot subclass, so the meet has to fall badly below the centerline 7064 ptr = NotNull; 7065 interfaces = this_interfaces->intersection_with(tp->_interfaces); 7066 FlatInArray flat_in_array = meet_flat_in_array(NotFlat, tp->flat_in_array()); 7067 return TypeInstKlassPtr::make(ptr, ciEnv::current()->Object_klass(), interfaces, offset, flat_in_array); 7068 } 7069 case Constant: 7070 case NotNull: 7071 case BotPTR: { // Fall down to object klass 7072 // LCA is object_klass, but if we subclass from the top we can do better 7073 if (above_centerline(tp->ptr())) { 7074 // If 'tp' is above the centerline and it is Object class 7075 // then we can subclass in the Java class hierarchy. 7076 // For instances when a subclass meets a superclass we fall 7077 // below the centerline when the superclass is exact. We need 7078 // to do the same here. 7079 // 7080 // Flat in array: See explanation for meet with TypeInstPtr in TypeAryPtr::xmeet_helper(). 7081 if (tp->klass()->equals(ciEnv::current()->Object_klass()) && this_interfaces->contains(tp_interfaces) && 7082 !tp->klass_is_exact() && !tp->is_not_flat_in_array()) { 7083 // that is, my array type is a subtype of 'tp' klass 7084 return make(ptr, _elem, _klass, offset, is_not_flat(), is_not_null_free(), is_flat(), is_null_free(), is_atomic(), is_refined_type()); 7085 } 7086 } 7087 // The other case cannot happen, since t cannot be a subtype of an array. 7088 // The meet falls down to Object class below centerline. 7089 if (ptr == Constant) 7090 ptr = NotNull; 7091 interfaces = this_interfaces->intersection_with(tp_interfaces); 7092 FlatInArray flat_in_array = meet_flat_in_array(NotFlat, tp->flat_in_array()); 7093 return TypeInstKlassPtr::make(ptr, ciEnv::current()->Object_klass(), interfaces, offset, tp->flat_in_array()); 7094 } 7095 default: typerr(t); 7096 } 7097 } 7098 7099 } // End of switch 7100 return this; // Return the double constant 7101 } 7102 7103 template <class T1, class T2> bool TypePtr::is_java_subtype_of_helper_for_array(const T1* this_one, const T2* other, bool this_exact, bool other_exact) { 7104 static_assert(std::is_base_of<T2, T1>::value, ""); 7105 7106 if (other->klass() == ciEnv::current()->Object_klass() && other->_interfaces->empty() && other_exact) { 7107 return true; 7108 } 7109 7110 int dummy; 7111 bool this_top_or_bottom = (this_one->base_element_type(dummy) == Type::TOP || this_one->base_element_type(dummy) == Type::BOTTOM); 7112 7113 if (!this_one->is_loaded() || !other->is_loaded() || this_top_or_bottom) { 7114 return false; 7115 } 7116 7117 if (this_one->is_instance_type(other)) { 7118 return other->klass() == ciEnv::current()->Object_klass() && this_one->_interfaces->contains(other->_interfaces) && 7119 other_exact; 7120 } 7121 7122 assert(this_one->is_array_type(other), ""); 7123 const T1* other_ary = this_one->is_array_type(other); 7124 bool other_top_or_bottom = (other_ary->base_element_type(dummy) == Type::TOP || other_ary->base_element_type(dummy) == Type::BOTTOM); 7125 if (other_top_or_bottom) { 7126 return false; 7127 } 7128 7129 const TypePtr* other_elem = other_ary->elem()->make_ptr(); 7130 const TypePtr* this_elem = this_one->elem()->make_ptr(); 7131 if (this_elem != nullptr && other_elem != nullptr) { 7132 if (other->is_null_free() && !this_one->is_null_free()) { 7133 return false; // A nullable array can't be a subtype of a null-free array 7134 } 7135 return this_one->is_reference_type(this_elem)->is_java_subtype_of_helper(this_one->is_reference_type(other_elem), this_exact, other_exact); 7136 } 7137 if (this_elem == nullptr && other_elem == nullptr) { 7138 return this_one->klass()->is_subtype_of(other->klass()); 7139 } 7140 return false; 7141 } 7142 7143 bool TypeAryKlassPtr::is_java_subtype_of_helper(const TypeKlassPtr* other, bool this_exact, bool other_exact) const { 7144 return TypePtr::is_java_subtype_of_helper_for_array(this, other, this_exact, other_exact); 7145 } 7146 7147 template <class T1, class T2> bool TypePtr::is_same_java_type_as_helper_for_array(const T1* this_one, const T2* other) { 7148 static_assert(std::is_base_of<T2, T1>::value, ""); 7149 7150 int dummy; 7151 bool this_top_or_bottom = (this_one->base_element_type(dummy) == Type::TOP || this_one->base_element_type(dummy) == Type::BOTTOM); 7152 7153 if (!this_one->is_array_type(other) || 7154 !this_one->is_loaded() || !other->is_loaded() || this_top_or_bottom) { 7155 return false; 7156 } 7157 const T1* other_ary = this_one->is_array_type(other); 7158 bool other_top_or_bottom = (other_ary->base_element_type(dummy) == Type::TOP || other_ary->base_element_type(dummy) == Type::BOTTOM); 7159 7160 if (other_top_or_bottom) { 7161 return false; 7162 } 7163 7164 const TypePtr* other_elem = other_ary->elem()->make_ptr(); 7165 const TypePtr* this_elem = this_one->elem()->make_ptr(); 7166 if (other_elem != nullptr && this_elem != nullptr) { 7167 return this_one->is_reference_type(this_elem)->is_same_java_type_as(this_one->is_reference_type(other_elem)); 7168 } 7169 if (other_elem == nullptr && this_elem == nullptr) { 7170 return this_one->klass()->equals(other->klass()); 7171 } 7172 return false; 7173 } 7174 7175 bool TypeAryKlassPtr::is_same_java_type_as_helper(const TypeKlassPtr* other) const { 7176 return TypePtr::is_same_java_type_as_helper_for_array(this, other); 7177 } 7178 7179 template <class T1, class T2> bool TypePtr::maybe_java_subtype_of_helper_for_array(const T1* this_one, const T2* other, bool this_exact, bool other_exact) { 7180 static_assert(std::is_base_of<T2, T1>::value, ""); 7181 if (other->klass() == ciEnv::current()->Object_klass() && other->_interfaces->empty() && other_exact) { 7182 return true; 7183 } 7184 if (!this_one->is_loaded() || !other->is_loaded()) { 7185 return true; 7186 } 7187 if (this_one->is_instance_type(other)) { 7188 return other->klass()->equals(ciEnv::current()->Object_klass()) && 7189 this_one->_interfaces->contains(other->_interfaces); 7190 } 7191 7192 int dummy; 7193 bool this_top_or_bottom = (this_one->base_element_type(dummy) == Type::TOP || this_one->base_element_type(dummy) == Type::BOTTOM); 7194 if (this_top_or_bottom) { 7195 return true; 7196 } 7197 7198 assert(this_one->is_array_type(other), ""); 7199 7200 const T1* other_ary = this_one->is_array_type(other); 7201 bool other_top_or_bottom = (other_ary->base_element_type(dummy) == Type::TOP || other_ary->base_element_type(dummy) == Type::BOTTOM); 7202 if (other_top_or_bottom) { 7203 return true; 7204 } 7205 if (this_exact && other_exact) { 7206 return this_one->is_java_subtype_of(other); 7207 } 7208 7209 const TypePtr* this_elem = this_one->elem()->make_ptr(); 7210 const TypePtr* other_elem = other_ary->elem()->make_ptr(); 7211 if (other_elem != nullptr && this_elem != nullptr) { 7212 return this_one->is_reference_type(this_elem)->maybe_java_subtype_of_helper(this_one->is_reference_type(other_elem), this_exact, other_exact); 7213 } 7214 if (other_elem == nullptr && this_elem == nullptr) { 7215 return this_one->klass()->is_subtype_of(other->klass()); 7216 } 7217 return false; 7218 } 7219 7220 bool TypeAryKlassPtr::maybe_java_subtype_of_helper(const TypeKlassPtr* other, bool this_exact, bool other_exact) const { 7221 return TypePtr::maybe_java_subtype_of_helper_for_array(this, other, this_exact, other_exact); 7222 } 7223 7224 //------------------------------xdual------------------------------------------ 7225 // Dual: compute field-by-field dual 7226 const Type *TypeAryKlassPtr::xdual() const { 7227 return new TypeAryKlassPtr(dual_ptr(), elem()->dual(), klass(), dual_offset(), !is_not_flat(), !is_not_null_free(), dual_flat(), dual_null_free(), dual_atomic(), _refined_type); 7228 } 7229 7230 // Is there a single ciKlass* that can represent that type? 7231 ciKlass* TypeAryKlassPtr::exact_klass_helper() const { 7232 if (elem()->isa_klassptr()) { 7233 ciKlass* k = elem()->is_klassptr()->exact_klass_helper(); 7234 if (k == nullptr) { 7235 return nullptr; 7236 } 7237 assert(!k->is_array_klass() || !k->as_array_klass()->is_refined(), "no mechanism to create an array of refined arrays %s", k->name()->as_utf8()); 7238 k = ciArrayKlass::make(k, is_null_free(), is_atomic(), _refined_type); 7239 return k; 7240 } 7241 7242 return klass(); 7243 } 7244 7245 ciKlass* TypeAryKlassPtr::klass() const { 7246 if (_klass != nullptr) { 7247 return _klass; 7248 } 7249 ciKlass* k = nullptr; 7250 if (elem()->isa_klassptr()) { 7251 // leave null 7252 } else if ((elem()->base() == Type::Top) || 7253 (elem()->base() == Type::Bottom)) { 7254 } else { 7255 k = ciTypeArrayKlass::make(elem()->basic_type()); 7256 ((TypeAryKlassPtr*)this)->_klass = k; 7257 } 7258 return k; 7259 } 7260 7261 //------------------------------dump2------------------------------------------ 7262 // Dump Klass Type 7263 #ifndef PRODUCT 7264 void TypeAryKlassPtr::dump2( Dict & d, uint depth, outputStream *st ) const { 7265 st->print("aryklassptr:["); 7266 _elem->dump2(d, depth, st); 7267 _interfaces->dump(st); 7268 st->print(":%s", ptr_msg[_ptr]); 7269 if (_flat) st->print(":flat"); 7270 if (_null_free) st->print(":null free"); 7271 if (_atomic) st->print(":atomic"); 7272 if (_refined_type) st->print(":refined_type"); 7273 if (Verbose) { 7274 if (_not_flat) st->print(":not flat"); 7275 if (_not_null_free) st->print(":nullable"); 7276 } 7277 dump_offset(st); 7278 } 7279 #endif 7280 7281 const Type* TypeAryKlassPtr::base_element_type(int& dims) const { 7282 const Type* elem = this->elem(); 7283 dims = 1; 7284 while (elem->isa_aryklassptr()) { 7285 elem = elem->is_aryklassptr()->elem(); 7286 dims++; 7287 } 7288 return elem; 7289 } 7290 7291 //============================================================================= 7292 // Convenience common pre-built types. 7293 7294 //------------------------------make------------------------------------------- 7295 const TypeFunc *TypeFunc::make(const TypeTuple *domain_sig, const TypeTuple* domain_cc, 7296 const TypeTuple *range_sig, const TypeTuple *range_cc) { 7297 return (TypeFunc*)(new TypeFunc(domain_sig, domain_cc, range_sig, range_cc))->hashcons(); 7298 } 7299 7300 const TypeFunc *TypeFunc::make(const TypeTuple *domain, const TypeTuple *range) { 7301 return make(domain, domain, range, range); 7302 } 7303 7304 //------------------------------osr_domain----------------------------- 7305 const TypeTuple* osr_domain() { 7306 const Type **fields = TypeTuple::fields(2); 7307 fields[TypeFunc::Parms+0] = TypeRawPtr::BOTTOM; // address of osr buffer 7308 return TypeTuple::make(TypeFunc::Parms+1, fields); 7309 } 7310 7311 //------------------------------make------------------------------------------- 7312 const TypeFunc* TypeFunc::make(ciMethod* method, bool is_osr_compilation) { 7313 Compile* C = Compile::current(); 7314 const TypeFunc* tf = nullptr; 7315 if (!is_osr_compilation) { 7316 tf = C->last_tf(method); // check cache 7317 if (tf != nullptr) return tf; // The hit rate here is almost 50%. 7318 } 7319 // Inline types are not passed/returned by reference, instead each field of 7320 // the inline type is passed/returned as an argument. We maintain two views of 7321 // the argument/return list here: one based on the signature (with an inline 7322 // type argument/return as a single slot), one based on the actual calling 7323 // convention (with an inline type argument/return as a list of its fields). 7324 bool has_scalar_args = method->has_scalarized_args() && !is_osr_compilation; 7325 // Fall back to the non-scalarized calling convention when compiling a call via a mismatching method 7326 if (method != C->method() && method->get_Method()->mismatch()) { 7327 has_scalar_args = false; 7328 } 7329 const TypeTuple* domain_sig = is_osr_compilation ? osr_domain() : TypeTuple::make_domain(method, ignore_interfaces, false); 7330 const TypeTuple* domain_cc = has_scalar_args ? TypeTuple::make_domain(method, ignore_interfaces, true) : domain_sig; 7331 ciSignature* sig = method->signature(); 7332 bool has_scalar_ret = !method->is_native() && sig->return_type()->is_inlinetype() && sig->return_type()->as_inline_klass()->can_be_returned_as_fields(); 7333 const TypeTuple* range_sig = TypeTuple::make_range(sig, ignore_interfaces, false); 7334 const TypeTuple* range_cc = has_scalar_ret ? TypeTuple::make_range(sig, ignore_interfaces, true) : range_sig; 7335 tf = TypeFunc::make(domain_sig, domain_cc, range_sig, range_cc); 7336 if (!is_osr_compilation) { 7337 C->set_last_tf(method, tf); // fill cache 7338 } 7339 return tf; 7340 } 7341 7342 //------------------------------meet------------------------------------------- 7343 // Compute the MEET of two types. It returns a new Type object. 7344 const Type *TypeFunc::xmeet( const Type *t ) const { 7345 // Perform a fast test for common case; meeting the same types together. 7346 if( this == t ) return this; // Meeting same type-rep? 7347 7348 // Current "this->_base" is Func 7349 switch (t->base()) { // switch on original type 7350 7351 case Bottom: // Ye Olde Default 7352 return t; 7353 7354 default: // All else is a mistake 7355 typerr(t); 7356 7357 case Top: 7358 break; 7359 } 7360 return this; // Return the double constant 7361 } 7362 7363 //------------------------------xdual------------------------------------------ 7364 // Dual: compute field-by-field dual 7365 const Type *TypeFunc::xdual() const { 7366 return this; 7367 } 7368 7369 //------------------------------eq--------------------------------------------- 7370 // Structural equality check for Type representations 7371 bool TypeFunc::eq( const Type *t ) const { 7372 const TypeFunc *a = (const TypeFunc*)t; 7373 return _domain_sig == a->_domain_sig && 7374 _domain_cc == a->_domain_cc && 7375 _range_sig == a->_range_sig && 7376 _range_cc == a->_range_cc; 7377 } 7378 7379 //------------------------------hash------------------------------------------- 7380 // Type-specific hashing function. 7381 uint TypeFunc::hash(void) const { 7382 return (uint)(intptr_t)_domain_sig + (uint)(intptr_t)_domain_cc + (uint)(intptr_t)_range_sig + (uint)(intptr_t)_range_cc; 7383 } 7384 7385 //------------------------------dump2------------------------------------------ 7386 // Dump Function Type 7387 #ifndef PRODUCT 7388 void TypeFunc::dump2( Dict &d, uint depth, outputStream *st ) const { 7389 if( _range_sig->cnt() <= Parms ) 7390 st->print("void"); 7391 else { 7392 uint i; 7393 for (i = Parms; i < _range_sig->cnt()-1; i++) { 7394 _range_sig->field_at(i)->dump2(d,depth,st); 7395 st->print("/"); 7396 } 7397 _range_sig->field_at(i)->dump2(d,depth,st); 7398 } 7399 st->print(" "); 7400 st->print("( "); 7401 if( !depth || d[this] ) { // Check for recursive dump 7402 st->print("...)"); 7403 return; 7404 } 7405 d.Insert((void*)this,(void*)this); // Stop recursion 7406 if (Parms < _domain_sig->cnt()) 7407 _domain_sig->field_at(Parms)->dump2(d,depth-1,st); 7408 for (uint i = Parms+1; i < _domain_sig->cnt(); i++) { 7409 st->print(", "); 7410 _domain_sig->field_at(i)->dump2(d,depth-1,st); 7411 } 7412 st->print(" )"); 7413 } 7414 #endif 7415 7416 //------------------------------singleton-------------------------------------- 7417 // TRUE if Type is a singleton type, FALSE otherwise. Singletons are simple 7418 // constants (Ldi nodes). Singletons are integer, float or double constants 7419 // or a single symbol. 7420 bool TypeFunc::singleton(void) const { 7421 return false; // Never a singleton 7422 } 7423 7424 bool TypeFunc::empty(void) const { 7425 return false; // Never empty 7426 } 7427 7428 7429 BasicType TypeFunc::return_type() const{ 7430 if (range_sig()->cnt() == TypeFunc::Parms) { 7431 return T_VOID; 7432 } 7433 return range_sig()->field_at(TypeFunc::Parms)->basic_type(); 7434 } --- EOF ---