/*

 * Copyright 1997-2008 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

# include "incls/_precompiled.incl"

# include "incls/_universe.cpp.incl"

// Known objects

klassOop Universe::_boolArrayKlassObj                 = NULL;

klassOop Universe::_byteArrayKlassObj                 = NULL;

klassOop Universe::_charArrayKlassObj                 = NULL;

klassOop Universe::_intArrayKlassObj                  = NULL;

klassOop Universe::_shortArrayKlassObj                = NULL;

klassOop Universe::_longArrayKlassObj                 = NULL;

klassOop Universe::_singleArrayKlassObj               = NULL;

klassOop Universe::_doubleArrayKlassObj               = NULL;

klassOop Universe::_typeArrayKlassObjs[T_VOID+1]      = { NULL /*, NULL...*/ };

klassOop Universe::_objectArrayKlassObj               = NULL;

klassOop Universe::_symbolKlassObj                    = NULL;

klassOop Universe::_methodKlassObj                    = NULL;

klassOop Universe::_constMethodKlassObj               = NULL;

klassOop Universe::_methodDataKlassObj                = NULL;

klassOop Universe::_klassKlassObj                     = NULL;

klassOop Universe::_arrayKlassKlassObj                = NULL;

klassOop Universe::_objArrayKlassKlassObj             = NULL;

klassOop Universe::_typeArrayKlassKlassObj            = NULL;

klassOop Universe::_instanceKlassKlassObj             = NULL;

klassOop Universe::_constantPoolKlassObj              = NULL;

klassOop Universe::_constantPoolCacheKlassObj         = NULL;

klassOop Universe::_compiledICHolderKlassObj          = NULL;

klassOop Universe::_systemObjArrayKlassObj            = NULL;

oop Universe::_int_mirror                             = NULL;

oop Universe::_float_mirror                           = NULL;

oop Universe::_double_mirror                          = NULL;

oop Universe::_byte_mirror                            = NULL;

oop Universe::_bool_mirror                            = NULL;

oop Universe::_char_mirror                            = NULL;

oop Universe::_long_mirror                            = NULL;

oop Universe::_short_mirror                           = NULL;

oop Universe::_void_mirror                            = NULL;

oop Universe::_mirrors[T_VOID+1]                      = { NULL /*, NULL...*/ };

oop Universe::_main_thread_group                      = NULL;

oop Universe::_system_thread_group                    = NULL;

typeArrayOop Universe::_the_empty_byte_array          = NULL;

typeArrayOop Universe::_the_empty_short_array         = NULL;

typeArrayOop Universe::_the_empty_int_array           = NULL;

objArrayOop Universe::_the_empty_system_obj_array     = NULL;

objArrayOop Universe::_the_empty_class_klass_array    = NULL;

objArrayOop Universe::_the_array_interfaces_array     = NULL;

LatestMethodOopCache* Universe::_finalizer_register_cache = NULL;

LatestMethodOopCache* Universe::_loader_addClass_cache    = NULL;

ActiveMethodOopsCache* Universe::_reflect_invoke_cache    = NULL;

oop Universe::_out_of_memory_error_java_heap          = NULL;

oop Universe::_out_of_memory_error_perm_gen           = NULL;

oop Universe::_out_of_memory_error_array_size         = NULL;

oop Universe::_out_of_memory_error_gc_overhead_limit  = NULL;

objArrayOop Universe::_preallocated_out_of_memory_error_array = NULL;

volatile jint Universe::_preallocated_out_of_memory_error_avail_count = 0;

bool Universe::_verify_in_progress                    = false;

oop Universe::_null_ptr_exception_instance            = NULL;

oop Universe::_arithmetic_exception_instance          = NULL;

oop Universe::_virtual_machine_error_instance         = NULL;

oop Universe::_vm_exception                           = NULL;

oop Universe::_emptySymbol                            = NULL;

// These variables are guarded by FullGCALot_lock.

debug_only(objArrayOop Universe::_fullgc_alot_dummy_array = NULL;)

debug_only(int Universe::_fullgc_alot_dummy_next      = 0;)

// Heap

int             Universe::_verify_count = 0;

int             Universe::_base_vtable_size = 0;

bool            Universe::_bootstrapping = false;

bool            Universe::_fully_initialized = false;

size_t          Universe::_heap_capacity_at_last_gc;

size_t          Universe::_heap_used_at_last_gc = 0;

CollectedHeap*  Universe::_collectedHeap = NULL;

address         Universe::_heap_base = NULL;

