< prev index next >

src/hotspot/share/opto/memnode.cpp

Print this page

 245       assert(phase->C->get_alias_index(t) == phase->C->get_alias_index(t_adr), "correct memory chain");
 246     }
 247   }
 248   return result;
 249 }
 250 
 251 static Node *step_through_mergemem(PhaseGVN *phase, MergeMemNode *mmem,  const TypePtr *tp, const TypePtr *adr_check, outputStream *st) {
 252   uint alias_idx = phase->C->get_alias_index(tp);
 253   Node *mem = mmem;
 254 #ifdef ASSERT
 255   {
 256     // Check that current type is consistent with the alias index used during graph construction
 257     assert(alias_idx >= Compile::AliasIdxRaw, "must not be a bad alias_idx");
 258     bool consistent =  adr_check == nullptr || adr_check->empty() ||
 259                        phase->C->must_alias(adr_check, alias_idx );
 260     // Sometimes dead array references collapse to a[-1], a[-2], or a[-3]
 261     if( !consistent && adr_check != nullptr && !adr_check->empty() &&
 262                tp->isa_aryptr() &&        tp->offset() == Type::OffsetBot &&
 263         adr_check->isa_aryptr() && adr_check->offset() != Type::OffsetBot &&
 264         ( adr_check->offset() == arrayOopDesc::length_offset_in_bytes() ||
 265           adr_check->offset() == oopDesc::klass_offset_in_bytes() ||
 266           adr_check->offset() == oopDesc::mark_offset_in_bytes() ) ) {
 267       // don't assert if it is dead code.
 268       consistent = true;
 269     }
 270     if( !consistent ) {
 271       st->print("alias_idx==%d, adr_check==", alias_idx);
 272       if( adr_check == nullptr ) {
 273         st->print("null");
 274       } else {
 275         adr_check->dump();
 276       }
 277       st->cr();
 278       print_alias_types();
 279       assert(consistent, "adr_check must match alias idx");
 280     }
 281   }
 282 #endif
 283   // TypeOopPtr::NOTNULL+any is an OOP with unknown offset - generally
 284   // means an array I have not precisely typed yet.  Do not do any
 285   // alias stuff with it any time soon.

 926 
 927     for (size_t i = 0; i < sizeof offsets / sizeof offsets[0]; i++) {
 928       if (offset == offsets[i]) {
 929         return true;
 930       }
 931     }
 932   }
 933 
 934   return false;
 935 }
 936 #endif
 937 
 938 //----------------------------LoadNode::make-----------------------------------
 939 // Polymorphic factory method:
 940 Node* LoadNode::make(PhaseGVN& gvn, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, const Type* rt, BasicType bt, MemOrd mo,
 941                      ControlDependency control_dependency, bool require_atomic_access, bool unaligned, bool mismatched, bool unsafe, uint8_t barrier_data) {
 942   Compile* C = gvn.C;
 943 
 944   // sanity check the alias category against the created node type
 945   assert(!(adr_type->isa_oopptr() &&
 946            adr_type->offset() == oopDesc::klass_offset_in_bytes()),
 947          "use LoadKlassNode instead");
 948   assert(!(adr_type->isa_aryptr() &&
 949            adr_type->offset() == arrayOopDesc::length_offset_in_bytes()),
 950          "use LoadRangeNode instead");
 951   // Check control edge of raw loads
 952   assert( ctl != nullptr || C->get_alias_index(adr_type) != Compile::AliasIdxRaw ||
 953           // oop will be recorded in oop map if load crosses safepoint
 954           rt->isa_oopptr() || is_immutable_value(adr),
 955           "raw memory operations should have control edge");
 956   LoadNode* load = nullptr;
 957   switch (bt) {
 958   case T_BOOLEAN: load = new LoadUBNode(ctl, mem, adr, adr_type, rt->is_int(),  mo, control_dependency); break;
 959   case T_BYTE:    load = new LoadBNode (ctl, mem, adr, adr_type, rt->is_int(),  mo, control_dependency); break;
 960   case T_INT:     load = new LoadINode (ctl, mem, adr, adr_type, rt->is_int(),  mo, control_dependency); break;
 961   case T_CHAR:    load = new LoadUSNode(ctl, mem, adr, adr_type, rt->is_int(),  mo, control_dependency); break;
 962   case T_SHORT:   load = new LoadSNode (ctl, mem, adr, adr_type, rt->is_int(),  mo, control_dependency); break;
 963   case T_LONG:    load = new LoadLNode (ctl, mem, adr, adr_type, rt->is_long(), mo, control_dependency, require_atomic_access); break;
 964   case T_FLOAT:   load = new LoadFNode (ctl, mem, adr, adr_type, rt,            mo, control_dependency); break;
 965   case T_DOUBLE:  load = new LoadDNode (ctl, mem, adr, adr_type, rt,            mo, control_dependency, require_atomic_access); break;
 966   case T_ADDRESS: load = new LoadPNode (ctl, mem, adr, adr_type, rt->is_ptr(),  mo, control_dependency); break;

2451         // constant oop => constant klass
2452         if (offset == java_lang_Class::array_klass_offset()) {
2453           if (t->is_void()) {
2454             // We cannot create a void array.  Since void is a primitive type return null
2455             // klass.  Users of this result need to do a null check on the returned klass.
2456             return TypePtr::NULL_PTR;
2457           }
2458           return TypeKlassPtr::make(ciArrayKlass::make(t), Type::trust_interfaces);
2459         }
2460         if (!t->is_klass()) {
2461           // a primitive Class (e.g., int.class) has null for a klass field
2462           return TypePtr::NULL_PTR;
2463         }
2464         // (Folds up the 1st indirection in aClassConstant.getModifiers().)
2465         return TypeKlassPtr::make(t->as_klass(), Type::trust_interfaces);
2466       }
2467       // non-constant mirror, so we can't tell what's going on
2468     }
2469     if (!tinst->is_loaded())
2470       return _type;             // Bail out if not loaded
2471     if (offset == oopDesc::klass_offset_in_bytes()) {
2472       return tinst->as_klass_type(true);
2473     }
2474   }
2475 
2476   // Check for loading klass from an array
2477   const TypeAryPtr *tary = tp->isa_aryptr();
2478   if (tary != nullptr &&
2479       tary->offset() == oopDesc::klass_offset_in_bytes()) {
2480     return tary->as_klass_type(true);
2481   }
2482 
2483   // Check for loading klass from an array klass
2484   const TypeKlassPtr *tkls = tp->isa_klassptr();
2485   if (tkls != nullptr && !StressReflectiveCode) {
2486     if (!tkls->is_loaded())
2487      return _type;             // Bail out if not loaded
2488     if (tkls->isa_aryklassptr() && tkls->is_aryklassptr()->elem()->isa_klassptr() &&
2489         tkls->offset() == in_bytes(ObjArrayKlass::element_klass_offset())) {
2490       // // Always returning precise element type is incorrect,
2491       // // e.g., element type could be object and array may contain strings
2492       // return TypeKlassPtr::make(TypePtr::Constant, elem, 0);
2493 
2494       // The array's TypeKlassPtr was declared 'precise' or 'not precise'
2495       // according to the element type's subclassing.
2496       return tkls->is_aryklassptr()->elem()->isa_klassptr()->cast_to_exactness(tkls->klass_is_exact());
2497     }
2498     if (tkls->isa_instklassptr() != nullptr && tkls->klass_is_exact() &&
2499         tkls->offset() == in_bytes(Klass::super_offset())) {

2525   Node* x = LoadNode::Identity(phase);
2526   if (x != this)  return x;
2527 
2528   // Take apart the address into an oop and offset.
2529   // Return 'this' if we cannot.
2530   Node*    adr    = in(MemNode::Address);
2531   intptr_t offset = 0;
2532   Node*    base   = AddPNode::Ideal_base_and_offset(adr, phase, offset);
2533   if (base == nullptr)     return this;
2534   const TypeOopPtr* toop = phase->type(adr)->isa_oopptr();
2535   if (toop == nullptr)     return this;
2536 
2537   // Step over potential GC barrier for OopHandle resolve
2538   BarrierSetC2* bs = BarrierSet::barrier_set()->barrier_set_c2();
2539   if (bs->is_gc_barrier_node(base)) {
2540     base = bs->step_over_gc_barrier(base);
2541   }
2542 
2543   // We can fetch the klass directly through an AllocateNode.
2544   // This works even if the klass is not constant (clone or newArray).
2545   if (offset == oopDesc::klass_offset_in_bytes()) {
2546     Node* allocated_klass = AllocateNode::Ideal_klass(base, phase);
2547     if (allocated_klass != nullptr) {
2548       return allocated_klass;
2549     }
2550   }
2551 
2552   // Simplify k.java_mirror.as_klass to plain k, where k is a Klass*.
2553   // See inline_native_Class_query for occurrences of these patterns.
2554   // Java Example:  x.getClass().isAssignableFrom(y)
2555   //
2556   // This improves reflective code, often making the Class
2557   // mirror go completely dead.  (Current exception:  Class
2558   // mirrors may appear in debug info, but we could clean them out by
2559   // introducing a new debug info operator for Klass.java_mirror).
2560 
2561   if (toop->isa_instptr() && toop->is_instptr()->instance_klass() == phase->C->env()->Class_klass()
2562       && offset == java_lang_Class::klass_offset()) {
2563     if (base->is_Load()) {
2564       Node* base2 = base->in(MemNode::Address);
2565       if (base2->is_Load()) { /* direct load of a load which is the OopHandle */

 245       assert(phase->C->get_alias_index(t) == phase->C->get_alias_index(t_adr), "correct memory chain");
 246     }
 247   }
 248   return result;
 249 }
 250 
 251 static Node *step_through_mergemem(PhaseGVN *phase, MergeMemNode *mmem,  const TypePtr *tp, const TypePtr *adr_check, outputStream *st) {
 252   uint alias_idx = phase->C->get_alias_index(tp);
 253   Node *mem = mmem;
 254 #ifdef ASSERT
 255   {
 256     // Check that current type is consistent with the alias index used during graph construction
 257     assert(alias_idx >= Compile::AliasIdxRaw, "must not be a bad alias_idx");
 258     bool consistent =  adr_check == nullptr || adr_check->empty() ||
 259                        phase->C->must_alias(adr_check, alias_idx );
 260     // Sometimes dead array references collapse to a[-1], a[-2], or a[-3]
 261     if( !consistent && adr_check != nullptr && !adr_check->empty() &&
 262                tp->isa_aryptr() &&        tp->offset() == Type::OffsetBot &&
 263         adr_check->isa_aryptr() && adr_check->offset() != Type::OffsetBot &&
 264         ( adr_check->offset() == arrayOopDesc::length_offset_in_bytes() ||
 265           adr_check->offset() == Type::klass_offset() ||
 266           adr_check->offset() == oopDesc::mark_offset_in_bytes() ) ) {
 267       // don't assert if it is dead code.
 268       consistent = true;
 269     }
 270     if( !consistent ) {
 271       st->print("alias_idx==%d, adr_check==", alias_idx);
 272       if( adr_check == nullptr ) {
 273         st->print("null");
 274       } else {
 275         adr_check->dump();
 276       }
 277       st->cr();
 278       print_alias_types();
 279       assert(consistent, "adr_check must match alias idx");
 280     }
 281   }
 282 #endif
 283   // TypeOopPtr::NOTNULL+any is an OOP with unknown offset - generally
 284   // means an array I have not precisely typed yet.  Do not do any
 285   // alias stuff with it any time soon.

 926 
 927     for (size_t i = 0; i < sizeof offsets / sizeof offsets[0]; i++) {
 928       if (offset == offsets[i]) {
 929         return true;
 930       }
 931     }
 932   }
 933 
 934   return false;
 935 }
 936 #endif
 937 
 938 //----------------------------LoadNode::make-----------------------------------
 939 // Polymorphic factory method:
 940 Node* LoadNode::make(PhaseGVN& gvn, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, const Type* rt, BasicType bt, MemOrd mo,
 941                      ControlDependency control_dependency, bool require_atomic_access, bool unaligned, bool mismatched, bool unsafe, uint8_t barrier_data) {
 942   Compile* C = gvn.C;
 943 
 944   // sanity check the alias category against the created node type
 945   assert(!(adr_type->isa_oopptr() &&
 946            adr_type->offset() == Type::klass_offset()),
 947          "use LoadKlassNode instead");
 948   assert(!(adr_type->isa_aryptr() &&
 949            adr_type->offset() == arrayOopDesc::length_offset_in_bytes()),
 950          "use LoadRangeNode instead");
 951   // Check control edge of raw loads
 952   assert( ctl != nullptr || C->get_alias_index(adr_type) != Compile::AliasIdxRaw ||
 953           // oop will be recorded in oop map if load crosses safepoint
 954           rt->isa_oopptr() || is_immutable_value(adr),
 955           "raw memory operations should have control edge");
 956   LoadNode* load = nullptr;
 957   switch (bt) {
 958   case T_BOOLEAN: load = new LoadUBNode(ctl, mem, adr, adr_type, rt->is_int(),  mo, control_dependency); break;
 959   case T_BYTE:    load = new LoadBNode (ctl, mem, adr, adr_type, rt->is_int(),  mo, control_dependency); break;
 960   case T_INT:     load = new LoadINode (ctl, mem, adr, adr_type, rt->is_int(),  mo, control_dependency); break;
 961   case T_CHAR:    load = new LoadUSNode(ctl, mem, adr, adr_type, rt->is_int(),  mo, control_dependency); break;
 962   case T_SHORT:   load = new LoadSNode (ctl, mem, adr, adr_type, rt->is_int(),  mo, control_dependency); break;
 963   case T_LONG:    load = new LoadLNode (ctl, mem, adr, adr_type, rt->is_long(), mo, control_dependency, require_atomic_access); break;
 964   case T_FLOAT:   load = new LoadFNode (ctl, mem, adr, adr_type, rt,            mo, control_dependency); break;
 965   case T_DOUBLE:  load = new LoadDNode (ctl, mem, adr, adr_type, rt,            mo, control_dependency, require_atomic_access); break;
 966   case T_ADDRESS: load = new LoadPNode (ctl, mem, adr, adr_type, rt->is_ptr(),  mo, control_dependency); break;

2451         // constant oop => constant klass
2452         if (offset == java_lang_Class::array_klass_offset()) {
2453           if (t->is_void()) {
2454             // We cannot create a void array.  Since void is a primitive type return null
2455             // klass.  Users of this result need to do a null check on the returned klass.
2456             return TypePtr::NULL_PTR;
2457           }
2458           return TypeKlassPtr::make(ciArrayKlass::make(t), Type::trust_interfaces);
2459         }
2460         if (!t->is_klass()) {
2461           // a primitive Class (e.g., int.class) has null for a klass field
2462           return TypePtr::NULL_PTR;
2463         }
2464         // (Folds up the 1st indirection in aClassConstant.getModifiers().)
2465         return TypeKlassPtr::make(t->as_klass(), Type::trust_interfaces);
2466       }
2467       // non-constant mirror, so we can't tell what's going on
2468     }
2469     if (!tinst->is_loaded())
2470       return _type;             // Bail out if not loaded
2471     if (offset == Type::klass_offset()) {
2472       return tinst->as_klass_type(true);
2473     }
2474   }
2475 
2476   // Check for loading klass from an array
2477   const TypeAryPtr *tary = tp->isa_aryptr();
2478   if (tary != nullptr &&
2479       tary->offset() == Type::klass_offset()) {
2480     return tary->as_klass_type(true);
2481   }
2482 
2483   // Check for loading klass from an array klass
2484   const TypeKlassPtr *tkls = tp->isa_klassptr();
2485   if (tkls != nullptr && !StressReflectiveCode) {
2486     if (!tkls->is_loaded())
2487      return _type;             // Bail out if not loaded
2488     if (tkls->isa_aryklassptr() && tkls->is_aryklassptr()->elem()->isa_klassptr() &&
2489         tkls->offset() == in_bytes(ObjArrayKlass::element_klass_offset())) {
2490       // // Always returning precise element type is incorrect,
2491       // // e.g., element type could be object and array may contain strings
2492       // return TypeKlassPtr::make(TypePtr::Constant, elem, 0);
2493 
2494       // The array's TypeKlassPtr was declared 'precise' or 'not precise'
2495       // according to the element type's subclassing.
2496       return tkls->is_aryklassptr()->elem()->isa_klassptr()->cast_to_exactness(tkls->klass_is_exact());
2497     }
2498     if (tkls->isa_instklassptr() != nullptr && tkls->klass_is_exact() &&
2499         tkls->offset() == in_bytes(Klass::super_offset())) {

2525   Node* x = LoadNode::Identity(phase);
2526   if (x != this)  return x;
2527 
2528   // Take apart the address into an oop and offset.
2529   // Return 'this' if we cannot.
2530   Node*    adr    = in(MemNode::Address);
2531   intptr_t offset = 0;
2532   Node*    base   = AddPNode::Ideal_base_and_offset(adr, phase, offset);
2533   if (base == nullptr)     return this;
2534   const TypeOopPtr* toop = phase->type(adr)->isa_oopptr();
2535   if (toop == nullptr)     return this;
2536 
2537   // Step over potential GC barrier for OopHandle resolve
2538   BarrierSetC2* bs = BarrierSet::barrier_set()->barrier_set_c2();
2539   if (bs->is_gc_barrier_node(base)) {
2540     base = bs->step_over_gc_barrier(base);
2541   }
2542 
2543   // We can fetch the klass directly through an AllocateNode.
2544   // This works even if the klass is not constant (clone or newArray).
2545   if (offset == Type::klass_offset()) {
2546     Node* allocated_klass = AllocateNode::Ideal_klass(base, phase);
2547     if (allocated_klass != nullptr) {
2548       return allocated_klass;
2549     }
2550   }
2551 
2552   // Simplify k.java_mirror.as_klass to plain k, where k is a Klass*.
2553   // See inline_native_Class_query for occurrences of these patterns.
2554   // Java Example:  x.getClass().isAssignableFrom(y)
2555   //
2556   // This improves reflective code, often making the Class
2557   // mirror go completely dead.  (Current exception:  Class
2558   // mirrors may appear in debug info, but we could clean them out by
2559   // introducing a new debug info operator for Klass.java_mirror).
2560 
2561   if (toop->isa_instptr() && toop->is_instptr()->instance_klass() == phase->C->env()->Class_klass()
2562       && offset == java_lang_Class::klass_offset()) {
2563     if (base->is_Load()) {
2564       Node* base2 = base->in(MemNode::Address);
2565       if (base2->is_Load()) { /* direct load of a load which is the OopHandle */
< prev index next >