/*

 * 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/javaClasses.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/verifier.hpp"

#include "classfile/vmSymbols.hpp"

#include "compiler/compileBroker.hpp"

#include "gc_implementation/shared/markSweep.inline.hpp"

#include "gc_interface/collectedHeap.inline.hpp"

#include "interpreter/oopMapCache.hpp"

#include "interpreter/rewriter.hpp"

#include "jvmtifiles/jvmti.h"

#include "memory/genOopClosures.inline.hpp"

#include "memory/metadataFactory.hpp"

#include "memory/oopFactory.hpp"

#include "oops/fieldStreams.hpp"

#include "oops/instanceClassLoaderKlass.hpp"

#include "oops/instanceKlass.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/jvmtiRedefineClassesTrace.hpp"

#include "prims/methodComparator.hpp"

#include "runtime/fieldDescriptor.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/mutexLocker.hpp"

#include "runtime/thread.inline.hpp"

#include "services/threadService.hpp"

#include "utilities/dtrace.hpp"

#ifndef SERIALGC

#include "gc_implementation/concurrentMarkSweep/cmsOopClosures.inline.hpp"

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

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

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

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

#include "gc_implementation/parNew/parOopClosures.inline.hpp"

#include "gc_implementation/parallelScavenge/parallelScavengeHeap.inline.hpp"

#include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"

#include "gc_implementation/parallelScavenge/psScavenge.inline.hpp"

#include "oops/oop.pcgc.inline.hpp"

#endif

#ifdef COMPILER1

#include "c1/c1_Compiler.hpp"

#endif

#ifdef DTRACE_ENABLED

#ifndef USDT2

HS_DTRACE_PROBE_DECL4(hotspot, class__initialization__required,

  char*, intptr_t, oop, intptr_t);

HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__recursive,

  char*, intptr_t, oop, intptr_t, int);

HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__concurrent,

  char*, intptr_t, oop, intptr_t, int);

HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__erroneous,

  char*, intptr_t, oop, intptr_t, int);

HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__super__failed,

  char*, intptr_t, oop, intptr_t, int);

HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__clinit,

  char*, intptr_t, oop, intptr_t, int);

HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__error,

  char*, intptr_t, oop, intptr_t, int);

HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__end,

  char*, intptr_t, oop, intptr_t, int);

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

    }                                                            \

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

    }                                                            \

    HS_DTRACE_PROBE5(hotspot, class__initialization__##type,     \

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

  }

#else /* USDT2 */

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

  }

#endif /* USDT2 */

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