void Universe::basic_type_classes_do(void f(klassOop)) {

  f(boolArrayKlassObj());

  f(byteArrayKlassObj());

  f(charArrayKlassObj());

  f(intArrayKlassObj());

  f(shortArrayKlassObj());

  f(longArrayKlassObj());

  f(singleArrayKlassObj());

  f(doubleArrayKlassObj());

}

void Universe::system_classes_do(void f(klassOop)) {

  f(symbolKlassObj());

  f(methodKlassObj());

  f(constMethodKlassObj());

  f(methodDataKlassObj());

  f(klassKlassObj());

  f(arrayKlassKlassObj());

  f(objArrayKlassKlassObj());

  f(typeArrayKlassKlassObj());

  f(instanceKlassKlassObj());

  f(constantPoolKlassObj());

  f(systemObjArrayKlassObj());

}

void Universe::oops_do(OopClosure* f, bool do_all) {

  f->do_oop((oop*) &_int_mirror);

  f->do_oop((oop*) &_float_mirror);

  f->do_oop((oop*) &_double_mirror);

  f->do_oop((oop*) &_byte_mirror);

  f->do_oop((oop*) &_bool_mirror);

  f->do_oop((oop*) &_char_mirror);

  f->do_oop((oop*) &_long_mirror);

  f->do_oop((oop*) &_short_mirror);

  f->do_oop((oop*) &_void_mirror);

  // It's important to iterate over these guys even if they are null,

  // since that's how shared heaps are restored.

  for (int i = T_BOOLEAN; i < T_VOID+1; i++) {

    f->do_oop((oop*) &_mirrors[i]);

  }

  assert(_mirrors[0] == NULL && _mirrors[T_BOOLEAN - 1] == NULL, "checking");

  // %%% Consider moving those "shared oops" over here with the others.

  f->do_oop((oop*)&_boolArrayKlassObj);

  f->do_oop((oop*)&_byteArrayKlassObj);

  f->do_oop((oop*)&_charArrayKlassObj);

  f->do_oop((oop*)&_intArrayKlassObj);

  f->do_oop((oop*)&_shortArrayKlassObj);

  f->do_oop((oop*)&_longArrayKlassObj);

  f->do_oop((oop*)&_singleArrayKlassObj);

  f->do_oop((oop*)&_doubleArrayKlassObj);

  f->do_oop((oop*)&_objectArrayKlassObj);

  {

    for (int i = 0; i < T_VOID+1; i++) {

      if (_typeArrayKlassObjs[i] != NULL) {

        assert(i >= T_BOOLEAN, "checking");

        f->do_oop((oop*)&_typeArrayKlassObjs[i]);

      } else if (do_all) {

        f->do_oop((oop*)&_typeArrayKlassObjs[i]);

      }

    }

  }

  f->do_oop((oop*)&_symbolKlassObj);

  f->do_oop((oop*)&_methodKlassObj);

  f->do_oop((oop*)&_constMethodKlassObj);

  f->do_oop((oop*)&_methodDataKlassObj);

  f->do_oop((oop*)&_klassKlassObj);

  f->do_oop((oop*)&_arrayKlassKlassObj);

  f->do_oop((oop*)&_objArrayKlassKlassObj);

  f->do_oop((oop*)&_typeArrayKlassKlassObj);

  f->do_oop((oop*)&_instanceKlassKlassObj);

  f->do_oop((oop*)&_constantPoolKlassObj);

  f->do_oop((oop*)&_constantPoolCacheKlassObj);

  f->do_oop((oop*)&_compiledICHolderKlassObj);

  f->do_oop((oop*)&_systemObjArrayKlassObj);

  f->do_oop((oop*)&_the_empty_byte_array);

  f->do_oop((oop*)&_the_empty_short_array);

  f->do_oop((oop*)&_the_empty_int_array);

  f->do_oop((oop*)&_the_empty_system_obj_array);

  f->do_oop((oop*)&_the_empty_class_klass_array);

  f->do_oop((oop*)&_the_array_interfaces_array);

  _finalizer_register_cache->oops_do(f);

  _loader_addClass_cache->oops_do(f);

  _reflect_invoke_cache->oops_do(f);

  f->do_oop((oop*)&_out_of_memory_error_java_heap);

  f->do_oop((oop*)&_out_of_memory_error_perm_gen);

  f->do_oop((oop*)&_out_of_memory_error_array_size);

  f->do_oop((oop*)&_out_of_memory_error_gc_overhead_limit);

  if (_preallocated_out_of_memory_error_array != (oop)NULL) {   // NULL when DumpSharedSpaces

    f->do_oop((oop*)&_preallocated_out_of_memory_error_array);

  }

  f->do_oop((oop*)&_null_ptr_exception_instance);

  f->do_oop((oop*)&_arithmetic_exception_instance);

  f->do_oop((oop*)&_virtual_machine_error_instance);

  f->do_oop((oop*)&_main_thread_group);

  f->do_oop((oop*)&_system_thread_group);

  f->do_oop((oop*)&_vm_exception);

  f->do_oop((oop*)&_emptySymbol);

  debug_only(f->do_oop((oop*)&_fullgc_alot_dummy_array);)

}

