truffle: src/share/vm/oops/klass.cpp annotate

annotate src/share/vm/oops/klass.cpp @ 17716:cdb71841f4bc

6498581: ThreadInterruptTest3 produces wrong output on Windows Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set. Reviewed-by: acorn, kvn Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com

author	minqi
date	Wed, 26 Feb 2014 15:20:41 -0800
parents	85318d1fe8fe
children	7f0e0366ec81 9428a0b94204

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
17674 85318d1fe8fe 8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on coleenp parents: 17663 diff changeset	2 * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1155 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1155 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1155 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	25 #include "precompiled.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	26 #include "classfile/javaClasses.hpp"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	27 #include "classfile/dictionary.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	28 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	29 #include "classfile/vmSymbols.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	30 #include "gc_implementation/shared/markSweep.inline.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	31 #include "gc_interface/collectedHeap.inline.hpp"
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7185 diff changeset	32 #include "memory/heapInspection.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	33 #include "memory/metadataFactory.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	34 #include "memory/oopFactory.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	35 #include "memory/resourceArea.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	36 #include "oops/instanceKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	37 #include "oops/klass.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	38 #include "oops/oop.inline2.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	39 #include "runtime/atomic.hpp"
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10376 diff changeset	40 #include "trace/traceMacros.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	41 #include "utilities/stack.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7185 diff changeset	42 #include "utilities/macros.hpp"
db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7185 diff changeset	43 #if INCLUDE_ALL_GCS
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	44 #include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	45 #include "gc_implementation/parallelScavenge/psPromotionManager.hpp"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	46 #include "gc_implementation/parallelScavenge/psScavenge.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7185 diff changeset	47 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	48
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	49 void Klass::set_name(Symbol* n) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	50 _name = n;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	51 if (_name != NULL) _name->increment_refcount();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	52 }
0 a61af66fc99e Initial load duke parents: diff changeset	53
10265 92ef81e2f571 8003557: NPG: Klass* const k should be const Klass* k. minqi parents: 8751 diff changeset	54 bool Klass::is_subclass_of(const Klass* k) const {
0 a61af66fc99e Initial load duke parents: diff changeset	55 // Run up the super chain and check
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	56 if (this == k) return true;
0 a61af66fc99e Initial load duke parents: diff changeset	57
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	58 Klass* t = const_cast<Klass*>(this)->super();
0 a61af66fc99e Initial load duke parents: diff changeset	59
a61af66fc99e Initial load duke parents: diff changeset	60 while (t != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	61 if (t == k) return true;
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6867 diff changeset	62 t = t->super();
0 a61af66fc99e Initial load duke parents: diff changeset	63 }
a61af66fc99e Initial load duke parents: diff changeset	64 return false;
a61af66fc99e Initial load duke parents: diff changeset	65 }
a61af66fc99e Initial load duke parents: diff changeset	66
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	67 bool Klass::search_secondary_supers(Klass* k) const {
0 a61af66fc99e Initial load duke parents: diff changeset	68 // Put some extra logic here out-of-line, before the search proper.
a61af66fc99e Initial load duke parents: diff changeset	69 // This cuts down the size of the inline method.
a61af66fc99e Initial load duke parents: diff changeset	70
a61af66fc99e Initial load duke parents: diff changeset	71 // This is necessary, since I am never in my own secondary_super list.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	72 if (this == k)
0 a61af66fc99e Initial load duke parents: diff changeset	73 return true;
a61af66fc99e Initial load duke parents: diff changeset	74 // Scan the array-of-objects for a match
a61af66fc99e Initial load duke parents: diff changeset	75 int cnt = secondary_supers()->length();
a61af66fc99e Initial load duke parents: diff changeset	76 for (int i = 0; i < cnt; i++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	77 if (secondary_supers()->at(i) == k) {
0 a61af66fc99e Initial load duke parents: diff changeset	78 ((Klass*)this)->set_secondary_super_cache(k);
a61af66fc99e Initial load duke parents: diff changeset	79 return true;
a61af66fc99e Initial load duke parents: diff changeset	80 }
a61af66fc99e Initial load duke parents: diff changeset	81 }
a61af66fc99e Initial load duke parents: diff changeset	82 return false;
a61af66fc99e Initial load duke parents: diff changeset	83 }
a61af66fc99e Initial load duke parents: diff changeset	84
a61af66fc99e Initial load duke parents: diff changeset	85 // Return self, except for abstract classes with exactly 1
a61af66fc99e Initial load duke parents: diff changeset	86 // implementor. Then return the 1 concrete implementation.
a61af66fc99e Initial load duke parents: diff changeset	87 Klass *Klass::up_cast_abstract() {
a61af66fc99e Initial load duke parents: diff changeset	88 Klass *r = this;
a61af66fc99e Initial load duke parents: diff changeset	89 while( r->is_abstract() ) { // Receiver is abstract?
a61af66fc99e Initial load duke parents: diff changeset	90 Klass *s = r->subklass(); // Check for exactly 1 subklass
a61af66fc99e Initial load duke parents: diff changeset	91 if( !s \|\| s->next_sibling() ) // Oops; wrong count; give up
a61af66fc99e Initial load duke parents: diff changeset	92 return this; // Return 'this' as a no-progress flag
a61af66fc99e Initial load duke parents: diff changeset	93 r = s; // Loop till find concrete class
a61af66fc99e Initial load duke parents: diff changeset	94 }
a61af66fc99e Initial load duke parents: diff changeset	95 return r; // Return the 1 concrete class
a61af66fc99e Initial load duke parents: diff changeset	96 }
a61af66fc99e Initial load duke parents: diff changeset	97
605 98cb887364d3 6810672: Comment typos twisti parents: 431 diff changeset	98 // Find LCA in class hierarchy
0 a61af66fc99e Initial load duke parents: diff changeset	99 Klass Klass::LCA( Klass k2 ) {
a61af66fc99e Initial load duke parents: diff changeset	100 Klass *k1 = this;
a61af66fc99e Initial load duke parents: diff changeset	101 while( 1 ) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	102 if( k1->is_subtype_of(k2) ) return k2;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	103 if( k2->is_subtype_of(k1) ) return k1;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	104 k1 = k1->super();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	105 k2 = k2->super();
0 a61af66fc99e Initial load duke parents: diff changeset	106 }
a61af66fc99e Initial load duke parents: diff changeset	107 }
a61af66fc99e Initial load duke parents: diff changeset	108
a61af66fc99e Initial load duke parents: diff changeset	109
a61af66fc99e Initial load duke parents: diff changeset	110 void Klass::check_valid_for_instantiation(bool throwError, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	111 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	112 THROW_MSG(throwError ? vmSymbols::java_lang_InstantiationError()
a61af66fc99e Initial load duke parents: diff changeset	113 : vmSymbols::java_lang_InstantiationException(), external_name());
a61af66fc99e Initial load duke parents: diff changeset	114 }
a61af66fc99e Initial load duke parents: diff changeset	115
a61af66fc99e Initial load duke parents: diff changeset	116
a61af66fc99e Initial load duke parents: diff changeset	117 void Klass::copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	118 THROW(vmSymbols::java_lang_ArrayStoreException());
a61af66fc99e Initial load duke parents: diff changeset	119 }
a61af66fc99e Initial load duke parents: diff changeset	120
a61af66fc99e Initial load duke parents: diff changeset	121
a61af66fc99e Initial load duke parents: diff changeset	122 void Klass::initialize(TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	123 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	124 }
a61af66fc99e Initial load duke parents: diff changeset	125
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	126 bool Klass::compute_is_subtype_of(Klass* k) {
0 a61af66fc99e Initial load duke parents: diff changeset	127 assert(k->is_klass(), "argument must be a class");
a61af66fc99e Initial load duke parents: diff changeset	128 return is_subclass_of(k);
a61af66fc99e Initial load duke parents: diff changeset	129 }
a61af66fc99e Initial load duke parents: diff changeset	130
a61af66fc99e Initial load duke parents: diff changeset	131
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	132 Method* Klass::uncached_lookup_method(Symbol* name, Symbol* signature) const {
0 a61af66fc99e Initial load duke parents: diff changeset	133 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	134 tty->print_cr("Error: uncached_lookup_method called on a klass oop."
a61af66fc99e Initial load duke parents: diff changeset	135 " Likely error: reflection method does not correctly"
a61af66fc99e Initial load duke parents: diff changeset	136 " wrap return value in a mirror object.");
a61af66fc99e Initial load duke parents: diff changeset	137 #endif
a61af66fc99e Initial load duke parents: diff changeset	138 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	139 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	140 }
a61af66fc99e Initial load duke parents: diff changeset	141
12146 9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 11096 diff changeset	142 void* Klass::operator new(size_t size, ClassLoaderData* loader_data, size_t word_size, TRAPS) throw() {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	143 return Metaspace::allocate(loader_data, word_size, /read_only/false,
10376 a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10343 diff changeset	144 MetaspaceObj::ClassType, CHECK_NULL);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	145 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	146
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	147 Klass::Klass() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	148 Klass* k = this;
0 a61af66fc99e Initial load duke parents: diff changeset	149
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8003 diff changeset	150 // Preinitialize supertype information.
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8003 diff changeset	151 // A later call to initialize_supers() may update these settings:
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8003 diff changeset	152 set_super(NULL);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8003 diff changeset	153 for (juint i = 0; i < Klass::primary_super_limit(); i++) {
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8003 diff changeset	154 _primary_supers[i] = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	155 }
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8003 diff changeset	156 set_secondary_supers(NULL);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8003 diff changeset	157 set_secondary_super_cache(NULL);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8003 diff changeset	158 _primary_supers[0] = k;
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8003 diff changeset	159 set_super_check_offset(in_bytes(primary_supers_offset()));
0 a61af66fc99e Initial load duke parents: diff changeset	160
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	161 set_java_mirror(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	162 set_modifier_flags(0);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	163 set_layout_helper(Klass::_lh_neutral_value);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	164 set_name(NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	165 AccessFlags af;
a61af66fc99e Initial load duke parents: diff changeset	166 af.set_flags(0);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	167 set_access_flags(af);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	168 set_subklass(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	169 set_next_sibling(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	170 set_next_link(NULL);
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10376 diff changeset	171 TRACE_INIT_ID(this);
0 a61af66fc99e Initial load duke parents: diff changeset	172
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	173 set_prototype_header(markOopDesc::prototype());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	174 set_biased_lock_revocation_count(0);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	175 set_last_biased_lock_bulk_revocation_time(0);
0 a61af66fc99e Initial load duke parents: diff changeset	176
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	177 // The klass doesn't have any references at this point.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	178 clear_modified_oops();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	179 clear_accumulated_modified_oops();
0 a61af66fc99e Initial load duke parents: diff changeset	180 }
a61af66fc99e Initial load duke parents: diff changeset	181
a61af66fc99e Initial load duke parents: diff changeset	182 jint Klass::array_layout_helper(BasicType etype) {
a61af66fc99e Initial load duke parents: diff changeset	183 assert(etype >= T_BOOLEAN && etype <= T_OBJECT, "valid etype");
a61af66fc99e Initial load duke parents: diff changeset	184 // Note that T_ARRAY is not allowed here.
a61af66fc99e Initial load duke parents: diff changeset	185 int hsize = arrayOopDesc::base_offset_in_bytes(etype);
29 d5fc211aea19 6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM kvn parents: 0 diff changeset	186 int esize = type2aelembytes(etype);
0 a61af66fc99e Initial load duke parents: diff changeset	187 bool isobj = (etype == T_OBJECT);
a61af66fc99e Initial load duke parents: diff changeset	188 int tag = isobj ? _lh_array_tag_obj_value : _lh_array_tag_type_value;
a61af66fc99e Initial load duke parents: diff changeset	189 int lh = array_layout_helper(tag, hsize, etype, exact_log2(esize));
a61af66fc99e Initial load duke parents: diff changeset	190
a61af66fc99e Initial load duke parents: diff changeset	191 assert(lh < (int)_lh_neutral_value, "must look like an array layout");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	192 assert(layout_helper_is_array(lh), "correct kind");
0 a61af66fc99e Initial load duke parents: diff changeset	193 assert(layout_helper_is_objArray(lh) == isobj, "correct kind");
a61af66fc99e Initial load duke parents: diff changeset	194 assert(layout_helper_is_typeArray(lh) == !isobj, "correct kind");
a61af66fc99e Initial load duke parents: diff changeset	195 assert(layout_helper_header_size(lh) == hsize, "correct decode");
a61af66fc99e Initial load duke parents: diff changeset	196 assert(layout_helper_element_type(lh) == etype, "correct decode");
a61af66fc99e Initial load duke parents: diff changeset	197 assert(1 << layout_helper_log2_element_size(lh) == esize, "correct decode");
a61af66fc99e Initial load duke parents: diff changeset	198
a61af66fc99e Initial load duke parents: diff changeset	199 return lh;
a61af66fc99e Initial load duke parents: diff changeset	200 }
a61af66fc99e Initial load duke parents: diff changeset	201
a61af66fc99e Initial load duke parents: diff changeset	202 bool Klass::can_be_primary_super_slow() const {
a61af66fc99e Initial load duke parents: diff changeset	203 if (super() == NULL)
a61af66fc99e Initial load duke parents: diff changeset	204 return true;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	205 else if (super()->super_depth() >= primary_super_limit()-1)
0 a61af66fc99e Initial load duke parents: diff changeset	206 return false;
a61af66fc99e Initial load duke parents: diff changeset	207 else
a61af66fc99e Initial load duke parents: diff changeset	208 return true;
a61af66fc99e Initial load duke parents: diff changeset	209 }
a61af66fc99e Initial load duke parents: diff changeset	210
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	211 void Klass::initialize_supers(Klass* k, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	212 if (FastSuperclassLimit == 0) {
a61af66fc99e Initial load duke parents: diff changeset	213 // None of the other machinery matters.
a61af66fc99e Initial load duke parents: diff changeset	214 set_super(k);
a61af66fc99e Initial load duke parents: diff changeset	215 return;
a61af66fc99e Initial load duke parents: diff changeset	216 }
a61af66fc99e Initial load duke parents: diff changeset	217 if (k == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	218 set_super(NULL);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	219 _primary_supers[0] = this;
0 a61af66fc99e Initial load duke parents: diff changeset	220 assert(super_depth() == 0, "Object must already be initialized properly");
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1039 diff changeset	221 } else if (k != super() \|\| k == SystemDictionary::Object_klass()) {
4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1039 diff changeset	222 assert(super() == NULL \|\| super() == SystemDictionary::Object_klass(),
0 a61af66fc99e Initial load duke parents: diff changeset	223 "initialize this only once to a non-trivial value");
a61af66fc99e Initial load duke parents: diff changeset	224 set_super(k);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	225 Klass* sup = k;
0 a61af66fc99e Initial load duke parents: diff changeset	226 int sup_depth = sup->super_depth();
a61af66fc99e Initial load duke parents: diff changeset	227 juint my_depth = MIN2(sup_depth + 1, (int)primary_super_limit());
a61af66fc99e Initial load duke parents: diff changeset	228 if (!can_be_primary_super_slow())
a61af66fc99e Initial load duke parents: diff changeset	229 my_depth = primary_super_limit();
a61af66fc99e Initial load duke parents: diff changeset	230 for (juint i = 0; i < my_depth; i++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	231 _primary_supers[i] = sup->_primary_supers[i];
0 a61af66fc99e Initial load duke parents: diff changeset	232 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	233 Klass* *super_check_cell;
0 a61af66fc99e Initial load duke parents: diff changeset	234 if (my_depth < primary_super_limit()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	235 _primary_supers[my_depth] = this;
0 a61af66fc99e Initial load duke parents: diff changeset	236 super_check_cell = &_primary_supers[my_depth];
a61af66fc99e Initial load duke parents: diff changeset	237 } else {
a61af66fc99e Initial load duke parents: diff changeset	238 // Overflow of the primary_supers array forces me to be secondary.
a61af66fc99e Initial load duke parents: diff changeset	239 super_check_cell = &_secondary_super_cache;
a61af66fc99e Initial load duke parents: diff changeset	240 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	241 set_super_check_offset((address)super_check_cell - (address) this);
0 a61af66fc99e Initial load duke parents: diff changeset	242
a61af66fc99e Initial load duke parents: diff changeset	243 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	244 {
a61af66fc99e Initial load duke parents: diff changeset	245 juint j = super_depth();
a61af66fc99e Initial load duke parents: diff changeset	246 assert(j == my_depth, "computed accessor gets right answer");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	247 Klass* t = this;
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6867 diff changeset	248 while (!t->can_be_primary_super()) {
070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6867 diff changeset	249 t = t->super();
070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6867 diff changeset	250 j = t->super_depth();
0 a61af66fc99e Initial load duke parents: diff changeset	251 }
a61af66fc99e Initial load duke parents: diff changeset	252 for (juint j1 = j+1; j1 < primary_super_limit(); j1++) {
a61af66fc99e Initial load duke parents: diff changeset	253 assert(primary_super_of_depth(j1) == NULL, "super list padding");
a61af66fc99e Initial load duke parents: diff changeset	254 }
a61af66fc99e Initial load duke parents: diff changeset	255 while (t != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	256 assert(primary_super_of_depth(j) == t, "super list initialization");
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6867 diff changeset	257 t = t->super();
0 a61af66fc99e Initial load duke parents: diff changeset	258 --j;
a61af66fc99e Initial load duke parents: diff changeset	259 }
a61af66fc99e Initial load duke parents: diff changeset	260 assert(j == (juint)-1, "correct depth count");
a61af66fc99e Initial load duke parents: diff changeset	261 }
a61af66fc99e Initial load duke parents: diff changeset	262 #endif
a61af66fc99e Initial load duke parents: diff changeset	263 }
a61af66fc99e Initial load duke parents: diff changeset	264
a61af66fc99e Initial load duke parents: diff changeset	265 if (secondary_supers() == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	266 KlassHandle this_kh (THREAD, this);
a61af66fc99e Initial load duke parents: diff changeset	267
a61af66fc99e Initial load duke parents: diff changeset	268 // Now compute the list of secondary supertypes.
a61af66fc99e Initial load duke parents: diff changeset	269 // Secondaries can occasionally be on the super chain,
a61af66fc99e Initial load duke parents: diff changeset	270 // if the inline "_primary_supers" array overflows.
a61af66fc99e Initial load duke parents: diff changeset	271 int extras = 0;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	272 Klass* p;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	273 for (p = super(); !(p == NULL \|\| p->can_be_primary_super()); p = p->super()) {
0 a61af66fc99e Initial load duke parents: diff changeset	274 ++extras;
a61af66fc99e Initial load duke parents: diff changeset	275 }
a61af66fc99e Initial load duke parents: diff changeset	276
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	277 ResourceMark rm(THREAD); // need to reclaim GrowableArrays allocated below
0 a61af66fc99e Initial load duke parents: diff changeset	278
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	279 // Compute the "real" non-extra secondaries.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	280 GrowableArray<Klass> secondaries = compute_secondary_supers(extras);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	281 if (secondaries == NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	282 // secondary_supers set by compute_secondary_supers
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	283 return;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	284 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	285
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	286 GrowableArray<Klass> primaries = new GrowableArray<Klass*>(extras);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	287
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	288 for (p = this_kh->super(); !(p == NULL \|\| p->can_be_primary_super()); p = p->super()) {
0 a61af66fc99e Initial load duke parents: diff changeset	289 int i; // Scan for overflow primaries being duplicates of 2nd'arys
a61af66fc99e Initial load duke parents: diff changeset	290
a61af66fc99e Initial load duke parents: diff changeset	291 // This happens frequently for very deeply nested arrays: the
a61af66fc99e Initial load duke parents: diff changeset	292 // primary superclass chain overflows into the secondary. The
a61af66fc99e Initial load duke parents: diff changeset	293 // secondary list contains the element_klass's secondaries with
a61af66fc99e Initial load duke parents: diff changeset	294 // an extra array dimension added. If the element_klass's
a61af66fc99e Initial load duke parents: diff changeset	295 // secondary list already contains some primary overflows, they
a61af66fc99e Initial load duke parents: diff changeset	296 // (with the extra level of array-ness) will collide with the
a61af66fc99e Initial load duke parents: diff changeset	297 // normal primary superclass overflows.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	298 for( i = 0; i < secondaries->length(); i++ ) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	299 if( secondaries->at(i) == p )
0 a61af66fc99e Initial load duke parents: diff changeset	300 break;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	301 }
0 a61af66fc99e Initial load duke parents: diff changeset	302 if( i < secondaries->length() )
a61af66fc99e Initial load duke parents: diff changeset	303 continue; // It's a dup, don't put it in
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	304 primaries->push(p);
0 a61af66fc99e Initial load duke parents: diff changeset	305 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	306 // Combine the two arrays into a metadata object to pack the array.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	307 // The primaries are added in the reverse order, then the secondaries.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	308 int new_length = primaries->length() + secondaries->length();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	309 Array<Klass> s2 = MetadataFactory::new_array<Klass*>(
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	310 class_loader_data(), new_length, CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	311 int fill_p = primaries->length();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	312 for (int j = 0; j < fill_p; j++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	313 s2->at_put(j, primaries->pop()); // add primaries in reverse order.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	314 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	315 for( int j = 0; j < secondaries->length(); j++ ) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	316 s2->at_put(j+fill_p, secondaries->at(j)); // add secondaries on the end.
0 a61af66fc99e Initial load duke parents: diff changeset	317 }
a61af66fc99e Initial load duke parents: diff changeset	318
a61af66fc99e Initial load duke parents: diff changeset	319 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	320 // We must not copy any NULL placeholders left over from bootstrap.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	321 for (int j = 0; j < s2->length(); j++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	322 assert(s2->at(j) != NULL, "correct bootstrapping order");
0 a61af66fc99e Initial load duke parents: diff changeset	323 }
a61af66fc99e Initial load duke parents: diff changeset	324 #endif
a61af66fc99e Initial load duke parents: diff changeset	325
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	326 this_kh->set_secondary_supers(s2);
0 a61af66fc99e Initial load duke parents: diff changeset	327 }
a61af66fc99e Initial load duke parents: diff changeset	328 }
a61af66fc99e Initial load duke parents: diff changeset	329
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	330 GrowableArray<Klass> Klass::compute_secondary_supers(int num_extra_slots) {
0 a61af66fc99e Initial load duke parents: diff changeset	331 assert(num_extra_slots == 0, "override for complex klasses");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	332 set_secondary_supers(Universe::the_empty_klass_array());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	333 return NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	334 }
a61af66fc99e Initial load duke parents: diff changeset	335
a61af66fc99e Initial load duke parents: diff changeset	336
a61af66fc99e Initial load duke parents: diff changeset	337 Klass* Klass::subklass() const {
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6867 diff changeset	338 return _subklass == NULL ? NULL : _subklass;
0 a61af66fc99e Initial load duke parents: diff changeset	339 }
a61af66fc99e Initial load duke parents: diff changeset	340
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	341 InstanceKlass* Klass::superklass() const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	342 assert(super() == NULL \|\| super()->oop_is_instance(), "must be instance klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	343 return _super == NULL ? NULL : InstanceKlass::cast(_super);
0 a61af66fc99e Initial load duke parents: diff changeset	344 }
a61af66fc99e Initial load duke parents: diff changeset	345
a61af66fc99e Initial load duke parents: diff changeset	346 Klass* Klass::next_sibling() const {
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6867 diff changeset	347 return _next_sibling == NULL ? NULL : _next_sibling;
0 a61af66fc99e Initial load duke parents: diff changeset	348 }
a61af66fc99e Initial load duke parents: diff changeset	349
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	350 void Klass::set_subklass(Klass* s) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	351 assert(s != this, "sanity check");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	352 _subklass = s;
0 a61af66fc99e Initial load duke parents: diff changeset	353 }
a61af66fc99e Initial load duke parents: diff changeset	354
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	355 void Klass::set_next_sibling(Klass* s) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	356 assert(s != this, "sanity check");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	357 _next_sibling = s;
0 a61af66fc99e Initial load duke parents: diff changeset	358 }
a61af66fc99e Initial load duke parents: diff changeset	359
a61af66fc99e Initial load duke parents: diff changeset	360 void Klass::append_to_sibling_list() {
6867 bdb5f8c9978b 7199068: NPG: SharedSkipVerify is meaningless coleenp parents: 6831 diff changeset	361 debug_only(verify();)
0 a61af66fc99e Initial load duke parents: diff changeset	362 // add ourselves to superklass' subklass list
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	363 InstanceKlass* super = superklass();
0 a61af66fc99e Initial load duke parents: diff changeset	364 if (super == NULL) return; // special case: class Object
6867 bdb5f8c9978b 7199068: NPG: SharedSkipVerify is meaningless coleenp parents: 6831 diff changeset	365 assert((!super->is_interface() // interfaces cannot be supers
0 a61af66fc99e Initial load duke parents: diff changeset	366 && (super->superklass() == NULL \|\| !is_interface())),
a61af66fc99e Initial load duke parents: diff changeset	367 "an interface can only be a subklass of Object");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	368 Klass* prev_first_subklass = super->subklass_oop();
0 a61af66fc99e Initial load duke parents: diff changeset	369 if (prev_first_subklass != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	370 // set our sibling to be the superklass' previous first subklass
a61af66fc99e Initial load duke parents: diff changeset	371 set_next_sibling(prev_first_subklass);
a61af66fc99e Initial load duke parents: diff changeset	372 }
a61af66fc99e Initial load duke parents: diff changeset	373 // make ourselves the superklass' first subklass
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	374 super->set_subklass(this);
6867 bdb5f8c9978b 7199068: NPG: SharedSkipVerify is meaningless coleenp parents: 6831 diff changeset	375 debug_only(verify();)
0 a61af66fc99e Initial load duke parents: diff changeset	376 }
a61af66fc99e Initial load duke parents: diff changeset	377
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	378 bool Klass::is_loader_alive(BoolObjectClosure* is_alive) {
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	379 #ifdef ASSERT
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	380 // The class is alive iff the class loader is alive.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	381 oop loader = class_loader();
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	382 bool loader_alive = (loader == NULL) \|\| is_alive->do_object_b(loader);
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	383 #endif // ASSERT
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	384
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	385 // The class is alive if it's mirror is alive (which should be marked if the
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	386 // loader is alive) unless it's an anoymous class.
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	387 bool mirror_alive = is_alive->do_object_b(java_mirror());
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	388 assert(!mirror_alive \|\| loader_alive, "loader must be alive if the mirror is"
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	389 " but not the other way around with anonymous classes");
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	390 return mirror_alive;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	391 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	392
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	393 void Klass::clean_weak_klass_links(BoolObjectClosure* is_alive) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	394 if (!ClassUnloading) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	395 return;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	396 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	397
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	398 Klass* root = SystemDictionary::Object_klass();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	399 Stack<Klass*, mtGC> stack;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	400
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	401 stack.push(root);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	402 while (!stack.is_empty()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	403 Klass* current = stack.pop();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	404
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	405 assert(current->is_loader_alive(is_alive), "just checking, this should be live");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	406
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	407 // Find and set the first alive subklass
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	408 Klass* sub = current->subklass_oop();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	409 while (sub != NULL && !sub->is_loader_alive(is_alive)) {
0 a61af66fc99e Initial load duke parents: diff changeset	410 #ifndef PRODUCT
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	411 if (TraceClassUnloading && WizardMode) {
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	412 ResourceMark rm;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	413 tty->print_cr("[Unlinking class (subclass) %s]", sub->external_name());
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	414 }
0 a61af66fc99e Initial load duke parents: diff changeset	415 #endif
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	416 sub = sub->next_sibling_oop();
0 a61af66fc99e Initial load duke parents: diff changeset	417 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	418 current->set_subklass(sub);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	419 if (sub != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	420 stack.push(sub);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	421 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	422
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	423 // Find and set the first alive sibling
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	424 Klass* sibling = current->next_sibling_oop();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	425 while (sibling != NULL && !sibling->is_loader_alive(is_alive)) {
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	426 if (TraceClassUnloading && WizardMode) {
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	427 ResourceMark rm;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	428 tty->print_cr("[Unlinking class (sibling) %s]", sibling->external_name());
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	429 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	430 sibling = sibling->next_sibling_oop();
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	431 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	432 current->set_next_sibling(sibling);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	433 if (sibling != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	434 stack.push(sibling);
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	435 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	436
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	437 // Clean the implementors list and method data.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	438 if (current->oop_is_instance()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	439 InstanceKlass* ik = InstanceKlass::cast(current);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	440 ik->clean_implementors_list(is_alive);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	441 ik->clean_method_data(is_alive);
0 a61af66fc99e Initial load duke parents: diff changeset	442 }
a61af66fc99e Initial load duke parents: diff changeset	443 }
a61af66fc99e Initial load duke parents: diff changeset	444 }
a61af66fc99e Initial load duke parents: diff changeset	445
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	446 void Klass::klass_update_barrier_set(oop v) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	447 record_modified_oops();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	448 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	449
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	450 void Klass::klass_update_barrier_set_pre(void* p, oop v) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	451 // This barrier used by G1, where it's used remember the old oop values,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	452 // so that we don't forget any objects that were live at the snapshot at
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	453 // the beginning. This function is only used when we write oops into
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	454 // Klasses. Since the Klasses are used as roots in G1, we don't have to
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	455 // do anything here.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	456 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	457
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	458 void Klass::klass_oop_store(oop* p, oop v) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	459 assert(!Universe::heap()->is_in_reserved((void*)p), "Should store pointer into metadata");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	460 assert(v == NULL \|\| Universe::heap()->is_in_reserved((void*)v), "Should store pointer to an object");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	461
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	462 // do the store
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	463 if (always_do_update_barrier) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	464 klass_oop_store((volatile oop*)p, v);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	465 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	466 klass_update_barrier_set_pre((void*)p, v);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	467 *p = v;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	468 klass_update_barrier_set(v);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	469 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	470 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	471
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	472 void Klass::klass_oop_store(volatile oop* p, oop v) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	473 assert(!Universe::heap()->is_in_reserved((void*)p), "Should store pointer into metadata");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	474 assert(v == NULL \|\| Universe::heap()->is_in_reserved((void*)v), "Should store pointer to an object");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	475
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	476 klass_update_barrier_set_pre((void*)p, v);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	477 OrderAccess::release_store_ptr(p, v);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	478 klass_update_barrier_set(v);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	479 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	480
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	481 void Klass::oops_do(OopClosure* cl) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	482 cl->do_oop(&_java_mirror);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	483 }
0 a61af66fc99e Initial load duke parents: diff changeset	484
a61af66fc99e Initial load duke parents: diff changeset	485 void Klass::remove_unshareable_info() {
8751 1fc4d4768b90 8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL) coleenp parents: 8712 diff changeset	486 if (!DumpSharedSpaces) {
1fc4d4768b90 8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL) coleenp parents: 8712 diff changeset	487 // Clean up after OOM during class loading
1fc4d4768b90 8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL) coleenp parents: 8712 diff changeset	488 if (class_loader_data() != NULL) {
1fc4d4768b90 8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL) coleenp parents: 8712 diff changeset	489 class_loader_data()->remove_class(this);
1fc4d4768b90 8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL) coleenp parents: 8712 diff changeset	490 }
1fc4d4768b90 8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL) coleenp parents: 8712 diff changeset	491 }
0 a61af66fc99e Initial load duke parents: diff changeset	492 set_subklass(NULL);
a61af66fc99e Initial load duke parents: diff changeset	493 set_next_sibling(NULL);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	494 // Clear the java mirror
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	495 set_java_mirror(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	496 set_next_link(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	497
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	498 // Null out class_loader_data because we don't share that yet.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	499 set_class_loader_data(NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	500 }
a61af66fc99e Initial load duke parents: diff changeset	501
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	502 void Klass::restore_unshareable_info(TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	503 ClassLoaderData* loader_data = ClassLoaderData::the_null_class_loader_data();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	504 // Restore class_loader_data to the null class loader data
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	505 set_class_loader_data(loader_data);
0 a61af66fc99e Initial load duke parents: diff changeset	506
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	507 // Add to null class loader list first before creating the mirror
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	508 // (same order as class file parsing)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	509 loader_data->add_class(this);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	510
10343 6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	511 // Recreate the class mirror. The protection_domain is always null for
6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	512 // boot loader, for now.
6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	513 java_lang_Class::create_mirror(this, Handle(NULL), CHECK);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	514 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	515
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	516 Klass* Klass::array_klass_or_null(int rank) {
0 a61af66fc99e Initial load duke parents: diff changeset	517 EXCEPTION_MARK;
a61af66fc99e Initial load duke parents: diff changeset	518 // No exception can be thrown by array_klass_impl when called with or_null == true.
a61af66fc99e Initial load duke parents: diff changeset	519 // (In anycase, the execption mark will fail if it do so)
a61af66fc99e Initial load duke parents: diff changeset	520 return array_klass_impl(true, rank, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	521 }
a61af66fc99e Initial load duke parents: diff changeset	522
a61af66fc99e Initial load duke parents: diff changeset	523
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	524 Klass* Klass::array_klass_or_null() {
0 a61af66fc99e Initial load duke parents: diff changeset	525 EXCEPTION_MARK;
a61af66fc99e Initial load duke parents: diff changeset	526 // No exception can be thrown by array_klass_impl when called with or_null == true.
a61af66fc99e Initial load duke parents: diff changeset	527 // (In anycase, the execption mark will fail if it do so)
a61af66fc99e Initial load duke parents: diff changeset	528 return array_klass_impl(true, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	529 }
a61af66fc99e Initial load duke parents: diff changeset	530
a61af66fc99e Initial load duke parents: diff changeset	531
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	532 Klass* Klass::array_klass_impl(bool or_null, int rank, TRAPS) {
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	533 fatal("array_klass should be dispatched to InstanceKlass, ObjArrayKlass or TypeArrayKlass");
0 a61af66fc99e Initial load duke parents: diff changeset	534 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	535 }
a61af66fc99e Initial load duke parents: diff changeset	536
a61af66fc99e Initial load duke parents: diff changeset	537
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	538 Klass* Klass::array_klass_impl(bool or_null, TRAPS) {
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	539 fatal("array_klass should be dispatched to InstanceKlass, ObjArrayKlass or TypeArrayKlass");
0 a61af66fc99e Initial load duke parents: diff changeset	540 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	541 }
a61af66fc99e Initial load duke parents: diff changeset	542
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	543 oop Klass::class_loader() const { return class_loader_data()->class_loader(); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	544
0 a61af66fc99e Initial load duke parents: diff changeset	545 const char* Klass::external_name() const {
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	546 if (oop_is_instance()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	547 InstanceKlass* ik = (InstanceKlass*) this;
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	548 if (ik->is_anonymous()) {
2416 38fea01eb669 6817525: turn on method handle functionality by default for JSR 292 twisti parents: 2177 diff changeset	549 assert(EnableInvokeDynamic, "");
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	550 intptr_t hash = 0;
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	551 if (ik->java_mirror() != NULL) {
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	552 // java_mirror might not be created yet, return 0 as hash.
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	553 hash = ik->java_mirror()->identity_hash();
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	554 }
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	555 char hash_buf[40];
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	556 sprintf(hash_buf, "/" UINTX_FORMAT, (uintx)hash);
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	557 size_t hash_len = strlen(hash_buf);
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	558
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	559 size_t result_len = name()->utf8_length();
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	560 char* result = NEW_RESOURCE_ARRAY(char, result_len + hash_len + 1);
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	561 name()->as_klass_external_name(result, (int) result_len + 1);
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	562 assert(strlen(result) == result_len, "");
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	563 strcpy(result + result_len, hash_buf);
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	564 assert(strlen(result) == result_len + hash_len, "");
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	565 return result;
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	566 }
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	567 }
1039 987e948ebbc8 6815692: method handle code needs some cleanup (post-6655638) jrose parents: 605 diff changeset	568 if (name() == NULL) return "<unknown>";
0 a61af66fc99e Initial load duke parents: diff changeset	569 return name()->as_klass_external_name();
a61af66fc99e Initial load duke parents: diff changeset	570 }
a61af66fc99e Initial load duke parents: diff changeset	571
a61af66fc99e Initial load duke parents: diff changeset	572
1039 987e948ebbc8 6815692: method handle code needs some cleanup (post-6655638) jrose parents: 605 diff changeset	573 const char* Klass::signature_name() const {
987e948ebbc8 6815692: method handle code needs some cleanup (post-6655638) jrose parents: 605 diff changeset	574 if (name() == NULL) return "<unknown>";
0 a61af66fc99e Initial load duke parents: diff changeset	575 return name()->as_C_string();
a61af66fc99e Initial load duke parents: diff changeset	576 }
a61af66fc99e Initial load duke parents: diff changeset	577
a61af66fc99e Initial load duke parents: diff changeset	578 // Unless overridden, modifier_flags is 0.
a61af66fc99e Initial load duke parents: diff changeset	579 jint Klass::compute_modifier_flags(TRAPS) const {
a61af66fc99e Initial load duke parents: diff changeset	580 return 0;
a61af66fc99e Initial load duke parents: diff changeset	581 }
a61af66fc99e Initial load duke parents: diff changeset	582
a61af66fc99e Initial load duke parents: diff changeset	583 int Klass::atomic_incr_biased_lock_revocation_count() {
a61af66fc99e Initial load duke parents: diff changeset	584 return (int) Atomic::add(1, &_biased_lock_revocation_count);
a61af66fc99e Initial load duke parents: diff changeset	585 }
a61af66fc99e Initial load duke parents: diff changeset	586
a61af66fc99e Initial load duke parents: diff changeset	587 // Unless overridden, jvmti_class_status has no flags set.
a61af66fc99e Initial load duke parents: diff changeset	588 jint Klass::jvmti_class_status() const {
a61af66fc99e Initial load duke parents: diff changeset	589 return 0;
a61af66fc99e Initial load duke parents: diff changeset	590 }
a61af66fc99e Initial load duke parents: diff changeset	591
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	592
0 a61af66fc99e Initial load duke parents: diff changeset	593 // Printing
a61af66fc99e Initial load duke parents: diff changeset	594
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	595 void Klass::print_on(outputStream* st) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	596 ResourceMark rm;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	597 // print title
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	598 st->print("%s", internal_name());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	599 print_address_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	600 st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	601 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	602
0 a61af66fc99e Initial load duke parents: diff changeset	603 void Klass::oop_print_on(oop obj, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	604 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	605 // print title
a61af66fc99e Initial load duke parents: diff changeset	606 st->print_cr("%s ", internal_name());
a61af66fc99e Initial load duke parents: diff changeset	607 obj->print_address_on(st);
a61af66fc99e Initial load duke parents: diff changeset	608
a61af66fc99e Initial load duke parents: diff changeset	609 if (WizardMode) {
a61af66fc99e Initial load duke parents: diff changeset	610 // print header
a61af66fc99e Initial load duke parents: diff changeset	611 obj->mark()->print_on(st);
a61af66fc99e Initial load duke parents: diff changeset	612 }
a61af66fc99e Initial load duke parents: diff changeset	613
a61af66fc99e Initial load duke parents: diff changeset	614 // print class
a61af66fc99e Initial load duke parents: diff changeset	615 st->print(" - klass: ");
a61af66fc99e Initial load duke parents: diff changeset	616 obj->klass()->print_value_on(st);
a61af66fc99e Initial load duke parents: diff changeset	617 st->cr();
a61af66fc99e Initial load duke parents: diff changeset	618 }
a61af66fc99e Initial load duke parents: diff changeset	619
a61af66fc99e Initial load duke parents: diff changeset	620 void Klass::oop_print_value_on(oop obj, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	621 // print title
a61af66fc99e Initial load duke parents: diff changeset	622 ResourceMark rm; // Cannot print in debug mode without this
a61af66fc99e Initial load duke parents: diff changeset	623 st->print("%s", internal_name());
a61af66fc99e Initial load duke parents: diff changeset	624 obj->print_address_on(st);
a61af66fc99e Initial load duke parents: diff changeset	625 }
a61af66fc99e Initial load duke parents: diff changeset	626
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7185 diff changeset	627 #if INCLUDE_SERVICES
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7185 diff changeset	628 // Size Statistics
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7185 diff changeset	629 void Klass::collect_statistics(KlassSizeStats *sz) const {
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7185 diff changeset	630 sz->_klass_bytes = sz->count(this);
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7185 diff changeset	631 sz->_mirror_bytes = sz->count(java_mirror());
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7185 diff changeset	632 sz->_secondary_supers_bytes = sz->count_array(secondary_supers());
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7185 diff changeset	633
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7185 diff changeset	634 sz->_ro_bytes += sz->_secondary_supers_bytes;
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7185 diff changeset	635 sz->_rw_bytes += sz->_klass_bytes + sz->_mirror_bytes;
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7185 diff changeset	636 }
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7185 diff changeset	637 #endif // INCLUDE_SERVICES
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	638
0 a61af66fc99e Initial load duke parents: diff changeset	639 // Verification
a61af66fc99e Initial load duke parents: diff changeset	640
17674 85318d1fe8fe 8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on coleenp parents: 17663 diff changeset	641 void Klass::verify_on(outputStream* st) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	642
11034 e0c9a1d29eb4 8016325: JVM hangs verifying system dictionary coleenp parents: 10405 diff changeset	643 // This can be expensive, but it is worth checking that this klass is actually
e0c9a1d29eb4 8016325: JVM hangs verifying system dictionary coleenp parents: 10405 diff changeset	644 // in the CLD graph but not in production.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	645 assert(ClassLoaderDataGraph::contains((address)this), "Should be");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	646
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	647 guarantee(this->is_klass(),"should be klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	648
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	649 if (super() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	650 guarantee(super()->is_klass(), "should be klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	651 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	652 if (secondary_super_cache() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	653 Klass* ko = secondary_super_cache();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	654 guarantee(ko->is_klass(), "should be klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	655 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	656 for ( uint i = 0; i < primary_super_limit(); i++ ) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	657 Klass* ko = _primary_supers[i];
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	658 if (ko != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	659 guarantee(ko->is_klass(), "should be klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	660 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	661 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	662
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	663 if (java_mirror() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	664 guarantee(java_mirror()->is_oop(), "should be instance");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	665 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	666 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	667
0 a61af66fc99e Initial load duke parents: diff changeset	668 void Klass::oop_verify_on(oop obj, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	669 guarantee(obj->is_oop(), "should be oop");
a61af66fc99e Initial load duke parents: diff changeset	670 guarantee(obj->klass()->is_klass(), "klass field is not a klass");
a61af66fc99e Initial load duke parents: diff changeset	671 }
a61af66fc99e Initial load duke parents: diff changeset	672
a61af66fc99e Initial load duke parents: diff changeset	673 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	674
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12146 diff changeset	675 bool Klass::verify_vtable_index(int i) {
0 a61af66fc99e Initial load duke parents: diff changeset	676 if (oop_is_instance()) {
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12146 diff changeset	677 int limit = ((InstanceKlass*)this)->vtable_length()/vtableEntry::size();
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12146 diff changeset	678 assert(i >= 0 && i < limit, err_msg("index %d out of bounds %d", i, limit));
0 a61af66fc99e Initial load duke parents: diff changeset	679 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	680 assert(oop_is_array(), "Must be");
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12146 diff changeset	681 int limit = ((ArrayKlass*)this)->vtable_length()/vtableEntry::size();
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12146 diff changeset	682 assert(i >= 0 && i < limit, err_msg("index %d out of bounds %d", i, limit));
0 a61af66fc99e Initial load duke parents: diff changeset	683 }
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12146 diff changeset	684 return true;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12146 diff changeset	685 }
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12146 diff changeset	686
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12146 diff changeset	687 bool Klass::verify_itable_index(int i) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12146 diff changeset	688 assert(oop_is_instance(), "");
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12146 diff changeset	689 int method_count = klassItable::method_count_for_interface(this);
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12146 diff changeset	690 assert(i >= 0 && i < method_count, "index out of bounds");
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 12146 diff changeset	691 return true;
0 a61af66fc99e Initial load duke parents: diff changeset	692 }
a61af66fc99e Initial load duke parents: diff changeset	693
a61af66fc99e Initial load duke parents: diff changeset	694 #endif

Mercurial > hg > truffle

annotate src/share/vm/oops/klass.cpp @ 17716:cdb71841f4bc