/*

 * Copyright 1997-2007 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/_systemDictionary.cpp.incl"

Dictionary*       SystemDictionary::_dictionary = NULL;

PlaceholderTable* SystemDictionary::_placeholders = NULL;

Dictionary*       SystemDictionary::_shared_dictionary = NULL;

LoaderConstraintTable* SystemDictionary::_loader_constraints = NULL;

ResolutionErrorTable* SystemDictionary::_resolution_errors = NULL;

int         SystemDictionary::_number_of_modifications = 0;

oop         SystemDictionary::_system_loader_lock_obj     =  NULL;

klassOop    SystemDictionary::_box_klasses[T_VOID+1]      =  { NULL /*, NULL...*/ };

oop         SystemDictionary::_java_system_loader         =  NULL;

bool        SystemDictionary::_has_loadClassInternal      =  false;

bool        SystemDictionary::_has_checkPackageAccess     =  false;

// lazily initialized klass variables

volatile klassOop    SystemDictionary::_abstract_ownable_synchronizer_klass = NULL;

// ----------------------------------------------------------------------------

// Java-level SystemLoader

oop SystemDictionary::java_system_loader() {

  return _java_system_loader;

}

void SystemDictionary::compute_java_system_loader(TRAPS) {

  JavaValue result(T_OBJECT);

  JavaCalls::call_static(&result,

                         vmSymbolHandles::getSystemClassLoader_name(),

                         vmSymbolHandles::void_classloader_signature(),

                         CHECK);

  _java_system_loader = (oop)result.get_jobject();

}

// ----------------------------------------------------------------------------

// debugging

#ifdef ASSERT

// return true if class_name contains no '.' (internal format is '/')

bool SystemDictionary::is_internal_format(symbolHandle class_name) {

  if (class_name.not_null()) {

    ResourceMark rm;

    char* name = class_name->as_C_string();

    return strchr(name, '.') == NULL;

  } else {

    return true;

  }

}

#endif

// ----------------------------------------------------------------------------

// Resolving of classes

// Forwards to resolve_or_null

klassOop SystemDictionary::resolve_or_fail(symbolHandle class_name, Handle class_loader, Handle protection_domain, bool throw_error, TRAPS) {

  klassOop klass = resolve_or_null(class_name, class_loader, protection_domain, THREAD);

  if (HAS_PENDING_EXCEPTION || klass == NULL) {

    KlassHandle k_h(THREAD, klass);

    // can return a null klass

    klass = handle_resolution_exception(class_name, class_loader, protection_domain, throw_error, k_h, THREAD);

  }

  return klass;

}

klassOop SystemDictionary::handle_resolution_exception(symbolHandle class_name, Handle class_loader, Handle protection_domain, bool throw_error, KlassHandle klass_h, TRAPS) {

  if (HAS_PENDING_EXCEPTION) {

    // If we have a pending exception we forward it to the caller, unless throw_error is true,

    // in which case we have to check whether the pending exception is a ClassNotFoundException,

    // and if so convert it to a NoClassDefFoundError

    // And chain the original ClassNotFoundException

    if (throw_error && PENDING_EXCEPTION->is_a(SystemDictionary::classNotFoundException_klass())) {

      ResourceMark rm(THREAD);

      assert(klass_h() == NULL, "Should not have result with exception pending");

      Handle e(THREAD, PENDING_EXCEPTION);

      CLEAR_PENDING_EXCEPTION;

      THROW_MSG_CAUSE_0(vmSymbols::java_lang_NoClassDefFoundError(), class_name->as_C_string(), e);

    } else {

      return NULL;

    }

  }

  // Class not found, throw appropriate error or exception depending on value of throw_error

  if (klass_h() == NULL) {

    ResourceMark rm(THREAD);

    if (throw_error) {

      THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), class_name->as_C_string());

    } else {

      THROW_MSG_0(vmSymbols::java_lang_ClassNotFoundException(), class_name->as_C_string());

    }

  }

  return (klassOop)klass_h();

}

klassOop SystemDictionary::resolve_or_fail(symbolHandle class_name,

                                           bool throw_error, TRAPS)

