jdk-sandbox: comparison src/hotspot/share/oops/klass.cpp

equal deleted inserted replaced

-:d5d542d50e3c
+:30a5049a36bb
 /*
-* Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2019, 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.
 *
 */
 #include "precompiled.hpp"
 #include "classfile/classLoaderData.inline.hpp"
+#include "classfile/classLoaderDataGraph.inline.hpp"
 #include "classfile/dictionary.hpp"
 #include "classfile/javaClasses.hpp"
+#include "classfile/moduleEntry.hpp"
 #include "classfile/systemDictionary.hpp"
 #include "classfile/vmSymbols.hpp"
 #include "gc/shared/collectedHeap.inline.hpp"
 #include "logging/log.hpp"
 #include "memory/heapInspection.hpp"
+#include "memory/heapShared.hpp"
 #include "memory/metadataFactory.hpp"
 #include "memory/metaspaceClosure.hpp"
 #include "memory/metaspaceShared.hpp"
 #include "memory/oopFactory.hpp"
 #include "memory/resourceArea.hpp"
+#include "memory/universe.hpp"
 #include "oops/compressedOops.inline.hpp"
 #include "oops/instanceKlass.hpp"
 #include "oops/klass.inline.hpp"
 #include "oops/oop.inline.hpp"
 #include "oops/oopHandle.inline.hpp"
 assert(!m.is_null(), "New mirror should never be null.");
 assert(_java_mirror.resolve() == NULL, "should only be used to initialize mirror");
 _java_mirror = class_loader_data()->add_handle(m);
 }
