C++ instanceKlassHandle::constants方法代码示例

 FieldStreamBase(instanceKlassHandle klass) {
   _fields = klass->fields();
   _constants = klass->constants();
   _index = 0;
   _limit = klass->java_fields_count();
   init_generic_signature_start_slot();
 }

 // Calls to this constructor must be proceeded by a ResourceMark
 // and a HandleMark
 JvmtiConstantPoolReconstituter(instanceKlassHandle ikh){
   set_error(JVMTI_ERROR_NONE);
   _ikh = ikh;
   _cpool = constantPoolHandle(Thread::current(), ikh->constants());
   _symmap = new SymbolHashMap();
   _classmap = new SymbolHashMap();
   _cpool_size = _cpool->hash_entries_to(_symmap, _classmap);
   if (_cpool_size == 0) {
     set_error(JVMTI_ERROR_OUT_OF_MEMORY);
   } else if (_cpool_size < 0) {
     set_error(JVMTI_ERROR_INTERNAL);
   }
 }

 AllFieldStream(instanceKlassHandle k): FieldStreamBase(k->fields(), k->constants()) {}

 InternalFieldStream(instanceKlassHandle k): FieldStreamBase(k->fields(), k->constants(), k->java_fields_count(), 0) {}

void Rewriter::rewrite(instanceKlassHandle klass, TRAPS) {
  ResourceMark rm(THREAD);
  Rewriter     rw(klass, klass->constants(), klass->methods(), CHECK);
  // (That's all, folks.)
}

