/*

 * Copyright (c) 1997, 2017, 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/classFileParser.hpp"

#include "classfile/classFileStream.hpp"

#include "classfile/classLoader.hpp"

#include "classfile/javaClasses.hpp"

#include "classfile/moduleEntry.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/systemDictionaryShared.hpp"

#include "classfile/verifier.hpp"

#include "classfile/vmSymbols.hpp"

#include "code/dependencyContext.hpp"

#include "compiler/compileBroker.hpp"

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

#include "gc/shared/specialized_oop_closures.hpp"

#include "interpreter/oopMapCache.hpp"

#include "interpreter/rewriter.hpp"

#include "jvmtifiles/jvmti.h"

#include "logging/log.hpp"

#include "logging/logMessage.hpp"

#include "logging/logStream.hpp"

#include "memory/heapInspection.hpp"

#include "memory/iterator.inline.hpp"

#include "memory/metadataFactory.hpp"

#include "memory/metaspaceClosure.hpp"

#include "memory/metaspaceShared.hpp"

#include "memory/oopFactory.hpp"

#include "memory/resourceArea.hpp"

#include "oops/fieldStreams.hpp"

#include "oops/instanceClassLoaderKlass.hpp"

#include "oops/instanceKlass.inline.hpp"

#include "oops/instanceMirrorKlass.hpp"

#include "oops/instanceOop.hpp"

#include "oops/klass.inline.hpp"

#include "oops/method.hpp"

#include "oops/oop.inline.hpp"

#include "oops/symbol.hpp"

#include "prims/jvm.h"

#include "prims/jvmtiExport.hpp"

#include "prims/jvmtiRedefineClasses.hpp"

#include "prims/jvmtiThreadState.hpp"

#include "prims/methodComparator.hpp"

#include "runtime/atomic.hpp"

#include "runtime/fieldDescriptor.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/mutexLocker.hpp"

#include "runtime/orderAccess.inline.hpp"

#include "runtime/thread.inline.hpp"

#include "services/classLoadingService.hpp"

#include "services/threadService.hpp"

#include "utilities/dtrace.hpp"

#include "utilities/macros.hpp"

#include "utilities/stringUtils.hpp"

#ifdef COMPILER1

#include "c1/c1_Compiler.hpp"

#endif

#ifdef DTRACE_ENABLED

#define HOTSPOT_CLASS_INITIALIZATION_required HOTSPOT_CLASS_INITIALIZATION_REQUIRED

#define HOTSPOT_CLASS_INITIALIZATION_recursive HOTSPOT_CLASS_INITIALIZATION_RECURSIVE

#define HOTSPOT_CLASS_INITIALIZATION_concurrent HOTSPOT_CLASS_INITIALIZATION_CONCURRENT

#define HOTSPOT_CLASS_INITIALIZATION_erroneous HOTSPOT_CLASS_INITIALIZATION_ERRONEOUS

#define HOTSPOT_CLASS_INITIALIZATION_super__failed HOTSPOT_CLASS_INITIALIZATION_SUPER_FAILED

#define HOTSPOT_CLASS_INITIALIZATION_clinit HOTSPOT_CLASS_INITIALIZATION_CLINIT

#define HOTSPOT_CLASS_INITIALIZATION_error HOTSPOT_CLASS_INITIALIZATION_ERROR

#define HOTSPOT_CLASS_INITIALIZATION_end HOTSPOT_CLASS_INITIALIZATION_END

#define DTRACE_CLASSINIT_PROBE(type, thread_type)                \

  {                                                              \

    char* data = NULL;                                           \

    int len = 0;                                                 \

    Symbol* clss_name = name();                                  \

    if (clss_name != NULL) {                                     \

      data = (char*)clss_name->bytes();                          \

      len = clss_name->utf8_length();                            \

    }                                                            \

    HOTSPOT_CLASS_INITIALIZATION_##type(                         \

      data, len, (void*)class_loader(), thread_type);            \

  }

#define DTRACE_CLASSINIT_PROBE_WAIT(type, thread_type, wait)     \

  {                                                              \

    char* data = NULL;                                           \

    int len = 0;                                                 \

    Symbol* clss_name = name();                                  \

    if (clss_name != NULL) {                                     \

      data = (char*)clss_name->bytes();                          \

      len = clss_name->utf8_length();                            \

    }                                                            \

    HOTSPOT_CLASS_INITIALIZATION_##type(                         \

      data, len, (void*)class_loader(), thread_type, wait);      \

  }

#else //  ndef DTRACE_ENABLED

#define DTRACE_CLASSINIT_PROBE(type, thread_type)

#define DTRACE_CLASSINIT_PROBE_WAIT(type, thread_type, wait)

#endif //  ndef DTRACE_ENABLED

volatile int InstanceKlass::_total_instanceKlass_count = 0;

static inline bool is_class_loader(const Symbol* class_name,

                                   const ClassFileParser& parser) {

  assert(class_name != NULL, "invariant");

  if (class_name == vmSymbols::java_lang_ClassLoader()) {

    return true;

  }

  if (SystemDictionary::ClassLoader_klass_loaded()) {

    const Klass* const super_klass = parser.super_klass();

    if (super_klass != NULL) {

      if (super_klass->is_subtype_of(SystemDictionary::ClassLoader_klass())) {

        return true;

      }

    }

  }

  return false;

}

InstanceKlass* InstanceKlass::allocate_instance_klass(const ClassFileParser& parser, TRAPS) {

  const int size = InstanceKlass::size(parser.vtable_size(),

                                       parser.itable_size(),

                                       nonstatic_oop_map_size(parser.total_oop_map_count()),

                                       parser.is_interface(),

                                       parser.is_anonymous(),

                                       should_store_fingerprint());

  const Symbol* const class_name = parser.class_name();

  assert(class_name != NULL, "invariant");

  ClassLoaderData* loader_data = parser.loader_data();

  assert(loader_data != NULL, "invariant");

  InstanceKlass* ik;

  // Allocation

  if (REF_NONE == parser.reference_type()) {

    if (class_name == vmSymbols::java_lang_Class()) {

      // mirror

      ik = new (loader_data, size, THREAD) InstanceMirrorKlass(parser);

    }

    else if (is_class_loader(class_name, parser)) {

      // class loader

      ik = new (loader_data, size, THREAD) InstanceClassLoaderKlass(parser);

    }

    else {

      // normal

      ik = new (loader_data, size, THREAD) InstanceKlass(parser, InstanceKlass::_misc_kind_other);

    }

  }

  else {

    // reference

    ik = new (loader_data, size, THREAD) InstanceRefKlass(parser);

  }

  // Check for pending exception before adding to the loader data and incrementing

  // class count.  Can get OOM here.

  if (HAS_PENDING_EXCEPTION) {

    return NULL;

  }

  assert(ik != NULL, "invariant");

  const bool publicize = !parser.is_internal();

  // Add all classes to our internal class loader list here,

  // including classes in the bootstrap (NULL) class loader.

  loader_data->add_class(ik, publicize);

  Atomic::inc(&_total_instanceKlass_count);

  return ik;

}

// copy method ordering from resource area to Metaspace

void InstanceKlass::copy_method_ordering(const intArray* m, TRAPS) {

  if (m != NULL) {

    // allocate a new array and copy contents (memcpy?)

    _method_ordering = MetadataFactory::new_array<int>(class_loader_data(), m->length(), CHECK);

    for (int i = 0; i < m->length(); i++) {

      _method_ordering->at_put(i, m->at(i));

    }

  } else {

    _method_ordering = Universe::the_empty_int_array();

  }

}

// create a new array of vtable_indices for default methods

Array<int>* InstanceKlass::create_new_default_vtable_indices(int len, TRAPS) {

  Array<int>* vtable_indices = MetadataFactory::new_array<int>(class_loader_data(), len, CHECK_NULL);

  assert(default_vtable_indices() == NULL, "only create once");

  set_default_vtable_indices(vtable_indices);

  return vtable_indices;

}

InstanceKlass::InstanceKlass(const ClassFileParser& parser, unsigned kind) :

  _static_field_size(parser.static_field_size()),

  _nonstatic_oop_map_size(nonstatic_oop_map_size(parser.total_oop_map_count())),

  _itable_len(parser.itable_size()),

  _reference_type(parser.reference_type()) {

    set_vtable_length(parser.vtable_size());

    set_kind(kind);

    set_access_flags(parser.access_flags());

    set_is_anonymous(parser.is_anonymous());

    set_layout_helper(Klass::instance_layout_helper(parser.layout_size(),

                                                    false));

    assert(NULL == _methods, "underlying memory not zeroed?");

    assert(is_instance_klass(), "is layout incorrect?");

    assert(size_helper() == parser.layout_size(), "incorrect size_helper?");

}

void InstanceKlass::deallocate_methods(ClassLoaderData* loader_data,

                                       Array<Method*>* methods) {

  if (methods != NULL && methods != Universe::the_empty_method_array() &&

      !methods->is_shared()) {

    for (int i = 0; i < methods->length(); i++) {

      Method* method = methods->at(i);

      if (method == NULL) continue;  // maybe null if error processing

      // Only want to delete methods that are not executing for RedefineClasses.

      // The previous version will point to them so they're not totally dangling

      assert (!method->on_stack(), "shouldn't be called with methods on stack");

      MetadataFactory::free_metadata(loader_data, method);

    }

    MetadataFactory::free_array<Method*>(loader_data, methods);

  }

}

void InstanceKlass::deallocate_interfaces(ClassLoaderData* loader_data,

                                          const Klass* super_klass,

                                          Array<Klass*>* local_interfaces,

                                          Array<Klass*>* transitive_interfaces) {

  // Only deallocate transitive interfaces if not empty, same as super class

  // or same as local interfaces.  See code in parseClassFile.

  Array<Klass*>* ti = transitive_interfaces;

  if (ti != Universe::the_empty_klass_array() && ti != local_interfaces) {

    // check that the interfaces don't come from super class

    Array<Klass*>* sti = (super_klass == NULL) ? NULL :

                    InstanceKlass::cast(super_klass)->transitive_interfaces();

    if (ti != sti && ti != NULL && !ti->is_shared()) {

      MetadataFactory::free_array<Klass*>(loader_data, ti);

    }

  }

  // local interfaces can be empty

  if (local_interfaces != Universe::the_empty_klass_array() &&

      local_interfaces != NULL && !local_interfaces->is_shared()) {

    MetadataFactory::free_array<Klass*>(loader_data, local_interfaces);

  }

}

// This function deallocates the metadata and C heap pointers that the

// InstanceKlass points to.

void InstanceKlass::deallocate_contents(ClassLoaderData* loader_data) {

  // Orphan the mirror first, CMS thinks it's still live.

  if (java_mirror() != NULL) {

    java_lang_Class::set_klass(java_mirror(), NULL);

  }

  // Need to take this class off the class loader data list.

  loader_data->remove_class(this);

  // The array_klass for this class is created later, after error handling.

  // For class redefinition, we keep the original class so this scratch class

  // doesn't have an array class.  Either way, assert that there is nothing

  // to deallocate.

  assert(array_klasses() == NULL, "array classes shouldn't be created for this class yet");

  // Release C heap allocated data that this might point to, which includes

  // reference counting symbol names.

  release_C_heap_structures();

  deallocate_methods(loader_data, methods());

  set_methods(NULL);

  if (method_ordering() != NULL &&

      method_ordering() != Universe::the_empty_int_array() &&

      !method_ordering()->is_shared()) {

    MetadataFactory::free_array<int>(loader_data, method_ordering());

  }

  set_method_ordering(NULL);

  // default methods can be empty

  if (default_methods() != NULL &&

      default_methods() != Universe::the_empty_method_array() &&

      !default_methods()->is_shared()) {

    MetadataFactory::free_array<Method*>(loader_data, default_methods());

  }

  // Do NOT deallocate the default methods, they are owned by superinterfaces.

  set_default_methods(NULL);

  // default methods vtable indices can be empty

  if (default_vtable_indices() != NULL &&

      !default_vtable_indices()->is_shared()) {

    MetadataFactory::free_array<int>(loader_data, default_vtable_indices());

  }

  set_default_vtable_indices(NULL);

  // This array is in Klass, but remove it with the InstanceKlass since

  // this place would be the only caller and it can share memory with transitive

  // interfaces.

  if (secondary_supers() != NULL &&

      secondary_supers() != Universe::the_empty_klass_array() &&

      secondary_supers() != transitive_interfaces() &&

      !secondary_supers()->is_shared()) {

    MetadataFactory::free_array<Klass*>(loader_data, secondary_supers());

  }

  set_secondary_supers(NULL);

  deallocate_interfaces(loader_data, super(), local_interfaces(), transitive_interfaces());

  set_transitive_interfaces(NULL);

  set_local_interfaces(NULL);

  if (fields() != NULL && !fields()->is_shared()) {

    MetadataFactory::free_array<jushort>(loader_data, fields());

  }

  set_fields(NULL, 0);

  // If a method from a redefined class is using this constant pool, don't

  // delete it, yet.  The new class's previous version will point to this.

  if (constants() != NULL) {

    assert (!constants()->on_stack(), "shouldn't be called if anything is onstack");

    if (!constants()->is_shared()) {

      MetadataFactory::free_metadata(loader_data, constants());

    }

    // Delete any cached resolution errors for the constant pool

    SystemDictionary::delete_resolution_error(constants());

    set_constants(NULL);

  }

  if (inner_classes() != NULL &&

      inner_classes() != Universe::the_empty_short_array() &&

      !inner_classes()->is_shared()) {

    MetadataFactory::free_array<jushort>(loader_data, inner_classes());

  }

  set_inner_classes(NULL);

  // We should deallocate the Annotations instance if it's not in shared spaces.

  if (annotations() != NULL && !annotations()->is_shared()) {

    MetadataFactory::free_metadata(loader_data, annotations());

  }

  set_annotations(NULL);

}

bool InstanceKlass::should_be_initialized() const {

  return !is_initialized();

}

klassItable InstanceKlass::itable() const {

  return klassItable(const_cast<InstanceKlass*>(this));

}

void InstanceKlass::eager_initialize(Thread *thread) {

  if (!EagerInitialization) return;

  if (this->is_not_initialized()) {

    // abort if the the class has a class initializer

    if (this->class_initializer() != NULL) return;

    // abort if it is java.lang.Object (initialization is handled in genesis)

    Klass* super_klass = super();

    if (super_klass == NULL) return;

    // abort if the super class should be initialized

    if (!InstanceKlass::cast(super_klass)->is_initialized()) return;

    // call body to expose the this pointer

    eager_initialize_impl();

  }

}

// JVMTI spec thinks there are signers and protection domain in the

// instanceKlass.  These accessors pretend these fields are there.

// The hprof specification also thinks these fields are in InstanceKlass.

oop InstanceKlass::protection_domain() const {

  // return the protection_domain from the mirror

  return java_lang_Class::protection_domain(java_mirror());

}

// To remove these from requires an incompatible change and CCC request.

objArrayOop InstanceKlass::signers() const {

  // return the signers from the mirror

  return java_lang_Class::signers(java_mirror());

}

oop InstanceKlass::init_lock() const {

  // return the init lock from the mirror

  oop lock = java_lang_Class::init_lock(java_mirror());

  // Prevent reordering with any access of initialization state

  OrderAccess::loadload();

  assert((oop)lock != NULL || !is_not_initialized(), // initialized or in_error state

         "only fully initialized state can have a null lock");

  return lock;

}

// Set the initialization lock to null so the object can be GC'ed.  Any racing

// threads to get this lock will see a null lock and will not lock.

// That's okay because they all check for initialized state after getting

// the lock and return.

void InstanceKlass::fence_and_clear_init_lock() {

  // make sure previous stores are all done, notably the init_state.

  OrderAccess::storestore();

  java_lang_Class::set_init_lock(java_mirror(), NULL);

  assert(!is_not_initialized(), "class must be initialized now");

}

void InstanceKlass::eager_initialize_impl() {

  EXCEPTION_MARK;

  HandleMark hm(THREAD);

  Handle h_init_lock(THREAD, init_lock());

  ObjectLocker ol(h_init_lock, THREAD, h_init_lock() != NULL);

  // abort if someone beat us to the initialization

  if (!is_not_initialized()) return;  // note: not equivalent to is_initialized()

  ClassState old_state = init_state();

  link_class_impl(true, THREAD);

  if (HAS_PENDING_EXCEPTION) {

    CLEAR_PENDING_EXCEPTION;

    // Abort if linking the class throws an exception.

    // Use a test to avoid redundantly resetting the state if there's

    // no change.  Set_init_state() asserts that state changes make

    // progress, whereas here we might just be spinning in place.

    if (old_state != _init_state)

      set_init_state(old_state);

  } else {

    // linking successfull, mark class as initialized

    set_init_state(fully_initialized);

    fence_and_clear_init_lock();

    // trace

    if (log_is_enabled(Info, class, init)) {

      ResourceMark rm(THREAD);

      log_info(class, init)("[Initialized %s without side effects]", external_name());

    }

  }

}

// See "The Virtual Machine Specification" section 2.16.5 for a detailed explanation of the class initialization

// process. The step comments refers to the procedure described in that section.

// Note: implementation moved to static method to expose the this pointer.

void InstanceKlass::initialize(TRAPS) {

  if (this->should_be_initialized()) {

    initialize_impl(CHECK);

    // Note: at this point the class may be initialized

    //       OR it may be in the state of being initialized

    //       in case of recursive initialization!

  } else {

    assert(is_initialized(), "sanity check");

  }

}

bool InstanceKlass::verify_code(bool throw_verifyerror, TRAPS) {

  // 1) Verify the bytecodes

  Verifier::Mode mode =

    throw_verifyerror ? Verifier::ThrowException : Verifier::NoException;

  return Verifier::verify(this, mode, should_verify_class(), THREAD);

}