-oop Klass::java_mirror() const {
+oop Klass::java_mirror_no_keepalive() const {
-return _java_mirror.resolve();
+return _java_mirror.peek();
 }
 bool Klass::is_cloneable() const {
 return _access_flags.is_cloneable_fast() ||
 is_subtype_of(SystemDictionary::Cloneable_klass());
 // implementor.  Then return the 1 concrete implementation.
 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 || s->next_sibling() ) // Oops; wrong count; give up
+if (s == NULL || s->next_sibling() != NULL) // Oops; wrong count; give up
 return this;              // Return 'this' as a no-progress flag
 r = s;                    // Loop till find concrete class
 }
 return r;                   // Return the 1 concrete class
 }
 }
 void Klass::initialize(TRAPS) {
 ShouldNotReachHere();
-}
-bool Klass::compute_is_subtype_of(Klass* k) {
-assert(k->is_klass(), "argument must be a class");
-return is_subclass_of(k);
 }
 Klass* Klass::find_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const {
 #ifdef ASSERT
 tty->print_cr("Error: find_field called on a klass oop."
 // which doesn't zero out the memory before calling the constructor.
 // Need to set the _java_mirror field explicitly to not hit an assert that the field
 // should be NULL before setting it.
 Klass::Klass(KlassID id) : _id(id),
 _java_mirror(NULL),
-_prototype_header(markOopDesc::prototype()),
+_prototype_header(markWord::prototype()),
 _shared_class_path_index(-1) {
 CDS_ONLY(_shared_class_flags = 0;)
 CDS_JAVA_HEAP_ONLY(_archived_mirror = 0;)
 _primary_supers[0] = this;
 set_super_check_offset(in_bytes(primary_supers_offset()));
 else
 return true;
 }
 void Klass::initialize_supers(Klass* k, Array<InstanceKlass*>* transitive_interfaces, TRAPS) {
-if (FastSuperclassLimit == 0) {
-// None of the other machinery matters.
-set_super(k);
-return;
-}
 if (k == NULL) {
 set_super(NULL);
 _primary_supers[0] = this;
 assert(super_depth() == 0, "Object must already be initialized properly");
 } else if (k != super() || k == SystemDictionary::Object_klass()) {
 set_secondary_supers(Universe::the_empty_klass_array());
 return NULL;
 }
+// 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 {
+// Need load_acquire on the _subklass, because it races with inserts that
+// publishes freshly initialized data.
+for (Klass* chain = OrderAccess::load_acquire(&_subklass);
+chain != NULL;
+// Do not need load_acquire on _next_sibling, because inserts never
+// create _next_sibling edges to dead data.
+chain = Atomic::load(&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 {
+// Do not need load_acquire on _next_sibling, because inserts never
+// create _next_sibling edges to dead data.
+for (Klass* chain = Atomic::load(&_next_sibling);
+chain != NULL;
+chain = Atomic::load(&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;
+OrderAccess::release_store(&_subklass, s);
 }
 void Klass::set_next_sibling(Klass* s) {
 assert(s != this, "sanity check");
-_next_sibling = s;
+// Does not need release semantics. If used by cleanup, it will link to
+// already safely published data, and if used by inserts, will be published
+// safely using cmpxchg.
+Atomic::store(s, &_next_sibling);
 }
 void Klass::append_to_sibling_list() {
+assert_locked_or_safepoint(Compile_lock);
 debug_only(verify();)
 // add ourselves to superklass' subklass list
 InstanceKlass* super = superklass();
 if (super == NULL) return;        // special case: class Object
 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) {
+// Make sure there is no stale subklass head
-// set our sibling to be the superklass' previous first subklass
+super->clean_subklass();
-set_next_sibling(prev_first_subklass);
-}
+for (;;) {
-// make ourselves the superklass' first subklass
+Klass* prev_first_subklass = OrderAccess::load_acquire(&_super->_subklass);
-super->set_subklass(this);
+if (prev_first_subklass != NULL) {
+// set our sibling to be the superklass' previous first subklass
+assert(prev_first_subklass->is_loader_alive(), "May not attach not alive klasses");
+set_next_sibling(prev_first_subklass);
+}
+// Note that the prev_first_subklass is always alive, meaning no sibling_next links
+// are ever created to not alive klasses. This is an important invariant of the lock-free
+// cleaning protocol, that allows us to safely unlink dead klasses from the sibling list.
+if (Atomic::cmpxchg(this, &super->_subklass, prev_first_subklass) == prev_first_subklass) {
+return;
+}
+}
 debug_only(verify();)
 }
-oop Klass::holder_phantom() const {
+void Klass::clean_subklass() {
-return class_loader_data()->holder_phantom();
+for (;;) {
+// Need load_acquire, due to contending with concurrent inserts
+Klass* subklass = OrderAccess::load_acquire(&_subklass);
+if (subklass == NULL || subklass->is_loader_alive()) {
+return;
+}
+// Try to fix _subklass until it points at something not dead.
+Atomic::cmpxchg(subklass->next_sibling(), &_subklass, subklass);
+}
 }
 void Klass::clean_weak_klass_links(bool unloading_occurred, bool clean_alive_klasses) {
 if (!ClassUnloading || !unloading_occurred) {
 return;
 Klass* current = stack.pop();
 assert(current->is_loader_alive(), "just checking, this should be live");
 // Find and set the first alive subklass
-Klass* sub = current->subklass();
+Klass* sub = current->subklass(true);
-while (sub != NULL && !sub->is_loader_alive()) {
+current->clean_subklass();
-#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();
+Klass* sibling = current->next_sibling(true);
-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);
 }
 it->push(&_secondary_supers);
 for (int i = 0; i < _primary_super_limit; i++) {
 it->push(&_primary_supers[i]);
 }
 it->push(&_super);
-it->push(&_subklass);
+it->push((Klass**)&_subklass);
-it->push(&_next_sibling);
+it->push((Klass**)&_next_sibling);
 it->push(&_next_link);
 vtableEntry* vt = start_of_vtable();
 for (int i=0; i<vtable_length(); i++) {
 it->push(vt[i].method_addr());
 }
 }
 void Klass::remove_unshareable_info() {
-assert (DumpSharedSpaces, "only called for DumpSharedSpaces");
+assert (Arguments::is_dumping_archive(),
+"only called during CDS dump time");
 JFR_ONLY(REMOVE_ID(this);)
 if (log_is_enabled(Trace, cds, unshareable)) {
 ResourceMark rm;
 log_trace(cds, unshareable)("remove: %s", external_name());
 }
 set_class_loader_data(NULL);
 set_is_shared();
 }
 void Klass::remove_java_mirror() {
-assert (DumpSharedSpaces, "only called for DumpSharedSpaces");
+Arguments::assert_is_dumping_archive();
 if (log_is_enabled(Trace, cds, unshareable)) {
 ResourceMark rm;
 log_trace(cds, unshareable)("remove java_mirror: %s", external_name());
 }
 // Just null out the mirror.  The class_loader_data() no longer exists.
 // modify the CLD list outside a safepoint.
 if (class_loader_data() == NULL) {
 // Restore class_loader_data to the null class loader data
 set_class_loader_data(loader_data);
+// Workaround for suspected bug.  Make sure other threads see this assignment.
+// This shouldn't be necessary but the compiler thread seems to be behind
+// the times, even though this thread takes MethodCompileQueue_lock and the thread
+// that doesn't see this value also takes that lock.
+OrderAccess::fence();
 // Add to null class loader list first before creating the mirror
 // (same order as class file parsing)
 loader_data->add_class(this);
 }
 Handle module_handle(THREAD, ((module_entry != NULL) ? module_entry->module() : (oop)NULL));
 if (this->has_raw_archived_mirror()) {
 ResourceMark rm;
 log_debug(cds, mirror)("%s has raw archived mirror", external_name());
-if (MetaspaceShared::open_archive_heap_region_mapped()) {
+if (HeapShared::open_archive_heap_region_mapped()) {
 bool present = java_lang_Class::restore_archived_mirror(this, loader, module_handle,
 protection_domain,
 CHECK);
 if (present) {
 return;
 Klass* Klass::array_klass_impl(bool or_null, TRAPS) {
 fatal("array_klass should be dispatched to InstanceKlass, ObjArrayKlass or TypeArrayKlass");
 return NULL;
 }
-oop Klass::class_loader() const { return class_loader_data()->class_loader(); }
+void Klass::check_array_allocation_length(int length, int max_length, TRAPS) {
+if (length > max_length) {
+if (!THREAD->in_retryable_allocation()) {
+report_java_out_of_memory("Requested array size exceeds VM limit");
+JvmtiExport::post_array_size_exhausted();
+THROW_OOP(Universe::out_of_memory_error_array_size());
+} else {
+THROW_OOP(Universe::out_of_memory_error_retry());
+}
+} else if (length < 0) {
+THROW_MSG(vmSymbols::java_lang_NegativeArraySizeException(), err_msg("%d", length));
+}
+}
 // In product mode, this function doesn't have virtual function calls so
 // there might be some performance advantage to handling InstanceKlass here.
 const char* Klass::external_name() const {
 if (is_instance_klass()) {
 st->print("%s", internal_name());
 print_address_on(st);
 st->cr();
 }
+#define BULLET  " - "
 void Klass::oop_print_on(oop obj, outputStream* st) {
-ResourceMark rm;
 // print title
 st->print_cr("%s ", internal_name());
 obj->print_address_on(st);
 if (WizardMode) {
 // print header
-obj->mark()->print_on(st);
+obj->mark().print_on(st);
+st->cr();
+st->print(BULLET"prototype_header: " INTPTR_FORMAT, _prototype_header.value());
+st->cr();
 }
 // print class
-st->print(" - klass: ");
+st->print(BULLET"klass: ");
 obj->klass()->print_value_on(st);
 st->cr();
 }
 void Klass::oop_print_value_on(oop obj, outputStream* st) {
 #if INCLUDE_SERVICES
 // Size Statistics
 void Klass::collect_statistics(KlassSizeStats *sz) const {
 sz->_klass_bytes = sz->count(this);
-sz->_mirror_bytes = sz->count(java_mirror());
+sz->_mirror_bytes = sz->count(java_mirror_no_keepalive());
 sz->_secondary_supers_bytes = sz->count_array(secondary_supers());
 sz->_ro_bytes += sz->_secondary_supers_bytes;
 sz->_rw_bytes += sz->_klass_bytes + sz->_mirror_bytes;
 }
 if (ko != NULL) {
 guarantee(ko->is_klass(), "should be klass");
 }
 }
-if (java_mirror() != NULL) {
+if (java_mirror_no_keepalive() != NULL) {
-guarantee(oopDesc::is_oop(java_mirror()), "should be instance");
+guarantee(oopDesc::is_oop(java_mirror_no_keepalive()), "should be instance");
 }
 }
 void Klass::oop_verify_on(oop obj, outputStream* st) {
 guarantee(oopDesc::is_oop(obj),  "should be oop");
 guarantee(obj->klass()->is_klass(), "klass field is not a klass");
 }
-klassVtable Klass::vtable() const {
+bool Klass::is_valid(Klass* k) {
-return klassVtable(const_cast<Klass*>(this), start_of_vtable(), vtable_length() / vtableEntry::size());
+if (!is_aligned(k, sizeof(MetaWord))) return false;
-}
+if ((size_t)k < os::min_page_size()) return false;
-vtableEntry* Klass::start_of_vtable() const {
+if (!os::is_readable_range(k, k + 1)) return false;
-return (vtableEntry*) ((address)this + in_bytes(vtable_start_offset()));
+if (!Metaspace::contains(k)) return false;
+if (!Symbol::is_valid(k->name())) return false;
+return ClassLoaderDataGraph::is_valid(k->class_loader_data());
 }
 Method* Klass::method_at_vtable(int index)  {
 #ifndef PRODUCT
 assert(index >= 0, "valid vtable index");
 }
 #endif
 return start_of_vtable()[index].method();
 }
-ByteSize Klass::vtable_start_offset() {
-return in_ByteSize(InstanceKlass::header_size() * wordSize);
-}
 #ifndef PRODUCT
 bool Klass::verify_vtable_index(int i) {
 int limit = vtable_length()/vtableEntry::size();
 const char* parent_loader_phrase = "";
 const char* parent_loader_name_and_id = "";
 if (include_parent_loader &&
 !cld->is_builtin_class_loader_data()) {
 oop parent_loader = java_lang_ClassLoader::parent(class_loader());
-ClassLoaderData *parent_cld = ClassLoaderData::class_loader_data(parent_loader);
+ClassLoaderData *parent_cld = ClassLoaderData::class_loader_data_or_null(parent_loader);
-assert(parent_cld != NULL, "parent's class loader data should not be null");
+// The parent loader's ClassLoaderData could be null if it is
-parent_loader_name_and_id = parent_cld->loader_name_and_id();
+// a delegating class loader that has never defined a class.
+// In this case the loader's name must be obtained via the parent loader's oop.
+if (parent_cld == NULL) {
+oop cl_name_and_id = java_lang_ClassLoader::nameAndId(parent_loader);
+if (cl_name_and_id != NULL) {
+parent_loader_name_and_id = java_lang_String::as_utf8_string(cl_name_and_id);
+}
+} else {
+parent_loader_name_and_id = parent_cld->loader_name_and_id();
+}
 parent_loader_phrase = ", parent loader ";
 len += strlen(parent_loader_phrase) + strlen(parent_loader_name_and_id);
 }
 // Start to construct final full class description string

branch	ihse-cflags-rewrite-branch
changeset 58665	30a5049a36bb
parent 56900	d5d542d50e3c
parent 58537	30a9612a657d