/*

 * Copyright (c) 1997, 2017, 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 "aot/aotLoader.hpp"

#include "classfile/classFileParser.hpp"

#include "classfile/classFileStream.hpp"

#include "classfile/classLoader.hpp"

#include "classfile/classLoaderData.inline.hpp"

#include "classfile/classLoaderExt.hpp"

#include "classfile/dictionary.hpp"

#include "classfile/javaClasses.inline.hpp"

#include "classfile/klassFactory.hpp"

#include "classfile/loaderConstraints.hpp"

#include "classfile/packageEntry.hpp"

#include "classfile/placeholders.hpp"

#include "classfile/protectionDomainCache.hpp"

#include "classfile/resolutionErrors.hpp"

#include "classfile/stringTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "code/codeCache.hpp"

#include "compiler/compileBroker.hpp"

#include "gc/shared/gcLocker.hpp"

#include "gc/shared/gcTraceTime.inline.hpp"

#include "interpreter/bytecodeStream.hpp"

#include "interpreter/interpreter.hpp"

#include "logging/log.hpp"

#include "logging/logStream.hpp"

#include "memory/filemap.hpp"

#include "memory/oopFactory.hpp"

#include "memory/resourceArea.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/instanceRefKlass.hpp"

#include "oops/klass.inline.hpp"

#include "oops/methodData.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/objArrayOop.inline.hpp"

#include "oops/oop.inline.hpp"

#include "oops/symbol.hpp"

#include "oops/typeArrayKlass.hpp"

#include "prims/jvm.h"

#include "prims/jvmtiEnvBase.hpp"

#include "prims/resolvedMethodTable.hpp"

#include "prims/methodHandles.hpp"

#include "runtime/arguments.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/orderAccess.inline.hpp"

#include "runtime/signature.hpp"

#include "services/classLoadingService.hpp"

#include "services/threadService.hpp"

#include "trace/traceMacros.hpp"

#include "utilities/macros.hpp"

#include "utilities/ticks.hpp"

#if INCLUDE_CDS

#include "classfile/sharedClassUtil.hpp"

#include "classfile/systemDictionaryShared.hpp"

#endif

#if INCLUDE_JVMCI

#include "jvmci/jvmciRuntime.hpp"

#endif

#if INCLUDE_TRACE

#include "trace/tracing.hpp"

#endif

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;

ProtectionDomainCacheTable*   SystemDictionary::_pd_cache_table = NULL;

int         SystemDictionary::_number_of_modifications = 0;

oop         SystemDictionary::_system_loader_lock_obj     =  NULL;

InstanceKlass*      SystemDictionary::_well_known_klasses[SystemDictionary::WKID_LIMIT]

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

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

InstanceKlass* volatile SystemDictionary::_abstract_ownable_synchronizer_klass = NULL;

// Default ProtectionDomainCacheSize value

const int defaultProtectionDomainCacheSize = 1009;

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

// Java-level SystemLoader

oop SystemDictionary::java_system_loader() {

  return _java_system_loader;

}

void SystemDictionary::compute_java_system_loader(TRAPS) {

  Klass* system_klass = WK_KLASS(ClassLoader_klass);

  JavaValue result(T_OBJECT);

  JavaCalls::call_static(&result,

                         WK_KLASS(ClassLoader_klass),

                         vmSymbols::getSystemClassLoader_name(),

                         vmSymbols::void_classloader_signature(),

                         CHECK);

  _java_system_loader = (oop)result.get_jobject();

  CDS_ONLY(SystemDictionaryShared::initialize(CHECK);)

}

ClassLoaderData* SystemDictionary::register_loader(Handle class_loader, TRAPS) {

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

  return ClassLoaderDataGraph::find_or_create(class_loader, THREAD);

}

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

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

}

// Returns true if the passed class loader is the builtin application class loader

// or a custom system class loader. A customer system class loader can be

// specified via -Djava.system.class.loader.

bool SystemDictionary::is_system_class_loader(oop class_loader) {

  if (class_loader == NULL) {

    return false;

  }

  return (class_loader->klass() == SystemDictionary::jdk_internal_loader_ClassLoaders_AppClassLoader_klass() ||

          class_loader == _java_system_loader);

}

// Returns true if the passed class loader is the platform class loader.

bool SystemDictionary::is_platform_class_loader(oop class_loader) {

  if (class_loader == NULL) {

    return false;

  }

  return (class_loader->klass() == SystemDictionary::jdk_internal_loader_ClassLoaders_PlatformClassLoader_klass());

}

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

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

    // can return a null klass

    klass = handle_resolution_exception(class_name, throw_error, klass, THREAD);

  }

  return klass;

}

Klass* SystemDictionary::handle_resolution_exception(Symbol* class_name,

                                                     bool throw_error,

                                                     Klass* klass, 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 == NULL, "Should not have result with exception pending");

      Handle e(THREAD, PENDING_EXCEPTION);

      CLEAR_PENDING_EXCEPTION;

      THROW_MSG_CAUSE_NULL(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 == NULL) {

    ResourceMark rm(THREAD);

    if (throw_error) {

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

    } else {

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

    }

  }

  return klass;

}

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

         "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, THREAD);

  } 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, THREAD);

  } else {

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

  }

}

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 = k->array_klass(fd.dimension(), CHECK_NULL);

    }

  } else {

    k = Universe::typeArrayKlassObj(t);

    k = TypeArrayKlass::cast(k)->array_klass(fd.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_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.

// Be careful when modifying this code: once you have run

// placeholders()->find_and_add(PlaceholderTable::LOAD_SUPER),

// you need to find_and_remove it before returning.

// So be careful to not exit with a CHECK_ macro betweeen these calls.

Klass* SystemDictionary::resolve_super_or_fail(Symbol* child_name,

                                                 Symbol* class_name,

                                                 Handle class_loader,

                                                 Handle protection_domain,

                                                 bool is_superclass,

                                                 TRAPS) {

#if INCLUDE_CDS

  if (DumpSharedSpaces) {

    // Special processing for CDS dump time.

    Klass* k = SystemDictionaryShared::dump_time_resolve_super_or_fail(child_name,

        class_name, class_loader, protection_domain, is_superclass, CHECK_NULL);

    if (k) {

      return k;

    }

  }

#endif // INCLUDE_CDS

  // 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 appropriate class loader

  // 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 needs to be in its class loader 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

  ClassLoaderData* loader_data = class_loader_data(class_loader);

  Dictionary* dictionary = loader_data->dictionary();

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

  int d_index = dictionary->hash_to_index(d_hash);

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

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

    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 = childk->super()) != NULL) &&

         ((quicksuperk->name() == class_name) &&

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

      // Be careful not to exit resolve_super

      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_NULL(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 = SystemDictionary::resolve_or_null(class_name,

                                                    class_loader,

                                                    protection_domain,

                                                    THREAD);

  // Clean up of placeholders moved so that each classloadAction registrar self-cleans up

  // It is no longer necessary to keep the placeholder table alive until update_dictionary

  // or error. GC used to walk the placeholder table as strong roots.

  // The instanceKlass is kept alive because the class loader is on the stack,

  // which keeps the loader_data alive, as well as all instanceKlasses in

  // the loader_data. parseClassFile adds the instanceKlass to loader_data.

  {

    MutexLocker mu(SystemDictionary_lock, THREAD);

    placeholders()->find_and_remove(p_index, p_hash, child_name, loader_data, PlaceholderTable::LOAD_SUPER, THREAD);

    SystemDictionary_lock->notify_all();

  }

  if (HAS_PENDING_EXCEPTION || superk == NULL) {

    // can null superk

    superk = handle_resolution_exception(class_name, true, superk, THREAD);

  }

  return superk;

}

void SystemDictionary::validate_protection_domain(InstanceKlass* 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);

  LogTarget(Debug, protectiondomain) lt;

  if (lt.is_enabled()) {

    ResourceMark rm;

    // Print out trace information

    LogStream ls(lt);

    ls.print_cr("Checking package access");

    ls.print("class loader: "); class_loader()->print_value_on(&ls);

    ls.print(" protection domain: "); protection_domain()->print_value_on(&ls);

    ls.print(" loading: "); klass->print_value_on(&ls);

    ls.cr();

  }

  // This handle and the class_loader handle passed in keeps this class from

  // being unloaded through several GC points.

  // The class_loader handle passed in is the initiating loader.

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

  InstanceKlass* system_loader = SystemDictionary::ClassLoader_klass();

  JavaCalls::call_special(&result,

                         class_loader,

                         system_loader,

                         vmSymbols::checkPackageAccess_name(),

                         vmSymbols::class_protectiondomain_signature(),

                         mirror,

                         protection_domain,

                         THREAD);

  if (HAS_PENDING_EXCEPTION) {

    log_debug(protectiondomain)("DENIED !!!!!!!!!!!!!!!!!!!!!");

  } else {

   log_debug(protectiondomain)("granted");

  }

  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.

  {

    ClassLoaderData* loader_data = class_loader_data(class_loader);

    Dictionary* dictionary = loader_data->dictionary();

    Symbol*  kn = klass->name();

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

    int d_index = dictionary->hash_to_index(d_hash);

    MutexLocker mu(SystemDictionary_lock, THREAD);

    dictionary->add_protection_domain(d_index, d_hash, klass,

                                      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