/*

 * Copyright (c) 1997, 2019, 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 "aot/aotLoader.hpp"

#include "classfile/classLoader.hpp"

#include "classfile/classLoaderDataGraph.hpp"

#include "classfile/javaClasses.hpp"

#include "classfile/stringTable.hpp"

#include "classfile/symbolTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "code/codeBehaviours.hpp"

#include "code/codeCache.hpp"

#include "code/dependencies.hpp"

#include "gc/shared/collectedHeap.inline.hpp"

#include "gc/shared/gcArguments.hpp"

#include "gc/shared/gcConfig.hpp"

#include "gc/shared/gcTraceTime.inline.hpp"

#include "interpreter/interpreter.hpp"

#include "logging/log.hpp"

#include "logging/logStream.hpp"

#include "memory/heapShared.hpp"

#include "memory/filemap.hpp"

#include "memory/metadataFactory.hpp"

#include "memory/metaspaceClosure.hpp"

#include "memory/metaspaceCounters.hpp"

#include "memory/metaspaceShared.hpp"

#include "memory/oopFactory.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.hpp"

#include "oops/compressedOops.hpp"

#include "oops/constantPool.hpp"

#include "oops/instanceClassLoaderKlass.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/instanceMirrorKlass.hpp"

#include "oops/instanceRefKlass.hpp"

#include "oops/objArrayOop.inline.hpp"

#include "oops/oop.inline.hpp"

#include "oops/typeArrayKlass.hpp"

#include "prims/resolvedMethodTable.hpp"

#include "runtime/arguments.hpp"

#include "runtime/atomic.hpp"

#include "runtime/deoptimization.hpp"

#include "runtime/flags/flagSetting.hpp"

#include "runtime/flags/jvmFlagConstraintList.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/thread.inline.hpp"

#include "runtime/timerTrace.hpp"

#include "runtime/vmOperations.hpp"

#include "services/memoryService.hpp"

#include "utilities/align.hpp"

#include "utilities/copy.hpp"

#include "utilities/debug.hpp"

#include "utilities/events.hpp"

#include "utilities/formatBuffer.hpp"

#include "utilities/hashtable.inline.hpp"

#include "utilities/macros.hpp"

#include "utilities/ostream.hpp"

#include "utilities/preserveException.hpp"

// Known objects

Klass* Universe::_typeArrayKlassObjs[T_LONG+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_sentinel                      = NULL;

oop Universe::_the_null_string                        = NULL;

oop Universe::_the_min_jint_string                   = NULL;

LatestMethodCache* Universe::_finalizer_register_cache = NULL;

LatestMethodCache* Universe::_loader_addClass_cache    = NULL;

LatestMethodCache* Universe::_throw_illegal_access_error_cache = NULL;

LatestMethodCache* Universe::_throw_no_such_method_error_cache = NULL;

LatestMethodCache* Universe::_do_stack_walk_cache     = NULL;

oop Universe::_out_of_memory_error_java_heap          = NULL;

oop Universe::_out_of_memory_error_metaspace          = NULL;

oop Universe::_out_of_memory_error_class_metaspace    = NULL;

oop Universe::_out_of_memory_error_array_size         = NULL;

oop Universe::_out_of_memory_error_gc_overhead_limit  = NULL;

oop Universe::_out_of_memory_error_realloc_objects    = NULL;

oop Universe::_out_of_memory_error_retry              = NULL;

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

long Universe::verify_flags                           = Universe::Verify_All;

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::_reference_pending_list                 = 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<InstanceKlass*>* Universe::_the_empty_instance_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;

// Oop verification (see MacroAssembler::verify_oop)

uintptr_t       Universe::_verify_oop_mask = 0;

uintptr_t       Universe::_verify_oop_bits = (uintptr_t) -1;

int             Universe::_base_vtable_size = 0;

bool            Universe::_bootstrapping = false;

bool            Universe::_module_initialized = 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;

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

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

    f(_typeArrayKlassObjs[i]);

  }

}

void Universe::basic_type_classes_do(KlassClosure *closure) {

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

    closure->do_klass(_typeArrayKlassObjs[i]);

  }

}

void Universe::oops_do(OopClosure* f) {

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

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

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

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

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

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

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

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

}

void LatestMethodCache::metaspace_pointers_do(MetaspaceClosure* it) {

  it->push(&_klass);

}

void Universe::metaspace_pointers_do(MetaspaceClosure* it) {

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

    it->push(&_typeArrayKlassObjs[i]);

  }

  it->push(&_objectArrayKlassObj);

  it->push(&_the_empty_int_array);

  it->push(&_the_empty_short_array);

  it->push(&_the_empty_klass_array);

  it->push(&_the_empty_instance_klass_array);

  it->push(&_the_empty_method_array);

  it->push(&_the_array_interfaces_array);

  _finalizer_register_cache->metaspace_pointers_do(it);

  _loader_addClass_cache->metaspace_pointers_do(it);

  _throw_illegal_access_error_cache->metaspace_pointers_do(it);

  _throw_no_such_method_error_cache->metaspace_pointers_do(it);

  _do_stack_walk_cache->metaspace_pointers_do(it);

}

// Serialize metadata and pointers to primitive type mirrors in and out of CDS archive

void Universe::serialize(SerializeClosure* f) {

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

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

  }

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

#if INCLUDE_CDS_JAVA_HEAP

#ifdef ASSERT

  if (DumpSharedSpaces && !HeapShared::is_heap_object_archiving_allowed()) {

    assert(_int_mirror == NULL    && _float_mirror == NULL &&

           _double_mirror == NULL && _byte_mirror == NULL  &&

           _bool_mirror == NULL   && _char_mirror == NULL  &&

           _long_mirror == NULL   && _short_mirror == NULL &&

           _void_mirror == NULL, "mirrors should be NULL");

  }

#endif

  f->do_oop(&_int_mirror);

  f->do_oop(&_float_mirror);

  f->do_oop(&_double_mirror);

  f->do_oop(&_byte_mirror);

  f->do_oop(&_bool_mirror);

  f->do_oop(&_char_mirror);

  f->do_oop(&_long_mirror);

  f->do_oop(&_short_mirror);

  f->do_oop(&_void_mirror);

#endif

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

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

  _finalizer_register_cache->serialize(f);

  _loader_addClass_cache->serialize(f);

  _throw_illegal_access_error_cache->serialize(f);

  _throw_no_such_method_error_cache->serialize(f);

  _do_stack_walk_cache->serialize(f);

}

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

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

    vm_exit_during_initialization(

      err_msg("Size of %s (" UINTX_FORMAT " bytes) must be aligned to " UINTX_FORMAT " bytes", name, size, alignment));

  }

}

void initialize_basic_type_klass(Klass* k, TRAPS) {

  Klass* ok = SystemDictionary::Object_klass();

#if INCLUDE_CDS

  if (UseSharedSpaces) {

    ClassLoaderData* loader_data = ClassLoaderData::the_null_class_loader_data();

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

    k->restore_unshareable_info(loader_data, Handle(), CHECK);

  } else

#endif

  {

    k->initialize_supers(ok, NULL, CHECK);

  }

  k->append_to_sibling_list();

}

void Universe::genesis(TRAPS) {

  ResourceMark rm;

  { FlagSetting fs(_bootstrapping, true);

    { MutexLocker mc(Compile_lock);

      java_lang_Class::allocate_fixup_lists();

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

      compute_base_vtable_size();

      if (!UseSharedSpaces) {

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

          _typeArrayKlassObjs[i] = TypeArrayKlass::create_klass((BasicType)i, CHECK);

        }

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

        _the_empty_instance_klass_array = MetadataFactory::new_array<InstanceKlass*>(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 INCLUDE_CDS

    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

#endif

    {

      // 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(floatArrayKlassObj(), 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

  {

    Handle tns = java_lang_String::create_from_str("<null_sentinel>", CHECK);

    _the_null_sentinel = tns();

  }

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

  _objectArrayKlassObj->append_to_sibling_list();

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

      log_warning(gc)("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 = 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

}

void Universe::initialize_basic_type_mirrors(TRAPS) {

#if INCLUDE_CDS_JAVA_HEAP

    if (UseSharedSpaces &&

        HeapShared::open_archive_heap_region_mapped() &&

        _int_mirror != NULL) {

      assert(HeapShared::is_heap_object_archiving_allowed(), "Sanity");

      assert(_float_mirror != NULL && _double_mirror != NULL &&

             _byte_mirror  != NULL && _byte_mirror   != NULL &&

             _bool_mirror  != NULL && _char_mirror   != NULL &&

             _long_mirror  != NULL && _short_mirror  != NULL &&

             _void_mirror  != NULL, "Sanity");

    } else

#endif

    {

      _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]  = _object_klass->java_mirror();

  //_mirrors[T_ARRAY]   = _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);

  if (!UseSharedSpaces) {

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

    java_lang_Class::fixup_mirror(k, CATCH);

  }