{

  return resolve_or_fail(class_name, Handle(), Handle(), throw_error, THREAD);

}

// Forwards to resolve_instance_class_or_null

klassOop SystemDictionary::resolve_or_null(symbolHandle class_name, Handle class_loader, Handle protection_domain, TRAPS) {

  assert(!THREAD->is_Compiler_thread(), "Can not load classes with the Compiler thread");

  if (FieldType::is_array(class_name())) {

    return resolve_array_class_or_null(class_name, class_loader, protection_domain, CHECK_NULL);

  } else {

    return resolve_instance_class_or_null(class_name, class_loader, protection_domain, CHECK_NULL);

  }

}

klassOop SystemDictionary::resolve_or_null(symbolHandle class_name, TRAPS) {

  return resolve_or_null(class_name, Handle(), Handle(), THREAD);

}

// Forwards to resolve_instance_class_or_null

klassOop SystemDictionary::resolve_array_class_or_null(symbolHandle class_name,

                                                       Handle class_loader,

                                                       Handle protection_domain,

                                                       TRAPS) {

  assert(FieldType::is_array(class_name()), "must be array");

  jint dimension;

  symbolOop object_key;

  klassOop k = NULL;

  // dimension and object_key are assigned as a side-effect of this call

  BasicType t = FieldType::get_array_info(class_name(),

                                          &dimension,

                                          &object_key,

                                          CHECK_NULL);

  if (t == T_OBJECT) {

    symbolHandle h_key(THREAD, object_key);

    // naked oop "k" is OK here -- we assign back into it

    k = SystemDictionary::resolve_instance_class_or_null(h_key,

                                                         class_loader,

                                                         protection_domain,

                                                         CHECK_NULL);

    if (k != NULL) {

      k = Klass::cast(k)->array_klass(dimension, CHECK_NULL);

    }

  } else {

    k = Universe::typeArrayKlassObj(t);

    k = typeArrayKlass::cast(k)->array_klass(dimension, CHECK_NULL);

  }

  return k;

}

// Must be called for any super-class or super-interface resolution

// during class definition to allow class circularity checking

// super-interface callers:

//    parse_interfaces - for defineClass & jvmtiRedefineClasses

// super-class callers:

//   ClassFileParser - for defineClass & jvmtiRedefineClasses

//   load_shared_class - while loading a class from shared archive

//   resolve_instance_class_or_fail:

//      when resolving a class that has an existing placeholder with

//      a saved superclass [i.e. a defineClass is currently in progress]

//      if another thread is trying to resolve the class, it must do

//      super-class checks on its own thread to catch class circularity

// This last call is critical in class circularity checking for cases

// where classloading is delegated to different threads and the

// classloader lock is released.

// Take the case: Base->Super->Base

//   1. If thread T1 tries to do a defineClass of class Base

//    resolve_super_or_fail creates placeholder: T1, Base (super Super)

//   2. resolve_instance_class_or_null does not find SD or placeholder for Super

//    so it tries to load Super

//   3. If we load the class internally, or user classloader uses same thread

//      loadClassFromxxx or defineClass via parseClassFile Super ...

//      3.1 resolve_super_or_fail creates placeholder: T1, Super (super Base)

//      3.3 resolve_instance_class_or_null Base, finds placeholder for Base

//      3.4 calls resolve_super_or_fail Base

//      3.5 finds T1,Base -> throws class circularity

//OR 4. If T2 tries to resolve Super via defineClass Super ...

//      4.1 resolve_super_or_fail creates placeholder: T2, Super (super Base)

//      4.2 resolve_instance_class_or_null Base, finds placeholder for Base (super Super)

//      4.3 calls resolve_super_or_fail Super in parallel on own thread T2

//      4.4 finds T2, Super -> throws class circularity

// Must be called, even if superclass is null, since this is

// where the placeholder entry is created which claims this

// thread is loading this class/classloader.

