/*

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

#include "classfile/classLoaderDataGraph.hpp"

#include "classfile/classFileStream.hpp"

#include "classfile/javaClasses.inline.hpp"

#include "classfile/metadataOnStackMark.hpp"

#include "classfile/symbolTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/verifier.hpp"

#include "code/codeCache.hpp"

#include "compiler/compileBroker.hpp"

#include "interpreter/oopMapCache.hpp"

#include "interpreter/rewriter.hpp"

#include "logging/logStream.hpp"

#include "memory/metadataFactory.hpp"

#include "memory/metaspaceShared.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.hpp"

#include "oops/constantPool.hpp"

#include "oops/klassVtable.hpp"

#include "oops/oop.inline.hpp"

#include "prims/jvmtiImpl.hpp"

#include "prims/jvmtiRedefineClasses.hpp"

#include "prims/jvmtiThreadState.inline.hpp"

#include "prims/resolvedMethodTable.hpp"

#include "prims/methodComparator.hpp"

#include "runtime/deoptimization.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/jniHandles.inline.hpp"

#include "runtime/relocator.hpp"

#include "runtime/safepointVerifiers.hpp"

#include "utilities/bitMap.inline.hpp"

#include "utilities/events.hpp"

Array<Method*>* VM_RedefineClasses::_old_methods = NULL;

Array<Method*>* VM_RedefineClasses::_new_methods = NULL;

Method**  VM_RedefineClasses::_matching_old_methods = NULL;

Method**  VM_RedefineClasses::_matching_new_methods = NULL;

Method**  VM_RedefineClasses::_deleted_methods      = NULL;

Method**  VM_RedefineClasses::_added_methods        = NULL;

int       VM_RedefineClasses::_matching_methods_length = 0;

int       VM_RedefineClasses::_deleted_methods_length  = 0;

int       VM_RedefineClasses::_added_methods_length    = 0;

bool      VM_RedefineClasses::_has_redefined_Object = false;

bool      VM_RedefineClasses::_has_null_class_loader = false;

VM_RedefineClasses::VM_RedefineClasses(jint class_count,

                                       const jvmtiClassDefinition *class_defs,

                                       JvmtiClassLoadKind class_load_kind) {

  _class_count = class_count;

  _class_defs = class_defs;

  _class_load_kind = class_load_kind;

  _any_class_has_resolved_methods = false;

  _res = JVMTI_ERROR_NONE;

  _the_class = NULL;

  _has_redefined_Object = false;

  _has_null_class_loader = false;

}

static inline InstanceKlass* get_ik(jclass def) {

  oop mirror = JNIHandles::resolve_non_null(def);

  return InstanceKlass::cast(java_lang_Class::as_Klass(mirror));

}

// If any of the classes are being redefined, wait

// Parallel constant pool merging leads to indeterminate constant pools.

void VM_RedefineClasses::lock_classes() {

  MonitorLocker ml(RedefineClasses_lock);

  bool has_redefined;

  do {

    has_redefined = false;

    // Go through classes each time until none are being redefined.

    for (int i = 0; i < _class_count; i++) {

      if (get_ik(_class_defs[i].klass)->is_being_redefined()) {

        ml.wait();

        has_redefined = true;

        break;  // for loop

      }

    }

  } while (has_redefined);

  for (int i = 0; i < _class_count; i++) {

    get_ik(_class_defs[i].klass)->set_is_being_redefined(true);

  }

  ml.notify_all();

}

void VM_RedefineClasses::unlock_classes() {

  MonitorLocker ml(RedefineClasses_lock);

  for (int i = 0; i < _class_count; i++) {

    assert(get_ik(_class_defs[i].klass)->is_being_redefined(),

           "should be being redefined to get here");

    get_ik(_class_defs[i].klass)->set_is_being_redefined(false);

  }

  ml.notify_all();

}

bool VM_RedefineClasses::doit_prologue() {

  if (_class_count == 0) {

    _res = JVMTI_ERROR_NONE;

    return false;

  }

  if (_class_defs == NULL) {

    _res = JVMTI_ERROR_NULL_POINTER;

    return false;

  }

  for (int i = 0; i < _class_count; i++) {

    if (_class_defs[i].klass == NULL) {

      _res = JVMTI_ERROR_INVALID_CLASS;

      return false;

    }

    if (_class_defs[i].class_byte_count == 0) {

      _res = JVMTI_ERROR_INVALID_CLASS_FORMAT;

      return false;

    }

    if (_class_defs[i].class_bytes == NULL) {

      _res = JVMTI_ERROR_NULL_POINTER;

      return false;

    }

    oop mirror = JNIHandles::resolve_non_null(_class_defs[i].klass);

    // classes for primitives and arrays and vm unsafe anonymous classes cannot be redefined

    // check here so following code can assume these classes are InstanceKlass

    if (!is_modifiable_class(mirror)) {

      _res = JVMTI_ERROR_UNMODIFIABLE_CLASS;

      return false;

    }

  }

  // Start timer after all the sanity checks; not quite accurate, but

  // better than adding a bunch of stop() calls.

  if (log_is_enabled(Info, redefine, class, timer)) {

    _timer_vm_op_prologue.start();

  }

  lock_classes();

  // We first load new class versions in the prologue, because somewhere down the

  // call chain it is required that the current thread is a Java thread.

  _res = load_new_class_versions(Thread::current());

  if (_res != JVMTI_ERROR_NONE) {

    // free any successfully created classes, since none are redefined

    for (int i = 0; i < _class_count; i++) {

      if (_scratch_classes[i] != NULL) {

        ClassLoaderData* cld = _scratch_classes[i]->class_loader_data();

        // Free the memory for this class at class unloading time.  Not before

        // because CMS might think this is still live.

        InstanceKlass* ik = get_ik(_class_defs[i].klass);

        if (ik->get_cached_class_file() == _scratch_classes[i]->get_cached_class_file()) {

          // Don't double-free cached_class_file copied from the original class if error.

          _scratch_classes[i]->set_cached_class_file(NULL);

        }

        cld->add_to_deallocate_list(InstanceKlass::cast(_scratch_classes[i]));

      }

    }

    // Free os::malloc allocated memory in load_new_class_version.

    os::free(_scratch_classes);

    _timer_vm_op_prologue.stop();

    unlock_classes();

    return false;

  }

  _timer_vm_op_prologue.stop();

  return true;

}

void VM_RedefineClasses::doit() {

  Thread *thread = Thread::current();

#if INCLUDE_CDS

  if (UseSharedSpaces) {

    // Sharing is enabled so we remap the shared readonly space to

    // shared readwrite, private just in case we need to redefine

    // a shared class. We do the remap during the doit() phase of

    // the safepoint to be safer.

    if (!MetaspaceShared::remap_shared_readonly_as_readwrite()) {

      log_info(redefine, class, load)("failed to remap shared readonly space to readwrite, private");

      _res = JVMTI_ERROR_INTERNAL;

      return;

    }

  }

#endif

  // Mark methods seen on stack and everywhere else so old methods are not

  // cleaned up if they're on the stack.

  MetadataOnStackMark md_on_stack(/*walk_all_metadata*/true, /*redefinition_walk*/true);

  HandleMark hm(thread);   // make sure any handles created are deleted

                           // before the stack walk again.

  for (int i = 0; i < _class_count; i++) {

    redefine_single_class(_class_defs[i].klass, _scratch_classes[i], thread);

  }

  // Flush all compiled code that depends on the classes redefined.

  flush_dependent_code();

  // Adjust constantpool caches and vtables for all classes

  // that reference methods of the evolved classes.

  // Have to do this after all classes are redefined and all methods that

  // are redefined are marked as old.

  AdjustAndCleanMetadata adjust_and_clean_metadata(thread);

  ClassLoaderDataGraph::classes_do(&adjust_and_clean_metadata);

  // JSR-292 support

  if (_any_class_has_resolved_methods) {

    bool trace_name_printed = false;

    ResolvedMethodTable::adjust_method_entries(&trace_name_printed);

  }

  // Increment flag indicating that some invariants are no longer true.

  // See jvmtiExport.hpp for detailed explanation.

  JvmtiExport::increment_redefinition_count();

  // check_class() is optionally called for product bits, but is

  // always called for non-product bits.

