jdk-sandbox: comparison hotspot/src/share/vm/code/dependencies.cpp

equal deleted inserted replaced

-:9464a1b5c184
+:da53c1ffc837
 /*
-* Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2005, 2014, 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(arg.is_metadata(), "must be");
 what = "context";
 put_star = !Dependencies::is_concrete_klass((Klass*)arg.metadata_value());
 } else if (arg.is_method()) {
 what = "method ";
-put_star = !Dependencies::is_concrete_method((Method*)arg.metadata_value());
+put_star = !Dependencies::is_concrete_method((Method*)arg.metadata_value(), NULL);
 } else if (arg.is_klass()) {
 what = "class  ";
 } else {
 what = "object ";
 }
 }
 if (lm->is_static()) {
 // Static methods don't override non-static so punt
 return true;
 }
-if (   !Dependencies::is_concrete_method(lm)
+if (   !Dependencies::is_concrete_method(lm, k)
-&& !Dependencies::is_concrete_method(m)
+&& !Dependencies::is_concrete_method(m, ctxk)
 && lm->method_holder()->is_subtype_of(m->method_holder()))
 // Method m is overridden by lm, but both are non-concrete.
 return true;
 }
 ResourceMark rm;
 if (doing_subtype_search()) {
 return Dependencies::is_concrete_klass(k);
 } else if (!k->oop_is_instance()) {
 return false; // no methods to find in an array type
 } else {
-Method* m = InstanceKlass::cast(k)->find_method(_name, _signature);
+// Search class hierarchy first.
-if (m == NULL || !Dependencies::is_concrete_method(m))  return false;
+Method* m = InstanceKlass::cast(k)->find_instance_method(_name, _signature);
+if (!Dependencies::is_concrete_method(m, k)) {
+// Check interface defaults also, if any exist.
+Array<Method*>* default_methods = InstanceKlass::cast(k)->default_methods();
+if (default_methods == NULL)
+return false;
+m = InstanceKlass::cast(k)->find_method(default_methods, _name, _signature);
+if (!Dependencies::is_concrete_method(m, NULL))
+return false;
+}
 _found_methods[_num_participants] = m;
 // Note:  If add_participant(k) is called,
 // the method m will already be memoized for it.
 return true;
 }
 // This would require a deoptimization barrier on first instantiation.
 //if (k->is_not_instantiated())  return false;
 return true;
 }
-bool Dependencies::is_concrete_method(Method* m) {
+bool Dependencies::is_concrete_method(Method* m, Klass * k) {
-// Statics are irrelevant to virtual call sites.
+// NULL is not a concrete method,
-if (m->is_static())  return false;
+// statics are irrelevant to virtual call sites,
+// abstract methods are not concrete,
-// We could also return false if m does not yet appear to be
+// overpass (error) methods are not concrete if k is abstract
-// executed, if the VM version supports this distinction also.
+//
-// Default methods are considered "concrete" as well.
+// note "true" is conservative answer --
-return !m->is_abstract() &&
+//     overpass clause is false if k == NULL, implies return true if
-!m->is_overpass(); // error functions aren't concrete
+//     answer depends on overpass clause.
+return ! ( m == NULL || m -> is_static() || m -> is_abstract() ||
+m->is_overpass() && k != NULL && k -> is_abstract() );
 }
 Klass* Dependencies::find_finalizable_subclass(Klass* k) {
 if (k->is_interface())  return NULL;
 // We could also return false if k does not yet appear to be
 // instantiated, if the VM version supports this distinction also.
 //if (k->is_not_instantiated())  return false;
 return true;
 }
-bool Dependencies::is_concrete_method(ciMethod* m) {
-// Statics are irrelevant to virtual call sites.
-if (m->is_static())  return false;
-// We could also return false if m does not yet appear to be
-// executed, if the VM version supports this distinction also.
-return !m->is_abstract();
-}
 bool Dependencies::has_finalizable_subclass(ciInstanceKlass* k) {
 return k->has_finalizable_subclass();
 }
 assert(wf.check_method_context(ctxk, m), "proper context");
 wf.record_witnesses(1);
 Klass* wit = wf.find_witness_definer(ctxk);
 if (wit != NULL)  return NULL;  // Too many witnesses.
 Method* fm = wf.found_method(0);  // Will be NULL if num_parts == 0.
-if (Dependencies::is_concrete_method(m)) {
+if (Dependencies::is_concrete_method(m, ctxk)) {
 if (fm == NULL) {
 // It turns out that m was always the only implementation.
 fm = m;
 } else if (fm != m) {
 // Two conflicting implementations after all.
 wf.add_participant(m1->method_holder());
 wf.add_participant(m2->method_holder());
 return wf.find_witness_definer(ctxk, changes);
 }
-// Find the set of all non-abstract methods under ctxk that match m[0].
-// (The method m[0] must be defined or inherited in ctxk.)
-// Include m itself in the set, unless it is abstract.
-// Fill the given array m[0..(mlen-1)] with this set, and return the length.
-// (The length may be zero if no concrete methods are found anywhere.)
-// If there are too many concrete methods to fit in marray, return -1.
-int Dependencies::find_exclusive_concrete_methods(Klass* ctxk,
-int mlen,
-Method* marray[]) {
-Method* m0 = marray[0];
-ClassHierarchyWalker wf(m0);
-assert(wf.check_method_context(ctxk, m0), "proper context");
-wf.record_witnesses(mlen);
-bool participants_hide_witnesses = true;
-Klass* wit = wf.find_witness_definer(ctxk);
-if (wit != NULL)  return -1;  // Too many witnesses.
-int num = wf.num_participants();
-assert(num <= mlen, "oob");
-// Keep track of whether m is also part of the result set.
-int mfill = 0;
-assert(marray[mfill] == m0, "sanity");
-if (Dependencies::is_concrete_method(m0))
-mfill++;  // keep m0 as marray[0], the first result
-for (int i = 0; i < num; i++) {
-Method* fm = wf.found_method(i);
-if (fm == m0)  continue;  // Already put this guy in the list.
-if (mfill == mlen) {
-return -1;              // Oops.  Too many methods after all!
-}
-marray[mfill++] = fm;
-}
-#ifndef PRODUCT
-// Make sure the dependency mechanism will pass this discovery:
-if (VerifyDependencies) {
-// Turn off dependency tracing while actually testing deps.
-FlagSetting fs(TraceDependencies, false);
-switch (mfill) {
-case 1:
-guarantee(NULL == (void *)check_unique_concrete_method(ctxk, marray[0]),
-"verify dep.");
-break;
-case 2:
-guarantee(NULL == (void *)
-check_exclusive_concrete_methods(ctxk, marray[0], marray[1]),
-"verify dep.");
-break;
-default:
-ShouldNotReachHere();  // mlen > 2 yet supported
-}
-}
-#endif //PRODUCT
-return mfill;
-}
 Klass* Dependencies::check_has_no_finalizable_subclasses(Klass* ctxk, KlassDepChange* changes) {
 Klass* search_at = ctxk;
 if (changes != NULL)
 search_at = changes->new_type(); // just look at the new bit
 return find_finalizable_subclass(search_at);
 }
 Klass* Dependencies::check_call_site_target_value(oop call_site, oop method_handle, CallSiteDepChange* changes) {
 assert(call_site    ->is_a(SystemDictionary::CallSite_klass()),     "sanity");
 assert(method_handle->is_a(SystemDictionary::MethodHandle_klass()), "sanity");
 if (changes == NULL) {

changeset 28514	da53c1ffc837
parent 27700	a402738ebfcf
child 29081	c61eb4914428