/*

 * 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/classLoaderData.inline.hpp"

#include "classfile/dictionary.hpp"

#include "classfile/javaClasses.hpp"

#include "classfile/loaderConstraints.hpp"

#include "classfile/placeholders.hpp"

#include "classfile/resolutionErrors.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "compiler/compileBroker.hpp"

#include "interpreter/bytecodeStream.hpp"

#include "interpreter/interpreter.hpp"

#include "memory/gcLocker.hpp"

#include "memory/oopFactory.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/instanceRefKlass.hpp"

#include "oops/klass.inline.hpp"

#include "oops/methodData.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/oop.inline.hpp"

#include "oops/oop.inline2.hpp"

#include "oops/typeArrayKlass.hpp"

#include "prims/jvmtiEnvBase.hpp"

#include "prims/methodHandles.hpp"

#include "runtime/biasedLocking.hpp"

#include "runtime/fieldType.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/java.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/mutexLocker.hpp"

#include "runtime/signature.hpp"

#include "services/classLoadingService.hpp"

#include "services/threadService.hpp"

Dictionary*            SystemDictionary::_dictionary          = NULL;

PlaceholderTable*      SystemDictionary::_placeholders        = NULL;

Dictionary*            SystemDictionary::_shared_dictionary   = NULL;

LoaderConstraintTable* SystemDictionary::_loader_constraints  = NULL;

ResolutionErrorTable*  SystemDictionary::_resolution_errors   = NULL;

SymbolPropertyTable*   SystemDictionary::_invoke_method_table = NULL;

int         SystemDictionary::_number_of_modifications = 0;

int         SystemDictionary::_sdgeneration               = 0;

const int   SystemDictionary::_primelist[_prime_array_size] = {1009,2017,4049,5051,10103,

              20201,40423,99991};

oop         SystemDictionary::_system_loader_lock_obj     =  NULL;

Klass*      SystemDictionary::_well_known_klasses[SystemDictionary::WKID_LIMIT]

                                                          =  { NULL /*, NULL...*/ };

Klass*      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

Klass* volatile 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) {

  KlassHandle system_klass(THREAD, WK_KLASS(ClassLoader_klass));

  JavaValue result(T_OBJECT);

  JavaCalls::call_static(&result,

                         KlassHandle(THREAD, WK_KLASS(ClassLoader_klass)),

                         vmSymbols::getSystemClassLoader_name(),

                         vmSymbols::void_classloader_signature(),

                         CHECK);

  _java_system_loader = (oop)result.get_jobject();

}

ClassLoaderData* SystemDictionary::register_loader(Handle class_loader) {

  if (class_loader() == NULL) return ClassLoaderData::the_null_class_loader_data();

  return ClassLoaderDataGraph::find_or_create(class_loader);

}

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

// debugging

#ifdef ASSERT

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

bool SystemDictionary::is_internal_format(Symbol* class_name) {

  if (class_name != NULL) {

    ResourceMark rm;

    char* name = class_name->as_C_string();

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

  } else {

    return true;

  }

}

#endif

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

// Parallel class loading check

bool SystemDictionary::is_parallelCapable(Handle class_loader) {

  if (UnsyncloadClass || class_loader.is_null()) return true;

  if (AlwaysLockClassLoader) return false;

  return java_lang_ClassLoader::parallelCapable(class_loader());

}

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

// ParallelDefineClass flag does not apply to bootclass loader

bool SystemDictionary::is_parallelDefine(Handle class_loader) {

   if (class_loader.is_null()) return false;

   if (AllowParallelDefineClass && java_lang_ClassLoader::parallelCapable(class_loader())) {

     return true;

   }

   return false;

}

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

// Resolving of classes

// Forwards to resolve_or_null

Klass* SystemDictionary::resolve_or_fail(Symbol* class_name, Handle class_loader, Handle protection_domain, bool throw_error, TRAPS) {

  Klass* 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;

}

Klass* SystemDictionary::handle_resolution_exception(Symbol* 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 (Klass*)klass_h();

}

Klass* SystemDictionary::resolve_or_fail(Symbol* class_name,

                                           bool throw_error, TRAPS)

{

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

}

// Forwards to resolve_instance_class_or_null

Klass* SystemDictionary::resolve_or_null(Symbol* class_name, Handle class_loader, Handle protection_domain, TRAPS) {

  assert(!THREAD->is_Compiler_thread(),

         err_msg("can not load classes with compiler thread: class=%s, classloader=%s",

                 class_name->as_C_string(),

                 class_loader.is_null() ? "null" : class_loader->klass()->name()->as_C_string()));

  if (FieldType::is_array(class_name)) {

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

  } else if (FieldType::is_obj(class_name)) {

    ResourceMark rm(THREAD);

    // Ignore wrapping L and ;.

    TempNewSymbol name = SymbolTable::new_symbol(class_name->as_C_string() + 1,

                                   class_name->utf8_length() - 2, CHECK_NULL);

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

  } else {

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

  }

}

Klass* SystemDictionary::resolve_or_null(Symbol* class_name, TRAPS) {

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

}

// Forwards to resolve_instance_class_or_null

Klass* SystemDictionary::resolve_array_class_or_null(Symbol* class_name,

                                                       Handle class_loader,

                                                       Handle protection_domain,

                                                       TRAPS) {

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

  Klass* k = NULL;

  FieldArrayInfo fd;

  // dimension and object_key in FieldArrayInfo are assigned as a side-effect

  // of this call

  BasicType t = FieldType::get_array_info(class_name, fd, CHECK_NULL);

  if (t == T_OBJECT) {

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

    k = SystemDictionary::resolve_instance_class_or_null(fd.object_key(),

                                                         class_loader,

                                                         protection_domain,

                                                         CHECK_NULL);

    if (k != NULL) {

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

    }

  } else {

    k = Universe::typeArrayKlassObj(t);

  }

  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_null:

//     via: handle_parallel_super_load

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

Klass* SystemDictionary::resolve_super_or_fail(Symbol* child_name,

                                                 Symbol* class_name,

                                                 Handle class_loader,

                                                 Handle protection_domain,

                                                 bool is_superclass,

                                                 TRAPS) {

  // Try to get one of the well-known klasses.

  // They are trusted, and do not participate in circularities.

  if (LinkWellKnownClasses) {

    Klass* k = find_well_known_klass(class_name);

    if (k != NULL) {

      return k;

    }

  }

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

  ClassLoaderData* loader_data = class_loader_data(class_loader);

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

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

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

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

    Klass* childk = find_class(d_index, d_hash, child_name, loader_data);

    Klass* 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, loader_data);

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

          throw_circularity_error = true;

      }

    }

    if (!throw_circularity_error) {

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

    }

  }

  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

  Klass* 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, loader_data);

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

  }

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

  JavaCalls::call_special(&result,

                         class_loader,

                         system_loader,

                         vmSymbols::checkPackageAccess_name(),

                         vmSymbols::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.

    ClassLoaderData* loader_data = class_loader_data(class_loader);

    Symbol*  kn = klass->name();

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

    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, loader_data,

                                          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((!(lockObject() == _system_loader_lock_obj) && !is_parallelCapable(lockObject)), "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 for circularity detection

// Caller must check for pending exception

// Returns non-null Klass* if other thread has completed load

// and we are done,

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

instanceKlassHandle SystemDictionary::handle_parallel_super_load(

    Symbol* name, Symbol* superclassname, Handle class_loader,

    Handle protection_domain, Handle lockObject, TRAPS) {

  instanceKlassHandle nh = instanceKlassHandle(); // null Handle