/*

 * 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/classLoaderData.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/gcLocker.inline.hpp"

#include "memory/genCollectedHeap.hpp"

#include "memory/genRemSet.hpp"

#include "memory/generation.hpp"

#include "memory/metadataFactory.hpp"

#include "memory/metaspaceShared.hpp"

#include "memory/oopFactory.hpp"

#include "memory/space.hpp"

#include "memory/universe.hpp"

#include "memory/universe.inline.hpp"

#include "oops/constantPool.hpp"

#include "oops/instanceClassLoaderKlass.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/instanceMirrorKlass.hpp"

#include "oops/instanceRefKlass.hpp"

#include "oops/oop.inline.hpp"

#include "oops/typeArrayKlass.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

Klass* Universe::_boolArrayKlassObj                 = NULL;

Klass* Universe::_byteArrayKlassObj                 = NULL;

Klass* Universe::_charArrayKlassObj                 = NULL;

Klass* Universe::_intArrayKlassObj                  = NULL;

Klass* Universe::_shortArrayKlassObj                = NULL;

Klass* Universe::_longArrayKlassObj                 = NULL;

Klass* Universe::_singleArrayKlassObj               = NULL;

Klass* Universe::_doubleArrayKlassObj               = NULL;

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

Klass* Universe::_objectArrayKlassObj               = 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;

objArrayOop Universe::_the_empty_class_klass_array    = NULL;

Array<Klass*>* 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;

Array<int>* Universe::_the_empty_int_array            = NULL;

Array<u2>* Universe::_the_empty_short_array           = NULL;

Array<Klass*>* Universe::_the_empty_klass_array     = NULL;

Array<Method*>* Universe::_the_empty_method_array   = 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;

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

NarrowPtrStruct Universe::_narrow_klass = { NULL, 0, true };

address Universe::_narrow_ptrs_base;

void Universe::basic_type_classes_do(void f(Klass*)) {

  f(boolArrayKlassObj());

  f(byteArrayKlassObj());

  f(charArrayKlassObj());

  f(intArrayKlassObj());

  f(shortArrayKlassObj());

  f(longArrayKlassObj());

  f(singleArrayKlassObj());

  f(doubleArrayKlassObj());

}

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

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

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

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

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

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

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

}

// Serialize metadata in and out of CDS archive, not oops.

void Universe::serialize(SerializeClosure* f, bool do_all) {

  f->do_ptr((void**)&_boolArrayKlassObj);

  f->do_ptr((void**)&_byteArrayKlassObj);

  f->do_ptr((void**)&_charArrayKlassObj);

  f->do_ptr((void**)&_intArrayKlassObj);

  f->do_ptr((void**)&_shortArrayKlassObj);

  f->do_ptr((void**)&_longArrayKlassObj);

  f->do_ptr((void**)&_singleArrayKlassObj);

  f->do_ptr((void**)&_doubleArrayKlassObj);

  f->do_ptr((void**)&_objectArrayKlassObj);

  {

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

      if (_typeArrayKlassObjs[i] != NULL) {

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

        f->do_ptr((void**)&_typeArrayKlassObjs[i]);

      } else if (do_all) {

        f->do_ptr((void**)&_typeArrayKlassObjs[i]);

      }

    }

  }

  f->do_ptr((void**)&_the_array_interfaces_array);

  f->do_ptr((void**)&_the_empty_int_array);

  f->do_ptr((void**)&_the_empty_short_array);

  f->do_ptr((void**)&_the_empty_method_array);

  f->do_ptr((void**)&_the_empty_klass_array);

  _finalizer_register_cache->serialize(f);

  _loader_addClass_cache->serialize(f);

  _reflect_invoke_cache->serialize(f);

}

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 initialize_basic_type_klass(Klass* k, TRAPS) {

  Klass* ok = SystemDictionary::Object_klass();

  if (UseSharedSpaces) {

    assert(k->super() == ok, "u3");

    k->restore_unshareable_info(CHECK);

  } else {

    k->initialize_supers(ok, CHECK);

  }

  k->append_to_sibling_list();

}

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

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

        ClassLoaderData* null_cld = ClassLoaderData::the_null_class_loader_data();

        _the_array_interfaces_array = MetadataFactory::new_array<Klass*>(null_cld, 2, NULL, CHECK);

        _the_empty_int_array        = MetadataFactory::new_array<int>(null_cld, 0, CHECK);

        _the_empty_short_array      = MetadataFactory::new_array<u2>(null_cld, 0, CHECK);

        _the_empty_method_array     = MetadataFactory::new_array<Method*>(null_cld, 0, CHECK);

        _the_empty_klass_array      = MetadataFactory::new_array<Klass*>(null_cld, 0, CHECK);

      }

    }

    vmSymbols::initialize(CHECK);

    SystemDictionary::initialize(CHECK);

    Klass* 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->at(0) ==

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

      assert(_the_array_interfaces_array->at(1) ==

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

    } else {

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

      _the_array_interfaces_array->at_put(0, SystemDictionary::Cloneable_klass());

      _the_array_interfaces_array->at_put(1, SystemDictionary::Serializable_klass());

    }

    initialize_basic_type_klass(boolArrayKlassObj(), CHECK);

    initialize_basic_type_klass(charArrayKlassObj(), CHECK);

    initialize_basic_type_klass(singleArrayKlassObj(), CHECK);

    initialize_basic_type_klass(doubleArrayKlassObj(), CHECK);

    initialize_basic_type_klass(byteArrayKlassObj(), CHECK);

    initialize_basic_type_klass(shortArrayKlassObj(), CHECK);

    initialize_basic_type_klass(intArrayKlassObj(), CHECK);

    initialize_basic_type_klass(longArrayKlassObj(), CHECK);

  } // end of core bootstrapping

  // Maybe this could be lifted up now that object array can be initialized

  // during the bootstrapping.

  // OLD

  // Initialize _objectArrayKlass after core bootstraping to make

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

  // ---

  // NEW

  // Since some of the old system object arrays have been converted to

  // ordinary object arrays, _objectArrayKlass will be loaded when

  // SystemDictionary::initialize(CHECK); is run. See the extra check

  // for Object_klass_loaded in objArrayKlassKlass::allocate_objArray_klass_impl.

  _objectArrayKlassObj = InstanceKlass::

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

  // OLD

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

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

  // ---

  // New

  // Have already been initialized.

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

    Klass* 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_objArray(SystemDictionary::Object_klass(), size, CHECK);

    objArrayHandle dummy_array(THREAD, naked_array);

    int i = 0;

    while (i < size) {

        // Allocate dummy in old generation

      oop dummy = InstanceKlass::cast(SystemDictionary::Object_klass())->allocate_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

}

// CDS support for patching vtables in metadata in the shared archive.

// All types inherited from Metadata have vtables, but not types inherited

// from MetaspaceObj, because the latter does not have virtual functions.

// If the metadata type has a vtable, it cannot be shared in the read-only

// section of the CDS archive, because the vtable pointer is patched.

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

  assert(dereference(vtable) != NULL, "invalid vtable");

  list[(*n)++] = vtable;

}

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

  int n = 0;

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

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

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

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

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

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

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

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

}

void Universe::initialize_basic_type_mirrors(TRAPS) {

    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;

  //_mirrors[T_OBJECT]  = InstanceKlass::cast(_object_klass)->java_mirror();

  //_mirrors[T_ARRAY]   = InstanceKlass::cast(_object_klass)->java_mirror();

}

void Universe::fixup_mirrors(TRAPS) {

  // Bootstrap problem: all classes gets a mirror (java.lang.Class instance) assigned eagerly,

  // but we cannot do that for classes created before java.lang.Class is loaded. Here we simply

  // walk over permanent objects created so far (mostly classes) and fixup their mirrors. Note

  // that the number of objects allocated at this point is very small.

  assert(SystemDictionary::Class_klass_loaded(), "java.lang.Class should be loaded");

  HandleMark hm(THREAD);

  // Cache the start of the static fields

  InstanceMirrorKlass::init_offset_of_static_fields();

  GrowableArray <Klass*>* list = java_lang_Class::fixup_mirror_list();

  int list_length = list->length();

  for (int i = 0; i < list_length; i++) {

    Klass* k = list->at(i);

    assert(k->is_klass(), "List should only hold classes");

    EXCEPTION_MARK;

    KlassHandle kh(THREAD, k);

    java_lang_Class::fixup_mirror(kh, CATCH);

}

  delete java_lang_Class::fixup_mirror_list();