/*

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

#include "classfile/systemDictionary.hpp"

#include "classfile/verifier.hpp"

#include "classfile/vmSymbols.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 "memory/heapInspection.hpp"

#include "memory/iterator.inline.hpp"

#include "memory/metadataFactory.hpp"

#include "memory/oopFactory.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/jvmtiExport.hpp"

#include "prims/jvmtiRedefineClasses.hpp"

#include "prims/jvmtiRedefineClassesTrace.hpp"

#include "prims/jvmtiThreadState.hpp"

#include "prims/methodComparator.hpp"

#include "runtime/atomic.inline.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"

#ifdef COMPILER1

#include "c1/c1_Compiler.hpp"

#endif

PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC

#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, clss, thread_type)          \

  {                                                              \

    char* data = NULL;                                           \

    int len = 0;                                                 \

    Symbol* name = (clss)->name();                               \

    if (name != NULL) {                                          \

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

      len = name->utf8_length();                                 \

    }                                                            \

    HOTSPOT_CLASS_INITIALIZATION_##type(                         \

      data, len, (clss)->class_loader(), thread_type);           \

  }

#define DTRACE_CLASSINIT_PROBE_WAIT(type, clss, thread_type, wait) \

  {                                                              \

    char* data = NULL;                                           \

    int len = 0;                                                 \

    Symbol* name = (clss)->name();                               \

    if (name != NULL) {                                          \

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

      len = name->utf8_length();                                 \

    }                                                            \

    HOTSPOT_CLASS_INITIALIZATION_##type(                         \

      data, len, (clss)->class_loader(), thread_type, wait);     \

  }

#else //  ndef DTRACE_ENABLED

#define DTRACE_CLASSINIT_PROBE(type, clss, thread_type)

#define DTRACE_CLASSINIT_PROBE_WAIT(type, clss, thread_type, wait)

#endif //  ndef DTRACE_ENABLED

volatile int InstanceKlass::_total_instanceKlass_count = 0;

InstanceKlass* InstanceKlass::allocate_instance_klass(

                                              ClassLoaderData* loader_data,

                                              int vtable_len,

                                              int itable_len,

                                              int static_field_size,

                                              int nonstatic_oop_map_size,

                                              ReferenceType rt,

                                              AccessFlags access_flags,

                                              Symbol* name,

                                              Klass* super_klass,

                                              bool is_anonymous,

                                              TRAPS) {

  int size = InstanceKlass::size(vtable_len, itable_len, nonstatic_oop_map_size,

                                 access_flags.is_interface(), is_anonymous);

  // Allocation

  InstanceKlass* ik;

  if (rt == REF_NONE) {

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

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

        vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt,

        access_flags, is_anonymous);

    } else if (name == vmSymbols::java_lang_ClassLoader() ||

          (SystemDictionary::ClassLoader_klass_loaded() &&

          super_klass != NULL &&

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

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

        vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt,

        access_flags, is_anonymous);

    } else {

      // normal class

      ik = new (loader_data, size, THREAD) InstanceKlass(

        vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt,

        access_flags, is_anonymous);

    }

  } else {

    // reference klass

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

        vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt,

        access_flags, is_anonymous);

  }

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

  // class count.  Can get OOM here.

  if (HAS_PENDING_EXCEPTION) {

    return NULL;

  }

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

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

  loader_data->add_class(ik);

  Atomic::inc(&_total_instanceKlass_count);

  return ik;

}

// copy method ordering from resource area to Metaspace

void InstanceKlass::copy_method_ordering(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(int vtable_len,

                             int itable_len,

                             int static_field_size,

                             int nonstatic_oop_map_size,

                             ReferenceType rt,

                             AccessFlags access_flags,

                             bool is_anonymous) {

  No_Safepoint_Verifier no_safepoint; // until k becomes parsable

  int iksize = InstanceKlass::size(vtable_len, itable_len, nonstatic_oop_map_size,

                                   access_flags.is_interface(), is_anonymous);

  set_vtable_length(vtable_len);

  set_itable_length(itable_len);

  set_static_field_size(static_field_size);

  set_nonstatic_oop_map_size(nonstatic_oop_map_size);

  set_access_flags(access_flags);

  _misc_flags = 0;  // initialize to zero

  set_is_anonymous(is_anonymous);

  assert(size() == iksize, "wrong size for object");

  set_array_klasses(NULL);

  set_methods(NULL);

  set_method_ordering(NULL);

  set_default_methods(NULL);

  set_default_vtable_indices(NULL);

  set_local_interfaces(NULL);

  set_transitive_interfaces(NULL);

  init_implementor();

  set_fields(NULL, 0);

  set_constants(NULL);

  set_class_loader_data(NULL);

  set_source_file_name_index(0);

  set_source_debug_extension(NULL, 0);

  set_array_name(NULL);

  set_inner_classes(NULL);

  set_static_oop_field_count(0);

  set_nonstatic_field_size(0);

  set_is_marked_dependent(false);

  set_has_unloaded_dependent(false);

  set_init_state(InstanceKlass::allocated);

  set_init_thread(NULL);

  set_reference_type(rt);

  set_oop_map_cache(NULL);

  set_jni_ids(NULL);

  set_osr_nmethods_head(NULL);

  set_breakpoints(NULL);

  init_previous_versions();

  set_generic_signature_index(0);

  release_set_methods_jmethod_ids(NULL);

  set_annotations(NULL);

  set_jvmti_cached_class_field_map(NULL);

  set_initial_method_idnum(0);

  _dependencies = NULL;

  set_jvmti_cached_class_field_map(NULL);

  set_cached_class_file(NULL);

  set_initial_method_idnum(0);

  set_minor_version(0);

  set_major_version(0);

  NOT_PRODUCT(_verify_count = 0;)

  // initialize the non-header words to zero

  intptr_t* p = (intptr_t*)this;

  for (int index = InstanceKlass::header_size(); index < iksize; index++) {

    p[index] = NULL_WORD;

  }

  // Set temporary value until parseClassFile updates it with the real instance

  // size.

  set_layout_helper(Klass::instance_layout_helper(0, true));

}

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,

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

    }

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

}

klassVtable* InstanceKlass::vtable() const {

  return new klassVtable(this, start_of_vtable(), vtable_length() / vtableEntry::size());

}

klassItable* InstanceKlass::itable() const {

  return new klassItable(instanceKlassHandle(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 = this->super();

    if (super == NULL) return;

    // abort if the super class should be initialized

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

    // call body to expose the this pointer

    instanceKlassHandle this_k(thread, this);

    eager_initialize_impl(this_k);

  }

}

// 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(instanceKlassHandle this_k) {

  EXCEPTION_MARK;

  oop init_lock = this_k->init_lock();

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

  // abort if someone beat us to the initialization

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

  ClassState old_state = this_k->init_state();

  link_class_impl(this_k, 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 != this_k->_init_state )

      this_k->set_init_state (old_state);

  } else {