#ifdef PRODUCT

  if (log_is_enabled(Trace, redefine, class, obsolete, metadata)) {

#endif

    log_trace(redefine, class, obsolete, metadata)("calling check_class");

    CheckClass check_class(thread);

    ClassLoaderDataGraph::classes_do(&check_class);

#ifdef PRODUCT

  }

#endif

  // Clean up any metadata now unreferenced while MetadataOnStackMark is set.

  ClassLoaderDataGraph::clean_deallocate_lists(false);

}

void VM_RedefineClasses::doit_epilogue() {

  unlock_classes();

  // Free os::malloc allocated memory.

  os::free(_scratch_classes);

  // Reset the_class to null for error printing.

  _the_class = NULL;

  if (log_is_enabled(Info, redefine, class, timer)) {

    // Used to have separate timers for "doit" and "all", but the timer

    // overhead skewed the measurements.

    julong doit_time = _timer_rsc_phase1.milliseconds() +

                       _timer_rsc_phase2.milliseconds();

    julong all_time = _timer_vm_op_prologue.milliseconds() + doit_time;

    log_info(redefine, class, timer)

      ("vm_op: all=" JULONG_FORMAT "  prologue=" JULONG_FORMAT "  doit=" JULONG_FORMAT,

       all_time, (julong)_timer_vm_op_prologue.milliseconds(), doit_time);

    log_info(redefine, class, timer)

      ("redefine_single_class: phase1=" JULONG_FORMAT "  phase2=" JULONG_FORMAT,

       (julong)_timer_rsc_phase1.milliseconds(), (julong)_timer_rsc_phase2.milliseconds());

  }

}

