/*

 * Copyright (c) 1997, 2019, 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 "jvm.h"

#include "aot/aotLoader.hpp"

#include "classfile/classFileParser.hpp"

#include "classfile/classFileStream.hpp"

#include "classfile/classLoader.hpp"

#include "classfile/classLoaderData.inline.hpp"

#include "classfile/javaClasses.hpp"

#include "classfile/moduleEntry.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/systemDictionaryShared.hpp"

#include "classfile/verifier.hpp"

#include "classfile/vmSymbols.hpp"

#include "code/dependencyContext.hpp"

#include "compiler/compileBroker.hpp"

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

#include "interpreter/oopMapCache.hpp"

#include "interpreter/rewriter.hpp"

#include "jvmtifiles/jvmti.h"

#include "logging/log.hpp"

#include "logging/logMessage.hpp"

#include "logging/logStream.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/heapInspection.hpp"

#include "memory/iterator.inline.hpp"

#include "memory/metadataFactory.hpp"

#include "memory/metaspaceClosure.hpp"

#include "memory/metaspaceShared.hpp"

#include "memory/oopFactory.hpp"

#include "memory/resourceArea.hpp"

#include "oops/fieldStreams.hpp"

#include "oops/constantPool.hpp"

#include "oops/instanceClassLoaderKlass.hpp"

#include "oops/instanceKlass.inline.hpp"

#include "oops/instanceMirrorKlass.hpp"

#include "oops/instanceOop.hpp"

#include "oops/klass.inline.hpp"

#include "oops/method.hpp"

#include "oops/oop.inline.hpp"

#include "oops/symbol.hpp"

#include "prims/jvmtiExport.hpp"

#include "prims/jvmtiRedefineClasses.hpp"

#include "prims/jvmtiThreadState.hpp"

#include "prims/methodComparator.hpp"

#include "runtime/atomic.hpp"

#include "runtime/fieldDescriptor.inline.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/mutexLocker.hpp"

#include "runtime/orderAccess.hpp"

#include "runtime/thread.inline.hpp"

#include "services/classLoadingService.hpp"

#include "services/threadService.hpp"

#include "utilities/dtrace.hpp"

#include "utilities/events.hpp"

#include "utilities/macros.hpp"

#include "utilities/stringUtils.hpp"

#ifdef COMPILER1

#include "c1/c1_Compiler.hpp"

#endif

#if INCLUDE_JFR

#include "jfr/jfrEvents.hpp"

#endif

#ifdef DTRACE_ENABLED

#define HOTSPOT_CLASS_INITIALIZATION_required HOTSPOT_CLASS_INITIALIZATION_REQUIRED

#define HOTSPOT_CLASS_INITIALIZATION_recursive HOTSPOT_CLASS_INITIALIZATION_RECURSIVE

#define HOTSPOT_CLASS_INITIALIZATION_concurrent HOTSPOT_CLASS_INITIALIZATION_CONCURRENT

#define HOTSPOT_CLASS_INITIALIZATION_erroneous HOTSPOT_CLASS_INITIALIZATION_ERRONEOUS

#define HOTSPOT_CLASS_INITIALIZATION_super__failed HOTSPOT_CLASS_INITIALIZATION_SUPER_FAILED

#define HOTSPOT_CLASS_INITIALIZATION_clinit HOTSPOT_CLASS_INITIALIZATION_CLINIT

#define HOTSPOT_CLASS_INITIALIZATION_error HOTSPOT_CLASS_INITIALIZATION_ERROR

#define HOTSPOT_CLASS_INITIALIZATION_end HOTSPOT_CLASS_INITIALIZATION_END

#define DTRACE_CLASSINIT_PROBE(type, thread_type)                \

  {                                                              \

    char* data = NULL;                                           \

    int len = 0;                                                 \

    Symbol* clss_name = name();                                  \

    if (clss_name != NULL) {                                     \

      data = (char*)clss_name->bytes();                          \

      len = clss_name->utf8_length();                            \

    }                                                            \

    HOTSPOT_CLASS_INITIALIZATION_##type(                         \

      data, len, (void*)class_loader(), thread_type);            \

  }

#define DTRACE_CLASSINIT_PROBE_WAIT(type, thread_type, wait)     \

  {                                                              \

    char* data = NULL;                                           \

    int len = 0;                                                 \

    Symbol* clss_name = name();                                  \

    if (clss_name != NULL) {                                     \

      data = (char*)clss_name->bytes();                          \

      len = clss_name->utf8_length();                            \

    }                                                            \

    HOTSPOT_CLASS_INITIALIZATION_##type(                         \

      data, len, (void*)class_loader(), thread_type, wait);      \

  }

#else //  ndef DTRACE_ENABLED

#define DTRACE_CLASSINIT_PROBE(type, thread_type)

#define DTRACE_CLASSINIT_PROBE_WAIT(type, thread_type, wait)

#endif //  ndef DTRACE_ENABLED

static inline bool is_class_loader(const Symbol* class_name,

                                   const ClassFileParser& parser) {

  assert(class_name != NULL, "invariant");

  if (class_name == vmSymbols::java_lang_ClassLoader()) {

    return true;

  }

  if (SystemDictionary::ClassLoader_klass_loaded()) {

    const Klass* const super_klass = parser.super_klass();

    if (super_klass != NULL) {

      if (super_klass->is_subtype_of(SystemDictionary::ClassLoader_klass())) {

        return true;

      }

    }

  }

  return false;

}

// called to verify that k is a member of this nest

bool InstanceKlass::has_nest_member(InstanceKlass* k, TRAPS) const {

  if (_nest_members == NULL || _nest_members == Universe::the_empty_short_array()) {

    if (log_is_enabled(Trace, class, nestmates)) {

      ResourceMark rm(THREAD);

      log_trace(class, nestmates)("Checked nest membership of %s in non-nest-host class %s",

                                  k->external_name(), this->external_name());

    }

    return false;

  }

  if (log_is_enabled(Trace, class, nestmates)) {

    ResourceMark rm(THREAD);

    log_trace(class, nestmates)("Checking nest membership of %s in %s",

                                k->external_name(), this->external_name());

  }

  // Check for a resolved cp entry , else fall back to a name check.

  // We don't want to resolve any class other than the one being checked.

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

    int cp_index = _nest_members->at(i);

    if (_constants->tag_at(cp_index).is_klass()) {

      Klass* k2 = _constants->klass_at(cp_index, CHECK_false);

      if (k2 == k) {

        log_trace(class, nestmates)("- class is listed at nest_members[%d] => cp[%d]", i, cp_index);

        return true;

      }

    }

    else {

      Symbol* name = _constants->klass_name_at(cp_index);

      if (name == k->name()) {

        log_trace(class, nestmates)("- Found it at nest_members[%d] => cp[%d]", i, cp_index);

        // Names match so check actual klass - this may trigger class loading if

        // it doesn't match (though that should be impossible). But to be safe we

        // have to check for a compiler thread executing here.

        if (!THREAD->can_call_java() && !_constants->tag_at(cp_index).is_klass()) {

          log_trace(class, nestmates)("- validation required resolution in an unsuitable thread");

          return false;

        }

        Klass* k2 = _constants->klass_at(cp_index, CHECK_false);

        if (k2 == k) {

          log_trace(class, nestmates)("- class is listed as a nest member");

          return true;

        }

        else {

          // same name but different klass!

          log_trace(class, nestmates)(" - klass comparison failed!");

          // can't have two names the same, so we're done

          return false;

        }

      }

    }

  }

  log_trace(class, nestmates)("- class is NOT a nest member!");

  return false;

}

// Return nest-host class, resolving, validating and saving it if needed.

// In cases where this is called from a thread that can not do classloading

// (such as a native JIT thread) then we simply return NULL, which in turn

// causes the access check to return false. Such code will retry the access

// from a more suitable environment later.

InstanceKlass* InstanceKlass::nest_host(Symbol* validationException, TRAPS) {

  InstanceKlass* nest_host_k = _nest_host;

  if (nest_host_k == NULL) {

    // need to resolve and save our nest-host class. This could be attempted

    // concurrently but as the result is idempotent and we don't use the class

    // then we do not need any synchronization beyond what is implicitly used

    // during class loading.

    if (_nest_host_index != 0) { // we have a real nest_host

      // Before trying to resolve check if we're in a suitable context

      if (!THREAD->can_call_java() && !_constants->tag_at(_nest_host_index).is_klass()) {

        if (log_is_enabled(Trace, class, nestmates)) {

          ResourceMark rm(THREAD);

          log_trace(class, nestmates)("Rejected resolution of nest-host of %s in unsuitable thread",

                                      this->external_name());

        }

        return NULL;

      }

      if (log_is_enabled(Trace, class, nestmates)) {

        ResourceMark rm(THREAD);

        log_trace(class, nestmates)("Resolving nest-host of %s using cp entry for %s",

                                    this->external_name(),

                                    _constants->klass_name_at(_nest_host_index)->as_C_string());

      }

      Klass* k = _constants->klass_at(_nest_host_index, THREAD);

      if (HAS_PENDING_EXCEPTION) {

        Handle exc_h = Handle(THREAD, PENDING_EXCEPTION);

        if (exc_h->is_a(SystemDictionary::NoClassDefFoundError_klass())) {

          // throw a new CDNFE with the original as its cause, and a clear msg

          ResourceMark rm(THREAD);

          char buf[200];

          CLEAR_PENDING_EXCEPTION;

          jio_snprintf(buf, sizeof(buf),

                       "Unable to load nest-host class (%s) of %s",

                       _constants->klass_name_at(_nest_host_index)->as_C_string(),

                       this->external_name());

          log_trace(class, nestmates)("%s - NoClassDefFoundError", buf);

          THROW_MSG_CAUSE_NULL(vmSymbols::java_lang_NoClassDefFoundError(), buf, exc_h);

        }

        // All other exceptions pass through (OOME, StackOverflowError, LinkageErrors etc).

        return NULL;

      }

      // A valid nest-host is an instance class in the current package that lists this

      // class as a nest member. If any of these conditions are not met we post the

      // requested exception type (if any) and return NULL

      const char* error = NULL;

      // JVMS 5.4.4 indicates package check comes first

      if (is_same_class_package(k)) {

        // Now check actual membership. We can't be a member if our "host" is

        // not an instance class.

        if (k->is_instance_klass()) {

          nest_host_k = InstanceKlass::cast(k);

          bool is_member = nest_host_k->has_nest_member(this, CHECK_NULL);

          if (is_member) {

            // save resolved nest-host value

            _nest_host = nest_host_k;

            if (log_is_enabled(Trace, class, nestmates)) {

              ResourceMark rm(THREAD);

              log_trace(class, nestmates)("Resolved nest-host of %s to %s",

                                          this->external_name(), k->external_name());

            }

            return nest_host_k;

          }

        }

        error = "current type is not listed as a nest member";

      } else {

        error = "types are in different packages";

      }

      if (log_is_enabled(Trace, class, nestmates)) {

        ResourceMark rm(THREAD);

        log_trace(class, nestmates)

          ("Type %s (loader: %s) is not a nest member of "

           "resolved type %s (loader: %s): %s",

           this->external_name(),

           this->class_loader_data()->loader_name_and_id(),

           k->external_name(),

           k->class_loader_data()->loader_name_and_id(),

           error);

      }

      if (validationException != NULL && THREAD->can_call_java()) {

        ResourceMark rm(THREAD);

        Exceptions::fthrow(THREAD_AND_LOCATION,

                           validationException,

                           "Type %s (loader: %s) is not a nest member of %s (loader: %s): %s",

                           this->external_name(),

                           this->class_loader_data()->loader_name_and_id(),

                           k->external_name(),

                           k->class_loader_data()->loader_name_and_id(),

                           error

                           );

      }

      return NULL;

    } else {

      if (log_is_enabled(Trace, class, nestmates)) {

        ResourceMark rm(THREAD);

        log_trace(class, nestmates)("Type %s is not part of a nest: setting nest-host to self",

                                    this->external_name());

      }

      // save resolved nest-host value

      return (_nest_host = this);

    }

  }

  return nest_host_k;

}

// check if 'this' and k are nestmates (same nest_host), or k is our nest_host,

// or we are k's nest_host - all of which is covered by comparing the two

// resolved_nest_hosts

bool InstanceKlass::has_nestmate_access_to(InstanceKlass* k, TRAPS) {

  assert(this != k, "this should be handled by higher-level code");

  // Per JVMS 5.4.4 we first resolve and validate the current class, then

  // the target class k. Resolution exceptions will be passed on by upper

  // layers. IncompatibleClassChangeErrors from membership validation failures

  // will also be passed through.

  Symbol* icce = vmSymbols::java_lang_IncompatibleClassChangeError();

  InstanceKlass* cur_host = nest_host(icce, CHECK_false);

  if (cur_host == NULL) {

    return false;

  }

  Klass* k_nest_host = k->nest_host(icce, CHECK_false);

  if (k_nest_host == NULL) {

    return false;

  }

  bool access = (cur_host == k_nest_host);

  if (log_is_enabled(Trace, class, nestmates)) {

    ResourceMark rm(THREAD);

    log_trace(class, nestmates)("Class %s does %shave nestmate access to %s",

                                this->external_name(),

                                access ? "" : "NOT ",

                                k->external_name());

  }

  return access;

}

InstanceKlass* InstanceKlass::allocate_instance_klass(const ClassFileParser& parser, TRAPS) {

  const int size = InstanceKlass::size(parser.vtable_size(),

                                       parser.itable_size(),

                                       nonstatic_oop_map_size(parser.total_oop_map_count()),

                                       parser.is_interface(),

                                       parser.is_unsafe_anonymous(),

                                       should_store_fingerprint(parser.is_unsafe_anonymous()));

  const Symbol* const class_name = parser.class_name();

  assert(class_name != NULL, "invariant");

  ClassLoaderData* loader_data = parser.loader_data();

  assert(loader_data != NULL, "invariant");

  InstanceKlass* ik;

  // Allocation

  if (REF_NONE == parser.reference_type()) {

    if (class_name == vmSymbols::java_lang_Class()) {

      // mirror

      ik = new (loader_data, size, THREAD) InstanceMirrorKlass(parser);

    }

    else if (is_class_loader(class_name, parser)) {

      // class loader

      ik = new (loader_data, size, THREAD) InstanceClassLoaderKlass(parser);

    } else {

      // normal

      ik = new (loader_data, size, THREAD) InstanceKlass(parser, InstanceKlass::_misc_kind_other);

    }

  } else {

    // reference

    ik = new (loader_data, size, THREAD) InstanceRefKlass(parser);

  }

  // Check for pending exception before adding to the loader data and incrementing

  // class count.  Can get OOM here.

  if (HAS_PENDING_EXCEPTION) {

    return NULL;

  }

  return ik;

}

// copy method ordering from resource area to Metaspace

void InstanceKlass::copy_method_ordering(const intArray* m, TRAPS) {

  if (m != NULL) {

    // allocate a new array and copy contents (memcpy?)

    _method_ordering = MetadataFactory::new_array<int>(class_loader_data(), m->length(), CHECK);

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

      _method_ordering->at_put(i, m->at(i));

    }

  } else {

    _method_ordering = Universe::the_empty_int_array();

  }

}

// create a new array of vtable_indices for default methods

Array<int>* InstanceKlass::create_new_default_vtable_indices(int len, TRAPS) {

  Array<int>* vtable_indices = MetadataFactory::new_array<int>(class_loader_data(), len, CHECK_NULL);

  assert(default_vtable_indices() == NULL, "only create once");

  set_default_vtable_indices(vtable_indices);

  return vtable_indices;

}

InstanceKlass::InstanceKlass(const ClassFileParser& parser, unsigned kind, KlassID id) :

  Klass(id),

  _nest_members(NULL),

  _nest_host_index(0),

  _nest_host(NULL),

  _static_field_size(parser.static_field_size()),

  _nonstatic_oop_map_size(nonstatic_oop_map_size(parser.total_oop_map_count())),

  _itable_len(parser.itable_size()),

  _reference_type(parser.reference_type())

{

  set_vtable_length(parser.vtable_size());

  set_kind(kind);

  set_access_flags(parser.access_flags());

  set_is_unsafe_anonymous(parser.is_unsafe_anonymous());

  set_layout_helper(Klass::instance_layout_helper(parser.layout_size(),

                                                    false));

  assert(NULL == _methods, "underlying memory not zeroed?");

  assert(is_instance_klass(), "is layout incorrect?");

  assert(size_helper() == parser.layout_size(), "incorrect size_helper?");

  if (DumpSharedSpaces) {

    SystemDictionaryShared::init_dumptime_info(this);

  }

}

void InstanceKlass::deallocate_methods(ClassLoaderData* loader_data,

                                       Array<Method*>* methods) {

  if (methods != NULL && methods != Universe::the_empty_method_array() &&

      !methods->is_shared()) {

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

      Method* method = methods->at(i);

      if (method == NULL) continue;  // maybe null if error processing

      // Only want to delete methods that are not executing for RedefineClasses.

      // The previous version will point to them so they're not totally dangling

      assert (!method->on_stack(), "shouldn't be called with methods on stack");

      MetadataFactory::free_metadata(loader_data, method);

    }

    MetadataFactory::free_array<Method*>(loader_data, methods);

  }

}

void InstanceKlass::deallocate_interfaces(ClassLoaderData* loader_data,

                                          const Klass* super_klass,

                                          Array<InstanceKlass*>* local_interfaces,

                                          Array<InstanceKlass*>* transitive_interfaces) {

  // Only deallocate transitive interfaces if not empty, same as super class

  // or same as local interfaces.  See code in parseClassFile.

  Array<InstanceKlass*>* ti = transitive_interfaces;

  if (ti != Universe::the_empty_instance_klass_array() && ti != local_interfaces) {

    // check that the interfaces don't come from super class

    Array<InstanceKlass*>* sti = (super_klass == NULL) ? NULL :

                    InstanceKlass::cast(super_klass)->transitive_interfaces();

    if (ti != sti && ti != NULL && !ti->is_shared()) {

      MetadataFactory::free_array<InstanceKlass*>(loader_data, ti);

    }

  }