#include "memory/metadataFactory.hpp"

#include "oops/instanceClassLoaderKlass.hpp"

#include "oops/klass.inline.hpp"

#include "oops/method.hpp"

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

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

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

  }

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

  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 {

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

    Klass* super = this->super();

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

    instanceKlassHandle this_oop(thread, this);

void InstanceKlass::eager_initialize_impl(instanceKlassHandle this_oop) {

  volatile oop init_lock = this_oop->init_lock();

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

    this_oop->fence_and_clear_init_lock();

void InstanceKlass::initialize(TRAPS) {

    instanceKlassHandle this_oop(THREAD, this);

bool InstanceKlass::verify_code(

void InstanceKlass::unlink_class() {

void InstanceKlass::link_class(TRAPS) {