truffle: src/share/vm/classfile/classLoaderData.cpp comparison

comparison src/share/vm/classfile/classLoaderData.cpp @ 14518:d8041d695d19

Merged with jdk9/dev/hotspot changeset 3812c088b945

author	twisti
date	Tue, 11 Mar 2014 18:45:59 -0700
parents	f460c6926af7
children	4ca6dc0799b6

comparison

equal deleted inserted replaced

-:f97c5ec83832
+:d8041d695d19
 /*
-* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2012, 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.
 ClassLoaderData * ClassLoaderData::_the_null_class_loader_data = NULL;
 ClassLoaderData::ClassLoaderData(Handle h_class_loader, bool is_anonymous, Dependencies dependencies) :
 _class_loader(h_class_loader()),
-_is_anonymous(is_anonymous), _keep_alive(is_anonymous), // initially
+_is_anonymous(is_anonymous),
+// An anonymous class loader data doesn't have anything to keep
+// it from being unloaded during parsing of the anonymous class.
+// The null-class-loader should always be kept alive.
+_keep_alive(is_anonymous || h_class_loader.is_null()),
 _metaspace(NULL), _unloading(false), _klasses(NULL),
 _claimed(0), _jmethod_ids(NULL), _handles(NULL), _deallocate_list(NULL),
 _next(NULL), _dependencies(dependencies),
 _metaspace_lock(new Mutex(Monitor::leaf+1, "Metaspace allocation lock", true)) {
 // empty
 }
 tty->print_cr("]");
 }
 }
+oop ClassLoaderData::keep_alive_object() const {
+assert(!keep_alive(), "Don't use with CLDs that are artificially kept alive");
+return is_anonymous() ? _klasses->java_mirror() : class_loader();
+}
 bool ClassLoaderData::is_alive(BoolObjectClosure* is_alive_closure) const {
-bool alive =
+bool alive = keep_alive() // null class loader and incomplete anonymous klasses.
-is_anonymous() ?
+|| is_alive_closure->do_object_b(keep_alive_object());
-is_alive_closure->do_object_b(_klasses->java_mirror()) :
-class_loader() == NULL || is_alive_closure->do_object_b(class_loader());
 assert(!alive || claimed(), "must be claimed");
 return alive;
 }
 k->verify();
 assert(k != k->next_link(), "no loops!");
 }
 }
+bool ClassLoaderData::contains_klass(Klass* klass) {
+for (Klass* k = _klasses; k != NULL; k = k->next_link()) {
+if (k == klass) return true;
+}
+return false;
+}
 // GC root of class loader data created.
 ClassLoaderData* ClassLoaderDataGraph::_head = NULL;
 ClassLoaderData* ClassLoaderDataGraph::_unloading = NULL;
 ClassLoaderData* ClassLoaderDataGraph::_saved_head = NULL;
 }
 }
 void ClassLoaderDataGraph::always_strong_oops_do(OopClosure* f, KlassClosure* klass_closure, bool must_claim) {
 if (ClassUnloading) {
-ClassLoaderData::the_null_class_loader_data()->oops_do(f, klass_closure, must_claim);
-// keep any special CLDs alive.
 ClassLoaderDataGraph::keep_alive_oops_do(f, klass_closure, must_claim);
 } else {
 ClassLoaderDataGraph::oops_do(f, klass_closure, must_claim);
 }
 }
 }
 return array;
 }
-#ifndef PRODUCT
+// For profiling and hsfind() only.  Otherwise, this is unsafe (and slow).  This
-// for debugging and hsfind(x)
+// is done lock free to avoid lock inversion problems.  It is safe because
-bool ClassLoaderDataGraph::contains(address x) {
+// new ClassLoaderData are added to the end of the CLDG, and only removed at
-// I think we need the _metaspace_lock taken here because the class loader
+// safepoint.  The _unloading list can be deallocated concurrently with CMS so
-// data graph could be changing while we are walking it (new entries added,
+// this doesn't look in metaspace for classes that have been unloaded.
-// new entries being unloaded, etc).
+bool ClassLoaderDataGraph::contains(const void* x) {
 if (DumpSharedSpaces) {
 // There are only two metaspaces to worry about.
 ClassLoaderData* ncld = ClassLoaderData::the_null_class_loader_data();
 return (ncld->ro_metaspace()->contains(x) || ncld->rw_metaspace()->contains(x));
 }
 if (cld->metaspace_or_null() != NULL && cld->metaspace_or_null()->contains(x)) {
 return true;
 }
 }
-// Could also be on an unloading list which is okay, ie. still allocated
+// Do not check unloading list because deallocation can be concurrent.
-// for a little while.
-for (ClassLoaderData* ucld = _unloading; ucld != NULL; ucld = ucld->next()) {
-if (ucld->metaspace_or_null() != NULL && ucld->metaspace_or_null()->contains(x)) {
-return true;
-}
-}
 return false;
 }
+#ifndef PRODUCT
 bool ClassLoaderDataGraph::contains_loader_data(ClassLoaderData* loader_data) {
 for (ClassLoaderData* data = _head; data != NULL; data = data->next()) {
 if (loader_data == data) {
 return true;
 }
 // mark metadata seen on the stack and code cache so we can delete
 // unneeded entries.
 bool has_redefined_a_class = JvmtiExport::has_redefined_a_class();
 MetadataOnStackMark md_on_stack;
 while (data != NULL) {
-if (data->keep_alive() || data->is_alive(is_alive_closure)) {
+if (data->is_alive(is_alive_closure)) {
 if (has_redefined_a_class) {
 data->classes_do(InstanceKlass::purge_previous_versions);
 }
 data->free_deallocate_list();
 prev = data;

Mercurial > hg > truffle

comparison src/share/vm/classfile/classLoaderData.cpp @ 14518:d8041d695d19