/*

 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#include "precompiled.hpp"

#include "classfile/classLoader.hpp"

#include "classfile/javaClasses.hpp"

#include "classfile/symbolTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "code/codeCache.hpp"

#include "code/dependencies.hpp"

#include "gc_interface/collectedHeap.inline.hpp"

#include "interpreter/interpreter.hpp"

#include "memory/cardTableModRefBS.hpp"

#include "memory/filemap.hpp"

#include "memory/gcLocker.inline.hpp"

#include "memory/genCollectedHeap.hpp"

#include "memory/genRemSet.hpp"

#include "memory/generation.hpp"

#include "memory/oopFactory.hpp"

#include "memory/permGen.hpp"

#include "memory/space.hpp"

#include "memory/universe.hpp"

#include "memory/universe.inline.hpp"

#include "oops/arrayKlassKlass.hpp"

#include "oops/compiledICHolderKlass.hpp"

#include "oops/constMethodKlass.hpp"

#include "oops/constantPoolKlass.hpp"

#include "oops/constantPoolOop.hpp"

#include "oops/cpCacheKlass.hpp"

#include "oops/cpCacheOop.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/instanceMirrorKlass.hpp"

#include "oops/instanceKlassKlass.hpp"

#include "oops/instanceRefKlass.hpp"

#include "oops/klassKlass.hpp"

#include "oops/klassOop.hpp"

#include "oops/methodDataKlass.hpp"

#include "oops/methodKlass.hpp"

#include "oops/objArrayKlassKlass.hpp"

#include "oops/oop.inline.hpp"

#include "oops/typeArrayKlass.hpp"

#include "oops/typeArrayKlassKlass.hpp"

#include "prims/jvmtiRedefineClassesTrace.hpp"

#include "runtime/aprofiler.hpp"

#include "runtime/arguments.hpp"

#include "runtime/deoptimization.hpp"

#include "runtime/fprofiler.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/init.hpp"

#include "runtime/java.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/synchronizer.hpp"

#include "runtime/timer.hpp"

#include "runtime/vm_operations.hpp"

#include "services/memoryService.hpp"

#include "utilities/copy.hpp"

#include "utilities/events.hpp"

#include "utilities/hashtable.inline.hpp"

#include "utilities/preserveException.hpp"

#ifdef TARGET_OS_FAMILY_linux

# include "thread_linux.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_solaris

# include "thread_solaris.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_windows

# include "thread_windows.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_bsd

# include "thread_bsd.inline.hpp"

#endif

#ifndef SERIALGC

#include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp"

#include "gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.hpp"

#include "gc_implementation/g1/g1CollectedHeap.inline.hpp"

#include "gc_implementation/g1/g1CollectorPolicy.hpp"

#include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"

#endif

// 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::_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;

oop Universe::_the_null_string                        = NULL;

oop Universe::_the_min_jint_string                   = 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;

// 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;

NarrowOopStruct Universe::_narrow_oop = { NULL, 0, true };

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(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*)&_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);

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

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

  _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);

  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);

        _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);

      }

    }

    vmSymbols::initialize(CHECK);

    SystemDictionary::initialize(CHECK);

    klassOop ok = SystemDictionary::Object_klass();

    _the_null_string            = StringTable::intern("null", CHECK);

    _the_min_jint_string       = StringTable::intern("-2147483648", CHECK);

    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(

        vmSymbols::java_lang_management_MemoryUsage(), THREAD);

    CLEAR_PENDING_EXCEPTION; // ignore exceptions

    if (k == NULL) {

      k = SystemDictionary::resolve_or_null(

          vmSymbols::java_lang_CharSequence(), THREAD);

      CLEAR_PENDING_EXCEPTION; // ignore exceptions

      if (k == NULL) {

        k = SystemDictionary::resolve_or_null(

            vmSymbols::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* dereference(void* addr) {

  return *(void**)addr;

}

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

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

  void* vtable = dereference(o);