/*

 * Copyright (c) 1997, 2009, 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 "incls/_precompiled.incl"

# include "incls/_instanceKlass.cpp.incl"

#ifdef DTRACE_ENABLED

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

    symbolOop 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;                                                 \

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

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

    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;

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

  }

  // trace only the link time for this klass that includes

  // the verification time

  PerfClassTraceTime vmtimer(ClassLoader::perf_class_link_time(),

                             ClassLoader::perf_class_link_selftime(),

                             ClassLoader::perf_classes_linked(),

                             jt->get_thread_stat()->perf_recursion_counts_addr(),

                             jt->get_thread_stat()->perf_timers_addr(),

                             PerfClassTraceTime::CLASS_LINK);

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

        {

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

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

          PerfClassTraceTime timer(ClassLoader::perf_class_verify_time(),

                                   ClassLoader::perf_class_verify_selftime(),

                                   ClassLoader::perf_classes_verified(),

                                   jt->get_thread_stat()->perf_recursion_counts_addr(),

                                   jt->get_thread_stat()->perf_timers_addr(),

                                   PerfClassTraceTime::CLASS_VERIFY);

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

  DTRACE_CLASSINIT_PROBE(required, instanceKlass::cast(this_oop()), -1);

  bool wait = false;

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

        wait = true;

      ol.waitUninterruptibly(CHECK);

    }

    // Step 3

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

      DTRACE_CLASSINIT_PROBE_WAIT(recursive, instanceKlass::cast(this_oop()), -1,wait);

      return;

    }

    // Step 4

    if (this_oop->is_initialized()) {

      DTRACE_CLASSINIT_PROBE_WAIT(concurrent, instanceKlass::cast(this_oop()), -1,wait);

      return;

    }

    // Step 5

    if (this_oop->is_in_error_state()) {

      DTRACE_CLASSINIT_PROBE_WAIT(erroneous, instanceKlass::cast(this_oop()), -1,wait);

      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;

      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

      }

      DTRACE_CLASSINIT_PROBE_WAIT(super__failed, instanceKlass::cast(this_oop()), -1,wait);

      THROW_OOP(e());

    }

  }

  // Step 8

  {

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

    JavaThread* jt = (JavaThread*)THREAD;

    DTRACE_CLASSINIT_PROBE_WAIT(clinit, instanceKlass::cast(this_oop()), -1,wait);

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

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

    PerfClassTraceTime timer(ClassLoader::perf_class_init_time(),

                             ClassLoader::perf_class_init_selftime(),

                             ClassLoader::perf_classes_inited(),

                             jt->get_thread_stat()->perf_recursion_counts_addr(),

                             jt->get_thread_stat()->perf_timers_addr(),

                             PerfClassTraceTime::CLASS_CLINIT);

    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

    }

    DTRACE_CLASSINIT_PROBE_WAIT(error, instanceKlass::cast(this_oop()), -1,wait);

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

    }

  }

  DTRACE_CLASSINIT_PROBE_WAIT(end, instanceKlass::cast(this_oop()), -1,wait);

}

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