jvmtiError VM_RedefineClasses::compare_class_versions(instanceKlassHandle k_h_old, instanceKlassHandle k_h_new) {
  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 (k_h_old->super() != k_h_new->super() && 
      (k_h_old->super() == NULL || k_h_new->super() == NULL ||
       Klass::cast(k_h_old->super())->name() != Klass::cast(k_h_new->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 = k_h_old->local_interfaces();
  objArrayOop k_new_interfaces = k_h_new->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 (k_h_old->is_in_error_state()) {
    // TBD #5057930: special error code is needed in 1.6 
    return JVMTI_ERROR_INVALID_CLASS;
  }

  // Check whether class modifiers are the same.
  jushort old_flags = (jushort) k_h_old->access_flags().get_flags();
  jushort new_flags = (jushort) k_h_new->access_flags().get_flags();
  if (old_flags != new_flags) {
    return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_CLASS_MODIFIERS_CHANGED;
  }

  // Check if the number, names, types and order of fields declared in these classes
  // are the same.
  typeArrayOop k_old_fields = k_h_old->fields();
  typeArrayOop k_new_fields = k_h_new->fields();
  int n_fields = k_old_fields->length();
  if (n_fields != k_new_fields->length()) {
    return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED;
  }

  for (i = 0; i < n_fields; i += instanceKlass::next_offset) {
    // access
    old_flags = k_old_fields->ushort_at(i + instanceKlass::access_flags_offset);
    new_flags = k_new_fields->ushort_at(i + instanceKlass::access_flags_offset);
    if ((old_flags ^ new_flags) & JVM_RECOGNIZED_FIELD_MODIFIERS) {
      return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED;
    }
    // offset
    if (k_old_fields->short_at(i + instanceKlass::low_offset) != 
        k_new_fields->short_at(i + instanceKlass::low_offset) ||
        k_old_fields->short_at(i + instanceKlass::high_offset) != 
        k_new_fields->short_at(i + instanceKlass::high_offset)) {
      return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED;
    }
    // name and signature
    jshort name_index = k_old_fields->short_at(i + instanceKlass::name_index_offset);
    jshort sig_index = k_old_fields->short_at(i +instanceKlass::signature_index_offset);
    symbolOop name_sym1 = k_h_old->constants()->symbol_at(name_index);
    symbolOop sig_sym1 = k_h_old->constants()->symbol_at(sig_index);
    name_index = k_new_fields->short_at(i + instanceKlass::name_index_offset);
    sig_index = k_new_fields->short_at(i + instanceKlass::signature_index_offset);
    symbolOop name_sym2 = k_h_new->constants()->symbol_at(name_index);
    symbolOop sig_sym2 = k_h_new->constants()->symbol_at(sig_index);
    if (name_sym1 != name_sym2 || sig_sym1 != sig_sym2) {
      return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED;
    }
  }

  // Check if the number, names, signatures and order of methods declared in these classes
  // are the same.
  objArrayOop k_methods = k_h_old->methods();
  objArrayOop k_new_methods = k_h_new->methods();
  int n_methods = k_methods->length();
  if (n_methods < k_new_methods->length()) return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_ADDED;
  else if (n_methods > k_new_methods->length()) return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_DELETED;

  for (i = 0; i < n_methods; i++) {
    methodOop k_method = (methodOop) k_methods->obj_at(i);
    methodOop k_new_method = (methodOop) k_new_methods->obj_at(i);
    if (k_method->name() != k_new_method->name()) return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_DELETED;
    if (k_method->signature() != k_new_method->signature()) {
      return JVMTI_ERROR_UNSUPPORTED_REDEFINITION_METHOD_DELETED;
    }
    old_flags = (jushort) k_method->access_flags().get_flags();
    new_flags = (jushort) k_new_method->access_flags().get_flags();
    if (old_flags != new_flags) {
//.........这里部分代码省略.........

// Install the redefinition of a class --
// The original instanceKlass object (k_h) always represents the latest 
// version of the respective class. However, during class redefinition we swap
// or replace much of its content with that of the instanceKlass object created
// from the bytes of the redefine (k_h_new). Specifically, k_h points to the new
// constantpool and methods objects, which we take from k_h_new. k_h_new, in turn,
// assumes the role of the previous class version, with the old constantpool and
// methods (taken from k_h) attached to it. k_h links to k_h_new to create a 
// linked list of class versions. 
void VM_RedefineClasses::redefine_single_class(jclass j_clazz, instanceKlassHandle k_h_new, TRAPS) {

  oop mirror = JNIHandles::resolve_non_null(j_clazz);
  klassOop k_oop = java_lang_Class::as_klassOop(mirror);
  instanceKlassHandle k_h = instanceKlassHandle(THREAD, k_oop);

  // Remove all breakpoints in methods of this class
  JvmtiBreakpoints& jvmti_breakpoints = JvmtiCurrentBreakpoints::get_jvmti_breakpoints();
  jvmti_breakpoints.clearall_in_class_at_safepoint(k_oop); 

  // Deoptimize all compiled code that depends on this class
  NOT_CORE(Universe::flush_evol_dependents_on(k_h));

  _old_methods = k_h->methods();
  _new_methods = k_h_new->methods();
  _evolving_koop = k_oop;
  _old_constants = k_h->constants();

  // flush the cached jmethodID fields for _old_methods
  flush_method_jmethod_id_cache();

  // Patch the indexes into the constantpool from the array of fields of the evolving
  // class. This is required, because the layout of the new constantpool can be different,
  // so old indexes corresponding to field names and signatures can become invalid.
  patch_indexes_for_fields(k_h, k_h_new);

  // Make new constantpool object (and methodOops via it) point to the original class object
  k_h_new->constants()->set_pool_holder(k_h());

  // Replace methods and constantpool
  k_h->set_methods(_new_methods);
  k_h_new->set_methods(_old_methods);     // To prevent potential GCing of the old methods, 
                                          // and to be able to undo operation easily.

  constantPoolOop old_constants = k_h->constants();
  k_h->set_constants(k_h_new->constants());
  k_h_new->set_constants(old_constants);  // See the previous comment.

  check_methods_and_mark_as_old();
  transfer_old_native_function_registrations();

  // Replace inner_classes
  typeArrayOop old_inner_classes = k_h->inner_classes();
  k_h->set_inner_classes(k_h_new->inner_classes());
  k_h_new->set_inner_classes(old_inner_classes);

  // Initialize the vtable and interface table after
  // methods have been rewritten
  { ResourceMark rm(THREAD);
  k_h->vtable()->initialize_vtable(THREAD); // No exception can happen here
  k_h->itable()->initialize_itable();
  }

  // Copy the "source file name" attribute from new class version
  k_h->set_source_file_name(k_h_new->source_file_name());

  // Copy the "source debug extension" attribute from new class version
  k_h->set_source_debug_extension(k_h_new->source_debug_extension());

  // Use of javac -g could be different in the old and the new
  if (k_h_new->access_flags().has_localvariable_table() !=
      k_h->access_flags().has_localvariable_table()) {

    AccessFlags flags = k_h->access_flags();
    if (k_h_new->access_flags().has_localvariable_table()) {
      flags.set_has_localvariable_table();
    } else {
      flags.clear_has_localvariable_table();
    }
    k_h->set_access_flags(flags);
  }

  // Replace class annotation fields values
  typeArrayOop old_class_annotations = k_h->class_annotations();
  k_h->set_class_annotations(k_h_new->class_annotations());
  k_h_new->set_class_annotations(old_class_annotations);

  // Replace fields annotation fields values
  objArrayOop old_fields_annotations = k_h->fields_annotations();
  k_h->set_fields_annotations(k_h_new->fields_annotations());
  k_h_new->set_fields_annotations(old_fields_annotations);

  // Replace methods annotation fields values
  objArrayOop old_methods_annotations = k_h->methods_annotations();
  k_h->set_methods_annotations(k_h_new->methods_annotations());
  k_h_new->set_methods_annotations(old_methods_annotations);

  // Replace methods parameter annotation fields values
  objArrayOop old_methods_parameter_annotations = k_h->methods_parameter_annotations();
  k_h->set_methods_parameter_annotations(k_h_new->methods_parameter_annotations());
  k_h_new->set_methods_parameter_annotations(old_methods_parameter_annotations);
//.........这里部分代码省略.........

  jvmdiError compare_class_versions(instanceKlassHandle k_h_old, instanceKlassHandle k_h_new) {
    int i;

    // Check whether essential class modifiers are the same. The rest can probably differ, e.g.
    // why not allow substitute class to be synthetic, if it satisfies other conditions.
    AccessFlags old_flags = k_h_old->access_flags();
    AccessFlags new_flags = k_h_new->access_flags();
    if (old_flags.is_public() != new_flags.is_public() ||
	old_flags.is_final() != new_flags.is_final() ||
	old_flags.is_interface() != new_flags.is_interface() ||
	old_flags.is_abstract() != new_flags.is_abstract()) {
      return JVMDI_ERROR_CLASS_MODIFIERS_CHANGE_NOT_IMPLEMENTED;
    }

    // Check superclasses, or rather their names, since superclasses themselves can be
    // requested to replace
    if (Klass::cast(k_h_old->super())->name() != Klass::cast(k_h_new->super())->name()) {
      return JVMDI_ERROR_HIERARCHY_CHANGE_NOT_IMPLEMENTED;
    }

    // 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 = k_h_old->local_interfaces();
    objArrayOop k_new_interfaces = k_h_new->local_interfaces();
    int n_intfs = k_interfaces->length();
    if (n_intfs != k_new_interfaces->length()) {
      return JVMDI_ERROR_HIERARCHY_CHANGE_NOT_IMPLEMENTED;
    }
    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 JVMDI_ERROR_HIERARCHY_CHANGE_NOT_IMPLEMENTED;
      }
    }

    // Check if the number, names, types and order of fields declared in these classes
    // are the same.
    typeArrayOop k_old_fields = k_h_old->fields();
    typeArrayOop k_new_fields = k_h_new->fields();
    int n_fields = k_old_fields->length();
    if (n_fields != k_new_fields->length()) {
      return JVMDI_ERROR_SCHEMA_CHANGE_NOT_IMPLEMENTED;
    }

    for (i = 0; i < n_fields; i += instanceKlass::next_offset) {
      // access
      if (k_old_fields->ushort_at(i + instanceKlass::access_flags_offset) !=
        k_new_fields->ushort_at(i + instanceKlass::access_flags_offset)) {
        return JVMDI_ERROR_SCHEMA_CHANGE_NOT_IMPLEMENTED;
      }
      // offset
      if (k_old_fields->short_at(i + instanceKlass::low_offset) != 
	  k_new_fields->short_at(i + instanceKlass::low_offset) ||
	  k_old_fields->short_at(i + instanceKlass::high_offset) != 
	  k_new_fields->short_at(i + instanceKlass::high_offset)) {
        return JVMDI_ERROR_SCHEMA_CHANGE_NOT_IMPLEMENTED;
      }
      // name and signature
      jshort name_index = k_old_fields->short_at(i + instanceKlass::name_index_offset);
      jshort sig_index = k_old_fields->short_at(i +instanceKlass::signature_index_offset);
      symbolOop name_sym1 = k_h_old->constants()->symbol_at(name_index);
      symbolOop sig_sym1 = k_h_old->constants()->symbol_at(sig_index);
      name_index = k_new_fields->short_at(i + instanceKlass::name_index_offset);
      sig_index = k_new_fields->short_at(i + instanceKlass::signature_index_offset);
      symbolOop name_sym2 = k_h_new->constants()->symbol_at(name_index);
      symbolOop sig_sym2 = k_h_new->constants()->symbol_at(sig_index);
      if (name_sym1 != name_sym2 || sig_sym1 != sig_sym2) {
        return JVMDI_ERROR_SCHEMA_CHANGE_NOT_IMPLEMENTED;
      }
    }

    // Check if the number, names, signatures and order of methods declared in these classes
    // are the same.
    objArrayOop k_methods = k_h_old->methods();
    objArrayOop k_new_methods = k_h_new->methods();
    int n_methods = k_methods->length();
    if (n_methods < k_new_methods->length()) return JVMDI_ERROR_ADD_METHOD_NOT_IMPLEMENTED;
    else if (n_methods > k_new_methods->length()) return JVMDI_ERROR_DELETE_METHOD_NOT_IMPLEMENTED;

    for (i = 0; i < n_methods; i++) {
      methodOop k_method = (methodOop) k_methods->obj_at(i);
      methodOop k_new_method = (methodOop) k_new_methods->obj_at(i);
      if (k_method->name() != k_new_method->name()) return JVMDI_ERROR_DELETE_METHOD_NOT_IMPLEMENTED;
      if (k_method->signature() != k_new_method->signature()) {
        return JVMDI_ERROR_DELETE_METHOD_NOT_IMPLEMENTED;
      }
      old_flags = k_method->access_flags();
      new_flags = k_new_method->access_flags();
      // It's probably safer to not compare the values of access_flags directly, since
      // some bits in them encode some implementation-specific information, e.g.
      // something about inlined tables. This may be different in the new version,
      // but should not affect method changeability.
      if (old_flags.is_public() != new_flags.is_public() ||
	  old_flags.is_protected() != new_flags.is_protected() ||
	  old_flags.is_private() != new_flags.is_private() ||
//.........这里部分代码省略.........