stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8213211: [BACKOUT] Allow Klass::_subklass and _next_sibling to have unloaded classes

Browse Source 
Reviewed-by: jiangli, jwilhelm
This commit is contained in:
Coleen Phillimore 2018-10-31 14:38:14 -04:00
parent 84a22b6b36
commit d302072f50
16 changed files with 97 additions and 325 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src/hotspot/share/ci/ciInstanceKlass.cpp
View File

@ -57,7 +57,7 @@ ciInstanceKlass::ciInstanceKlass(Klass* k) :
AccessFlags access_flags = ik->access_flags();
_flags = ciFlags(access_flags);
_has_finalizer = access_flags.has_finalizer();
_has_subklass = flags().is_final() ? subklass_false : subklass_unknown;
_has_subklass = ik->subklass() != NULL;
_init_state = ik->init_state();
_nonstatic_field_size = ik->nonstatic_field_size();
_has_nonstatic_fields = ik->has_nonstatic_fields();
@ -146,10 +146,9 @@ void ciInstanceKlass::compute_shared_init_state() {
// ciInstanceKlass::compute_shared_has_subklass
bool ciInstanceKlass::compute_shared_has_subklass() {
GUARDED_VM_ENTRY(
MutexLocker ml(Compile_lock);
InstanceKlass* ik = get_instanceKlass();
_has_subklass = ik->subklass() != NULL ? subklass_true : subklass_false;
return _has_subklass == subklass_true;
_has_subklass = ik->subklass() != NULL;
return _has_subklass;
)
}
@ -375,7 +374,6 @@ ciInstanceKlass* ciInstanceKlass::unique_concrete_subklass() {
if (!is_abstract()) return NULL; // Only applies to abstract classes.
if (!has_subklass()) return NULL; // Must have at least one subklass.
VM_ENTRY_MARK;
MutexLocker ml(Compile_lock);
InstanceKlass* ik = get_instanceKlass();
Klass* up = ik->up_cast_abstract();
assert(up->is_instance_klass(), "must be InstanceKlass");
@ -390,7 +388,6 @@ ciInstanceKlass* ciInstanceKlass::unique_concrete_subklass() {
bool ciInstanceKlass::has_finalizable_subclass() {
if (!is_loaded()) return true;
VM_ENTRY_MARK;
MutexLocker ml(Compile_lock);
return Dependencies::find_finalizable_subclass(get_instanceKlass()) != NULL;
}
@ -580,7 +577,7 @@ bool ciInstanceKlass::is_leaf_type() {
if (is_shared()) {
return is_final(); // approximately correct
} else {
return !has_subklass() && (nof_implementors() == 0);
return !_has_subklass && (nof_implementors() == 0);
}
}

9
src/hotspot/share/ci/ciInstanceKlass.hpp
View File

@ -44,15 +44,13 @@ class ciInstanceKlass : public ciKlass {
friend class ciField;
private:
enum SubklassValue { subklass_unknown, subklass_false, subklass_true };
jobject _loader;
jobject _protection_domain;
InstanceKlass::ClassState _init_state; // state of class
bool _is_shared;
bool _has_finalizer;
SubklassValue _has_subklass;
bool _has_subklass;
bool _has_nonstatic_fields;
bool _has_nonstatic_concrete_methods;
bool _is_unsafe_anonymous;
@ -141,15 +139,14 @@ public:
return _has_finalizer; }
bool has_subklass() {
assert(is_loaded(), "must be loaded");
if (_has_subklass == subklass_unknown ||
(_is_shared && _has_subklass == subklass_false)) {
if (_is_shared && !_has_subklass) {
if (flags().is_final()) {
return false;
} else {
return compute_shared_has_subklass();
}
}
return _has_subklass == subklass_true;
return _has_subklass;
}
jint size_helper() {
return (Klass::layout_helper_size_in_bytes(layout_helper())

18
src/hotspot/share/jfr/jni/jfrGetAllEventClasses.cpp
View File

@ -90,6 +90,7 @@ static void fill_klasses(GrowableArray<const void*>& event_subklasses, const Kla
DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(thread));
Stack<const Klass*, mtTracing> mark_stack;
MutexLocker ml(Compile_lock, thread);
mark_stack.push(event_klass->subklass());
while (!mark_stack.is_empty()) {
@ -145,19 +146,16 @@ jobject JfrEventClasses::get_all_event_classes(TRAPS) {
assert(klass != NULL, "invariant");
assert(JdkJfrEvent::is(klass), "invariant");
if (klass->subklass() == NULL) {
return empty_java_util_arraylist;
}
ResourceMark rm(THREAD);
GrowableArray<const void*> event_subklasses(THREAD, initial_size_growable_array);
{
MutexLocker cl(Compile_lock);
if (klass->subklass() == NULL) {
return empty_java_util_arraylist;
}
fill_klasses(event_subklasses, klass, THREAD);
fill_klasses(event_subklasses, klass, THREAD);
if (event_subklasses.is_empty()) {
return empty_java_util_arraylist;
}
if (event_subklasses.is_empty()) {
return empty_java_util_arraylist;
}
transform_klasses_to_local_jni_handles(event_subklasses, THREAD);

1
src/hotspot/share/jvmci/jvmciCompilerToVM.cpp
View File

@ -627,7 +627,6 @@ C2V_END
C2V_VMENTRY(jboolean, hasFinalizableSubclass,(JNIEnv *, jobject, jobject jvmci_type))
Klass* klass = CompilerToVM::asKlass(jvmci_type);
assert(klass != NULL, "method must not be called for primitive types");
MutexLocker ml(Compile_lock);
return Dependencies::find_finalizable_subclass(klass) != NULL;
C2V_END

18
src/hotspot/share/memory/universe.cpp
View File

@ -531,6 +531,10 @@ oop Universe::swap_reference_pending_list(oop list) {
#undef assert_pll_locked
#undef assert_pll_ownership
// initialize_vtable could cause gc if
// 1) we specified true to initialize_vtable and
// 2) this ran after gc was enabled
// In case those ever change we use handles for oops
void Universe::reinitialize_vtable_of(Klass* ko, TRAPS) {
// init vtable of k and all subclasses
ko->vtable().initialize_vtable(false, CHECK);
@ -543,16 +547,6 @@ void Universe::reinitialize_vtable_of(Klass* ko, TRAPS) {
}
}
void Universe::reinitialize_vtables(TRAPS) {
// The vtables are initialized by starting at java.lang.Object and
// initializing through the subclass links, so that the super
// classes are always initialized first. The subclass links
// require the Compile_lock.
MutexLocker cl(Compile_lock);
Klass* ok = SystemDictionary::Object_klass();
Universe::reinitialize_vtable_of(ok, THREAD);
}
void initialize_itable_for_klass(InstanceKlass* k, TRAPS) {
k->itable().initialize_itable(false, CHECK);
@ -970,7 +964,9 @@ bool universe_post_init() {
{ ResourceMark rm;
Interpreter::initialize(); // needed for interpreter entry points
if (!UseSharedSpaces) {
Universe::reinitialize_vtables(CHECK_false);
HandleMark hm(THREAD);
Klass* ok = SystemDictionary::Object_klass();
Universe::reinitialize_vtable_of(ok, CHECK_false);
Universe::reinitialize_itables(CHECK_false);
}
}

1
src/hotspot/share/memory/universe.hpp
View File

@ -219,7 +219,6 @@ class Universe: AllStatic {
static void fixup_mirrors(TRAPS);
static void reinitialize_vtable_of(Klass* k, TRAPS);
static void reinitialize_vtables(TRAPS);
static void reinitialize_itables(TRAPS);
static void compute_base_vtable_size(); // compute vtable size of class Object

116
src/hotspot/share/oops/instanceKlass.cpp
View File

@ -1054,28 +1054,16 @@ void InstanceKlass::set_initialization_state_and_notify(ClassState state, TRAPS)
}
}
Klass* InstanceKlass::implementor(bool log) const {
Klass* InstanceKlass::implementor() const {
assert_locked_or_safepoint(Compile_lock);
Klass** k = adr_implementor();
if (k == NULL) {
return NULL;
} else {
Klass* kls = *k;
if (kls != NULL && !kls->is_loader_alive()) {
if (log) {
if (log_is_enabled(Trace, class, unload)) {
ResourceMark rm;
log_trace(class, unload)("unlinking class (implementor): %s", kls->external_name());
}
}
return NULL; // don't return unloaded class
} else {
return kls;
}
return *k;
}
}
void InstanceKlass::set_implementor(Klass* k) {
assert_lock_strong(Compile_lock);
assert(is_interface(), "not interface");
@ -2151,15 +2139,20 @@ void InstanceKlass::clean_weak_instanceklass_links() {
}
void InstanceKlass::clean_implementors_list() {
assert_locked_or_safepoint(Compile_lock);
assert(is_loader_alive(), "this klass should be live");
if (is_interface()) {
assert (ClassUnloading, "only called for ClassUnloading");
Klass* impl = implementor(true);
if (impl == NULL) {
// NULL this field, might be an unloaded klass or NULL
Klass** klass = adr_implementor();
*klass = NULL;
if (ClassUnloading) {
Klass* impl = implementor();
if (impl != NULL) {
if (!impl->is_loader_alive()) {
// remove this guy
Klass** klass = adr_implementor();
assert(klass != NULL, "null klass");
if (klass != NULL) {
*klass = NULL;
}
}
}
}
}
}
@ -3087,29 +3080,28 @@ void InstanceKlass::print_on(outputStream* st) const {
st->print(BULLET"name: "); name()->print_value_on(st); st->cr();
st->print(BULLET"super: "); Metadata::print_value_on_maybe_null(st, super()); st->cr();
st->print(BULLET"sub: ");
{
MutexLocker ml(Compile_lock);
Klass* sub = subklass();
int n;
for (n = 0; sub != NULL; n++, sub = sub->next_sibling()) {
if (n < MaxSubklassPrintSize) {
sub->print_value_on(st);
st->print(" ");
}
}
if (n >= MaxSubklassPrintSize) st->print("(" INTX_FORMAT " more klasses...)", n - MaxSubklassPrintSize);
st->cr();
if (is_interface()) {
st->print_cr(BULLET"nof implementors: %d", nof_implementors());
if (nof_implementors() == 1) {
st->print_cr(BULLET"implementor: ");
st->print(" ");
implementor()->print_value_on(st);
st->cr();
}
Klass* sub = subklass();
int n;
for (n = 0; sub != NULL; n++, sub = sub->next_sibling()) {
if (n < MaxSubklassPrintSize) {
sub->print_value_on(st);
st->print(" ");
}
}
if (n >= MaxSubklassPrintSize) st->print("(" INTX_FORMAT " more klasses...)", n - MaxSubklassPrintSize);
st->cr();
if (is_interface()) {
MutexLocker ml(Compile_lock);
st->print_cr(BULLET"nof implementors: %d", nof_implementors());
if (nof_implementors() == 1) {
st->print_cr(BULLET"implementor: ");
st->print(" ");
implementor()->print_value_on(st);
st->cr();
}
}
st->print(BULLET"arrays: "); Metadata::print_value_on_maybe_null(st, array_klasses()); st->cr();
st->print(BULLET"methods: "); methods()->print_value_on(st); st->cr();
if (Verbose || WizardMode) {
@ -3491,30 +3483,26 @@ void InstanceKlass::verify_on(outputStream* st) {
vtable().verify(st);
}
// This is called from add_to_hierarchy when the Compile_lock is owned.
{
MutexLockerEx ml(Compile_lock->owned_by_self() ? NULL : Compile_lock);
// Verify first subklass
if (subklass() != NULL) {
guarantee(subklass()->is_klass(), "should be klass");
}
// Verify siblings
Klass* super = this->super();
Klass* sib = next_sibling();
if (sib != NULL) {
if (sib == this) {
fatal("subclass points to itself " PTR_FORMAT, p2i(sib));
}
guarantee(sib->is_klass(), "should be klass");
guarantee(sib->super() == super, "siblings should have same superklass");
}
// Verify implementor fields requires the Compile_lock,
// but this is sometimes called inside a safepoint, so don't verify.
// Verify first subklass
if (subklass() != NULL) {
guarantee(subklass()->is_klass(), "should be klass");
}
// Verify siblings
Klass* super = this->super();
Klass* sib = next_sibling();
if (sib != NULL) {
if (sib == this) {
fatal("subclass points to itself " PTR_FORMAT, p2i(sib));
}
guarantee(sib->is_klass(), "should be klass");
guarantee(sib->super() == super, "siblings should have same superklass");
}
// Verify implementor fields requires the Compile_lock, but this is sometimes
// called inside a safepoint, so don't verify.
// Verify local interfaces
if (local_interfaces()) {
Array<InstanceKlass*>* local_interfaces = this->local_interfaces();

2
src/hotspot/share/oops/instanceKlass.hpp
View File

@ -1007,7 +1007,7 @@ public:
#endif
// Access to the implementor of an interface.
Klass* implementor(bool log = false) const;
Klass* implementor() const;
void set_implementor(Klass* k);
int nof_implementors() const;
void add_implementor(Klass* k); // k is a new class that implements this interface

63
src/hotspot/share/oops/klass.cpp
View File

@ -117,7 +117,7 @@ Klass *Klass::up_cast_abstract() {
Klass *r = this;
while( r->is_abstract() ) { // Receiver is abstract?
Klass *s = r->subklass(); // Check for exactly 1 subklass
if (s == NULL || s->next_sibling() != NULL) // Oops; wrong count; give up
if( !s || s->next_sibling() ) // Oops; wrong count; give up
return this; // Return 'this' as a no-progress flag
r = s; // Loop till find concrete class
}
@ -358,49 +358,11 @@ GrowableArray<Klass*>* Klass::compute_secondary_supers(int num_extra_slots,
}
// superklass links
InstanceKlass* Klass::superklass() const {
assert(super() == NULL || super()->is_instance_klass(), "must be instance klass");
return _super == NULL ? NULL : InstanceKlass::cast(_super);
}
// subklass links. Used by the compiler (and vtable initialization)
// May be cleaned concurrently, so must use the Compile_lock.
// The log parameter is for clean_weak_klass_links to report unlinked classes.
Klass* Klass::subklass(bool log) const {
assert_locked_or_safepoint(Compile_lock);
for (Klass* chain = _subklass; chain != NULL;
chain = chain->_next_sibling) {
if (chain->is_loader_alive()) {
return chain;
} else if (log) {
if (log_is_enabled(Trace, class, unload)) {
ResourceMark rm;
log_trace(class, unload)("unlinking class (subclass): %s", chain->external_name());
}
}
}
return NULL;
}
Klass* Klass::next_sibling(bool log) const {
assert_locked_or_safepoint(Compile_lock);
for (Klass* chain = _next_sibling; chain != NULL;
chain = chain->_next_sibling) {
// Only return alive klass, there may be stale klass
// in this chain if cleaned concurrently.
if (chain->is_loader_alive()) {
return chain;
} else if (log) {
if (log_is_enabled(Trace, class, unload)) {
ResourceMark rm;
log_trace(class, unload)("unlinking class (sibling): %s", chain->external_name());
}
}
}
return NULL;
}
void Klass::set_subklass(Klass* s) {
assert(s != this, "sanity check");
_subklass = s;
@ -412,7 +374,6 @@ void Klass::set_next_sibling(Klass* s) {
}
void Klass::append_to_sibling_list() {
assert_locked_or_safepoint(Compile_lock);
debug_only(verify();)
// add ourselves to superklass' subklass list
InstanceKlass* super = superklass();
@ -420,7 +381,6 @@ void Klass::append_to_sibling_list() {
assert((!super->is_interface() // interfaces cannot be supers
&& (super->superklass() == NULL || !is_interface())),
"an interface can only be a subklass of Object");
Klass* prev_first_subklass = super->subklass();
if (prev_first_subklass != NULL) {
// set our sibling to be the superklass' previous first subklass
@ -436,7 +396,6 @@ oop Klass::holder_phantom() const {
}
void Klass::clean_weak_klass_links(bool unloading_occurred, bool clean_alive_klasses) {
assert_locked_or_safepoint(Compile_lock);
if (!ClassUnloading || !unloading_occurred) {
return;
}
@ -451,14 +410,30 @@ void Klass::clean_weak_klass_links(bool unloading_occurred, bool clean_alive_kla
assert(current->is_loader_alive(), "just checking, this should be live");
// Find and set the first alive subklass
Klass* sub = current->subklass(true);
Klass* sub = current->subklass();
while (sub != NULL && !sub->is_loader_alive()) {
#ifndef PRODUCT
if (log_is_enabled(Trace, class, unload)) {
ResourceMark rm;
log_trace(class, unload)("unlinking class (subclass): %s", sub->external_name());
}
#endif
sub = sub->next_sibling();
}
current->set_subklass(sub);
if (sub != NULL) {
stack.push(sub);
}
// Find and set the first alive sibling
Klass* sibling = current->next_sibling(true);
Klass* sibling = current->next_sibling();
while (sibling != NULL && !sibling->is_loader_alive()) {
if (log_is_enabled(Trace, class, unload)) {
ResourceMark rm;
log_trace(class, unload)("[Unlinking class (sibling) %s]", sibling->external_name());
}
sibling = sibling->next_sibling();
}
current->set_next_sibling(sibling);
if (sibling != NULL) {
stack.push(sibling);

5
src/hotspot/share/oops/klass.hpp
View File

@ -284,9 +284,8 @@ protected:
// Use InstanceKlass::contains_field_offset to classify field offsets.
// sub/superklass links
Klass* subklass(bool log = false) const;
Klass* next_sibling(bool log = false) const;
Klass* subklass() const { return _subklass; }
Klass* next_sibling() const { return _next_sibling; }
InstanceKlass* superklass() const;
void append_to_sibling_list(); // add newly created receiver to superklass' subklass list

2
src/hotspot/share/runtime/mutex.cpp
View File

@ -876,7 +876,7 @@ void Monitor::lock(Thread * Self) {
#endif // CHECK_UNHANDLED_OOPS
debug_only(check_prelock_state(Self, StrictSafepointChecks));
assert(_owner != Self, "this lock %s is already held by this thread", name());
assert(_owner != Self, "invariant");
assert(_OnDeck != Self->_MutexEvent, "invariant");
if (TryFast()) {

2
src/hotspot/share/utilities/vmError.cpp
View File

@ -1467,8 +1467,6 @@ void VMError::report_and_die(int id, const char* message, const char* detail_fmt
log.set_fd(-1);
}
// Error handling generates replay data without the compile lock.
NOT_PRODUCT(FlagSetting fs(IgnoreLockingAssertions, true));
static bool skip_replay = ReplayCompiles; // Do not overwrite file during replay
if (DumpReplayDataOnError && _thread && _thread->is_Compiler_thread() && !skip_replay) {
skip_replay = true;

95
test/hotspot/jtreg/runtime/ClassUnload/UnloadInterfaceTest.java
View File

@ -1,95 +0,0 @@
/*
* Copyright (c) 2018, 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.
*/
/*
* @test UnloadInterfaceTest
* @requires vm.opt.final.ClassUnloading
* @modules java.base/jdk.internal.misc
* @library /runtime/testlibrary /test/lib
* @compile test/Interface.java
* @compile test/ImplementorClass.java
* @build sun.hotspot.WhiteBox
* @run driver ClassFileInstaller sun.hotspot.WhiteBox
* sun.hotspot.WhiteBox$WhiteBoxPermission
* @run main/othervm -Xbootclasspath/a:. -Xmn8m -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xlog:class+unload=trace UnloadInterfaceTest
*/
import sun.hotspot.WhiteBox;
import test.Interface;
import java.lang.ClassLoader;
/**
* Test that verifies that class unloaded removes the implementor from its the interface that it implements
* via logging.
* [1.364s][info][class,unload] unloading class test.ImplementorClass 0x00000008000a2840
* [1.366s][trace][class,unload] unlinking class (subclass): test.ImplementorClass
* [1.366s][trace][class,unload] unlinking class (implementor): test.ImplementorClass
*/
public class UnloadInterfaceTest {
private static String className = "test.ImplementorClass";
private static String interfaceName = "test.Interface";
static class LoaderToUnload extends ClassLoader {
ClassLoader myParent;
public Class loadClass(String name) throws ClassNotFoundException {
if (name.contains(className)) {
System.out.println("className found " + className);
byte[] data = ClassUnloadCommon.getClassData(name);
return defineClass(name, data, 0, data.length);
} else {
return myParent.loadClass(name);
}
}
public LoaderToUnload(ClassLoader parent) {
super();
myParent = parent;
}
}
public static void main(String... args) throws Exception {
run();
}
private static void run() throws Exception {
final WhiteBox wb = WhiteBox.getWhiteBox();
ClassUnloadCommon.failIf(wb.isClassAlive(className), "is not expected to be alive yet");
// Load interface Class with one class loader.
ClassLoader icl = ClassUnloadCommon.newClassLoader();
Class<?> ic = icl.loadClass(interfaceName);
ClassLoader cl = new LoaderToUnload(icl);
Class<?> c = cl.loadClass(className);
Object o = c.newInstance();
ClassUnloadCommon.failIf(!wb.isClassAlive(className), "should be live here");
ClassUnloadCommon.failIf(!wb.isClassAlive(interfaceName), "should be live here");
cl = null; c = null; o = null;
ClassUnloadCommon.triggerUnloading();
ClassUnloadCommon.failIf(wb.isClassAlive(className), "should have been unloaded");
ClassUnloadCommon.failIf(!wb.isClassAlive(interfaceName), "should be live here");
System.out.println("We still have Interface referenced" + ic);
}
}

29
test/hotspot/jtreg/runtime/ClassUnload/test/ImplementorClass.java
View File

@ -1,29 +0,0 @@
/*
* Copyright (c) 2018, 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.
*
*/
package test;
public class ImplementorClass implements Interface {
public void foo() { System.out.println("foo implemented!"); }
}

29
test/hotspot/jtreg/runtime/ClassUnload/test/Interface.java
View File

@ -1,29 +0,0 @@
/*
* Copyright (c) 2018, 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.
*
*/
package test;
public interface Interface {
public void foo();
}

21
test/hotspot/jtreg/runtime/testlibrary/ClassUnloadCommon.java
View File

@ -27,10 +27,7 @@
* for an example.
*/
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
@ -107,22 +104,4 @@ public class ClassUnloadCommon {
throw new RuntimeException(e);
}
}
// Get data for pre-compiled class file to load.
public static byte[] getClassData(String name) {
try {
String TempName = name.replaceAll("\\.", "/");
String currentDir = System.getProperty("test.classes");
String filename = currentDir + File.separator + TempName + ".class";
System.out.println("filename is " + filename);
FileInputStream fis = new FileInputStream(filename);
byte[] b = new byte[5000];
int cnt = fis.read(b, 0, 5000);
byte[] c = new byte[cnt];
for (int i=0; i<cnt; i++) c[i] = b[i];
return c;
} catch (IOException e) {
return null;
}
}
}