/*

 * Copyright (c) 2003, 2015, 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/metadataOnStackMark.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 "memory/gcLocker.hpp"

#include "memory/metadataFactory.hpp"

#include "memory/metaspaceShared.hpp"

#include "memory/universe.inline.hpp"

#include "oops/fieldStreams.hpp"

#include "oops/klassVtable.hpp"

#include "oops/oop.inline.hpp"

#include "prims/jvmtiImpl.hpp"

#include "prims/jvmtiRedefineClasses.hpp"

#include "prims/methodComparator.hpp"

#include "runtime/deoptimization.hpp"

#include "runtime/relocator.hpp"

#include "utilities/bitMap.inline.hpp"

PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC

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;

Klass*      VM_RedefineClasses::_the_class_oop = NULL;

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;

  _res = JVMTI_ERROR_NONE;

}

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;

    }

  }

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

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

  RC_TIMER_START(_timer_vm_op_prologue);

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

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

      }

    }

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

    os::free(_scratch_classes);

    RC_TIMER_STOP(_timer_vm_op_prologue);

    return false;

  }

  RC_TIMER_STOP(_timer_vm_op_prologue);

  return true;

}

void VM_RedefineClasses::doit() {

  Thread *thread = Thread::current();

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

      RC_TRACE_WITH_THREAD(0x00000001, thread,

        ("failed to remap shared readonly space to readwrite, private"));

      _res = JVMTI_ERROR_INTERNAL;

      return;

    }

  }

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

  }

  // Clean out MethodData pointing to old Method*

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

  // are redefined are marked as old.

  MethodDataCleaner clean_weak_method_links;

  ClassLoaderDataGraph::classes_do(&clean_weak_method_links);

  // Disable any dependent concurrent compilations

  SystemDictionary::notice_modification();

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

  // See jvmtiExport.hpp for detailed explanation.

  JvmtiExport::set_has_redefined_a_class();

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

  // always called for non-product bits.

#ifdef PRODUCT

  if (RC_TRACE_ENABLED(0x00004000)) {

#endif

    RC_TRACE_WITH_THREAD(0x00004000, thread, ("calling check_class"));

    CheckClass check_class(thread);

    ClassLoaderDataGraph::classes_do(&check_class);

#ifdef PRODUCT

  }

#endif

}

void VM_RedefineClasses::doit_epilogue() {

  // Free os::malloc allocated memory.

  os::free(_scratch_classes);

  if (RC_TRACE_ENABLED(0x00000004)) {

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

    // overhead skewed the measurements.

    jlong doit_time = _timer_rsc_phase1.milliseconds() +

                      _timer_rsc_phase2.milliseconds();

    jlong all_time = _timer_vm_op_prologue.milliseconds() + doit_time;

    RC_TRACE(0x00000004, ("vm_op: all=" UINT64_FORMAT

      "  prologue=" UINT64_FORMAT "  doit=" UINT64_FORMAT, all_time,

      _timer_vm_op_prologue.milliseconds(), doit_time));

    RC_TRACE(0x00000004,

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

       _timer_rsc_phase1.milliseconds(), _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* the_class_oop = java_lang_Class::as_Klass(klass_mirror);

  // classes for arrays cannot be redefined

  if (the_class_oop == NULL || !the_class_oop->oop_is_instance()) {

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

    case JVM_CONSTANT_Class:

    {

      // revert the copy to JVM_CONSTANT_UnresolvedClass

      (*merge_cp_p)->unresolved_klass_at_put(*merge_cp_length_p,

        scratch_cp->klass_name_at(scratch_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

    // These were indirect CP entries, but they have been changed into

    // Symbol*s so these entries can be directly appended.

    case JVM_CONSTANT_UnresolvedClass:  // 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) {

        RC_TRACE(0x00080000,

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

        RC_TRACE(0x00080000,

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

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

        RC_TRACE(0x00080000, ("%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) {

        RC_TRACE(0x00080000,

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

        RC_TRACE(0x00080000,

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

        RC_TRACE(0x00080000,

                 ("MethodHandle entry@%d ref_index change: %d to %d",

                  *merge_cp_length_p, ref_i, new_ref_i));

      }

      (*merge_cp_p)->method_handle_index_at_put(*merge_cp_length_p, ref_kind, 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_InvokeDynamic:

    {

      // Index of the bootstrap specifier in the operands array

      int old_bs_i = scratch_cp->invoke_dynamic_bootstrap_specifier_index(scratch_i);

      int new_bs_i = find_or_append_operand(scratch_cp, old_bs_i, merge_cp_p,

                                            merge_cp_length_p, THREAD);

      // The bootstrap method NameAndType_info index

      int old_ref_i = scratch_cp->invoke_dynamic_name_and_type_ref_index_at(scratch_i);

      int new_ref_i = find_or_append_indirect_entry(scratch_cp, old_ref_i, merge_cp_p,

                                                    merge_cp_length_p, THREAD);

      if (new_bs_i != old_bs_i) {

        RC_TRACE(0x00080000,

                 ("InvokeDynamic entry@%d bootstrap_method_attr_index change: %d to %d",

                  *merge_cp_length_p, old_bs_i, new_bs_i));

      }

      if (new_ref_i != old_ref_i) {

        RC_TRACE(0x00080000,

                 ("InvokeDynamic entry@%d name_and_type_index change: %d to %d",

                  *merge_cp_length_p, old_ref_i, new_ref_i));

      }

      (*merge_cp_p)->invoke_dynamic_at_put(*merge_cp_length_p, new_bs_i, 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;

    // At this stage, Class or UnresolvedClass could be here, but not

    // ClassIndex

    case JVM_CONSTANT_ClassIndex: // fall through

    // Invalid is used as the tag for the second constant pool entry

    // occupied by JVM_CONSTANT_Double or JVM_CONSTANT_Long. It should

    // not be seen by itself.

    case JVM_CONSTANT_Invalid: // fall through

    // At this stage, String could be here, but not StringIndex

    case JVM_CONSTANT_StringIndex: // fall through

    // At this stage JVM_CONSTANT_UnresolvedClassInError should not be

    // here

    case JVM_CONSTANT_UnresolvedClassInError: // fall through

    default:

    {

      // leave a breadcrumb

      jbyte bad_value = scratch_cp->tag_at(scratch_i).value();

      ShouldNotReachHere();

    } break;

  } // end switch tag value

} // end append_entry()

int VM_RedefineClasses::find_or_append_indirect_entry(constantPoolHandle scratch_cp,

      int ref_i, constantPoolHandle *merge_cp_p, int *merge_cp_length_p, TRAPS) {

  int new_ref_i = ref_i;

  bool match = (ref_i < *merge_cp_length_p) &&

               scratch_cp->compare_entry_to(ref_i, *merge_cp_p, ref_i, THREAD);

  if (!match) {

    // forward reference in *merge_cp_p or not a direct match

    int found_i = scratch_cp->find_matching_entry(ref_i, *merge_cp_p, THREAD);

    if (found_i != 0) {

      guarantee(found_i != ref_i, "compare_entry_to() and find_matching_entry() do not agree");

      // Found a matching entry somewhere else in *merge_cp_p so just need a mapping entry.

      new_ref_i = found_i;

      map_index(scratch_cp, ref_i, found_i);

    } else {

      // no match found so we have to append this entry to *merge_cp_p

      append_entry(scratch_cp, ref_i, merge_cp_p, merge_cp_length_p, THREAD);

      // The above call to append_entry() can only append one entry

      // so the post call query of *merge_cp_length_p is only for

      // the sake of consistency.

      new_ref_i = *merge_cp_length_p - 1;

    }

  }

  return new_ref_i;

} // end find_or_append_indirect_entry()

// Append a bootstrap specifier into the merge_cp operands that is semantically equal

// to the scratch_cp operands bootstrap specifier passed by the old_bs_i index.

// Recursively append new merge_cp entries referenced by the new bootstrap specifier.

void VM_RedefineClasses::append_operand(constantPoolHandle scratch_cp, int old_bs_i,

       constantPoolHandle *merge_cp_p, int *merge_cp_length_p, TRAPS) {