void Universe::check_alignment(uintx size, uintx alignment, const char* name) {

  if (size < alignment || size % alignment != 0) {

    ResourceMark rm;

    stringStream st;

    st.print("Size of %s (%ld bytes) must be aligned to %ld bytes", name, size, alignment);

    char* error = st.as_string();

    vm_exit_during_initialization(error);

  }

}

void Universe::genesis(TRAPS) {

  ResourceMark rm;

  { FlagSetting fs(_bootstrapping, true);

    { MutexLocker mc(Compile_lock);

      // determine base vtable size; without that we cannot create the array klasses

      compute_base_vtable_size();

      if (!UseSharedSpaces) {

        _klassKlassObj          = klassKlass::create_klass(CHECK);

        _arrayKlassKlassObj     = arrayKlassKlass::create_klass(CHECK);

        _objArrayKlassKlassObj  = objArrayKlassKlass::create_klass(CHECK);

        _instanceKlassKlassObj  = instanceKlassKlass::create_klass(CHECK);

        _typeArrayKlassKlassObj = typeArrayKlassKlass::create_klass(CHECK);

        _symbolKlassObj         = symbolKlass::create_klass(CHECK);

        _emptySymbol            = oopFactory::new_symbol("", CHECK);

        _boolArrayKlassObj      = typeArrayKlass::create_klass(T_BOOLEAN, sizeof(jboolean), CHECK);

        _charArrayKlassObj      = typeArrayKlass::create_klass(T_CHAR,    sizeof(jchar),    CHECK);

        _singleArrayKlassObj    = typeArrayKlass::create_klass(T_FLOAT,   sizeof(jfloat),   CHECK);

        _doubleArrayKlassObj    = typeArrayKlass::create_klass(T_DOUBLE,  sizeof(jdouble),  CHECK);

        _byteArrayKlassObj      = typeArrayKlass::create_klass(T_BYTE,    sizeof(jbyte),    CHECK);

        _shortArrayKlassObj     = typeArrayKlass::create_klass(T_SHORT,   sizeof(jshort),   CHECK);

        _intArrayKlassObj       = typeArrayKlass::create_klass(T_INT,     sizeof(jint),     CHECK);

        _longArrayKlassObj      = typeArrayKlass::create_klass(T_LONG,    sizeof(jlong),    CHECK);

        _typeArrayKlassObjs[T_BOOLEAN] = _boolArrayKlassObj;

        _typeArrayKlassObjs[T_CHAR]    = _charArrayKlassObj;

        _typeArrayKlassObjs[T_FLOAT]   = _singleArrayKlassObj;

        _typeArrayKlassObjs[T_DOUBLE]  = _doubleArrayKlassObj;

        _typeArrayKlassObjs[T_BYTE]    = _byteArrayKlassObj;

        _typeArrayKlassObjs[T_SHORT]   = _shortArrayKlassObj;

        _typeArrayKlassObjs[T_INT]     = _intArrayKlassObj;

        _typeArrayKlassObjs[T_LONG]    = _longArrayKlassObj;

        _methodKlassObj             = methodKlass::create_klass(CHECK);

        _constMethodKlassObj        = constMethodKlass::create_klass(CHECK);

        _methodDataKlassObj         = methodDataKlass::create_klass(CHECK);

        _constantPoolKlassObj       = constantPoolKlass::create_klass(CHECK);

        _constantPoolCacheKlassObj  = constantPoolCacheKlass::create_klass(CHECK);

        _compiledICHolderKlassObj   = compiledICHolderKlass::create_klass(CHECK);

        _systemObjArrayKlassObj     = objArrayKlassKlass::cast(objArrayKlassKlassObj())->allocate_system_objArray_klass(CHECK);

        _the_empty_byte_array       = oopFactory::new_permanent_byteArray(0, CHECK);

        _the_empty_short_array      = oopFactory::new_permanent_shortArray(0, CHECK);

        _the_empty_int_array        = oopFactory::new_permanent_intArray(0, CHECK);

        _the_empty_system_obj_array = oopFactory::new_system_objArray(0, CHECK);

        _the_array_interfaces_array = oopFactory::new_system_objArray(2, CHECK);

        _vm_exception               = oopFactory::new_symbol("vm exception holder", CHECK);

      } else {

        FileMapInfo *mapinfo = FileMapInfo::current_info();

        char* buffer = mapinfo->region_base(CompactingPermGenGen::md);

        void** vtbl_list = (void**)buffer;

        init_self_patching_vtbl_list(vtbl_list,

                                     CompactingPermGenGen::vtbl_list_size);

      }

    }

    vmSymbols::initialize(CHECK);

    SystemDictionary::initialize(CHECK);

    klassOop ok = SystemDictionary::object_klass();

    if (UseSharedSpaces) {

      // Verify shared interfaces array.

      assert(_the_array_interfaces_array->obj_at(0) ==

             SystemDictionary::cloneable_klass(), "u3");

      assert(_the_array_interfaces_array->obj_at(1) ==

             SystemDictionary::serializable_klass(), "u3");

      // Verify element klass for system obj array klass

      assert(objArrayKlass::cast(_systemObjArrayKlassObj)->element_klass() == ok, "u1");

      assert(objArrayKlass::cast(_systemObjArrayKlassObj)->bottom_klass() == ok, "u2");

      // Verify super class for the classes created above

      assert(Klass::cast(boolArrayKlassObj()     )->super() == ok, "u3");

      assert(Klass::cast(charArrayKlassObj()     )->super() == ok, "u3");

      assert(Klass::cast(singleArrayKlassObj()   )->super() == ok, "u3");

      assert(Klass::cast(doubleArrayKlassObj()   )->super() == ok, "u3");

      assert(Klass::cast(byteArrayKlassObj()     )->super() == ok, "u3");

      assert(Klass::cast(shortArrayKlassObj()    )->super() == ok, "u3");

      assert(Klass::cast(intArrayKlassObj()      )->super() == ok, "u3");

      assert(Klass::cast(longArrayKlassObj()     )->super() == ok, "u3");

      assert(Klass::cast(constantPoolKlassObj()  )->super() == ok, "u3");

      assert(Klass::cast(systemObjArrayKlassObj())->super() == ok, "u3");

    } else {

      // Set up shared interfaces array.  (Do this before supers are set up.)

      _the_array_interfaces_array->obj_at_put(0, SystemDictionary::cloneable_klass());

      _the_array_interfaces_array->obj_at_put(1, SystemDictionary::serializable_klass());

      // Set element klass for system obj array klass

      objArrayKlass::cast(_systemObjArrayKlassObj)->set_element_klass(ok);

      objArrayKlass::cast(_systemObjArrayKlassObj)->set_bottom_klass(ok);

      // Set super class for the classes created above

      Klass::cast(boolArrayKlassObj()     )->initialize_supers(ok, CHECK);

      Klass::cast(charArrayKlassObj()     )->initialize_supers(ok, CHECK);

      Klass::cast(singleArrayKlassObj()   )->initialize_supers(ok, CHECK);

      Klass::cast(doubleArrayKlassObj()   )->initialize_supers(ok, CHECK);

      Klass::cast(byteArrayKlassObj()     )->initialize_supers(ok, CHECK);

      Klass::cast(shortArrayKlassObj()    )->initialize_supers(ok, CHECK);

      Klass::cast(intArrayKlassObj()      )->initialize_supers(ok, CHECK);

      Klass::cast(longArrayKlassObj()     )->initialize_supers(ok, CHECK);

      Klass::cast(constantPoolKlassObj()  )->initialize_supers(ok, CHECK);

      Klass::cast(systemObjArrayKlassObj())->initialize_supers(ok, CHECK);

      Klass::cast(boolArrayKlassObj()     )->set_super(ok);

      Klass::cast(charArrayKlassObj()     )->set_super(ok);

      Klass::cast(singleArrayKlassObj()   )->set_super(ok);

      Klass::cast(doubleArrayKlassObj()   )->set_super(ok);

      Klass::cast(byteArrayKlassObj()     )->set_super(ok);

      Klass::cast(shortArrayKlassObj()    )->set_super(ok);

      Klass::cast(intArrayKlassObj()      )->set_super(ok);

      Klass::cast(longArrayKlassObj()     )->set_super(ok);

      Klass::cast(constantPoolKlassObj()  )->set_super(ok);

      Klass::cast(systemObjArrayKlassObj())->set_super(ok);

    }

    Klass::cast(boolArrayKlassObj()     )->append_to_sibling_list();

    Klass::cast(charArrayKlassObj()     )->append_to_sibling_list();

    Klass::cast(singleArrayKlassObj()   )->append_to_sibling_list();

    Klass::cast(doubleArrayKlassObj()   )->append_to_sibling_list();

    Klass::cast(byteArrayKlassObj()     )->append_to_sibling_list();

    Klass::cast(shortArrayKlassObj()    )->append_to_sibling_list();

    Klass::cast(intArrayKlassObj()      )->append_to_sibling_list();

    Klass::cast(longArrayKlassObj()     )->append_to_sibling_list();

    Klass::cast(constantPoolKlassObj()  )->append_to_sibling_list();

    Klass::cast(systemObjArrayKlassObj())->append_to_sibling_list();

  } // end of core bootstrapping

  // Initialize _objectArrayKlass after core bootstraping to make

  // sure the super class is set up properly for _objectArrayKlass.

  _objectArrayKlassObj = instanceKlass::

    cast(SystemDictionary::object_klass())->array_klass(1, CHECK);

  // Add the class to the class hierarchy manually to make sure that

  // its vtable is initialized after core bootstrapping is completed.

  Klass::cast(_objectArrayKlassObj)->append_to_sibling_list();

  // Compute is_jdk version flags.

  // Only 1.3 or later has the java.lang.Shutdown class.

  // Only 1.4 or later has the java.lang.CharSequence interface.

  // Only 1.5 or later has the java.lang.management.MemoryUsage class.

  if (JDK_Version::is_partially_initialized()) {

    uint8_t jdk_version;

    klassOop k = SystemDictionary::resolve_or_null(

        vmSymbolHandles::java_lang_management_MemoryUsage(), THREAD);

    CLEAR_PENDING_EXCEPTION; // ignore exceptions

    if (k == NULL) {

      k = SystemDictionary::resolve_or_null(

          vmSymbolHandles::java_lang_CharSequence(), THREAD);

      CLEAR_PENDING_EXCEPTION; // ignore exceptions

      if (k == NULL) {

        k = SystemDictionary::resolve_or_null(

            vmSymbolHandles::java_lang_Shutdown(), THREAD);

        CLEAR_PENDING_EXCEPTION; // ignore exceptions

        if (k == NULL) {

          jdk_version = 2;

        } else {

          jdk_version = 3;

        }

      } else {

        jdk_version = 4;

      }

    } else {

      jdk_version = 5;

    }

    JDK_Version::fully_initialize(jdk_version);

  }

  #ifdef ASSERT

  if (FullGCALot) {

    // Allocate an array of dummy objects.

    // We'd like these to be at the bottom of the old generation,

    // so that when we free one and then collect,

    // (almost) the whole heap moves

    // and we find out if we actually update all the oops correctly.

    // But we can't allocate directly in the old generation,

    // so we allocate wherever, and hope that the first collection

    // moves these objects to the bottom of the old generation.

    // We can allocate directly in the permanent generation, so we do.

    int size;

    if (UseConcMarkSweepGC) {

      warning("Using +FullGCALot with concurrent mark sweep gc "

              "will not force all objects to relocate");

      size = FullGCALotDummies;

    } else {

      size = FullGCALotDummies * 2;

    }

    objArrayOop    naked_array = oopFactory::new_system_objArray(size, CHECK);

    objArrayHandle dummy_array(THREAD, naked_array);

    int i = 0;

    while (i < size) {

      if (!UseConcMarkSweepGC) {

        // Allocate dummy in old generation

        oop dummy = instanceKlass::cast(SystemDictionary::object_klass())->allocate_instance(CHECK);

        dummy_array->obj_at_put(i++, dummy);

      }

      // Allocate dummy in permanent generation

      oop dummy = instanceKlass::cast(SystemDictionary::object_klass())->allocate_permanent_instance(CHECK);

      dummy_array->obj_at_put(i++, dummy);

    }

    {

      // Only modify the global variable inside the mutex.

      // If we had a race to here, the other dummy_array instances

      // and their elements just get dropped on the floor, which is fine.

      MutexLocker ml(FullGCALot_lock);

      if (_fullgc_alot_dummy_array == NULL) {

        _fullgc_alot_dummy_array = dummy_array();

      }

    }

    assert(i == _fullgc_alot_dummy_array->length(), "just checking");

  }

  #endif

}