klassOop SystemDictionary::resolve_super_or_fail(symbolHandle child_name,

                                                 symbolHandle class_name,

                                                 Handle class_loader,

                                                 Handle protection_domain,

                                                 bool is_superclass,

                                                 TRAPS) {

  // Double-check, if child class is already loaded, just return super-class,interface

  // Don't add a placedholder if already loaded, i.e. already in system dictionary

  // Make sure there's a placeholder for the *child* before resolving.

  // Used as a claim that this thread is currently loading superclass/classloader

  // Used here for ClassCircularity checks and also for heap verification

  // (every instanceKlass in the heap needs to be in the system dictionary

  // or have a placeholder).

  // Must check ClassCircularity before checking if super class is already loaded

  //

  // We might not already have a placeholder if this child_name was

  // first seen via resolve_from_stream (jni_DefineClass or JVM_DefineClass);

  // the name of the class might not be known until the stream is actually

  // parsed.

  // Bugs 4643874, 4715493

  // compute_hash can have a safepoint

  unsigned int d_hash = dictionary()->compute_hash(child_name, class_loader);

  int d_index = dictionary()->hash_to_index(d_hash);

  unsigned int p_hash = placeholders()->compute_hash(child_name, class_loader);

  int p_index = placeholders()->hash_to_index(p_hash);

  // can't throw error holding a lock

  bool child_already_loaded = false;

  bool throw_circularity_error = false;

  {

    MutexLocker mu(SystemDictionary_lock, THREAD);

    klassOop childk = find_class(d_index, d_hash, child_name, class_loader);

    klassOop quicksuperk;

    // to support // loading: if child done loading, just return superclass

    // if class_name, & class_loader don't match:

    // if initial define, SD update will give LinkageError

    // if redefine: compare_class_versions will give HIERARCHY_CHANGED

    // so we don't throw an exception here.

    // see: nsk redefclass014 & java.lang.instrument Instrument032

    if ((childk != NULL ) && (is_superclass) &&

       ((quicksuperk = instanceKlass::cast(childk)->super()) != NULL) &&

         ((Klass::cast(quicksuperk)->name() == class_name()) &&

            (Klass::cast(quicksuperk)->class_loader()  == class_loader()))) {

           return quicksuperk;

    } else {

      PlaceholderEntry* probe = placeholders()->get_entry(p_index, p_hash, child_name, class_loader);

      if (probe && probe->check_seen_thread(THREAD, PlaceholderTable::LOAD_SUPER)) {

          throw_circularity_error = true;

      }

      // add placeholder entry even if error - callers will remove on error

      PlaceholderEntry* newprobe = placeholders()->find_and_add(p_index, p_hash, child_name, class_loader, PlaceholderTable::LOAD_SUPER, class_name, THREAD);

      if (throw_circularity_error) {

         newprobe->remove_seen_thread(THREAD, PlaceholderTable::LOAD_SUPER);

      }

    }

  }

  if (throw_circularity_error) {

      ResourceMark rm(THREAD);

      THROW_MSG_0(vmSymbols::java_lang_ClassCircularityError(), child_name->as_C_string());

  }

// java.lang.Object should have been found above

  assert(class_name() != NULL, "null super class for resolving");

  // Resolve the super class or interface, check results on return

  klassOop superk = NULL;

  superk = SystemDictionary::resolve_or_null(class_name,

                                                 class_loader,

                                                 protection_domain,

                                                 THREAD);

  KlassHandle superk_h(THREAD, superk);

  // Note: clean up of placeholders currently in callers of

  // resolve_super_or_fail - either at update_dictionary time

  // or on error

  {

  MutexLocker mu(SystemDictionary_lock, THREAD);

   PlaceholderEntry* probe = placeholders()->get_entry(p_index, p_hash, child_name, class_loader);

   if (probe != NULL) {

      probe->remove_seen_thread(THREAD, PlaceholderTable::LOAD_SUPER);

   }

  }

  if (HAS_PENDING_EXCEPTION || superk_h() == NULL) {

    // can null superk

    superk_h = KlassHandle(THREAD, handle_resolution_exception(class_name, class_loader, protection_domain, true, superk_h, THREAD));

  }

  return superk_h();

}

