/*

 * Copyright 1997-2008 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

# include "incls/_precompiled.incl"

# include "incls/_instanceKlass.cpp.incl"

bool instanceKlass::should_be_initialized() const {

  return !is_initialized();

}

klassVtable* instanceKlass::vtable() const {

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

}

klassItable* instanceKlass::itable() const {

  return new klassItable(as_klassOop());

}

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)

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

    eager_initialize_impl(this_oop);

  }

}

void instanceKlass::eager_initialize_impl(instanceKlassHandle this_oop) {

  EXCEPTION_MARK;

  ObjectLocker ol(this_oop, THREAD);

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

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

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

    instanceKlassHandle this_oop(THREAD, this->as_klassOop());

    link_class_impl(this_oop, true, CHECK);

  }

}

// Called to verify that a class can link during initialization, without

// throwing a VerifyError.

bool instanceKlass::link_class_or_fail(TRAPS) {

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

  if (!is_linked()) {

    instanceKlassHandle this_oop(THREAD, this->as_klassOop());

    link_class_impl(this_oop, false, CHECK_false);

  }

  return is_linked();

}

bool instanceKlass::link_class_impl(

    instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS) {

  // check for error state

  if (this_oop->is_in_error_state()) {

    ResourceMark rm(THREAD);

    THROW_MSG_(vmSymbols::java_lang_NoClassDefFoundError(),

               this_oop->external_name(), false);

  }

  // return if already verified

  if (this_oop->is_linked()) {

    return true;

  }

  // Timing

  // timer handles recursion

  assert(THREAD->is_Java_thread(), "non-JavaThread in link_class_impl");

  JavaThread* jt = (JavaThread*)THREAD;

  PerfTraceTimedEvent vmtimer(ClassLoader::perf_class_link_time(),

                        ClassLoader::perf_classes_linked(),

                        jt->get_thread_stat()->class_link_recursion_count_addr());

  // link super class before linking this class

  instanceKlassHandle super(THREAD, this_oop->super());

  if (super.not_null()) {

    if (super->is_interface()) {  // check if super class is an interface

      ResourceMark rm(THREAD);

      Exceptions::fthrow(

        THREAD_AND_LOCATION,

        vmSymbolHandles::java_lang_IncompatibleClassChangeError(),

        "class %s has interface %s as super class",

        this_oop->external_name(),

        super->external_name()

      );

      return false;

    }

    link_class_impl(super, throw_verifyerror, CHECK_false);

  }

  // link all interfaces implemented by this class before linking this class

  objArrayHandle interfaces (THREAD, this_oop->local_interfaces());

  int num_interfaces = interfaces->length();

  for (int index = 0; index < num_interfaces; index++) {

    HandleMark hm(THREAD);

    instanceKlassHandle ih(THREAD, klassOop(interfaces->obj_at(index)));

    link_class_impl(ih, throw_verifyerror, CHECK_false);

  }

  // in case the class is linked in the process of linking its superclasses

  if (this_oop->is_linked()) {

    return true;

  }

  // verification & rewriting

  {

    ObjectLocker ol(this_oop, THREAD);

    // rewritten will have been set if loader constraint error found

    // on an earlier link attempt

    // don't verify or rewrite if already rewritten

    if (!this_oop->is_linked()) {

      if (!this_oop->is_rewritten()) {

        {

          assert(THREAD->is_Java_thread(), "non-JavaThread in link_class_impl");

          JavaThread* jt = (JavaThread*)THREAD;

          // Timer includes any side effects of class verification (resolution,

          // etc), but not recursive entry into verify_code().

          PerfTraceTime timer(ClassLoader::perf_class_verify_time(),

                            jt->get_thread_stat()->class_verify_recursion_count_addr());

          bool verify_ok = verify_code(this_oop, throw_verifyerror, THREAD);

          if (!verify_ok) {

            return false;

          }

        }

        // Just in case a side-effect of verify linked this class already

        // (which can sometimes happen since the verifier loads classes

        // using custom class loaders, which are free to initialize things)

        if (this_oop->is_linked()) {

          return true;

        }

        // also sets rewritten

        this_oop->rewrite_class(CHECK_false);

      }

      // Initialize the vtable and interface table after

      // methods have been rewritten since rewrite may

      // fabricate new methodOops.

      // also does loader constraint checking

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

        ResourceMark rm(THREAD);

        this_oop->vtable()->initialize_vtable(true, CHECK_false);

        this_oop->itable()->initialize_itable(true, CHECK_false);

      }

#ifdef ASSERT

      else {

        ResourceMark rm(THREAD);

        this_oop->vtable()->verify(tty, true);

        // In case itable verification is ever added.

        // this_oop->itable()->verify(tty, true);

      }

#endif

      this_oop->set_init_state(linked);

      if (JvmtiExport::should_post_class_prepare()) {

        Thread *thread = THREAD;

        assert(thread->is_Java_thread(), "thread->is_Java_thread()");

        JvmtiExport::post_class_prepare((JavaThread *) thread, this_oop());

      }

    }

  }

  return true;

}

// Rewrite the byte codes of all of the methods of a class.

// Three cases:

//    During the link of a newly loaded class.

//    During the preloading of classes to be written to the shared spaces.

//      - Rewrite the methods and update the method entry points.

//

//    During the link of a class in the shared spaces.

//      - The methods were already rewritten, update the metho entry points.

//

// The rewriter must be called exactly once. Rewriting must happen after

// verification but before the first method of the class is executed.

void instanceKlass::rewrite_class(TRAPS) {

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

  instanceKlassHandle this_oop(THREAD, this->as_klassOop());

  if (this_oop->is_rewritten()) {

    assert(this_oop()->is_shared(), "rewriting an unshared class?");

    return;

  }

  Rewriter::rewrite(this_oop, CHECK); // No exception can happen here

  this_oop->set_rewritten();

}

void instanceKlass::initialize_impl(instanceKlassHandle this_oop, TRAPS) {

  // Make sure klass is linked (verified) before initialization

  // A class could already be verified, since it has been reflected upon.

  this_oop->link_class(CHECK);

  // refer to the JVM book page 47 for description of steps

  // Step 1

  { ObjectLocker ol(this_oop, THREAD);

    Thread *self = THREAD; // it's passed the current thread

    // Step 2

    // If we were to use wait() instead of waitInterruptibly() then

    // we might end up throwing IE from link/symbol resolution sites

    // that aren't expected to throw.  This would wreak havoc.  See 6320309.

    while(this_oop->is_being_initialized() && !this_oop->is_reentrant_initialization(self)) {

      ol.waitUninterruptibly(CHECK);

    }

    // Step 3

    if (this_oop->is_being_initialized() && this_oop->is_reentrant_initialization(self))

      return;

    // Step 4

    if (this_oop->is_initialized())

      return;

    // Step 5

    if (this_oop->is_in_error_state()) {

      ResourceMark rm(THREAD);

      const char* desc = "Could not initialize class ";

      const char* className = this_oop->external_name();

      size_t msglen = strlen(desc) + strlen(className) + 1;

      char* message = NEW_C_HEAP_ARRAY(char, msglen);

      if (NULL == message) {

        // Out of memory: can't create detailed error message

        THROW_MSG(vmSymbols::java_lang_NoClassDefFoundError(), className);

      } else {

        jio_snprintf(message, msglen, "%s%s", desc, className);

        THROW_MSG(vmSymbols::java_lang_NoClassDefFoundError(), message);

      }

    }

    // Step 6

    this_oop->set_init_state(being_initialized);

    this_oop->set_init_thread(self);

  }

  // Step 7

  klassOop super_klass = this_oop->super();

  if (super_klass != NULL && !this_oop->is_interface() && Klass::cast(super_klass)->should_be_initialized()) {

    Klass::cast(super_klass)->initialize(THREAD);

    if (HAS_PENDING_EXCEPTION) {

      Handle e(THREAD, PENDING_EXCEPTION);

      CLEAR_PENDING_EXCEPTION;

      {

        EXCEPTION_MARK;

        this_oop->set_initialization_state_and_notify(initialization_error, THREAD); // Locks object, set state, and notify all waiting threads

        CLEAR_PENDING_EXCEPTION;   // ignore any exception thrown, superclass initialization error is thrown below

      }

      THROW_OOP(e());

    }

  }

  // Step 8

  {

    assert(THREAD->is_Java_thread(), "non-JavaThread in initialize_impl");

    JavaThread* jt = (JavaThread*)THREAD;

    // Timer includes any side effects of class initialization (resolution,

    // etc), but not recursive entry into call_class_initializer().

    PerfTraceTimedEvent timer(ClassLoader::perf_class_init_time(),

                              ClassLoader::perf_classes_inited(),

                              jt->get_thread_stat()->class_init_recursion_count_addr());

    this_oop->call_class_initializer(THREAD);

  }

  // Step 9

  if (!HAS_PENDING_EXCEPTION) {

    this_oop->set_initialization_state_and_notify(fully_initialized, CHECK);

    { ResourceMark rm(THREAD);

      debug_only(this_oop->vtable()->verify(tty, true);)

    }

  }

  else {

    // Step 10 and 11

    Handle e(THREAD, PENDING_EXCEPTION);

    CLEAR_PENDING_EXCEPTION;

    {

      EXCEPTION_MARK;

      this_oop->set_initialization_state_and_notify(initialization_error, THREAD);

      CLEAR_PENDING_EXCEPTION;   // ignore any exception thrown, class initialization error is thrown below

    }

    if (e->is_a(SystemDictionary::error_klass())) {

      THROW_OOP(e());

    } else {

      JavaCallArguments args(e);

      THROW_ARG(vmSymbolHandles::java_lang_ExceptionInInitializerError(),

                vmSymbolHandles::throwable_void_signature(),

                &args);

    }

  }

}

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

void instanceKlass::set_initialization_state_and_notify(ClassState state, TRAPS) {

  instanceKlassHandle kh(THREAD, this->as_klassOop());

  set_initialization_state_and_notify_impl(kh, state, CHECK);

}

void instanceKlass::set_initialization_state_and_notify_impl(instanceKlassHandle this_oop, ClassState state, TRAPS) {

  ObjectLocker ol(this_oop, THREAD);

  this_oop->set_init_state(state);

  ol.notify_all(CHECK);

}

void instanceKlass::add_implementor(klassOop k) {

  assert(Compile_lock->owned_by_self(), "");

  // Filter out my subinterfaces.

  // (Note: Interfaces are never on the subklass list.)

  if (instanceKlass::cast(k)->is_interface()) return;

  // Filter out subclasses whose supers already implement me.

  // (Note: CHA must walk subclasses of direct implementors

  // in order to locate indirect implementors.)

  klassOop sk = instanceKlass::cast(k)->super();

  if (sk != NULL && instanceKlass::cast(sk)->implements_interface(as_klassOop()))

    // We only need to check one immediate superclass, since the

    // implements_interface query looks at transitive_interfaces.

    // Any supers of the super have the same (or fewer) transitive_interfaces.

    return;

  // Update number of implementors

  int i = _nof_implementors++;

  // Record this implementor, if there are not too many already

  if (i < implementors_limit) {

    assert(_implementors[i] == NULL, "should be exactly one implementor");

    oop_store_without_check((oop*)&_implementors[i], k);

  } else if (i == implementors_limit) {

    // clear out the list on first overflow

    for (int i2 = 0; i2 < implementors_limit; i2++)

      oop_store_without_check((oop*)&_implementors[i2], NULL);

  }

  // The implementor also implements the transitive_interfaces

  for (int index = 0; index < local_interfaces()->length(); index++) {

    instanceKlass::cast(klassOop(local_interfaces()->obj_at(index)))->add_implementor(k);

  }

}

void instanceKlass::init_implementor() {

  for (int i = 0; i < implementors_limit; i++)

    oop_store_without_check((oop*)&_implementors[i], NULL);

  _nof_implementors = 0;

}

void instanceKlass::process_interfaces(Thread *thread) {

  // link this class into the implementors list of every interface it implements

  KlassHandle this_as_oop (thread, this->as_klassOop());

  for (int i = local_interfaces()->length() - 1; i >= 0; i--) {

    assert(local_interfaces()->obj_at(i)->is_klass(), "must be a klass");

    instanceKlass* interf = instanceKlass::cast(klassOop(local_interfaces()->obj_at(i)));

    assert(interf->is_interface(), "expected interface");

    interf->add_implementor(this_as_oop());

  }

}

bool instanceKlass::can_be_primary_super_slow() const {

  if (is_interface())

    return false;

  else

    return Klass::can_be_primary_super_slow();

}

objArrayOop instanceKlass::compute_secondary_supers(int num_extra_slots, TRAPS) {

  // The secondaries are the implemented interfaces.

  instanceKlass* ik = instanceKlass::cast(as_klassOop());

  objArrayHandle interfaces (THREAD, ik->transitive_interfaces());

  int num_secondaries = num_extra_slots + interfaces->length();

  if (num_secondaries == 0) {

    return Universe::the_empty_system_obj_array();

  } else if (num_extra_slots == 0) {

    return interfaces();

  } else {

    // a mix of both

    objArrayOop secondaries = oopFactory::new_system_objArray(num_secondaries, CHECK_NULL);

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

      secondaries->obj_at_put(num_extra_slots+i, interfaces->obj_at(i));

    }

    return secondaries;

  }

}

bool instanceKlass::compute_is_subtype_of(klassOop k) {

  if (Klass::cast(k)->is_interface()) {

    return implements_interface(k);

  } else {

    return Klass::compute_is_subtype_of(k);

  }

}

bool instanceKlass::implements_interface(klassOop k) const {

  if (as_klassOop() == k) return true;

  assert(Klass::cast(k)->is_interface(), "should be an interface class");

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

    if (transitive_interfaces()->obj_at(i) == k) {

      return true;

    }

  }

  return false;

}

objArrayOop instanceKlass::allocate_objArray(int n, int length, TRAPS) {

  if (length < 0) THROW_0(vmSymbols::java_lang_NegativeArraySizeException());

  if (length > arrayOopDesc::max_array_length(T_OBJECT)) {

    THROW_OOP_0(Universe::out_of_memory_error_array_size());

  }

  int size = objArrayOopDesc::object_size(length);

  klassOop ak = array_klass(n, CHECK_NULL);

  KlassHandle h_ak (THREAD, ak);

  objArrayOop o =

    (objArrayOop)CollectedHeap::array_allocate(h_ak, size, length, CHECK_NULL);

  return o;

}

instanceOop instanceKlass::register_finalizer(instanceOop i, TRAPS) {

  if (TraceFinalizerRegistration) {

    tty->print("Registered ");

    i->print_value_on(tty);

    tty->print_cr(" (" INTPTR_FORMAT ") as finalizable", (address)i);

  }

  instanceHandle h_i(THREAD, i);

  // Pass the handle as argument, JavaCalls::call expects oop as jobjects

  JavaValue result(T_VOID);

  JavaCallArguments args(h_i);

  methodHandle mh (THREAD, Universe::finalizer_register_method());

  JavaCalls::call(&result, mh, &args, CHECK_NULL);

  return h_i();

}

instanceOop instanceKlass::allocate_instance(TRAPS) {

  bool has_finalizer_flag = has_finalizer(); // Query before possible GC

  int size = size_helper();  // Query before forming handle.