static inline void add_vtable(void** list, int* n, Klass* o, int count) {

  list[(*n)++] = *(void**)&o->vtbl_value();

  guarantee((*n) <= count, "vtable list too small.");

}

void Universe::init_self_patching_vtbl_list(void** list, int count) {

  int n = 0;

  { klassKlass o;             add_vtable(list, &n, &o, count); }

  { arrayKlassKlass o;        add_vtable(list, &n, &o, count); }

  { objArrayKlassKlass o;     add_vtable(list, &n, &o, count); }

  { instanceKlassKlass o;     add_vtable(list, &n, &o, count); }

  { instanceKlass o;          add_vtable(list, &n, &o, count); }

  { instanceRefKlass o;       add_vtable(list, &n, &o, count); }

  { typeArrayKlassKlass o;    add_vtable(list, &n, &o, count); }

  { symbolKlass o;            add_vtable(list, &n, &o, count); }

  { typeArrayKlass o;         add_vtable(list, &n, &o, count); }

  { methodKlass o;            add_vtable(list, &n, &o, count); }

  { constMethodKlass o;       add_vtable(list, &n, &o, count); }

  { constantPoolKlass o;      add_vtable(list, &n, &o, count); }

  { constantPoolCacheKlass o; add_vtable(list, &n, &o, count); }

  { objArrayKlass o;          add_vtable(list, &n, &o, count); }

  { methodDataKlass o;        add_vtable(list, &n, &o, count); }

  { compiledICHolderKlass o;  add_vtable(list, &n, &o, count); }

}

