graal-compiler: src/share/vm/oops/klass.cpp annotate

annotate src/share/vm/oops/klass.cpp @ 10185:d50cc62e94ff

8012715: G1: GraphKit accesses PtrQueue::_index as int but is size_t Summary: In graphKit INT operations were generated to access PtrQueue::_index which has type size_t. This is 64 bit on 64-bit machines. No problems occur on little endian machines as long as the index fits into 32 bit, but on big endian machines the upper part is read, which is zero. This leads to unnecessary branches to the slow path in the runtime. Reviewed-by: twisti, johnc Contributed-by: Martin Doerr <martin.doerr@sap.com>

author	johnc
date	Wed, 24 Apr 2013 14:48:43 -0700
parents	1fc4d4768b90
children	b9a918201d47 92ef81e2f571

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7185 diff changeset	2 * Copyright (c) 1997, 2013, 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"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	40 #include "utilities/stack.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7185 diff changeset	41 #include "utilities/macros.hpp"
db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7185 diff changeset	42 #if INCLUDE_ALL_GCS
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	43 #include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	44 #include "gc_implementation/parallelScavenge/psPromotionManager.hpp"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	45 #include "gc_implementation/parallelScavenge/psScavenge.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7185 diff changeset	46 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	47
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	48 void Klass::set_name(Symbol* n) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	49 _name = n;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	50 if (_name != NULL) _name->increment_refcount();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	51 }
0 a61af66fc99e Initial load duke parents: diff changeset	52
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	53 bool Klass::is_subclass_of(Klass* k) const {
0 a61af66fc99e Initial load duke parents: diff changeset	54 // Run up the super chain and check
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	55 if (this == k) return true;
0 a61af66fc99e Initial load duke parents: diff changeset	56
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	57 Klass* t = const_cast<Klass*>(this)->super();
0 a61af66fc99e Initial load duke parents: diff changeset	58
a61af66fc99e Initial load duke parents: diff changeset	59 while (t != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	60 if (t == k) return true;
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6867 diff changeset	61 t = t->super();
0 a61af66fc99e Initial load duke parents: diff changeset	62 }
a61af66fc99e Initial load duke parents: diff changeset	63 return false;
a61af66fc99e Initial load duke parents: diff changeset	64 }
a61af66fc99e Initial load duke parents: diff changeset	65
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	66 bool Klass::search_secondary_supers(Klass* k) const {
0 a61af66fc99e Initial load duke parents: diff changeset	67 // Put some extra logic here out-of-line, before the search proper.
a61af66fc99e Initial load duke parents: diff changeset	68 // This cuts down the size of the inline method.
a61af66fc99e Initial load duke parents: diff changeset	69
a61af66fc99e Initial load duke parents: diff changeset	70 // 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	71 if (this == k)
0 a61af66fc99e Initial load duke parents: diff changeset	72 return true;
a61af66fc99e Initial load duke parents: diff changeset	73 // Scan the array-of-objects for a match
a61af66fc99e Initial load duke parents: diff changeset	74 int cnt = secondary_supers()->length();
a61af66fc99e Initial load duke parents: diff changeset	75 for (int i = 0; i < cnt; i++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	76 if (secondary_supers()->at(i) == k) {
0 a61af66fc99e Initial load duke parents: diff changeset	77 ((Klass*)this)->set_secondary_super_cache(k);
a61af66fc99e Initial load duke parents: diff changeset	78 return true;
a61af66fc99e Initial load duke parents: diff changeset	79 }
a61af66fc99e Initial load duke parents: diff changeset	80 }
a61af66fc99e Initial load duke parents: diff changeset	81 return false;
a61af66fc99e Initial load duke parents: diff changeset	82 }
a61af66fc99e Initial load duke parents: diff changeset	83
a61af66fc99e Initial load duke parents: diff changeset	84 // Return self, except for abstract classes with exactly 1
a61af66fc99e Initial load duke parents: diff changeset	85 // implementor. Then return the 1 concrete implementation.
a61af66fc99e Initial load duke parents: diff changeset	86 Klass *Klass::up_cast_abstract() {
a61af66fc99e Initial load duke parents: diff changeset	87 Klass *r = this;
a61af66fc99e Initial load duke parents: diff changeset	88 while( r->is_abstract() ) { // Receiver is abstract?
a61af66fc99e Initial load duke parents: diff changeset	89 Klass *s = r->subklass(); // Check for exactly 1 subklass
a61af66fc99e Initial load duke parents: diff changeset	90 if( !s \|\| s->next_sibling() ) // Oops; wrong count; give up
a61af66fc99e Initial load duke parents: diff changeset	91 return this; // Return 'this' as a no-progress flag
a61af66fc99e Initial load duke parents: diff changeset	92 r = s; // Loop till find concrete class
a61af66fc99e Initial load duke parents: diff changeset	93 }
a61af66fc99e Initial load duke parents: diff changeset	94 return r; // Return the 1 concrete class
a61af66fc99e Initial load duke parents: diff changeset	95 }
a61af66fc99e Initial load duke parents: diff changeset	96
605 98cb887364d3 6810672: Comment typos twisti parents: 431 diff changeset	97 // Find LCA in class hierarchy
0 a61af66fc99e Initial load duke parents: diff changeset	98 Klass Klass::LCA( Klass k2 ) {
a61af66fc99e Initial load duke parents: diff changeset	99 Klass *k1 = this;
a61af66fc99e Initial load duke parents: diff changeset	100 while( 1 ) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	101 if( k1->is_subtype_of(k2) ) return k2;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	102 if( k2->is_subtype_of(k1) ) return k1;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	103 k1 = k1->super();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	104 k2 = k2->super();
0 a61af66fc99e Initial load duke parents: diff changeset	105 }
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 void Klass::check_valid_for_instantiation(bool throwError, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	110 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	111 THROW_MSG(throwError ? vmSymbols::java_lang_InstantiationError()
a61af66fc99e Initial load duke parents: diff changeset	112 : vmSymbols::java_lang_InstantiationException(), external_name());
a61af66fc99e Initial load duke parents: diff changeset	113 }
a61af66fc99e Initial load duke parents: diff changeset	114
a61af66fc99e Initial load duke parents: diff changeset	115
a61af66fc99e Initial load duke parents: diff changeset	116 void Klass::copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	117 THROW(vmSymbols::java_lang_ArrayStoreException());
a61af66fc99e Initial load duke parents: diff changeset	118 }
a61af66fc99e Initial load duke parents: diff changeset	119
a61af66fc99e Initial load duke parents: diff changeset	120
a61af66fc99e Initial load duke parents: diff changeset	121 void Klass::initialize(TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	122 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	123 }
a61af66fc99e Initial load duke parents: diff changeset	124
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	125 bool Klass::compute_is_subtype_of(Klass* k) {
0 a61af66fc99e Initial load duke parents: diff changeset	126 assert(k->is_klass(), "argument must be a class");
a61af66fc99e Initial load duke parents: diff changeset	127 return is_subclass_of(k);
a61af66fc99e Initial load duke parents: diff changeset	128 }
a61af66fc99e Initial load duke parents: diff changeset	129
a61af66fc99e Initial load duke parents: diff changeset	130
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	131 Method* Klass::uncached_lookup_method(Symbol* name, Symbol* signature) const {
0 a61af66fc99e Initial load duke parents: diff changeset	132 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	133 tty->print_cr("Error: uncached_lookup_method called on a klass oop."
a61af66fc99e Initial load duke parents: diff changeset	134 " Likely error: reflection method does not correctly"
a61af66fc99e Initial load duke parents: diff changeset	135 " wrap return value in a mirror object.");
a61af66fc99e Initial load duke parents: diff changeset	136 #endif
a61af66fc99e Initial load duke parents: diff changeset	137 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	138 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	139 }
a61af66fc99e Initial load duke parents: diff changeset	140
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	141 void* Klass::operator new(size_t size, ClassLoaderData* loader_data, size_t word_size, TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	142 return Metaspace::allocate(loader_data, word_size, /read_only/false,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	143 Metaspace::ClassType, CHECK_NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	144 }
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 Klass::Klass() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	147 Klass* k = this;
0 a61af66fc99e Initial load duke parents: diff changeset	148
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8003 diff changeset	149 // Preinitialize supertype information.
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8003 diff changeset	150 // 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	151 set_super(NULL);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8003 diff changeset	152 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	153 _primary_supers[i] = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	154 }
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8003 diff changeset	155 set_secondary_supers(NULL);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8003 diff changeset	156 set_secondary_super_cache(NULL);
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8003 diff changeset	157 _primary_supers[0] = k;
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8003 diff changeset	158 set_super_check_offset(in_bytes(primary_supers_offset()));
0 a61af66fc99e Initial load duke parents: diff changeset	159
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	160 set_java_mirror(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	161 set_modifier_flags(0);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	162 set_layout_helper(Klass::_lh_neutral_value);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	163 set_name(NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	164 AccessFlags af;
a61af66fc99e Initial load duke parents: diff changeset	165 af.set_flags(0);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	166 set_access_flags(af);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	167 set_subklass(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	168 set_next_sibling(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	169 set_next_link(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	170 set_alloc_count(0);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	171 TRACE_SET_KLASS_TRACE_ID(this, 0);
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) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	379 assert(is_metadata(), "p is not meta-data");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	380 assert(ClassLoaderDataGraph::contains((address)this), "is in the metaspace");
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	381
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	382 #ifdef ASSERT
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	383 // 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	384 oop loader = class_loader();
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	385 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	386 #endif // ASSERT
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	387
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	388 // 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	389 // 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	390 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	391 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	392 " 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	393 return mirror_alive;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	394 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	395
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	396 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	397 if (!ClassUnloading) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	398 return;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	399 }
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 Klass* root = SystemDictionary::Object_klass();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	402 Stack<Klass*, mtGC> stack;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	403
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	404 stack.push(root);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	405 while (!stack.is_empty()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	406 Klass* current = stack.pop();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	407
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	408 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	409
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	410 // Find and set the first alive subklass
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	411 Klass* sub = current->subklass_oop();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	412 while (sub != NULL && !sub->is_loader_alive(is_alive)) {
0 a61af66fc99e Initial load duke parents: diff changeset	413 #ifndef PRODUCT
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	414 if (TraceClassUnloading && WizardMode) {
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	415 ResourceMark rm;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	416 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	417 }
0 a61af66fc99e Initial load duke parents: diff changeset	418 #endif
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	419 sub = sub->next_sibling_oop();
0 a61af66fc99e Initial load duke parents: diff changeset	420 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	421 current->set_subklass(sub);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	422 if (sub != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	423 stack.push(sub);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	424 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	425
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	426 // Find and set the first alive sibling
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	427 Klass* sibling = current->next_sibling_oop();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	428 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	429 if (TraceClassUnloading && WizardMode) {
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	430 ResourceMark rm;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	431 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	432 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	433 sibling = sibling->next_sibling_oop();
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	434 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	435 current->set_next_sibling(sibling);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	436 if (sibling != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	437 stack.push(sibling);
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	438 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	439
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	440 // Clean the implementors list and method data.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	441 if (current->oop_is_instance()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	442 InstanceKlass* ik = InstanceKlass::cast(current);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	443 ik->clean_implementors_list(is_alive);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	444 ik->clean_method_data(is_alive);
0 a61af66fc99e Initial load duke parents: diff changeset	445 }
a61af66fc99e Initial load duke parents: diff changeset	446 }
a61af66fc99e Initial load duke parents: diff changeset	447 }
a61af66fc99e Initial load duke parents: diff changeset	448
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	449 void Klass::klass_update_barrier_set(oop v) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	450 record_modified_oops();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	451 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	452
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	453 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	454 // 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	455 // 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	456 // 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	457 // 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	458 // do anything here.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	459 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	460
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	461 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	462 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	463 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	464
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	465 // do the store
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	466 if (always_do_update_barrier) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	467 klass_oop_store((volatile oop*)p, v);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	468 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	469 klass_update_barrier_set_pre((void*)p, v);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	470 *p = v;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	471 klass_update_barrier_set(v);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	472 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	473 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	474
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	475 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	476 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	477 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	478
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	479 klass_update_barrier_set_pre((void*)p, v);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	480 OrderAccess::release_store_ptr(p, v);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	481 klass_update_barrier_set(v);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	482 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	483
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	484 void Klass::oops_do(OopClosure* cl) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	485 cl->do_oop(&_java_mirror);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	486 }
0 a61af66fc99e Initial load duke parents: diff changeset	487
a61af66fc99e Initial load duke parents: diff changeset	488 void Klass::remove_unshareable_info() {
8751 1fc4d4768b90 8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL) coleenp parents: 8712 diff changeset	489 if (!DumpSharedSpaces) {
1fc4d4768b90 8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL) coleenp parents: 8712 diff changeset	490 // 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	491 if (class_loader_data() != NULL) {
1fc4d4768b90 8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL) coleenp parents: 8712 diff changeset	492 class_loader_data()->remove_class(this);
1fc4d4768b90 8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL) coleenp parents: 8712 diff changeset	493 }
1fc4d4768b90 8007725: NPG: Klass::restore_unshareable_info() triggers assert(k->java_mirror() == NULL) coleenp parents: 8712 diff changeset	494 }
0 a61af66fc99e Initial load duke parents: diff changeset	495 set_subklass(NULL);
a61af66fc99e Initial load duke parents: diff changeset	496 set_next_sibling(NULL);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	497 // Clear the java mirror
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	498 set_java_mirror(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	499 set_next_link(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	500
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	501 // 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	502 set_class_loader_data(NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	503 }
a61af66fc99e Initial load duke parents: diff changeset	504
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	505 void Klass::restore_unshareable_info(TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	506 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	507 // 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	508 set_class_loader_data(loader_data);
0 a61af66fc99e Initial load duke parents: diff changeset	509
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	510 // 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	511 // (same order as class file parsing)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	512 loader_data->add_class(this);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	513
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	514 // Recreate the class mirror
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	515 java_lang_Class::create_mirror(this, CHECK);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	516 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	517
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	518 Klass* Klass::array_klass_or_null(int rank) {
0 a61af66fc99e Initial load duke parents: diff changeset	519 EXCEPTION_MARK;
a61af66fc99e Initial load duke parents: diff changeset	520 // No exception can be thrown by array_klass_impl when called with or_null == true.
a61af66fc99e Initial load duke parents: diff changeset	521 // (In anycase, the execption mark will fail if it do so)
a61af66fc99e Initial load duke parents: diff changeset	522 return array_klass_impl(true, rank, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	523 }
a61af66fc99e Initial load duke parents: diff changeset	524
a61af66fc99e Initial load duke parents: diff changeset	525
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	526 Klass* Klass::array_klass_or_null() {
0 a61af66fc99e Initial load duke parents: diff changeset	527 EXCEPTION_MARK;
a61af66fc99e Initial load duke parents: diff changeset	528 // No exception can be thrown by array_klass_impl when called with or_null == true.
a61af66fc99e Initial load duke parents: diff changeset	529 // (In anycase, the execption mark will fail if it do so)
a61af66fc99e Initial load duke parents: diff changeset	530 return array_klass_impl(true, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	531 }
a61af66fc99e Initial load duke parents: diff changeset	532
a61af66fc99e Initial load duke parents: diff changeset	533
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	534 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	535 fatal("array_klass should be dispatched to InstanceKlass, ObjArrayKlass or TypeArrayKlass");
0 a61af66fc99e Initial load duke parents: diff changeset	536 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	537 }
a61af66fc99e Initial load duke parents: diff changeset	538
a61af66fc99e Initial load duke parents: diff changeset	539
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	540 Klass* Klass::array_klass_impl(bool or_null, TRAPS) {
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	541 fatal("array_klass should be dispatched to InstanceKlass, ObjArrayKlass or TypeArrayKlass");
0 a61af66fc99e Initial load duke parents: diff changeset	542 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	543 }
a61af66fc99e Initial load duke parents: diff changeset	544
a61af66fc99e Initial load duke parents: diff changeset	545
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	546 void Klass::with_array_klasses_do(void f(Klass* k)) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	547 f(this);
0 a61af66fc99e Initial load duke parents: diff changeset	548 }
a61af66fc99e Initial load duke parents: diff changeset	549
a61af66fc99e Initial load duke parents: diff changeset	550
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	551 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	552
0 a61af66fc99e Initial load duke parents: diff changeset	553 const char* Klass::external_name() const {
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	554 if (oop_is_instance()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	555 InstanceKlass* ik = (InstanceKlass*) this;
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	556 if (ik->is_anonymous()) {
2416 38fea01eb669 6817525: turn on method handle functionality by default for JSR 292 twisti parents: 2177 diff changeset	557 assert(EnableInvokeDynamic, "");
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	558 intptr_t hash = 0;
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	559 if (ik->java_mirror() != NULL) {
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	560 // 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	561 hash = ik->java_mirror()->identity_hash();
90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6983 diff changeset	562 }
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	563 char hash_buf[40];
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	564 sprintf(hash_buf, "/" UINTX_FORMAT, (uintx)hash);
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	565 size_t hash_len = strlen(hash_buf);
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 size_t result_len = name()->utf8_length();
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	568 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	569 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	570 assert(strlen(result) == result_len, "");
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	571 strcpy(result + result_len, hash_buf);
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	572 assert(strlen(result) == result_len + hash_len, "");
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	573 return result;
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	574 }
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	575 }
1039 987e948ebbc8 6815692: method handle code needs some cleanup (post-6655638) jrose parents: 605 diff changeset	576 if (name() == NULL) return "<unknown>";
0 a61af66fc99e Initial load duke parents: diff changeset	577 return name()->as_klass_external_name();
a61af66fc99e Initial load duke parents: diff changeset	578 }
a61af66fc99e Initial load duke parents: diff changeset	579
a61af66fc99e Initial load duke parents: diff changeset	580
1039 987e948ebbc8 6815692: method handle code needs some cleanup (post-6655638) jrose parents: 605 diff changeset	581 const char* Klass::signature_name() const {
987e948ebbc8 6815692: method handle code needs some cleanup (post-6655638) jrose parents: 605 diff changeset	582 if (name() == NULL) return "<unknown>";
0 a61af66fc99e Initial load duke parents: diff changeset	583 return name()->as_C_string();
a61af66fc99e Initial load duke parents: diff changeset	584 }
a61af66fc99e Initial load duke parents: diff changeset	585
a61af66fc99e Initial load duke parents: diff changeset	586 // Unless overridden, modifier_flags is 0.
a61af66fc99e Initial load duke parents: diff changeset	587 jint Klass::compute_modifier_flags(TRAPS) const {
a61af66fc99e Initial load duke parents: diff changeset	588 return 0;
a61af66fc99e Initial load duke parents: diff changeset	589 }
a61af66fc99e Initial load duke parents: diff changeset	590
a61af66fc99e Initial load duke parents: diff changeset	591 int Klass::atomic_incr_biased_lock_revocation_count() {
a61af66fc99e Initial load duke parents: diff changeset	592 return (int) Atomic::add(1, &_biased_lock_revocation_count);
a61af66fc99e Initial load duke parents: diff changeset	593 }
a61af66fc99e Initial load duke parents: diff changeset	594
a61af66fc99e Initial load duke parents: diff changeset	595 // Unless overridden, jvmti_class_status has no flags set.
a61af66fc99e Initial load duke parents: diff changeset	596 jint Klass::jvmti_class_status() const {
a61af66fc99e Initial load duke parents: diff changeset	597 return 0;
a61af66fc99e Initial load duke parents: diff changeset	598 }
a61af66fc99e Initial load duke parents: diff changeset	599
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	600
0 a61af66fc99e Initial load duke parents: diff changeset	601 // Printing
a61af66fc99e Initial load duke parents: diff changeset	602
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	603 void Klass::print_on(outputStream* st) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	604 ResourceMark rm;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	605 // print title
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	606 st->print("%s", internal_name());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	607 print_address_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	608 st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	609 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	610
0 a61af66fc99e Initial load duke parents: diff changeset	611 void Klass::oop_print_on(oop obj, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	612 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	613 // print title
a61af66fc99e Initial load duke parents: diff changeset	614 st->print_cr("%s ", internal_name());
a61af66fc99e Initial load duke parents: diff changeset	615 obj->print_address_on(st);
a61af66fc99e Initial load duke parents: diff changeset	616
a61af66fc99e Initial load duke parents: diff changeset	617 if (WizardMode) {
a61af66fc99e Initial load duke parents: diff changeset	618 // print header
a61af66fc99e Initial load duke parents: diff changeset	619 obj->mark()->print_on(st);
a61af66fc99e Initial load duke parents: diff changeset	620 }
a61af66fc99e Initial load duke parents: diff changeset	621
a61af66fc99e Initial load duke parents: diff changeset	622 // print class
a61af66fc99e Initial load duke parents: diff changeset	623 st->print(" - klass: ");
a61af66fc99e Initial load duke parents: diff changeset	624 obj->klass()->print_value_on(st);
a61af66fc99e Initial load duke parents: diff changeset	625 st->cr();
a61af66fc99e Initial load duke parents: diff changeset	626 }
a61af66fc99e Initial load duke parents: diff changeset	627
a61af66fc99e Initial load duke parents: diff changeset	628 void Klass::oop_print_value_on(oop obj, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	629 // print title
a61af66fc99e Initial load duke parents: diff changeset	630 ResourceMark rm; // Cannot print in debug mode without this
a61af66fc99e Initial load duke parents: diff changeset	631 st->print("%s", internal_name());
a61af66fc99e Initial load duke parents: diff changeset	632 obj->print_address_on(st);
a61af66fc99e Initial load duke parents: diff changeset	633 }
a61af66fc99e Initial load duke parents: diff changeset	634
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7185 diff changeset	635 #if INCLUDE_SERVICES
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7185 diff changeset	636 // Size Statistics
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7185 diff changeset	637 void Klass::collect_statistics(KlassSizeStats *sz) const {
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7185 diff changeset	638 sz->_klass_bytes = sz->count(this);
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7185 diff changeset	639 sz->_mirror_bytes = sz->count(java_mirror());
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7185 diff changeset	640 sz->_secondary_supers_bytes = sz->count_array(secondary_supers());
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7185 diff changeset	641
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7185 diff changeset	642 sz->_ro_bytes += sz->_secondary_supers_bytes;
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7185 diff changeset	643 sz->_rw_bytes += sz->_klass_bytes + sz->_mirror_bytes;
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7185 diff changeset	644 }
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7185 diff changeset	645 #endif // INCLUDE_SERVICES
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	646
0 a61af66fc99e Initial load duke parents: diff changeset	647 // Verification
a61af66fc99e Initial load duke parents: diff changeset	648
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	649 void Klass::verify_on(outputStream* st) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	650 guarantee(!Universe::heap()->is_in_reserved(this), "Shouldn't be");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	651 guarantee(this->is_metadata(), "should be in metaspace");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	652
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	653 assert(ClassLoaderDataGraph::contains((address)this), "Should be");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	654
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	655 guarantee(this->is_klass(),"should be klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	656
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	657 if (super() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	658 guarantee(super()->is_metadata(), "should be in metaspace");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	659 guarantee(super()->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 if (secondary_super_cache() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	662 Klass* ko = secondary_super_cache();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	663 guarantee(ko->is_metadata(), "should be in metaspace");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	664 guarantee(ko->is_klass(), "should be klass");
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 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	667 Klass* ko = _primary_supers[i];
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	668 if (ko != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	669 guarantee(ko->is_metadata(), "should be in metaspace");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	670 guarantee(ko->is_klass(), "should be klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	671 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	672 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	673
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	674 if (java_mirror() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	675 guarantee(java_mirror()->is_oop(), "should be instance");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	676 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	677 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	678
0 a61af66fc99e Initial load duke parents: diff changeset	679 void Klass::oop_verify_on(oop obj, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	680 guarantee(obj->is_oop(), "should be oop");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	681 guarantee(obj->klass()->is_metadata(), "should not be in Java heap");
0 a61af66fc99e Initial load duke parents: diff changeset	682 guarantee(obj->klass()->is_klass(), "klass field is not a klass");
a61af66fc99e Initial load duke parents: diff changeset	683 }
a61af66fc99e Initial load duke parents: diff changeset	684
a61af66fc99e Initial load duke parents: diff changeset	685 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	686
a61af66fc99e Initial load duke parents: diff changeset	687 void Klass::verify_vtable_index(int i) {
a61af66fc99e Initial load duke parents: diff changeset	688 if (oop_is_instance()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	689 assert(i>=0 && i<((InstanceKlass*)this)->vtable_length()/vtableEntry::size(), "index out of bounds");
0 a61af66fc99e Initial load duke parents: diff changeset	690 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	691 assert(oop_is_array(), "Must be");
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	692 assert(i>=0 && i<((ArrayKlass*)this)->vtable_length()/vtableEntry::size(), "index out of bounds");
0 a61af66fc99e Initial load duke parents: diff changeset	693 }
a61af66fc99e Initial load duke parents: diff changeset	694 }
a61af66fc99e Initial load duke parents: diff changeset	695
a61af66fc99e Initial load duke parents: diff changeset	696 #endif

Mercurial > hg > graal-compiler

annotate src/share/vm/oops/klass.cpp @ 10185:d50cc62e94ff