246 assert(phase->C->get_alias_index(t) == phase->C->get_alias_index(t_adr), "correct memory chain");
247 }
248 }
249 return result;
250 }
251
252 static Node *step_through_mergemem(PhaseGVN *phase, MergeMemNode *mmem, const TypePtr *tp, const TypePtr *adr_check, outputStream *st) {
253 uint alias_idx = phase->C->get_alias_index(tp);
254 Node *mem = mmem;
255 #ifdef ASSERT
256 {
257 // Check that current type is consistent with the alias index used during graph construction
258 assert(alias_idx >= Compile::AliasIdxRaw, "must not be a bad alias_idx");
259 bool consistent = adr_check == nullptr || adr_check->empty() ||
260 phase->C->must_alias(adr_check, alias_idx );
261 // Sometimes dead array references collapse to a[-1], a[-2], or a[-3]
262 if( !consistent && adr_check != nullptr && !adr_check->empty() &&
263 tp->isa_aryptr() && tp->offset() == Type::OffsetBot &&
264 adr_check->isa_aryptr() && adr_check->offset() != Type::OffsetBot &&
265 ( adr_check->offset() == arrayOopDesc::length_offset_in_bytes() ||
266 adr_check->offset() == oopDesc::klass_offset_in_bytes() ||
267 adr_check->offset() == oopDesc::mark_offset_in_bytes() ) ) {
268 // don't assert if it is dead code.
269 consistent = true;
270 }
271 if( !consistent ) {
272 st->print("alias_idx==%d, adr_check==", alias_idx);
273 if( adr_check == nullptr ) {
274 st->print("null");
275 } else {
276 adr_check->dump();
277 }
278 st->cr();
279 print_alias_types();
280 assert(consistent, "adr_check must match alias idx");
281 }
282 }
283 #endif
284 // TypeOopPtr::NOTNULL+any is an OOP with unknown offset - generally
285 // means an array I have not precisely typed yet. Do not do any
286 // alias stuff with it any time soon.
1000 for (size_t i = 0; i < sizeof offsets / sizeof offsets[0]; i++) {
1001 if (offset == offsets[i]) {
1002 return true;
1003 }
1004 }
1005 }
1006
1007 return false;
1008 }
1009 #endif
1010
1011 //----------------------------LoadNode::make-----------------------------------
1012 // Polymorphic factory method:
1013 Node* LoadNode::make(PhaseGVN& gvn, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, const Type* rt, BasicType bt, MemOrd mo,
1014 ControlDependency control_dependency, bool require_atomic_access, bool unaligned, bool mismatched, bool unsafe, uint8_t barrier_data) {
1015 Compile* C = gvn.C;
1016 assert(adr->is_top() || C->get_alias_index(gvn.type(adr)->is_ptr()) == C->get_alias_index(adr_type), "adr and adr_type must agree");
1017
1018 // sanity check the alias category against the created node type
1019 assert(!(adr_type->isa_oopptr() &&
1020 adr_type->offset() == oopDesc::klass_offset_in_bytes()),
1021 "use LoadKlassNode instead");
1022 assert(!(adr_type->isa_aryptr() &&
1023 adr_type->offset() == arrayOopDesc::length_offset_in_bytes()),
1024 "use LoadRangeNode instead");
1025 // Check control edge of raw loads
1026 assert( ctl != nullptr || C->get_alias_index(adr_type) != Compile::AliasIdxRaw ||
1027 // oop will be recorded in oop map if load crosses safepoint
1028 rt->isa_oopptr() || is_immutable_value(adr),
1029 "raw memory operations should have control edge");
1030 LoadNode* load = nullptr;
1031 switch (bt) {
1032 case T_BOOLEAN: load = new LoadUBNode(ctl, mem, adr, adr_type, rt->is_int(), mo, control_dependency); break;
1033 case T_BYTE: load = new LoadBNode (ctl, mem, adr, adr_type, rt->is_int(), mo, control_dependency); break;
1034 case T_INT: load = new LoadINode (ctl, mem, adr, adr_type, rt->is_int(), mo, control_dependency); break;
1035 case T_CHAR: load = new LoadUSNode(ctl, mem, adr, adr_type, rt->is_int(), mo, control_dependency); break;
1036 case T_SHORT: load = new LoadSNode (ctl, mem, adr, adr_type, rt->is_int(), mo, control_dependency); break;
1037 case T_LONG: load = new LoadLNode (ctl, mem, adr, adr_type, rt->is_long(), mo, control_dependency, require_atomic_access); break;
1038 case T_FLOAT: load = new LoadFNode (ctl, mem, adr, adr_type, rt, mo, control_dependency); break;
1039 case T_DOUBLE: load = new LoadDNode (ctl, mem, adr, adr_type, rt, mo, control_dependency, require_atomic_access); break;
1040 case T_ADDRESS: load = new LoadPNode (ctl, mem, adr, adr_type, rt->is_ptr(), mo, control_dependency); break;
2542 // constant oop => constant klass
2543 if (offset == java_lang_Class::array_klass_offset()) {
2544 if (t->is_void()) {
2545 // We cannot create a void array. Since void is a primitive type return null
2546 // klass. Users of this result need to do a null check on the returned klass.
2547 return TypePtr::NULL_PTR;
2548 }
2549 return TypeKlassPtr::make(ciArrayKlass::make(t), Type::trust_interfaces);
2550 }
2551 if (!t->is_klass()) {
2552 // a primitive Class (e.g., int.class) has null for a klass field
2553 return TypePtr::NULL_PTR;
2554 }
2555 // Fold up the load of the hidden field
2556 return TypeKlassPtr::make(t->as_klass(), Type::trust_interfaces);
2557 }
2558 // non-constant mirror, so we can't tell what's going on
2559 }
2560 if (!tinst->is_loaded())
2561 return _type; // Bail out if not loaded
2562 if (offset == oopDesc::klass_offset_in_bytes()) {
2563 return tinst->as_klass_type(true);
2564 }
2565 }
2566
2567 // Check for loading klass from an array
2568 const TypeAryPtr *tary = tp->isa_aryptr();
2569 if (tary != nullptr &&
2570 tary->offset() == oopDesc::klass_offset_in_bytes()) {
2571 return tary->as_klass_type(true);
2572 }
2573
2574 // Check for loading klass from an array klass
2575 const TypeKlassPtr *tkls = tp->isa_klassptr();
2576 if (tkls != nullptr && !StressReflectiveCode) {
2577 if (!tkls->is_loaded())
2578 return _type; // Bail out if not loaded
2579 if (tkls->isa_aryklassptr() && tkls->is_aryklassptr()->elem()->isa_klassptr() &&
2580 tkls->offset() == in_bytes(ObjArrayKlass::element_klass_offset())) {
2581 // // Always returning precise element type is incorrect,
2582 // // e.g., element type could be object and array may contain strings
2583 // return TypeKlassPtr::make(TypePtr::Constant, elem, 0);
2584
2585 // The array's TypeKlassPtr was declared 'precise' or 'not precise'
2586 // according to the element type's subclassing.
2587 return tkls->is_aryklassptr()->elem()->isa_klassptr()->cast_to_exactness(tkls->klass_is_exact());
2588 }
2589 if (tkls->isa_instklassptr() != nullptr && tkls->klass_is_exact() &&
2590 tkls->offset() == in_bytes(Klass::super_offset())) {
2616 Node* x = LoadNode::Identity(phase);
2617 if (x != this) return x;
2618
2619 // Take apart the address into an oop and offset.
2620 // Return 'this' if we cannot.
2621 Node* adr = in(MemNode::Address);
2622 intptr_t offset = 0;
2623 Node* base = AddPNode::Ideal_base_and_offset(adr, phase, offset);
2624 if (base == nullptr) return this;
2625 const TypeOopPtr* toop = phase->type(adr)->isa_oopptr();
2626 if (toop == nullptr) return this;
2627
2628 // Step over potential GC barrier for OopHandle resolve
2629 BarrierSetC2* bs = BarrierSet::barrier_set()->barrier_set_c2();
2630 if (bs->is_gc_barrier_node(base)) {
2631 base = bs->step_over_gc_barrier(base);
2632 }
2633
2634 // We can fetch the klass directly through an AllocateNode.
2635 // This works even if the klass is not constant (clone or newArray).
2636 if (offset == oopDesc::klass_offset_in_bytes()) {
2637 Node* allocated_klass = AllocateNode::Ideal_klass(base, phase);
2638 if (allocated_klass != nullptr) {
2639 return allocated_klass;
2640 }
2641 }
2642
2643 // Simplify k.java_mirror.as_klass to plain k, where k is a Klass*.
2644 // See inline_native_Class_query for occurrences of these patterns.
2645 // Java Example: x.getClass().isAssignableFrom(y)
2646 //
2647 // This improves reflective code, often making the Class
2648 // mirror go completely dead. (Current exception: Class
2649 // mirrors may appear in debug info, but we could clean them out by
2650 // introducing a new debug info operator for Klass.java_mirror).
2651
2652 if (toop->isa_instptr() && toop->is_instptr()->instance_klass() == phase->C->env()->Class_klass()
2653 && offset == java_lang_Class::klass_offset()) {
2654 if (base->is_Load()) {
2655 Node* base2 = base->in(MemNode::Address);
2656 if (base2->is_Load()) { /* direct load of a load which is the OopHandle */
|
246 assert(phase->C->get_alias_index(t) == phase->C->get_alias_index(t_adr), "correct memory chain");
247 }
248 }
249 return result;
250 }
251
252 static Node *step_through_mergemem(PhaseGVN *phase, MergeMemNode *mmem, const TypePtr *tp, const TypePtr *adr_check, outputStream *st) {
253 uint alias_idx = phase->C->get_alias_index(tp);
254 Node *mem = mmem;
255 #ifdef ASSERT
256 {
257 // Check that current type is consistent with the alias index used during graph construction
258 assert(alias_idx >= Compile::AliasIdxRaw, "must not be a bad alias_idx");
259 bool consistent = adr_check == nullptr || adr_check->empty() ||
260 phase->C->must_alias(adr_check, alias_idx );
261 // Sometimes dead array references collapse to a[-1], a[-2], or a[-3]
262 if( !consistent && adr_check != nullptr && !adr_check->empty() &&
263 tp->isa_aryptr() && tp->offset() == Type::OffsetBot &&
264 adr_check->isa_aryptr() && adr_check->offset() != Type::OffsetBot &&
265 ( adr_check->offset() == arrayOopDesc::length_offset_in_bytes() ||
266 adr_check->offset() == Type::klass_offset() ||
267 adr_check->offset() == oopDesc::mark_offset_in_bytes() ) ) {
268 // don't assert if it is dead code.
269 consistent = true;
270 }
271 if( !consistent ) {
272 st->print("alias_idx==%d, adr_check==", alias_idx);
273 if( adr_check == nullptr ) {
274 st->print("null");
275 } else {
276 adr_check->dump();
277 }
278 st->cr();
279 print_alias_types();
280 assert(consistent, "adr_check must match alias idx");
281 }
282 }
283 #endif
284 // TypeOopPtr::NOTNULL+any is an OOP with unknown offset - generally
285 // means an array I have not precisely typed yet. Do not do any
286 // alias stuff with it any time soon.
1000 for (size_t i = 0; i < sizeof offsets / sizeof offsets[0]; i++) {
1001 if (offset == offsets[i]) {
1002 return true;
1003 }
1004 }
1005 }
1006
1007 return false;
1008 }
1009 #endif
1010
1011 //----------------------------LoadNode::make-----------------------------------
1012 // Polymorphic factory method:
1013 Node* LoadNode::make(PhaseGVN& gvn, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, const Type* rt, BasicType bt, MemOrd mo,
1014 ControlDependency control_dependency, bool require_atomic_access, bool unaligned, bool mismatched, bool unsafe, uint8_t barrier_data) {
1015 Compile* C = gvn.C;
1016 assert(adr->is_top() || C->get_alias_index(gvn.type(adr)->is_ptr()) == C->get_alias_index(adr_type), "adr and adr_type must agree");
1017
1018 // sanity check the alias category against the created node type
1019 assert(!(adr_type->isa_oopptr() &&
1020 adr_type->offset() == Type::klass_offset()),
1021 "use LoadKlassNode instead");
1022 assert(!(adr_type->isa_aryptr() &&
1023 adr_type->offset() == arrayOopDesc::length_offset_in_bytes()),
1024 "use LoadRangeNode instead");
1025 // Check control edge of raw loads
1026 assert( ctl != nullptr || C->get_alias_index(adr_type) != Compile::AliasIdxRaw ||
1027 // oop will be recorded in oop map if load crosses safepoint
1028 rt->isa_oopptr() || is_immutable_value(adr),
1029 "raw memory operations should have control edge");
1030 LoadNode* load = nullptr;
1031 switch (bt) {
1032 case T_BOOLEAN: load = new LoadUBNode(ctl, mem, adr, adr_type, rt->is_int(), mo, control_dependency); break;
1033 case T_BYTE: load = new LoadBNode (ctl, mem, adr, adr_type, rt->is_int(), mo, control_dependency); break;
1034 case T_INT: load = new LoadINode (ctl, mem, adr, adr_type, rt->is_int(), mo, control_dependency); break;
1035 case T_CHAR: load = new LoadUSNode(ctl, mem, adr, adr_type, rt->is_int(), mo, control_dependency); break;
1036 case T_SHORT: load = new LoadSNode (ctl, mem, adr, adr_type, rt->is_int(), mo, control_dependency); break;
1037 case T_LONG: load = new LoadLNode (ctl, mem, adr, adr_type, rt->is_long(), mo, control_dependency, require_atomic_access); break;
1038 case T_FLOAT: load = new LoadFNode (ctl, mem, adr, adr_type, rt, mo, control_dependency); break;
1039 case T_DOUBLE: load = new LoadDNode (ctl, mem, adr, adr_type, rt, mo, control_dependency, require_atomic_access); break;
1040 case T_ADDRESS: load = new LoadPNode (ctl, mem, adr, adr_type, rt->is_ptr(), mo, control_dependency); break;
2542 // constant oop => constant klass
2543 if (offset == java_lang_Class::array_klass_offset()) {
2544 if (t->is_void()) {
2545 // We cannot create a void array. Since void is a primitive type return null
2546 // klass. Users of this result need to do a null check on the returned klass.
2547 return TypePtr::NULL_PTR;
2548 }
2549 return TypeKlassPtr::make(ciArrayKlass::make(t), Type::trust_interfaces);
2550 }
2551 if (!t->is_klass()) {
2552 // a primitive Class (e.g., int.class) has null for a klass field
2553 return TypePtr::NULL_PTR;
2554 }
2555 // Fold up the load of the hidden field
2556 return TypeKlassPtr::make(t->as_klass(), Type::trust_interfaces);
2557 }
2558 // non-constant mirror, so we can't tell what's going on
2559 }
2560 if (!tinst->is_loaded())
2561 return _type; // Bail out if not loaded
2562 if (offset == Type::klass_offset()) {
2563 return tinst->as_klass_type(true);
2564 }
2565 }
2566
2567 // Check for loading klass from an array
2568 const TypeAryPtr *tary = tp->isa_aryptr();
2569 if (tary != nullptr &&
2570 tary->offset() == Type::klass_offset()) {
2571 return tary->as_klass_type(true);
2572 }
2573
2574 // Check for loading klass from an array klass
2575 const TypeKlassPtr *tkls = tp->isa_klassptr();
2576 if (tkls != nullptr && !StressReflectiveCode) {
2577 if (!tkls->is_loaded())
2578 return _type; // Bail out if not loaded
2579 if (tkls->isa_aryklassptr() && tkls->is_aryklassptr()->elem()->isa_klassptr() &&
2580 tkls->offset() == in_bytes(ObjArrayKlass::element_klass_offset())) {
2581 // // Always returning precise element type is incorrect,
2582 // // e.g., element type could be object and array may contain strings
2583 // return TypeKlassPtr::make(TypePtr::Constant, elem, 0);
2584
2585 // The array's TypeKlassPtr was declared 'precise' or 'not precise'
2586 // according to the element type's subclassing.
2587 return tkls->is_aryklassptr()->elem()->isa_klassptr()->cast_to_exactness(tkls->klass_is_exact());
2588 }
2589 if (tkls->isa_instklassptr() != nullptr && tkls->klass_is_exact() &&
2590 tkls->offset() == in_bytes(Klass::super_offset())) {
2616 Node* x = LoadNode::Identity(phase);
2617 if (x != this) return x;
2618
2619 // Take apart the address into an oop and offset.
2620 // Return 'this' if we cannot.
2621 Node* adr = in(MemNode::Address);
2622 intptr_t offset = 0;
2623 Node* base = AddPNode::Ideal_base_and_offset(adr, phase, offset);
2624 if (base == nullptr) return this;
2625 const TypeOopPtr* toop = phase->type(adr)->isa_oopptr();
2626 if (toop == nullptr) return this;
2627
2628 // Step over potential GC barrier for OopHandle resolve
2629 BarrierSetC2* bs = BarrierSet::barrier_set()->barrier_set_c2();
2630 if (bs->is_gc_barrier_node(base)) {
2631 base = bs->step_over_gc_barrier(base);
2632 }
2633
2634 // We can fetch the klass directly through an AllocateNode.
2635 // This works even if the klass is not constant (clone or newArray).
2636 if (offset == Type::klass_offset()) {
2637 Node* allocated_klass = AllocateNode::Ideal_klass(base, phase);
2638 if (allocated_klass != nullptr) {
2639 return allocated_klass;
2640 }
2641 }
2642
2643 // Simplify k.java_mirror.as_klass to plain k, where k is a Klass*.
2644 // See inline_native_Class_query for occurrences of these patterns.
2645 // Java Example: x.getClass().isAssignableFrom(y)
2646 //
2647 // This improves reflective code, often making the Class
2648 // mirror go completely dead. (Current exception: Class
2649 // mirrors may appear in debug info, but we could clean them out by
2650 // introducing a new debug info operator for Klass.java_mirror).
2651
2652 if (toop->isa_instptr() && toop->is_instptr()->instance_klass() == phase->C->env()->Class_klass()
2653 && offset == java_lang_Class::klass_offset()) {
2654 if (base->is_Load()) {
2655 Node* base2 = base->in(MemNode::Address);
2656 if (base2->is_Load()) { /* direct load of a load which is the OopHandle */
|