/*

 * Copyright (c) 2003, 2012, 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/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 "prims/jvmtiImpl.hpp"

#include "prims/jvmtiRedefineClasses.hpp"

#include "prims/methodComparator.hpp"

#include "runtime/deoptimization.hpp"

#include "runtime/relocator.hpp"

#include "utilities/bitMap.inline.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;

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;

}

// Keep track of marked on-stack metadata so it can be cleared.

GrowableArray<Metadata*>* _marked_objects = NULL;

NOT_PRODUCT(bool MetadataOnStackMark::_is_active = false;)

// Walk metadata on the stack and mark it so that redefinition doesn't delete

// it.  Class unloading also walks the previous versions and might try to

// delete it, so this class is used by class unloading also.

MetadataOnStackMark::MetadataOnStackMark() {

  assert(SafepointSynchronize::is_at_safepoint(), "sanity check");

  NOT_PRODUCT(_is_active = true;)

  if (_marked_objects == NULL) {

    _marked_objects = new (ResourceObj::C_HEAP, mtClass) GrowableArray<Metadata*>(1000, true);

  }

  Threads::metadata_do(Metadata::mark_on_stack);

  CodeCache::alive_nmethods_do(nmethod::mark_on_stack);

  CompileBroker::mark_on_stack();

}

MetadataOnStackMark::~MetadataOnStackMark() {

  assert(SafepointSynchronize::is_at_safepoint(), "sanity check");

  // Unmark everything that was marked.   Can't do the same walk because

  // redefine classes messes up the code cache so the set of methods

  // might not be the same.

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

    _marked_objects->at(i)->set_on_stack(false);

  }

  _marked_objects->clear();   // reuse growable array for next time.

  NOT_PRODUCT(_is_active = false;)

}

// Record which objects are marked so we can unmark the same objects.

void MetadataOnStackMark::record(Metadata* m) {

  assert(_is_active, "metadata on stack marking is active");

  _marked_objects->push(m);

}

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;

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

    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]);

    _scratch_classes[i] = NULL;

  }

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

  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 || !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:

    {

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