jdk8-mips64-public/hotspot: comparison src/share/vm/oops/cpCache.cpp

-:2667e5c45e24
+:f8a45a60bc6b
 /*
-* Copyright (c) 1998, 2016, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1998, 2017, 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.
 assert(method->method_holder()->is_interface() || method->method_holder()->verify_vtable_index(index), "");
 // index >= 0; FIXME: inline and customize set_direct_or_vtable_call
 set_direct_or_vtable_call(invoke_code, method, index, false);
 }
-void ConstantPoolCacheEntry::set_itable_call(Bytecodes::Code invoke_code, methodHandle method, int index) {
+void ConstantPoolCacheEntry::set_itable_call(Bytecodes::Code invoke_code,
+KlassHandle referenced_klass,
+methodHandle method, int index) {
 assert(method->method_holder()->verify_itable_index(index), "");
 assert(invoke_code == Bytecodes::_invokeinterface, "");
 InstanceKlass* interf = method->method_holder();
 assert(interf->is_interface(), "must be an interface");
 assert(!method->is_final_method(), "interfaces do not have final methods; cannot link to one here");
-set_f1(interf);
+set_f1(referenced_klass());
-set_f2(index);
+set_f2((intx)method());
 set_method_flags(as_TosState(method->result_type()),
 0,  // no option bits
 method()->size_of_parameters());
 set_bytecode_1(Bytecodes::_invokeinterface);
 }
 return resolved_references->obj_at(ref_index);
 }
 #if INCLUDE_JVMTI
+void log_adjust(const char* entry_type, Method* old_method, Method* new_method, bool* trace_name_printed) {
+if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) {
+if (!(*trace_name_printed)) {
+// RC_TRACE_MESG macro has an embedded ResourceMark
+RC_TRACE_MESG(("adjust: name=%s",
+old_method->method_holder()->external_name()));
+*trace_name_printed = true;
+}
+// RC_TRACE macro has an embedded ResourceMark
+RC_TRACE(0x00400000, ("cpc %s entry update: %s(%s)",
+entry_type,
+new_method->name()->as_C_string(),
+new_method->signature()->as_C_string()));
+}
+}
 // RedefineClasses() API support:
 // If this ConstantPoolCacheEntry refers to old_method then update it
 // to refer to new_method.
-bool ConstantPoolCacheEntry::adjust_method_entry(Method* old_method,
+void ConstantPoolCacheEntry::adjust_method_entry(Method* old_method,
 Method* new_method, bool * trace_name_printed) {
 if (is_vfinal()) {
 // virtual and final so _f2 contains method ptr instead of vtable index
 if (f2_as_vfinal_method() == old_method) {
 // match old_method so need an update
 // NOTE: can't use set_f2_as_vfinal_method as it asserts on different values
 _f2 = (intptr_t)new_method;
-if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) {
+}
-if (!(*trace_name_printed)) {
+return;
-// RC_TRACE_MESG macro has an embedded ResourceMark
+}
-RC_TRACE_MESG(("adjust: name=%s",
-old_method->method_holder()->external_name()));
+assert (_f1 != NULL, "should not call with uninteresting entry");
-*trace_name_printed = true;
-}
+if (!(_f1->is_method())) {
-// RC_TRACE macro has an embedded ResourceMark
+// _f1 is a Klass* for an interface, _f2 is the method
-RC_TRACE(0x00400000, ("cpc vf-entry update: %s(%s)",
+if (f2_as_interface_method() == old_method) {
-new_method->name()->as_C_string(),
+_f2 = (intptr_t)new_method;
-new_method->signature()->as_C_string()));
+log_adjust("interface", old_method, new_method, trace_name_printed);
 }
-return true;
+} else if (_f1 == old_method) {
-}
-// f1() is not used with virtual entries so bail out
-return false;
-}
-if (_f1 == NULL) {
-// NULL f1() means this is a virtual entry so bail out
-// We are assuming that the vtable index does not need change.
-return false;
-}
-if (_f1 == old_method) {
 _f1 = new_method;
-if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) {
+log_adjust("special, static or dynamic", old_method, new_method, trace_name_printed);
-if (!(*trace_name_printed)) {
+}
-// RC_TRACE_MESG macro has an embedded ResourceMark
-RC_TRACE_MESG(("adjust: name=%s",
-old_method->method_holder()->external_name()));
-*trace_name_printed = true;
-}
-// RC_TRACE macro has an embedded ResourceMark
-RC_TRACE(0x00400000, ("cpc entry update: %s(%s)",
-new_method->name()->as_C_string(),
-new_method->signature()->as_C_string()));
-}
-return true;
-}
-return false;
 }
 // a constant pool cache entry should never contain old or obsolete methods
 bool ConstantPoolCacheEntry::check_no_old_or_obsolete_entries() {
-if (is_vfinal()) {
+Method* m = get_interesting_method_entry(NULL);
-// virtual and final so _f2 contains method ptr instead of vtable index
+// return false if m refers to a non-deleted old or obsolete method
-Metadata* f2 = (Metadata*)_f2;
+if (m != NULL) {
-// Return false if _f2 refers to an old or an obsolete method.
+assert(m->is_valid() && m->is_method(), "m is a valid method");
-// _f2 == NULL || !_f2->is_method() are just as unexpected here.
+return !m->is_old() && !m->is_obsolete(); // old is always set for old and obsolete
-return (f2 != NULL NOT_PRODUCT(&& f2->is_valid()) && f2->is_method() &&
+} else {
-!((Method*)f2)->is_old() && !((Method*)f2)->is_obsolete());
-} else if (_f1 == NULL ||
-(NOT_PRODUCT(_f1->is_valid() &&) !_f1->is_method())) {
-// _f1 == NULL || !_f1->is_method() are OK here
 return true;
 }
-// return false if _f1 refers to a non-deleted old or obsolete method
-return (NOT_PRODUCT(_f1->is_valid() &&) _f1->is_method() &&
-(f1_as_method()->is_deleted() ||
-(!f1_as_method()->is_old() && !f1_as_method()->is_obsolete())));
 }
 Method* ConstantPoolCacheEntry::get_interesting_method_entry(Klass* k) {
 if (!is_method_entry()) {
 // not a method entry so not interesting by default
 } else if (is_f1_null()) {
 // NULL _f1 means this is a virtual entry so also not interesting
 return NULL;
 } else {
 if (!(_f1->is_method())) {
-// _f1 can also contain a Klass* for an interface
+// _f1 is a Klass* for an interface
-return NULL;
+m = f2_as_interface_method();
-}
+} else {
 m = f1_as_method();
+}
 }
 assert(m != NULL && m->is_method(), "sanity check");
 if (m == NULL || !m->is_method() || (k != NULL && m->method_holder() != k)) {
 // robustness for above sanity checks or method is not in
 // the interesting class

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/oops/cpCache.cpp

src/share/vm/oops/cpCache.cpp