bool VM_RedefineClasses::is_modifiable_class(oop klass_mirror) {

  // classes for primitives cannot be redefined

  if (java_lang_Class::is_primitive(klass_mirror)) {

    return false;

  }

  Klass* k = java_lang_Class::as_Klass(klass_mirror);

  // classes for arrays cannot be redefined

  if (k == NULL || !k->is_instance_klass()) {

    return false;

  }

  // Cannot redefine or retransform an unsafe anonymous class.

  if (InstanceKlass::cast(k)->is_unsafe_anonymous()) {

    return false;

  }

  return true;

}

// Append the current entry at scratch_i in scratch_cp to *merge_cp_p

// where the end of *merge_cp_p is specified by *merge_cp_length_p. For

// direct CP entries, there is just the current entry to append. For

// indirect and double-indirect CP entries, there are zero or more

// referenced CP entries along with the current entry to append.

// Indirect and double-indirect CP entries are handled by recursive

// calls to append_entry() as needed. The referenced CP entries are

// always appended to *merge_cp_p before the referee CP entry. These

// referenced CP entries may already exist in *merge_cp_p in which case

// there is nothing extra to append and only the current entry is

// appended.

void VM_RedefineClasses::append_entry(const constantPoolHandle& scratch_cp,

       int scratch_i, constantPoolHandle *merge_cp_p, int *merge_cp_length_p,

       TRAPS) {

  // append is different depending on entry tag type

  switch (scratch_cp->tag_at(scratch_i).value()) {

    // The old verifier is implemented outside the VM. It loads classes,

    // but does not resolve constant pool entries directly so we never

    // see Class entries here with the old verifier. Similarly the old

    // verifier does not like Class entries in the input constant pool.

    // The split-verifier is implemented in the VM so it can optionally

    // and directly resolve constant pool entries to load classes. The

    // split-verifier can accept either Class entries or UnresolvedClass

    // entries in the input constant pool. We revert the appended copy

    // back to UnresolvedClass so that either verifier will be happy

    // with the constant pool entry.

    //

    // this is an indirect CP entry so it needs special handling

    case JVM_CONSTANT_Class:

    case JVM_CONSTANT_UnresolvedClass:

    {

      int name_i = scratch_cp->klass_name_index_at(scratch_i);

      int new_name_i = find_or_append_indirect_entry(scratch_cp, name_i, merge_cp_p,

                                                     merge_cp_length_p, THREAD);

      if (new_name_i != name_i) {

        log_trace(redefine, class, constantpool)

          ("Class entry@%d name_index change: %d to %d",

           *merge_cp_length_p, name_i, new_name_i);

      }

      (*merge_cp_p)->temp_unresolved_klass_at_put(*merge_cp_length_p, new_name_i);

      if (scratch_i != *merge_cp_length_p) {

        // The new entry in *merge_cp_p is at a different index than

        // the new entry in scratch_cp so we need to map the index values.

        map_index(scratch_cp, scratch_i, *merge_cp_length_p);

      }

      (*merge_cp_length_p)++;

    } break;

    // these are direct CP entries so they can be directly appended,

    // but double and long take two constant pool entries

    case JVM_CONSTANT_Double:  // fall through

    case JVM_CONSTANT_Long:

    {

      ConstantPool::copy_entry_to(scratch_cp, scratch_i, *merge_cp_p, *merge_cp_length_p,

        THREAD);

      if (scratch_i != *merge_cp_length_p) {

        // The new entry in *merge_cp_p is at a different index than

        // the new entry in scratch_cp so we need to map the index values.

        map_index(scratch_cp, scratch_i, *merge_cp_length_p);

      }

      (*merge_cp_length_p) += 2;

    } break;

    // these are direct CP entries so they can be directly appended

    case JVM_CONSTANT_Float:   // fall through

    case JVM_CONSTANT_Integer: // fall through

    case JVM_CONSTANT_Utf8:    // fall through

    // This was an indirect CP entry, but it has been changed into

    // Symbol*s so this entry can be directly appended.

    case JVM_CONSTANT_String:      // fall through

    {

      ConstantPool::copy_entry_to(scratch_cp, scratch_i, *merge_cp_p, *merge_cp_length_p,

        THREAD);

      if (scratch_i != *merge_cp_length_p) {

        // The new entry in *merge_cp_p is at a different index than

        // the new entry in scratch_cp so we need to map the index values.

        map_index(scratch_cp, scratch_i, *merge_cp_length_p);

      }

      (*merge_cp_length_p)++;

    } break;

    // this is an indirect CP entry so it needs special handling

    case JVM_CONSTANT_NameAndType:

    {

      int name_ref_i = scratch_cp->name_ref_index_at(scratch_i);

      int new_name_ref_i = find_or_append_indirect_entry(scratch_cp, name_ref_i, merge_cp_p,

                                                         merge_cp_length_p, THREAD);

      int signature_ref_i = scratch_cp->signature_ref_index_at(scratch_i);

      int new_signature_ref_i = find_or_append_indirect_entry(scratch_cp, signature_ref_i,

                                                              merge_cp_p, merge_cp_length_p,

                                                              THREAD);

      // If the referenced entries already exist in *merge_cp_p, then

      // both new_name_ref_i and new_signature_ref_i will both be 0.

      // In that case, all we are appending is the current entry.

      if (new_name_ref_i != name_ref_i) {

        log_trace(redefine, class, constantpool)

          ("NameAndType entry@%d name_ref_index change: %d to %d",

           *merge_cp_length_p, name_ref_i, new_name_ref_i);

      }

      if (new_signature_ref_i != signature_ref_i) {

        log_trace(redefine, class, constantpool)

          ("NameAndType entry@%d signature_ref_index change: %d to %d",

           *merge_cp_length_p, signature_ref_i, new_signature_ref_i);

      }

      (*merge_cp_p)->name_and_type_at_put(*merge_cp_length_p,

        new_name_ref_i, new_signature_ref_i);

      if (scratch_i != *merge_cp_length_p) {

        // The new entry in *merge_cp_p is at a different index than

        // the new entry in scratch_cp so we need to map the index values.

        map_index(scratch_cp, scratch_i, *merge_cp_length_p);

      }

      (*merge_cp_length_p)++;

    } break;

    // this is a double-indirect CP entry so it needs special handling

    case JVM_CONSTANT_Fieldref:           // fall through

    case JVM_CONSTANT_InterfaceMethodref: // fall through

    case JVM_CONSTANT_Methodref:

    {

      int klass_ref_i = scratch_cp->uncached_klass_ref_index_at(scratch_i);

      int new_klass_ref_i = find_or_append_indirect_entry(scratch_cp, klass_ref_i,

                                                          merge_cp_p, merge_cp_length_p, THREAD);

      int name_and_type_ref_i = scratch_cp->uncached_name_and_type_ref_index_at(scratch_i);

      int new_name_and_type_ref_i = find_or_append_indirect_entry(scratch_cp, name_and_type_ref_i,

                                                          merge_cp_p, merge_cp_length_p, THREAD);

      const char *entry_name = NULL;

      switch (scratch_cp->tag_at(scratch_i).value()) {

      case JVM_CONSTANT_Fieldref:

        entry_name = "Fieldref";

        (*merge_cp_p)->field_at_put(*merge_cp_length_p, new_klass_ref_i,

          new_name_and_type_ref_i);

        break;

      case JVM_CONSTANT_InterfaceMethodref:

        entry_name = "IFMethodref";

        (*merge_cp_p)->interface_method_at_put(*merge_cp_length_p,

          new_klass_ref_i, new_name_and_type_ref_i);

        break;

      case JVM_CONSTANT_Methodref:

        entry_name = "Methodref";

        (*merge_cp_p)->method_at_put(*merge_cp_length_p, new_klass_ref_i,

          new_name_and_type_ref_i);

        break;

      default:

        guarantee(false, "bad switch");

        break;

      }

      if (klass_ref_i != new_klass_ref_i) {

        log_trace(redefine, class, constantpool)

          ("%s entry@%d class_index changed: %d to %d", entry_name, *merge_cp_length_p, klass_ref_i, new_klass_ref_i);

      }

      if (name_and_type_ref_i != new_name_and_type_ref_i) {

        log_trace(redefine, class, constantpool)

          ("%s entry@%d name_and_type_index changed: %d to %d",

           entry_name, *merge_cp_length_p, name_and_type_ref_i, new_name_and_type_ref_i);

      }

      if (scratch_i != *merge_cp_length_p) {

        // The new entry in *merge_cp_p is at a different index than

        // the new entry in scratch_cp so we need to map the index values.

        map_index(scratch_cp, scratch_i, *merge_cp_length_p);

      }

      (*merge_cp_length_p)++;

    } break;

    // this is an indirect CP entry so it needs special handling

    case JVM_CONSTANT_MethodType:

    {

      int ref_i = scratch_cp->method_type_index_at(scratch_i);

      int new_ref_i = find_or_append_indirect_entry(scratch_cp, ref_i, merge_cp_p,

                                                    merge_cp_length_p, THREAD);

      if (new_ref_i != ref_i) {

        log_trace(redefine, class, constantpool)

          ("MethodType entry@%d ref_index change: %d to %d", *merge_cp_length_p, ref_i, new_ref_i);

      }

      (*merge_cp_p)->method_type_index_at_put(*merge_cp_length_p, new_ref_i);

      if (scratch_i != *merge_cp_length_p) {

        // The new entry in *merge_cp_p is at a different index than

        // the new entry in scratch_cp so we need to map the index values.

        map_index(scratch_cp, scratch_i, *merge_cp_length_p);

      }

      (*merge_cp_length_p)++;

    } break;

    // this is an indirect CP entry so it needs special handling

    case JVM_CONSTANT_MethodHandle:

    {

      int ref_kind = scratch_cp->method_handle_ref_kind_at(scratch_i);

      int ref_i = scratch_cp->method_handle_index_at(scratch_i);

      int new_ref_i = find_or_append_indirect_entry(scratch_cp, ref_i, merge_cp_p,

                                                    merge_cp_length_p, THREAD);

      if (new_ref_i != ref_i) {