Klass* 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,

                                                KlassHandle host_klass,

                                                TRAPS) {

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

                                 access_flags.is_interface(),

                                 !host_klass.is_null());

  // 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, !host_klass.is_null());

    } 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, !host_klass.is_null());

    } else {

      // normal class

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

        vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt,

        access_flags, !host_klass.is_null());

    }

  } else {

    // reference klass

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

        vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt,

        access_flags, !host_klass.is_null());

  }

  Atomic::inc(&_total_instanceKlass_count);

  return ik;

}

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 size = InstanceKlass::size(vtable_len, itable_len, nonstatic_oop_map_size,

                                 access_flags.is_interface(), is_anonymous);

  // The sizes of these these three variables are used for determining the

  // size of the instanceKlassOop. It is critical that these are set to the right

  // sizes before the first GC, i.e., when we allocate the mirror.

  this->set_vtable_length(vtable_len);

  this->set_itable_length(itable_len);

  this->set_static_field_size(static_field_size);

  this->set_nonstatic_oop_map_size(nonstatic_oop_map_size);

  this->set_access_flags(access_flags);

  this->set_is_anonymous(is_anonymous);

  assert(this->size() == size, "wrong size for object");

  this->set_array_klasses(NULL);

  this->set_methods(NULL);

  this->set_method_ordering(NULL);

  this->set_local_interfaces(NULL);

  this->set_transitive_interfaces(NULL);

  this->init_implementor();

  this->set_fields(NULL, 0);

  this->set_constants(NULL);

  this->set_class_loader_data(NULL);

  this->set_protection_domain(NULL);

  this->set_signers(NULL);

  this->set_source_file_name(NULL);

  this->set_source_debug_extension(NULL, 0);

  this->set_array_name(NULL);

  this->set_inner_classes(NULL);

  this->set_static_oop_field_count(0);

  this->set_nonstatic_field_size(0);

  this->set_is_marked_dependent(false);

  this->set_init_state(InstanceKlass::allocated);

  this->set_init_thread(NULL);

  this->set_init_lock(NULL);

  this->set_reference_type(rt);

  this->set_oop_map_cache(NULL);

  this->set_jni_ids(NULL);

  this->set_osr_nmethods_head(NULL);

  this->set_breakpoints(NULL);

  this->init_previous_versions();

  this->set_generic_signature(NULL);

  this->release_set_methods_jmethod_ids(NULL);

  this->release_set_methods_cached_itable_indices(NULL);

  this->set_annotations(NULL);

  this->set_jvmti_cached_class_field_map(NULL);

  this->set_initial_method_idnum(0);

  // initialize the non-header words to zero

  intptr_t* p = (intptr_t*)this;

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

    p[index] = NULL_WORD;

  }

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

  // size.

  this->set_layout_helper(Klass::instance_layout_helper(0, true));

}

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

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

  Array<Method*>* ms = methods();

  if (ms != Universe::the_empty_method_array()) {

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

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

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

  }

  set_methods(NULL);

  if (method_ordering() != Universe::the_empty_int_array()) {

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

  }

  set_method_ordering(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() != Universe::the_empty_klass_array() &&

      secondary_supers() != transitive_interfaces()) {

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

  }

  set_secondary_supers(NULL);

  // 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() == NULL) ? NULL :

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

    if (ti != sti) {

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

    }

  }

  set_transitive_interfaces(NULL);

  // local interfaces can be empty

  Array<Klass*>* li = local_interfaces();

  if (li != Universe::the_empty_klass_array()) {

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

  }

  set_local_interfaces(NULL);

  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.

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

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

  set_constants(NULL);

  if (inner_classes() != Universe::the_empty_short_array()) {

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

  }

  set_inner_classes(NULL);

  // Null out Java heap objects, although these won't be walked to keep

  // alive once this InstanceKlass is deallocated.

  set_protection_domain(NULL);

  set_signers(NULL);

  set_init_lock(NULL);

  // We should deallocate the Annotations instance

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

  set_annotations(NULL);

}

volatile oop InstanceKlass::init_lock() const {

  volatile oop lock = _init_lock;  // read once

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

  klass_oop_store(&_init_lock, NULL);

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

}

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_oop(thread, this);

    eager_initialize_impl(this_oop);

  }

}

void InstanceKlass::eager_initialize_impl(instanceKlassHandle this_oop) {

  EXCEPTION_MARK;

  volatile oop init_lock = this_oop->init_lock();

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

  // abort if someone beat us to the initialization

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

  ClassState old_state = this_oop->init_state();

  link_class_impl(this_oop, 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_oop->_init_state )

      this_oop->set_init_state (old_state);

  } else {

    // linking successfull, mark class as initialized

    this_oop->set_init_state (fully_initialized);

    this_oop->fence_and_clear_init_lock();

    // trace

    if (TraceClassInitialization) {

      ResourceMark rm(THREAD);

      tty->print_cr("[Initialized %s without side effects]", this_oop->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()) {

    HandleMark hm(THREAD);

    instanceKlassHandle this_oop(THREAD, this);

    initialize_impl(this_oop, 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(

    instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS) {

  // 1) Verify the bytecodes

  Verifier::Mode mode =

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

  return Verifier::verify(this_oop, mode, this_oop->should_verify_class(), CHECK_false);

}

// Used exclusively by the shared spaces dump mechanism to prevent

// classes mapped into the shared regions in new VMs from appearing linked.

void InstanceKlass::unlink_class() {

  assert(is_linked(), "must be linked");

  _init_state = loaded;

}

void InstanceKlass::link_class(TRAPS) {

  assert(is_loaded(), "must be loaded");

  if (!is_linked()) {

    HandleMark hm(THREAD);

    instanceKlassHandle this_oop(THREAD, this);

    link_class_impl(this_oop, true, CHECK);