hotspot/src/share/vm/oops/instanceKlassKlass.cpp
changeset 8725 8c1e3dd5fe1b
parent 8297 f05d10c1c4b8
child 9116 9bc44be338d6
equal deleted inserted replaced
8724:693c6b883b54 8725:8c1e3dd5fe1b
    29 #include "gc_interface/collectedHeap.inline.hpp"
    29 #include "gc_interface/collectedHeap.inline.hpp"
    30 #include "interpreter/oopMapCache.hpp"
    30 #include "interpreter/oopMapCache.hpp"
    31 #include "memory/gcLocker.hpp"
    31 #include "memory/gcLocker.hpp"
    32 #include "oops/constantPoolOop.hpp"
    32 #include "oops/constantPoolOop.hpp"
    33 #include "oops/instanceKlass.hpp"
    33 #include "oops/instanceKlass.hpp"
       
    34 #include "oops/instanceMirrorKlass.hpp"
    34 #include "oops/instanceKlassKlass.hpp"
    35 #include "oops/instanceKlassKlass.hpp"
    35 #include "oops/instanceRefKlass.hpp"
    36 #include "oops/instanceRefKlass.hpp"
    36 #include "oops/objArrayKlassKlass.hpp"
    37 #include "oops/objArrayKlassKlass.hpp"
    37 #include "oops/objArrayOop.hpp"
    38 #include "oops/objArrayOop.hpp"
    38 #include "oops/oop.inline.hpp"
    39 #include "oops/oop.inline.hpp"
    84 void instanceKlassKlass::oop_follow_contents(oop obj) {
    85 void instanceKlassKlass::oop_follow_contents(oop obj) {
    85   assert(obj->is_klass(),"must be a klass");
    86   assert(obj->is_klass(),"must be a klass");
    86   assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");
    87   assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");
    87 
    88 
    88   instanceKlass* ik = instanceKlass::cast(klassOop(obj));
    89   instanceKlass* ik = instanceKlass::cast(klassOop(obj));
    89   ik->follow_static_fields();
       
    90   {
    90   {
    91     HandleMark hm;
    91     HandleMark hm;
    92     ik->vtable()->oop_follow_contents();
    92     ik->vtable()->oop_follow_contents();
    93     ik->itable()->oop_follow_contents();
    93     ik->itable()->oop_follow_contents();
    94   }
    94   }
   125                                              oop obj) {
   125                                              oop obj) {
   126   assert(obj->is_klass(),"must be a klass");
   126   assert(obj->is_klass(),"must be a klass");
   127   assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");
   127   assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");
   128 
   128 
   129   instanceKlass* ik = instanceKlass::cast(klassOop(obj));
   129   instanceKlass* ik = instanceKlass::cast(klassOop(obj));
   130   ik->follow_static_fields(cm);
       
   131   ik->vtable()->oop_follow_contents(cm);
   130   ik->vtable()->oop_follow_contents(cm);
   132   ik->itable()->oop_follow_contents(cm);
   131   ik->itable()->oop_follow_contents(cm);
   133 
   132 
   134   PSParallelCompact::mark_and_push(cm, ik->adr_array_klasses());
   133   PSParallelCompact::mark_and_push(cm, ik->adr_array_klasses());
   135   PSParallelCompact::mark_and_push(cm, ik->adr_methods());
   134   PSParallelCompact::mark_and_push(cm, ik->adr_methods());
   166   instanceKlass* ik = instanceKlass::cast(klassOop(obj));
   165   instanceKlass* ik = instanceKlass::cast(klassOop(obj));
   167   // Get size before changing pointers.
   166   // Get size before changing pointers.
   168   // Don't call size() or oop_size() since that is a virtual call.
   167   // Don't call size() or oop_size() since that is a virtual call.
   169   int size = ik->object_size();
   168   int size = ik->object_size();
   170 
   169 
   171   ik->iterate_static_fields(blk);
       
   172   ik->vtable()->oop_oop_iterate(blk);
   170   ik->vtable()->oop_oop_iterate(blk);
   173   ik->itable()->oop_oop_iterate(blk);
   171   ik->itable()->oop_oop_iterate(blk);
   174 
   172 
   175   blk->do_oop(ik->adr_array_klasses());
   173   blk->do_oop(ik->adr_array_klasses());
   176   blk->do_oop(ik->adr_methods());
   174   blk->do_oop(ik->adr_methods());
   207   instanceKlass* ik = instanceKlass::cast(klassOop(obj));
   205   instanceKlass* ik = instanceKlass::cast(klassOop(obj));
   208   // Get size before changing pointers.
   206   // Get size before changing pointers.
   209   // Don't call size() or oop_size() since that is a virtual call.
   207   // Don't call size() or oop_size() since that is a virtual call.
   210   int size = ik->object_size();
   208   int size = ik->object_size();
   211 
   209 
   212   ik->iterate_static_fields(blk, mr);
       
   213   ik->vtable()->oop_oop_iterate_m(blk, mr);
   210   ik->vtable()->oop_oop_iterate_m(blk, mr);
   214   ik->itable()->oop_oop_iterate_m(blk, mr);
   211   ik->itable()->oop_oop_iterate_m(blk, mr);
   215 
   212 
   216   oop* adr;
   213   oop* adr;
   217   adr = ik->adr_array_klasses();
   214   adr = ik->adr_array_klasses();
   264 int instanceKlassKlass::oop_adjust_pointers(oop obj) {
   261 int instanceKlassKlass::oop_adjust_pointers(oop obj) {
   265   assert(obj->is_klass(),"must be a klass");
   262   assert(obj->is_klass(),"must be a klass");
   266   assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");
   263   assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");
   267 
   264 
   268   instanceKlass* ik = instanceKlass::cast(klassOop(obj));
   265   instanceKlass* ik = instanceKlass::cast(klassOop(obj));
   269   ik->adjust_static_fields();
       
   270   ik->vtable()->oop_adjust_pointers();
   266   ik->vtable()->oop_adjust_pointers();
   271   ik->itable()->oop_adjust_pointers();
   267   ik->itable()->oop_adjust_pointers();
   272 
   268 
   273   MarkSweep::adjust_pointer(ik->adr_array_klasses());
   269   MarkSweep::adjust_pointer(ik->adr_array_klasses());
   274   MarkSweep::adjust_pointer(ik->adr_methods());
   270   MarkSweep::adjust_pointer(ik->adr_methods());
   298 }
   294 }
   299 
   295 
   300 #ifndef SERIALGC
   296 #ifndef SERIALGC
   301 void instanceKlassKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
   297 void instanceKlassKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
   302   instanceKlass* ik = instanceKlass::cast(klassOop(obj));
   298   instanceKlass* ik = instanceKlass::cast(klassOop(obj));
   303   ik->push_static_fields(pm);
       
   304 
   299 
   305   oop* loader_addr = ik->adr_class_loader();
   300   oop* loader_addr = ik->adr_class_loader();
   306   if (PSScavenge::should_scavenge(loader_addr)) {
   301   if (PSScavenge::should_scavenge(loader_addr)) {
   307     pm->claim_or_forward_depth(loader_addr);
   302     pm->claim_or_forward_depth(loader_addr);
   308   }
   303   }
   334   assert(obj->is_klass(),"must be a klass");
   329   assert(obj->is_klass(),"must be a klass");
   335   assert(klassOop(obj)->klass_part()->oop_is_instance_slow(),
   330   assert(klassOop(obj)->klass_part()->oop_is_instance_slow(),
   336          "must be instance klass");
   331          "must be instance klass");
   337 
   332 
   338   instanceKlass* ik = instanceKlass::cast(klassOop(obj));
   333   instanceKlass* ik = instanceKlass::cast(klassOop(obj));
   339   ik->update_static_fields();
       
   340   ik->vtable()->oop_update_pointers(cm);
   334   ik->vtable()->oop_update_pointers(cm);
   341   ik->itable()->oop_update_pointers(cm);
   335   ik->itable()->oop_update_pointers(cm);
   342 
   336 
   343   oop* const beg_oop = ik->oop_block_beg();
   337   oop* const beg_oop = ik->oop_block_beg();
   344   oop* const end_oop = ik->oop_block_end();
   338   oop* const end_oop = ik->oop_block_end();
   354 }
   348 }
   355 
   349 
   356 #endif // SERIALGC
   350 #endif // SERIALGC
   357 
   351 
   358 klassOop
   352 klassOop
   359 instanceKlassKlass::allocate_instance_klass(int vtable_len, int itable_len,
   353 instanceKlassKlass::allocate_instance_klass(Symbol* name, int vtable_len, int itable_len,
   360                                             int static_field_size,
   354                                             int static_field_size,
   361                                             unsigned nonstatic_oop_map_count,
   355                                             unsigned nonstatic_oop_map_count,
   362                                             ReferenceType rt, TRAPS) {
   356                                             ReferenceType rt, TRAPS) {
   363 
   357 
   364   const int nonstatic_oop_map_size =
   358   const int nonstatic_oop_map_size =
   365     instanceKlass::nonstatic_oop_map_size(nonstatic_oop_map_count);
   359     instanceKlass::nonstatic_oop_map_size(nonstatic_oop_map_count);
   366   int size = instanceKlass::object_size(align_object_offset(vtable_len) + align_object_offset(itable_len) + static_field_size + nonstatic_oop_map_size);
   360   int size = instanceKlass::object_size(align_object_offset(vtable_len) + align_object_offset(itable_len) + nonstatic_oop_map_size);
   367 
   361 
   368   // Allocation
   362   // Allocation
   369   KlassHandle h_this_klass(THREAD, as_klassOop());
   363   KlassHandle h_this_klass(THREAD, as_klassOop());
   370   KlassHandle k;
   364   KlassHandle k;
   371   if (rt == REF_NONE) {
   365   if (rt == REF_NONE) {
   372     // regular klass
   366     if (name != vmSymbols::java_lang_Class()) {
   373     instanceKlass o;
   367       // regular klass
   374     k = base_create_klass(h_this_klass, size, o.vtbl_value(), CHECK_NULL);
   368       instanceKlass o;
       
   369       k = base_create_klass(h_this_klass, size, o.vtbl_value(), CHECK_NULL);
       
   370     } else {
       
   371       // Class
       
   372       instanceMirrorKlass o;
       
   373       k = base_create_klass(h_this_klass, size, o.vtbl_value(), CHECK_NULL);
       
   374     }
   375   } else {
   375   } else {
   376     // reference klass
   376     // reference klass
   377     instanceRefKlass o;
   377     instanceRefKlass o;
   378     k = base_create_klass(h_this_klass, size, o.vtbl_value(), CHECK_NULL);
   378     k = base_create_klass(h_this_klass, size, o.vtbl_value(), CHECK_NULL);
   379   }
   379   }
   406     ik->set_source_file_name(NULL);
   406     ik->set_source_file_name(NULL);
   407     ik->set_source_debug_extension(NULL);
   407     ik->set_source_debug_extension(NULL);
   408     ik->set_source_debug_extension(NULL);
   408     ik->set_source_debug_extension(NULL);
   409     ik->set_array_name(NULL);
   409     ik->set_array_name(NULL);
   410     ik->set_inner_classes(NULL);
   410     ik->set_inner_classes(NULL);
   411     ik->set_static_oop_field_size(0);
   411     ik->set_static_oop_field_count(0);
   412     ik->set_nonstatic_field_size(0);
   412     ik->set_nonstatic_field_size(0);
   413     ik->set_is_marked_dependent(false);
   413     ik->set_is_marked_dependent(false);
   414     ik->set_init_state(instanceKlass::allocated);
   414     ik->set_init_state(instanceKlass::allocated);
   415     ik->set_init_thread(NULL);
   415     ik->set_init_thread(NULL);
   416     ik->set_reference_type(rt);
   416     ik->set_reference_type(rt);
   440     }
   440     }
   441 
   441 
   442     // To get verify to work - must be set to partial loaded before first GC point.
   442     // To get verify to work - must be set to partial loaded before first GC point.
   443     k()->set_partially_loaded();
   443     k()->set_partially_loaded();
   444   }
   444   }
   445 
       
   446   // GC can happen here
       
   447   java_lang_Class::create_mirror(k, CHECK_NULL); // Allocate mirror
       
   448   return k();
   445   return k();
   449 }
   446 }
   450 
   447 
   451 
   448 
   452 
   449 
   564   ik->do_local_static_fields(&print_static_field);
   561   ik->do_local_static_fields(&print_static_field);
   565   st->print_cr(BULLET"---- non-static fields (%d words):", ik->nonstatic_field_size());
   562   st->print_cr(BULLET"---- non-static fields (%d words):", ik->nonstatic_field_size());
   566   FieldPrinter print_nonstatic_field(st);
   563   FieldPrinter print_nonstatic_field(st);
   567   ik->do_nonstatic_fields(&print_nonstatic_field);
   564   ik->do_nonstatic_fields(&print_nonstatic_field);
   568 
   565 
   569   st->print(BULLET"static oop maps:     ");
       
   570   if (ik->static_oop_field_size() > 0) {
       
   571     int first_offset = ik->offset_of_static_fields();
       
   572     st->print("%d-%d", first_offset, first_offset + ik->static_oop_field_size() - 1);
       
   573   }
       
   574   st->cr();
       
   575 
       
   576   st->print(BULLET"non-static oop maps: ");
   566   st->print(BULLET"non-static oop maps: ");
   577   OopMapBlock* map     = ik->start_of_nonstatic_oop_maps();
   567   OopMapBlock* map     = ik->start_of_nonstatic_oop_maps();
   578   OopMapBlock* end_map = map + ik->nonstatic_oop_map_count();
   568   OopMapBlock* end_map = map + ik->nonstatic_oop_map_count();
   579   while (map < end_map) {
   569   while (map < end_map) {
   580     st->print("%d-%d ", map->offset(), map->offset() + heapOopSize*(map->count() - 1));
   570     st->print("%d-%d ", map->offset(), map->offset() + heapOopSize*(map->count() - 1));
   628       SystemDictionary::verify_obj_klass_present(h_obj, h_name, h_loader);
   618       SystemDictionary::verify_obj_klass_present(h_obj, h_name, h_loader);
   629     }
   619     }
   630 
   620 
   631     // Verify static fields
   621     // Verify static fields
   632     VerifyFieldClosure blk;
   622     VerifyFieldClosure blk;
   633     ik->iterate_static_fields(&blk);
       
   634 
   623 
   635     // Verify vtables
   624     // Verify vtables
   636     if (ik->is_linked()) {
   625     if (ik->is_linked()) {
   637       ResourceMark rm(thread);
   626       ResourceMark rm(thread);
   638       // $$$ This used to be done only for m/s collections.  Doing it
   627       // $$$ This used to be done only for m/s collections.  Doing it