void SystemDictionary::validate_protection_domain(instanceKlassHandle klass,

                                                  Handle class_loader,

                                                  Handle protection_domain,

                                                  TRAPS) {

  if(!has_checkPackageAccess()) return;

  // Now we have to call back to java to check if the initating class has access

  JavaValue result(T_VOID);

  if (TraceProtectionDomainVerification) {

    // Print out trace information

    tty->print_cr("Checking package access");

    tty->print(" - class loader:      "); class_loader()->print_value_on(tty);      tty->cr();

    tty->print(" - protection domain: "); protection_domain()->print_value_on(tty); tty->cr();

    tty->print(" - loading:           "); klass()->print_value_on(tty);             tty->cr();

  }

  assert(class_loader() != NULL, "should not have non-null protection domain for null classloader");

  KlassHandle system_loader(THREAD, SystemDictionary::classloader_klass());

  JavaCalls::call_special(&result,

                         class_loader,

                         system_loader,

                         vmSymbolHandles::checkPackageAccess_name(),

                         vmSymbolHandles::class_protectiondomain_signature(),

                         Handle(THREAD, klass->java_mirror()),

                         protection_domain,

                         THREAD);

  if (TraceProtectionDomainVerification) {

    if (HAS_PENDING_EXCEPTION) {

      tty->print_cr(" -> DENIED !!!!!!!!!!!!!!!!!!!!!");

    } else {

     tty->print_cr(" -> granted");

    }

    tty->cr();

  }

  if (HAS_PENDING_EXCEPTION) return;

  // If no exception has been thrown, we have validated the protection domain

  // Insert the protection domain of the initiating class into the set.

  {

    // We recalculate the entry here -- we've called out to java since

    // the last time it was calculated.

    symbolHandle kn(THREAD, klass->name());

    unsigned int d_hash = dictionary()->compute_hash(kn, class_loader);

    int d_index = dictionary()->hash_to_index(d_hash);

    MutexLocker mu(SystemDictionary_lock, THREAD);

    {

      // Note that we have an entry, and entries can be deleted only during GC,

      // so we cannot allow GC to occur while we're holding this entry.

      // We're using a No_Safepoint_Verifier to catch any place where we

      // might potentially do a GC at all.

      // SystemDictionary::do_unloading() asserts that classes are only

      // unloaded at a safepoint.

      No_Safepoint_Verifier nosafepoint;

      dictionary()->add_protection_domain(d_index, d_hash, klass, class_loader,

                                          protection_domain, THREAD);

    }

  }

}

// We only get here if this thread finds that another thread

// has already claimed the placeholder token for the current operation,

// but that other thread either never owned or gave up the

// object lock

// Waits on SystemDictionary_lock to indicate placeholder table updated

// On return, caller must recheck placeholder table state

//

// We only get here if

//  1) custom classLoader, i.e. not bootstrap classloader

//  2) UnsyncloadClass not set

//  3) custom classLoader has broken the class loader objectLock

//     so another thread got here in parallel

//

// lockObject must be held.

// Complicated dance due to lock ordering:

// Must first release the classloader object lock to

// allow initial definer to complete the class definition

// and to avoid deadlock

// Reclaim classloader lock object with same original recursion count

// Must release SystemDictionary_lock after notify, since

// class loader lock must be claimed before SystemDictionary_lock

// to prevent deadlocks

//

// The notify allows applications that did an untimed wait() on

// the classloader object lock to not hang.

void SystemDictionary::double_lock_wait(Handle lockObject, TRAPS) {

  assert_lock_strong(SystemDictionary_lock);

  bool calledholdinglock

      = ObjectSynchronizer::current_thread_holds_lock((JavaThread*)THREAD, lockObject);

  assert(calledholdinglock,"must hold lock for notify");

  assert(!UnsyncloadClass, "unexpected double_lock_wait");

  ObjectSynchronizer::notifyall(lockObject, THREAD);

  intptr_t recursions =  ObjectSynchronizer::complete_exit(lockObject, THREAD);

  SystemDictionary_lock->wait();

  SystemDictionary_lock->unlock();

  ObjectSynchronizer::reenter(lockObject, recursions, THREAD);

  SystemDictionary_lock->lock();

}

