/*

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

 *

 *

 */

# include "incls/_precompiled.incl"

# include "incls/_jvmtiRedefineClasses.cpp.incl"

objArrayOop VM_RedefineClasses::_old_methods = NULL;

objArrayOop VM_RedefineClasses::_new_methods = NULL;

methodOop*  VM_RedefineClasses::_matching_old_methods = NULL;

methodOop*  VM_RedefineClasses::_matching_new_methods = NULL;

methodOop*  VM_RedefineClasses::_deleted_methods      = NULL;

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

klassOop    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 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 (!CompactingPermGenGen::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;

    }

  }

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

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

  }

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

#ifdef ASSERT

  SystemDictionary::classes_do(check_class, thread);

#endif

}

void VM_RedefineClasses::doit_epilogue() {

  // Free os::malloc allocated memory.

  // The memory allocated in redefine will be free'ed in next VM operation.

  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;

  }

  klassOop the_class_oop = java_lang_Class::as_klassOop(klass_mirror);

  // classes for arrays cannot be redefined

  if (the_class_oop == NULL || !Klass::cast(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:

    {

      scratch_cp->copy_entry_to(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

    // an interned string so this entry can be directly appended.

    case JVM_CONSTANT_String:      // fall through

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

    // symbolOops so these entries can be directly appended.

    case JVM_CONSTANT_UnresolvedClass:  // fall through

    case JVM_CONSTANT_UnresolvedString:

    {

      scratch_cp->copy_entry_to(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 = 0;

      bool match = (name_ref_i < *merge_cp_length_p) &&

        scratch_cp->compare_entry_to(name_ref_i, *merge_cp_p, name_ref_i,

          THREAD);

      if (!match) {

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

        int found_i = scratch_cp->find_matching_entry(name_ref_i, *merge_cp_p,

          THREAD);

        if (found_i != 0) {

          guarantee(found_i != name_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_name_ref_i = found_i;

          map_index(scratch_cp, name_ref_i, found_i);

        } else {

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

          append_entry(scratch_cp, name_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_name_ref_i = *merge_cp_length_p - 1;

        }

      }

      int signature_ref_i = scratch_cp->signature_ref_index_at(scratch_i);

      int new_signature_ref_i = 0;

      match = (signature_ref_i < *merge_cp_length_p) &&

        scratch_cp->compare_entry_to(signature_ref_i, *merge_cp_p,

          signature_ref_i, THREAD);

      if (!match) {

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

        int found_i = scratch_cp->find_matching_entry(signature_ref_i,

          *merge_cp_p, THREAD);

        if (found_i != 0) {

          guarantee(found_i != signature_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_signature_ref_i = found_i;

          map_index(scratch_cp, signature_ref_i, found_i);

        } else {

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

          append_entry(scratch_cp, signature_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_signature_ref_i = *merge_cp_length_p - 1;

        }

      }

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

        new_name_ref_i = name_ref_i;

      } else {

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

        new_signature_ref_i = signature_ref_i;

      } else {

        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 = 0;

      bool match = (klass_ref_i < *merge_cp_length_p) &&

        scratch_cp->compare_entry_to(klass_ref_i, *merge_cp_p, klass_ref_i,

          THREAD);

      if (!match) {

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

        int found_i = scratch_cp->find_matching_entry(klass_ref_i, *merge_cp_p,

          THREAD);

        if (found_i != 0) {

          guarantee(found_i != klass_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_klass_ref_i = found_i;

          map_index(scratch_cp, klass_ref_i, found_i);

        } else {

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

          append_entry(scratch_cp, klass_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. Without the optimization where we

          // use JVM_CONSTANT_UnresolvedClass, then up to two entries

          // could be appended.

          new_klass_ref_i = *merge_cp_length_p - 1;

        }

      }

      int name_and_type_ref_i =

        scratch_cp->uncached_name_and_type_ref_index_at(scratch_i);

      int new_name_and_type_ref_i = 0;

      match = (name_and_type_ref_i < *merge_cp_length_p) &&

        scratch_cp->compare_entry_to(name_and_type_ref_i, *merge_cp_p,

          name_and_type_ref_i, THREAD);

      if (!match) {

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

        int found_i = scratch_cp->find_matching_entry(name_and_type_ref_i,

          *merge_cp_p, THREAD);

        if (found_i != 0) {

          guarantee(found_i != name_and_type_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_name_and_type_ref_i = found_i;

          map_index(scratch_cp, name_and_type_ref_i, found_i);

        } else {

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

          append_entry(scratch_cp, name_and_type_ref_i, merge_cp_p,

            merge_cp_length_p, THREAD);

          // The above call to append_entry() can append more than

          // one entry so the post call query of *merge_cp_length_p

          // is required in order to get the right index for the

          // JVM_CONSTANT_NameAndType entry.

          new_name_and_type_ref_i = *merge_cp_length_p - 1;

        }

      }

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

      // both new_klass_ref_i and new_name_and_type_ref_i will both be

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

      if (new_klass_ref_i == 0) {

        new_klass_ref_i = klass_ref_i;

      }

      if (new_name_and_type_ref_i == 0) {

        new_name_and_type_ref_i = name_and_type_ref_i;

      }

      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;

    // 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 or UnresolvedString 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()

void VM_RedefineClasses::swap_all_method_annotations(int i, int j, instanceKlassHandle scratch_class) {

  typeArrayOop save;

  save = scratch_class->get_method_annotations_of(i);

  scratch_class->set_method_annotations_of(i, scratch_class->get_method_annotations_of(j));

  scratch_class->set_method_annotations_of(j, save);

  save = scratch_class->get_method_parameter_annotations_of(i);

  scratch_class->set_method_parameter_annotations_of(i, scratch_class->get_method_parameter_annotations_of(j));

  scratch_class->set_method_parameter_annotations_of(j, save);

  save = scratch_class->get_method_default_annotations_of(i);

  scratch_class->set_method_default_annotations_of(i, scratch_class->get_method_default_annotations_of(j));

  scratch_class->set_method_default_annotations_of(j, save);

}

jvmtiError VM_RedefineClasses::compare_and_normalize_class_versions(

             instanceKlassHandle the_class,

             instanceKlassHandle scratch_class) {

  int i;

  // Check superclasses, or rather their names, since superclasses themselves can be

  // requested to replace.

  // Check for NULL superclass first since this might be java.lang.Object

  if (the_class->super() != scratch_class->super() &&

      (the_class->super() == NULL || scratch_class->super() == NULL ||

       Klass::cast(the_class->super())->name() !=

       Klass::cast(scratch_class->super())->name())) {

    return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED;

  }

  // Check if the number, names and order of directly implemented interfaces are the same.

  // I think in principle we should just check if the sets of names of directly implemented

  // interfaces are the same, i.e. the order of declaration (which, however, if changed in the

  // .java file, also changes in .class file) should not matter. However, comparing sets is

  // technically a bit more difficult, and, more importantly, I am not sure at present that the

  // order of interfaces does not matter on the implementation level, i.e. that the VM does not

  // rely on it somewhere.

  objArrayOop k_interfaces = the_class->local_interfaces();

  objArrayOop k_new_interfaces = scratch_class->local_interfaces();

  int n_intfs = k_interfaces->length();

  if (n_intfs != k_new_interfaces->length()) {

    return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED;

  }

  for (i = 0; i < n_intfs; i++) {

    if (Klass::cast((klassOop) k_interfaces->obj_at(i))->name() !=

        Klass::cast((klassOop) k_new_interfaces->obj_at(i))->name()) {

      return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED;

    }

  }

  // Check whether class is in the error init state.

  if (the_class->is_in_error_state()) {

    // TBD #5057930: special error code is needed in 1.6