*** old/src/share/vm/oops/instanceKlassKlass.cpp	Fri Mar 18 14:58:50 2011
--- new/src/share/vm/oops/instanceKlassKlass.cpp	Fri Mar 18 14:58:50 2011

*** 29,38 ****
--- 29,39 ----
  #include "gc_interface/collectedHeap.inline.hpp"
  #include "interpreter/oopMapCache.hpp"
  #include "memory/gcLocker.hpp"
  #include "oops/constantPoolOop.hpp"
  #include "oops/instanceKlass.hpp"
+ #include "oops/instanceMirrorKlass.hpp"
  #include "oops/instanceKlassKlass.hpp"
  #include "oops/instanceRefKlass.hpp"
  #include "oops/objArrayKlassKlass.hpp"
  #include "oops/objArrayOop.hpp"
  #include "oops/oop.inline.hpp"

*** 84,94 ****
--- 85,94 ----
  void instanceKlassKlass::oop_follow_contents(oop obj) {
    assert(obj->is_klass(),"must be a klass");
    assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");
  
    instanceKlass* ik = instanceKlass::cast(klassOop(obj));
    ik->follow_static_fields();
    {
      HandleMark hm;
      ik->vtable()->oop_follow_contents();
      ik->itable()->oop_follow_contents();
    }

*** 125,135 ****
--- 125,134 ----
                                               oop obj) {
    assert(obj->is_klass(),"must be a klass");
    assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");
  
    instanceKlass* ik = instanceKlass::cast(klassOop(obj));
    ik->follow_static_fields(cm);
    ik->vtable()->oop_follow_contents(cm);
    ik->itable()->oop_follow_contents(cm);
  
    PSParallelCompact::mark_and_push(cm, ik->adr_array_klasses());
    PSParallelCompact::mark_and_push(cm, ik->adr_methods());

*** 166,176 ****
--- 165,174 ----
    instanceKlass* ik = instanceKlass::cast(klassOop(obj));
    // Get size before changing pointers.
    // Don't call size() or oop_size() since that is a virtual call.
    int size = ik->object_size();
  
    ik->iterate_static_fields(blk);
    ik->vtable()->oop_oop_iterate(blk);
    ik->itable()->oop_oop_iterate(blk);
  
    blk->do_oop(ik->adr_array_klasses());
    blk->do_oop(ik->adr_methods());

*** 207,217 ****
--- 205,214 ----
    instanceKlass* ik = instanceKlass::cast(klassOop(obj));
    // Get size before changing pointers.
    // Don't call size() or oop_size() since that is a virtual call.
    int size = ik->object_size();
  
    ik->iterate_static_fields(blk, mr);
    ik->vtable()->oop_oop_iterate_m(blk, mr);
    ik->itable()->oop_oop_iterate_m(blk, mr);
  
    oop* adr;
    adr = ik->adr_array_klasses();

*** 264,274 ****
--- 261,270 ----
  int instanceKlassKlass::oop_adjust_pointers(oop obj) {
    assert(obj->is_klass(),"must be a klass");
    assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");
  
    instanceKlass* ik = instanceKlass::cast(klassOop(obj));
    ik->adjust_static_fields();
    ik->vtable()->oop_adjust_pointers();
    ik->itable()->oop_adjust_pointers();
  
    MarkSweep::adjust_pointer(ik->adr_array_klasses());
    MarkSweep::adjust_pointer(ik->adr_methods());

*** 298,308 ****
--- 294,303 ----
  }
  
  #ifndef SERIALGC
  void instanceKlassKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
    instanceKlass* ik = instanceKlass::cast(klassOop(obj));
    ik->push_static_fields(pm);
  
    oop* loader_addr = ik->adr_class_loader();
    if (PSScavenge::should_scavenge(loader_addr)) {
      pm->claim_or_forward_depth(loader_addr);
    }

*** 334,344 ****
--- 329,338 ----
    assert(obj->is_klass(),"must be a klass");
    assert(klassOop(obj)->klass_part()->oop_is_instance_slow(),
           "must be instance klass");
  
    instanceKlass* ik = instanceKlass::cast(klassOop(obj));
    ik->update_static_fields();
    ik->vtable()->oop_update_pointers(cm);
    ik->itable()->oop_update_pointers(cm);
  
    oop* const beg_oop = ik->oop_block_beg();
    oop* const end_oop = ik->oop_block_end();

*** 354,380 ****
--- 348,380 ----
  }
  
  #endif // SERIALGC
  
  klassOop