class FixupMirrorClosure: public ObjectClosure {

 public:

  virtual void do_object(oop obj) {

    if (obj->is_klass()) {

      EXCEPTION_MARK;

      KlassHandle k(THREAD, klassOop(obj));

      // We will never reach the CATCH below since Exceptions::_throw will cause

      // the VM to exit if an exception is thrown during initialization

      java_lang_Class::create_mirror(k, CATCH);

      // This call unconditionally creates a new mirror for k,

      // and links in k's component_mirror field if k is an array.

      // If k is an objArray, k's element type must already have

      // a mirror.  In other words, this closure must process

      // the component type of an objArray k before it processes k.

      // This works because the permgen iterator presents arrays

      // and their component types in order of creation.

    }

  }

};

void Universe::initialize_basic_type_mirrors(TRAPS) {

  if (UseSharedSpaces) {

    assert(_int_mirror != NULL, "already loaded");

    assert(_void_mirror == _mirrors[T_VOID], "consistently loaded");

  } else {

    assert(_int_mirror==NULL, "basic type mirrors already initialized");

    _int_mirror     =

      java_lang_Class::create_basic_type_mirror("int",    T_INT, CHECK);

    _float_mirror   =

      java_lang_Class::create_basic_type_mirror("float",  T_FLOAT,   CHECK);

    _double_mirror  =

      java_lang_Class::create_basic_type_mirror("double", T_DOUBLE,  CHECK);

    _byte_mirror    =

      java_lang_Class::create_basic_type_mirror("byte",   T_BYTE, CHECK);

    _bool_mirror    =

      java_lang_Class::create_basic_type_mirror("boolean",T_BOOLEAN, CHECK);

    _char_mirror    =

      java_lang_Class::create_basic_type_mirror("char",   T_CHAR, CHECK);

    _long_mirror    =

      java_lang_Class::create_basic_type_mirror("long",   T_LONG, CHECK);

    _short_mirror   =

      java_lang_Class::create_basic_type_mirror("short",  T_SHORT,   CHECK);

    _void_mirror    =

      java_lang_Class::create_basic_type_mirror("void",   T_VOID, CHECK);

    _mirrors[T_INT]     = _int_mirror;

    _mirrors[T_FLOAT]   = _float_mirror;

    _mirrors[T_DOUBLE]  = _double_mirror;

    _mirrors[T_BYTE]    = _byte_mirror;

    _mirrors[T_BOOLEAN] = _bool_mirror;

    _mirrors[T_CHAR]    = _char_mirror;

    _mirrors[T_LONG]    = _long_mirror;

    _mirrors[T_SHORT]   = _short_mirror;

    _mirrors[T_VOID]    = _void_mirror;