/*

 * 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 "gc_implementation/shared/markSweep.inline.hpp"

#include "gc_interface/collectedHeap.inline.hpp"

#include "interpreter/oopMapCache.hpp"

#include "memory/gcLocker.hpp"

#include "oops/constantPoolOop.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/instanceMirrorKlass.hpp"

#include "oops/instanceKlassKlass.hpp"

#include "oops/instanceRefKlass.hpp"

#include "oops/objArrayKlassKlass.hpp"

#include "oops/objArrayOop.hpp"

#include "oops/oop.inline.hpp"

#include "oops/oop.inline2.hpp"

#include "oops/symbol.hpp"

#include "oops/typeArrayOop.hpp"

#include "prims/jvmtiExport.hpp"

#include "runtime/fieldDescriptor.hpp"

#ifndef SERIALGC

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

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

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

#include "memory/cardTableRS.hpp"

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

#endif

klassOop instanceKlassKlass::create_klass(TRAPS) {

  instanceKlassKlass o;

  KlassHandle h_this_klass(THREAD, Universe::klassKlassObj());

  KlassHandle k = base_create_klass(h_this_klass, header_size(), o.vtbl_value(), CHECK_NULL);

  // Make sure size calculation is right

  assert(k()->size() == align_object_size(header_size()), "wrong size for object");

  java_lang_Class::create_mirror(k, CHECK_NULL); // Allocate mirror

  return k();

}

int instanceKlassKlass::oop_size(oop obj) const {

  assert(obj->is_klass(), "must be klass");

  return instanceKlass::cast(klassOop(obj))->object_size();

}

bool instanceKlassKlass::oop_is_parsable(oop obj) const {

  assert(obj->is_klass(), "must be klass");

  instanceKlass* ik = instanceKlass::cast(klassOop(obj));

  return (!ik->null_vtbl()) && ik->object_is_parsable();

}

void instanceKlassKlass::iterate_c_heap_oops(instanceKlass* ik,

                                             OopClosure* closure) {

  if (ik->oop_map_cache() != NULL) {

    ik->oop_map_cache()->oop_iterate(closure);

  }

  if (ik->jni_ids() != NULL) {

    ik->jni_ids()->oops_do(closure);

  }

}

void instanceKlassKlass::oop_follow_contents(oop obj) {

  assert(obj->is_klass(),"must be a klass");

  assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");

  instanceKlass* ik = instanceKlass::cast(klassOop(obj));

  {

    HandleMark hm;

    ik->vtable()->oop_follow_contents();

    ik->itable()->oop_follow_contents();

  }

  MarkSweep::mark_and_push(ik->adr_array_klasses());

  MarkSweep::mark_and_push(ik->adr_methods());

  MarkSweep::mark_and_push(ik->adr_method_ordering());

  MarkSweep::mark_and_push(ik->adr_local_interfaces());

  MarkSweep::mark_and_push(ik->adr_transitive_interfaces());

  MarkSweep::mark_and_push(ik->adr_fields());

  MarkSweep::mark_and_push(ik->adr_constants());

  MarkSweep::mark_and_push(ik->adr_class_loader());

  MarkSweep::mark_and_push(ik->adr_inner_classes());

  MarkSweep::mark_and_push(ik->adr_protection_domain());

  if (ik->adr_host_klass() != NULL) {

    MarkSweep::mark_and_push(ik->adr_host_klass());

  }

  MarkSweep::mark_and_push(ik->adr_signers());

  MarkSweep::mark_and_push(ik->adr_class_annotations());

  MarkSweep::mark_and_push(ik->adr_fields_annotations());

  MarkSweep::mark_and_push(ik->adr_methods_annotations());

  MarkSweep::mark_and_push(ik->adr_methods_parameter_annotations());

  MarkSweep::mark_and_push(ik->adr_methods_default_annotations());

  // We do not follow adr_implementor() here. It is followed later

  // in instanceKlass::follow_weak_klass_links()

  klassKlass::oop_follow_contents(obj);

  iterate_c_heap_oops(ik, &MarkSweep::mark_and_push_closure);

}

#ifndef SERIALGC

void instanceKlassKlass::oop_follow_contents(ParCompactionManager* cm,

                                             oop obj) {

  assert(obj->is_klass(),"must be a klass");

  assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");

  instanceKlass* ik = instanceKlass::cast(klassOop(obj));

  ik->vtable()->oop_follow_contents(cm);

  ik->itable()->oop_follow_contents(cm);

  PSParallelCompact::mark_and_push(cm, ik->adr_array_klasses());

  PSParallelCompact::mark_and_push(cm, ik->adr_methods());

  PSParallelCompact::mark_and_push(cm, ik->adr_method_ordering());

  PSParallelCompact::mark_and_push(cm, ik->adr_local_interfaces());

  PSParallelCompact::mark_and_push(cm, ik->adr_transitive_interfaces());

  PSParallelCompact::mark_and_push(cm, ik->adr_fields());

  PSParallelCompact::mark_and_push(cm, ik->adr_constants());

  PSParallelCompact::mark_and_push(cm, ik->adr_class_loader());

  PSParallelCompact::mark_and_push(cm, ik->adr_inner_classes());

  PSParallelCompact::mark_and_push(cm, ik->adr_protection_domain());

  if (ik->adr_host_klass() != NULL) {

    PSParallelCompact::mark_and_push(cm, ik->adr_host_klass());

  }

  PSParallelCompact::mark_and_push(cm, ik->adr_signers());

  PSParallelCompact::mark_and_push(cm, ik->adr_class_annotations());

  PSParallelCompact::mark_and_push(cm, ik->adr_fields_annotations());

  PSParallelCompact::mark_and_push(cm, ik->adr_methods_annotations());

  PSParallelCompact::mark_and_push(cm, ik->adr_methods_parameter_annotations());

  PSParallelCompact::mark_and_push(cm, ik->adr_methods_default_annotations());

  // We do not follow adr_implementor() here. It is followed later

  // in instanceKlass::follow_weak_klass_links()

  klassKlass::oop_follow_contents(cm, obj);

  PSParallelCompact::MarkAndPushClosure mark_and_push_closure(cm);

  iterate_c_heap_oops(ik, &mark_and_push_closure);

}

#endif // SERIALGC

int instanceKlassKlass::oop_oop_iterate(oop obj, OopClosure* blk) {

  assert(obj->is_klass(),"must be a klass");

  assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");

  instanceKlass* ik = instanceKlass::cast(klassOop(obj));

  // Get size before changing pointers.

  // Don't call size() or oop_size() since that is a virtual call.

  int size = ik->object_size();

  ik->vtable()->oop_oop_iterate(blk);

  ik->itable()->oop_oop_iterate(blk);

  blk->do_oop(ik->adr_array_klasses());

  blk->do_oop(ik->adr_methods());

  blk->do_oop(ik->adr_method_ordering());

  blk->do_oop(ik->adr_local_interfaces());

  blk->do_oop(ik->adr_transitive_interfaces());

  blk->do_oop(ik->adr_fields());

  blk->do_oop(ik->adr_constants());

  blk->do_oop(ik->adr_class_loader());

  blk->do_oop(ik->adr_protection_domain());

  if (ik->adr_host_klass() != NULL) {

    blk->do_oop(ik->adr_host_klass());

  }

  blk->do_oop(ik->adr_signers());

  blk->do_oop(ik->adr_inner_classes());

  if (ik->adr_implementor() != NULL) {

    blk->do_oop(ik->adr_implementor());

  }

  blk->do_oop(ik->adr_class_annotations());

  blk->do_oop(ik->adr_fields_annotations());

  blk->do_oop(ik->adr_methods_annotations());

  blk->do_oop(ik->adr_methods_parameter_annotations());

  blk->do_oop(ik->adr_methods_default_annotations());

  klassKlass::oop_oop_iterate(obj, blk);

  if(ik->oop_map_cache() != NULL) ik->oop_map_cache()->oop_iterate(blk);

  return size;

}

int instanceKlassKlass::oop_oop_iterate_m(oop obj, OopClosure* blk,

                                           MemRegion mr) {

  assert(obj->is_klass(),"must be a klass");

  assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");

  instanceKlass* ik = instanceKlass::cast(klassOop(obj));

  // Get size before changing pointers.

  // Don't call size() or oop_size() since that is a virtual call.

  int size = ik->object_size();

  ik->vtable()->oop_oop_iterate_m(blk, mr);

  ik->itable()->oop_oop_iterate_m(blk, mr);

  oop* adr;

  adr = ik->adr_array_klasses();

  if (mr.contains(adr)) blk->do_oop(adr);

  adr = ik->adr_methods();

  if (mr.contains(adr)) blk->do_oop(adr);

  adr = ik->adr_method_ordering();

  if (mr.contains(adr)) blk->do_oop(adr);

  adr = ik->adr_local_interfaces();

  if (mr.contains(adr)) blk->do_oop(adr);

  adr = ik->adr_transitive_interfaces();

  if (mr.contains(adr)) blk->do_oop(adr);

  adr = ik->adr_fields();

  if (mr.contains(adr)) blk->do_oop(adr);

  adr = ik->adr_constants();

  if (mr.contains(adr)) blk->do_oop(adr);

  adr = ik->adr_class_loader();

  if (mr.contains(adr)) blk->do_oop(adr);

  adr = ik->adr_protection_domain();

  if (mr.contains(adr)) blk->do_oop(adr);

  adr = ik->adr_host_klass();

  if (adr != NULL && mr.contains(adr)) blk->do_oop(adr);

  adr = ik->adr_signers();

  if (mr.contains(adr)) blk->do_oop(adr);

  adr = ik->adr_inner_classes();

  if (mr.contains(adr)) blk->do_oop(adr);

  adr = ik->adr_implementor();

  if (adr != NULL && mr.contains(adr)) blk->do_oop(adr);

  adr = ik->adr_class_annotations();

  if (mr.contains(adr)) blk->do_oop(adr);

  adr = ik->adr_fields_annotations();

  if (mr.contains(adr)) blk->do_oop(adr);

  adr = ik->adr_methods_annotations();

  if (mr.contains(adr)) blk->do_oop(adr);

  adr = ik->adr_methods_parameter_annotations();

  if (mr.contains(adr)) blk->do_oop(adr);

  adr = ik->adr_methods_default_annotations();

  if (mr.contains(adr)) blk->do_oop(adr);

  klassKlass::oop_oop_iterate_m(obj, blk, mr);

  if(ik->oop_map_cache() != NULL) ik->oop_map_cache()->oop_iterate(blk, mr);

  return size;

}

int instanceKlassKlass::oop_adjust_pointers(oop obj) {

  assert(obj->is_klass(),"must be a klass");

  assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");

  instanceKlass* ik = instanceKlass::cast(klassOop(obj));

  ik->vtable()->oop_adjust_pointers();

  ik->itable()->oop_adjust_pointers();

  MarkSweep::adjust_pointer(ik->adr_array_klasses());

  MarkSweep::adjust_pointer(ik->adr_methods());

  MarkSweep::adjust_pointer(ik->adr_method_ordering());

  MarkSweep::adjust_pointer(ik->adr_local_interfaces());

  MarkSweep::adjust_pointer(ik->adr_transitive_interfaces());

  MarkSweep::adjust_pointer(ik->adr_fields());

  MarkSweep::adjust_pointer(ik->adr_constants());

  MarkSweep::adjust_pointer(ik->adr_class_loader());

  MarkSweep::adjust_pointer(ik->adr_protection_domain());

  if (ik->adr_host_klass() != NULL) {

    MarkSweep::adjust_pointer(ik->adr_host_klass());

  }

  MarkSweep::adjust_pointer(ik->adr_signers());

  MarkSweep::adjust_pointer(ik->adr_inner_classes());

  if (ik->adr_implementor() != NULL) {

    MarkSweep::adjust_pointer(ik->adr_implementor());

  }

  MarkSweep::adjust_pointer(ik->adr_class_annotations());

  MarkSweep::adjust_pointer(ik->adr_fields_annotations());

  MarkSweep::adjust_pointer(ik->adr_methods_annotations());

  MarkSweep::adjust_pointer(ik->adr_methods_parameter_annotations());

  MarkSweep::adjust_pointer(ik->adr_methods_default_annotations());

  iterate_c_heap_oops(ik, &MarkSweep::adjust_root_pointer_closure);

  return klassKlass::oop_adjust_pointers(obj);

}

#ifndef SERIALGC

void instanceKlassKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {

  instanceKlass* ik = instanceKlass::cast(klassOop(obj));

  oop* loader_addr = ik->adr_class_loader();

  if (PSScavenge::should_scavenge(loader_addr)) {

    pm->claim_or_forward_depth(loader_addr);

  }

  oop* pd_addr = ik->adr_protection_domain();

  if (PSScavenge::should_scavenge(pd_addr)) {

    pm->claim_or_forward_depth(pd_addr);

  }

  oop* hk_addr = ik->adr_host_klass();

  if (hk_addr != NULL && PSScavenge::should_scavenge(hk_addr)) {

    pm->claim_or_forward_depth(hk_addr);

  }

  oop* sg_addr = ik->adr_signers();

  if (PSScavenge::should_scavenge(sg_addr)) {

    pm->claim_or_forward_depth(sg_addr);

  }

  klassKlass::oop_push_contents(pm, obj);

}

int instanceKlassKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {

  assert(obj->is_klass(),"must be a klass");

  assert(klassOop(obj)->klass_part()->oop_is_instance_slow(),

         "must be instance klass");

  instanceKlass* ik = instanceKlass::cast(klassOop(obj));

  ik->vtable()->oop_update_pointers(cm);

  ik->itable()->oop_update_pointers(cm);

  oop* const beg_oop = ik->oop_block_beg();

  oop* const end_oop = ik->oop_block_end();

  for (oop* cur_oop = beg_oop; cur_oop < end_oop; ++cur_oop) {

    PSParallelCompact::adjust_pointer(cur_oop);

  }

  // embedded oops

  if (ik->adr_implementor() != NULL) {

    PSParallelCompact::adjust_pointer(ik->adr_implementor());

  }

  if (ik->adr_host_klass() != NULL) {

    PSParallelCompact::adjust_pointer(ik->adr_host_klass());

  }

  OopClosure* closure = PSParallelCompact::adjust_root_pointer_closure();

  iterate_c_heap_oops(ik, closure);

  klassKlass::oop_update_pointers(cm, obj);

  return ik->object_size();

}

#endif // SERIALGC

klassOop

instanceKlassKlass::allocate_instance_klass(Symbol* name, int vtable_len, int itable_len,

                                            int static_field_size,

                                            unsigned nonstatic_oop_map_count,

                                            AccessFlags access_flags,

                                            ReferenceType rt,

                                            KlassHandle host_klass, TRAPS) {

  const int nonstatic_oop_map_size =

    instanceKlass::nonstatic_oop_map_size(nonstatic_oop_map_count);

  int size = align_object_offset(vtable_len) + align_object_offset(itable_len);

  if (access_flags.is_interface() || !host_klass.is_null()) {

    size += align_object_offset(nonstatic_oop_map_size);

  } else {

    size += nonstatic_oop_map_size;

  }

  if (access_flags.is_interface()) {

    size += (int)sizeof(klassOop)/HeapWordSize;

  }

  if (!host_klass.is_null()) {

    size += (int)sizeof(klassOop)/HeapWordSize;

  }

  size = instanceKlass::object_size(size);

  // Allocation

  KlassHandle h_this_klass(THREAD, as_klassOop());

  KlassHandle k;

  if (rt == REF_NONE) {

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

      // regular klass

      instanceKlass o;

      k = base_create_klass(h_this_klass, size, o.vtbl_value(), CHECK_NULL);

    } else {

      // Class

      instanceMirrorKlass o;

      k = base_create_klass(h_this_klass, size, o.vtbl_value(), CHECK_NULL);

    }

  } else {

    // reference klass

    instanceRefKlass o;

    k = base_create_klass(h_this_klass, size, o.vtbl_value(), CHECK_NULL);

  }

  {

    No_Safepoint_Verifier no_safepoint; // until k becomes parsable

    instanceKlass* ik = (instanceKlass*) k()->klass_part();

    assert(!k()->is_parsable(), "not expecting parsability yet.");

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

    ik->set_vtable_length(vtable_len);

    ik->set_itable_length(itable_len);

    ik->set_static_field_size(static_field_size);

    ik->set_nonstatic_oop_map_size(nonstatic_oop_map_size);

    ik->set_access_flags(access_flags);

    ik->set_is_anonymous(!host_klass.is_null());

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

    ik->set_array_klasses(NULL);

    ik->set_methods(NULL);

    ik->set_method_ordering(NULL);

    ik->set_local_interfaces(NULL);

    ik->set_transitive_interfaces(NULL);

    ik->init_implementor();

    ik->set_fields(NULL, 0);

    ik->set_constants(NULL);

    ik->set_class_loader(NULL);

    ik->set_protection_domain(NULL);

    ik->set_signers(NULL);

    ik->set_source_file_name(NULL);

    ik->set_array_name(NULL);

    ik->set_inner_classes(NULL);

    ik->set_static_oop_field_count(0);

    ik->set_nonstatic_field_size(0);

    ik->set_is_marked_dependent(false);

    ik->set_init_state(instanceKlass::allocated);

    ik->set_init_thread(NULL);

    ik->set_reference_type(rt);

    ik->set_oop_map_cache(NULL);

    ik->set_jni_ids(NULL);

    ik->set_osr_nmethods_head(NULL);

    ik->set_breakpoints(NULL);

    ik->init_previous_versions();

    ik->set_generic_signature(NULL);

    ik->release_set_methods_jmethod_ids(NULL);

    ik->release_set_methods_cached_itable_indices(NULL);

    ik->set_class_annotations(NULL);

    ik->set_fields_annotations(NULL);

    ik->set_methods_annotations(NULL);

    ik->set_methods_parameter_annotations(NULL);

    ik->set_methods_default_annotations(NULL);

    ik->set_jvmti_cached_class_field_map(NULL);

    ik->set_initial_method_idnum(0);

    assert(k()->is_parsable(), "should be parsable here.");

    // initialize the non-header words to zero

    intptr_t* p = (intptr_t*)k();

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

      p[index] = NULL_WORD;

    }

    // To get verify to work - must be set to partial loaded before first GC point.

    k()->set_partially_loaded();

  }

  return k();

}

#ifndef PRODUCT

// Printing

#define BULLET  " - "

static const char* state_names[] = {

  "unparseable_by_gc", "allocated", "loaded", "linked", "being_initialized", "fully_initialized", "initialization_error"

};

void instanceKlassKlass::oop_print_on(oop obj, outputStream* st) {

  assert(obj->is_klass(), "must be klass");

  instanceKlass* ik = instanceKlass::cast(klassOop(obj));

  klassKlass::oop_print_on(obj, st);

  st->print(BULLET"instance size:     %d", ik->size_helper());                        st->cr();

  st->print(BULLET"klass size:        %d", ik->object_size());                        st->cr();

  st->print(BULLET"access:            "); ik->access_flags().print_on(st);            st->cr();

  st->print(BULLET"state:             "); st->print_cr(state_names[ik->_init_state]);

  st->print(BULLET"name:              "); ik->name()->print_value_on(st);             st->cr();

  st->print(BULLET"super:             "); ik->super()->print_value_on(st);            st->cr();

  st->print(BULLET"sub:               ");

  Klass* sub = ik->subklass();

  int n;

  for (n = 0; sub != NULL; n++, sub = sub->next_sibling()) {

    if (n < MaxSubklassPrintSize) {

      sub->as_klassOop()->print_value_on(st);

      st->print("   ");

    }

  }

  if (n >= MaxSubklassPrintSize) st->print("(%d more klasses...)", n - MaxSubklassPrintSize);

  st->cr();

  if (ik->is_interface()) {

    st->print_cr(BULLET"nof implementors:  %d", ik->nof_implementors());

    if (ik->nof_implementors() == 1) {

      st->print_cr(BULLET"implementor:    ");

      st->print("   ");

      ik->implementor()->print_value_on(st);

      st->cr();

    }

  }

  st->print(BULLET"arrays:            "); ik->array_klasses()->print_value_on(st);     st->cr();

  st->print(BULLET"methods:           "); ik->methods()->print_value_on(st);           st->cr();

  if (Verbose) {

    objArrayOop methods = ik->methods();

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

      tty->print("%d : ", i); methods->obj_at(i)->print_value(); tty->cr();

    }

  }