! instanceKlassKlass::allocate_instance_klass(Symbol* name, int vtable_len, int itable_len,
                                              int static_field_size,
                                              unsigned nonstatic_oop_map_count,
                                              ReferenceType rt, TRAPS) {
  
    const int nonstatic_oop_map_size =
      instanceKlass::nonstatic_oop_map_size(nonstatic_oop_map_count);
-   int size = instanceKlass::object_size(align_object_offset(vtable_len) + align_object_offset(itable_len) + static_field_size + nonstatic_oop_map_size);
  
    // Allocation
    KlassHandle h_this_klass(THREAD, as_klassOop());
    KlassHandle k;
    if (rt == REF_NONE) {
+     if (name != vmSymbols::java_lang_Class()) {
        // regular klass
        instanceKlass o;
        k = base_create_klass(h_this_klass, size, o.vtbl_value(), CHECK_NULL);
      } else {
+       // Class
+       instanceMirrorKlass o;
+       k = base_create_klass(h_this_klass, size, o.vtbl_value(), CHECK_NULL);
+     }
+   } else {
      // reference klass
      instanceRefKlass o;
      k = base_create_klass(h_this_klass, size, o.vtbl_value(), CHECK_NULL);
    }
    {

*** 406,416 ****
--- 406,416 ----
      ik->set_source_file_name(NULL);
      ik->set_source_debug_extension(NULL);
      ik->set_source_debug_extension(NULL);
      ik->set_array_name(NULL);
      ik->set_inner_classes(NULL);
!     ik->set_static_oop_field_size(0);
!     ik->set_static_oop_field_count(0);
      ik->set_nonstatic_field_size(0);
      ik->set_is_marked_dependent(false);
      ik->set_init_state(instanceKlass::allocated);
      ik->set_init_thread(NULL);
      ik->set_reference_type(rt);

*** 440,452 ****
--- 440,449 ----
      }
  
      // To get verify to work - must be set to partial loaded before first GC point.
      k()->set_partially_loaded();
    }
  
    // GC can happen here
    java_lang_Class::create_mirror(k, CHECK_NULL); // Allocate mirror
    return k();
  }
  
  
  

*** 564,580 ****
--- 561,570 ----
    ik->do_local_static_fields(&print_static_field);
    st->print_cr(BULLET"---- non-static fields (%d words):", ik->nonstatic_field_size());
    FieldPrinter print_nonstatic_field(st);
    ik->do_nonstatic_fields(&print_nonstatic_field);
  
    st->print(BULLET"static oop maps:     ");
    if (ik->static_oop_field_size() > 0) {
      int first_offset = ik->offset_of_static_fields();
      st->print("%d-%d", first_offset, first_offset + ik->static_oop_field_size() - 1);
    }
    st->cr();
  
    st->print(BULLET"non-static oop maps: ");
    OopMapBlock* map     = ik->start_of_nonstatic_oop_maps();
    OopMapBlock* end_map = map + ik->nonstatic_oop_map_count();
    while (map < end_map) {
      st->print("%d-%d ", map->offset(), map->offset() + heapOopSize*(map->count() - 1));

*** 628,638 ****
--- 618,627 ----
        SystemDictionary::verify_obj_klass_present(h_obj, h_name, h_loader);
      }
  
      // Verify static fields
      VerifyFieldClosure blk;
      ik->iterate_static_fields(&blk);
  
      // Verify vtables
      if (ik->is_linked()) {
        ResourceMark rm(thread);
        // $$$ This used to be done only for m/s collections.  Doing it