// If the class in is in the placeholder table, class loading is in progress

// For cases where the application changes threads to load classes, it

// is critical to ClassCircularity detection that we try loading

// the superclass on the same thread internally, so we do parallel

// super class loading here.

// This also is critical in cases where the original thread gets stalled

// even in non-circularity situations.

// Note: only one thread can define the class, but multiple can resolve

// Note: must call resolve_super_or_fail even if null super -

// to force placeholder entry creation for this class

// Caller must check for pending exception

// Returns non-null klassOop if other thread has completed load

// and we are done,

// If return null klassOop and no pending exception, the caller must load the class

instanceKlassHandle SystemDictionary::handle_parallel_super_load(

    symbolHandle name, symbolHandle superclassname, Handle class_loader,

    Handle protection_domain, Handle lockObject, TRAPS) {

  instanceKlassHandle nh = instanceKlassHandle(); // null Handle

  unsigned int d_hash = dictionary()->compute_hash(name, class_loader);

  int d_index = dictionary()->hash_to_index(d_hash);

  unsigned int p_hash = placeholders()->compute_hash(name, class_loader);

  int p_index = placeholders()->hash_to_index(p_hash);

  // superk is not used, resolve_super called for circularity check only

  // This code is reached in two situations. One if this thread

  // is loading the same class twice (e.g. ClassCircularity, or

  // java.lang.instrument).

  // The second is if another thread started the resolve_super first

  // and has not yet finished.

  // In both cases the original caller will clean up the placeholder

  // entry on error.

  klassOop superk = SystemDictionary::resolve_super_or_fail(name,

                                                          superclassname,

                                                          class_loader,

                                                          protection_domain,

                                                          true,

                                                          CHECK_(nh));

  // We don't redefine the class, so we just need to clean up if there

  // was not an error (don't want to modify any system dictionary

  // data structures).

  {

    MutexLocker mu(SystemDictionary_lock, THREAD);

    placeholders()->find_and_remove(p_index, p_hash, name, class_loader, THREAD);

    SystemDictionary_lock->notify_all();

  }

  // UnsyncloadClass does NOT wait for parallel superclass loads to complete

  // Bootstrap classloader does wait for parallel superclass loads

 if (UnsyncloadClass) {

    MutexLocker mu(SystemDictionary_lock, THREAD);

    // Check if classloading completed while we were loading superclass or waiting

    klassOop check = find_class(d_index, d_hash, name, class_loader);

    if (check != NULL) {

      // Klass is already loaded, so just return it

      return(instanceKlassHandle(THREAD, check));

    } else {

      return nh;

    }

  }

  // must loop to both handle other placeholder updates

  // and spurious notifications

  bool super_load_in_progress = true;

  PlaceholderEntry* placeholder;

  while (super_load_in_progress) {

    MutexLocker mu(SystemDictionary_lock, THREAD);

    // Check if classloading completed while we were loading superclass or waiting

    klassOop check = find_class(d_index, d_hash, name, class_loader);

    if (check != NULL) {

      // Klass is already loaded, so just return it

      return(instanceKlassHandle(THREAD, check));

    } else {

      placeholder = placeholders()->get_entry(p_index, p_hash, name, class_loader);

      if (placeholder && placeholder->super_load_in_progress() ){

        // Before UnsyncloadClass:

        // We only get here if the application has released the

        // classloader lock when another thread was in the middle of loading a

        // superclass/superinterface for this class, and now

        // this thread is also trying to load this class.

        // To minimize surprises, the first thread that started to

        // load a class should be the one to complete the loading

        // with the classfile it initially expected.

        // This logic has the current thread wait once it has done

        // all the superclass/superinterface loading it can, until

        // the original thread completes the class loading or fails

        // If it completes we will use the resulting instanceKlass

        // which we will find below in the systemDictionary.

        // We also get here for parallel bootstrap classloader

        if (class_loader.is_null()) {

          SystemDictionary_lock->wait();

        } else {

          double_lock_wait(lockObject, THREAD);

        }

      } else {