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

annotate src/share/vm/oops/klass.cpp @ 6862:8a5ea0a9ccc4

7127708: G1: change task num types from int to uint in concurrent mark Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich. Reviewed-by: johnc Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>

author	johnc
date	Sat, 06 Oct 2012 01:17:44 -0700
parents	da91efe96a93
children	d8ce2825b193

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
5972 9a9bb0010c91 7156764: Remove unused size parameter from some CollectedHeap methods brutisso parents: 4860 diff changeset	2 * Copyright (c) 1997, 2012, 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"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	32 #include "memory/metadataFactory.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	33 #include "memory/oopFactory.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	34 #include "memory/resourceArea.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	35 #include "oops/instanceKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	36 #include "oops/klass.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	37 #include "oops/oop.inline2.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1681 diff changeset	38 #include "runtime/atomic.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	39 #include "utilities/stack.hpp"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	40 #ifndef SERIALGC
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	41 #include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	42 #include "gc_implementation/parallelScavenge/psPromotionManager.hpp"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	43 #include "gc_implementation/parallelScavenge/psScavenge.hpp"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	44 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	45
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	46 void Klass::set_name(Symbol* n) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	47 _name = n;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	48 if (_name != NULL) _name->increment_refcount();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	49 }
0 a61af66fc99e Initial load duke parents: diff changeset	50
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	51 bool Klass::is_subclass_of(Klass* k) const {
0 a61af66fc99e Initial load duke parents: diff changeset	52 // Run up the super chain and check
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	53 if (this == k) return true;
0 a61af66fc99e Initial load duke parents: diff changeset	54
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	55 Klass* t = const_cast<Klass*>(this)->super();
0 a61af66fc99e Initial load duke parents: diff changeset	56
a61af66fc99e Initial load duke parents: diff changeset	57 while (t != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	58 if (t == k) return true;
a61af66fc99e Initial load duke parents: diff changeset	59 t = Klass::cast(t)->super();
a61af66fc99e Initial load duke parents: diff changeset	60 }
a61af66fc99e Initial load duke parents: diff changeset	61 return false;
a61af66fc99e Initial load duke parents: diff changeset	62 }
a61af66fc99e Initial load duke parents: diff changeset	63
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	64 bool Klass::search_secondary_supers(Klass* k) const {
0 a61af66fc99e Initial load duke parents: diff changeset	65 // Put some extra logic here out-of-line, before the search proper.
a61af66fc99e Initial load duke parents: diff changeset	66 // This cuts down the size of the inline method.
a61af66fc99e Initial load duke parents: diff changeset	67
a61af66fc99e Initial load duke parents: diff changeset	68 // 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	69 if (this == k)
0 a61af66fc99e Initial load duke parents: diff changeset	70 return true;
a61af66fc99e Initial load duke parents: diff changeset	71 // Scan the array-of-objects for a match
a61af66fc99e Initial load duke parents: diff changeset	72 int cnt = secondary_supers()->length();
a61af66fc99e Initial load duke parents: diff changeset	73 for (int i = 0; i < cnt; i++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	74 if (secondary_supers()->at(i) == k) {
0 a61af66fc99e Initial load duke parents: diff changeset	75 ((Klass*)this)->set_secondary_super_cache(k);
a61af66fc99e Initial load duke parents: diff changeset	76 return true;
a61af66fc99e Initial load duke parents: diff changeset	77 }
a61af66fc99e Initial load duke parents: diff changeset	78 }
a61af66fc99e Initial load duke parents: diff changeset	79 return false;
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 self, except for abstract classes with exactly 1
a61af66fc99e Initial load duke parents: diff changeset	83 // implementor. Then return the 1 concrete implementation.
a61af66fc99e Initial load duke parents: diff changeset	84 Klass *Klass::up_cast_abstract() {
a61af66fc99e Initial load duke parents: diff changeset	85 Klass *r = this;
a61af66fc99e Initial load duke parents: diff changeset	86 while( r->is_abstract() ) { // Receiver is abstract?
a61af66fc99e Initial load duke parents: diff changeset	87 Klass *s = r->subklass(); // Check for exactly 1 subklass
a61af66fc99e Initial load duke parents: diff changeset	88 if( !s \|\| s->next_sibling() ) // Oops; wrong count; give up
a61af66fc99e Initial load duke parents: diff changeset	89 return this; // Return 'this' as a no-progress flag
a61af66fc99e Initial load duke parents: diff changeset	90 r = s; // Loop till find concrete class
a61af66fc99e Initial load duke parents: diff changeset	91 }
a61af66fc99e Initial load duke parents: diff changeset	92 return r; // Return the 1 concrete class
a61af66fc99e Initial load duke parents: diff changeset	93 }
a61af66fc99e Initial load duke parents: diff changeset	94
605 98cb887364d3 6810672: Comment typos twisti parents: 431 diff changeset	95 // Find LCA in class hierarchy
0 a61af66fc99e Initial load duke parents: diff changeset	96 Klass Klass::LCA( Klass k2 ) {
a61af66fc99e Initial load duke parents: diff changeset	97 Klass *k1 = this;
a61af66fc99e Initial load duke parents: diff changeset	98 while( 1 ) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	99 if( k1->is_subtype_of(k2) ) return k2;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	100 if( k2->is_subtype_of(k1) ) return k1;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	101 k1 = k1->super();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	102 k2 = k2->super();
0 a61af66fc99e Initial load duke parents: diff changeset	103 }
a61af66fc99e Initial load duke parents: diff changeset	104 }
a61af66fc99e Initial load duke parents: diff changeset	105
a61af66fc99e Initial load duke parents: diff changeset	106
a61af66fc99e Initial load duke parents: diff changeset	107 void Klass::check_valid_for_instantiation(bool throwError, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	108 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	109 THROW_MSG(throwError ? vmSymbols::java_lang_InstantiationError()
a61af66fc99e Initial load duke parents: diff changeset	110 : vmSymbols::java_lang_InstantiationException(), external_name());
a61af66fc99e Initial load duke parents: diff changeset	111 }
a61af66fc99e Initial load duke parents: diff changeset	112
a61af66fc99e Initial load duke parents: diff changeset	113
a61af66fc99e Initial load duke parents: diff changeset	114 void Klass::copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	115 THROW(vmSymbols::java_lang_ArrayStoreException());
a61af66fc99e Initial load duke parents: diff changeset	116 }
a61af66fc99e Initial load duke parents: diff changeset	117
a61af66fc99e Initial load duke parents: diff changeset	118
a61af66fc99e Initial load duke parents: diff changeset	119 void Klass::initialize(TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	120 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	121 }
a61af66fc99e Initial load duke parents: diff changeset	122
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	123 bool Klass::compute_is_subtype_of(Klass* k) {
0 a61af66fc99e Initial load duke parents: diff changeset	124 assert(k->is_klass(), "argument must be a class");
a61af66fc99e Initial load duke parents: diff changeset	125 return is_subclass_of(k);
a61af66fc99e Initial load duke parents: diff changeset	126 }
a61af66fc99e Initial load duke parents: diff changeset	127
a61af66fc99e Initial load duke parents: diff changeset	128
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	129 Method* Klass::uncached_lookup_method(Symbol* name, Symbol* signature) const {
0 a61af66fc99e Initial load duke parents: diff changeset	130 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	131 tty->print_cr("Error: uncached_lookup_method called on a klass oop."
a61af66fc99e Initial load duke parents: diff changeset	132 " Likely error: reflection method does not correctly"
a61af66fc99e Initial load duke parents: diff changeset	133 " wrap return value in a mirror object.");
a61af66fc99e Initial load duke parents: diff changeset	134 #endif
a61af66fc99e Initial load duke parents: diff changeset	135 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	136 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	137 }
a61af66fc99e Initial load duke parents: diff changeset	138
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	139 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	140 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	141 Metaspace::ClassType, CHECK_NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	142 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	143
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	144 Klass::Klass() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	145 Klass* k = this;
0 a61af66fc99e Initial load duke parents: diff changeset	146
a61af66fc99e Initial load duke parents: diff changeset	147 { // Preinitialize supertype information.
a61af66fc99e Initial load duke parents: diff changeset	148 // A later call to initialize_supers() may update these settings:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	149 set_super(NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	150 for (juint i = 0; i < Klass::primary_super_limit(); i++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	151 _primary_supers[i] = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	152 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	153 set_secondary_supers(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	154 _primary_supers[0] = k;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	155 set_super_check_offset(in_bytes(primary_supers_offset()));
0 a61af66fc99e Initial load duke parents: diff changeset	156 }
a61af66fc99e Initial load duke parents: diff changeset	157
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	158 set_java_mirror(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	159 set_modifier_flags(0);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	160 set_layout_helper(Klass::_lh_neutral_value);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	161 set_name(NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	162 AccessFlags af;
a61af66fc99e Initial load duke parents: diff changeset	163 af.set_flags(0);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	164 set_access_flags(af);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	165 set_subklass(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	166 set_next_sibling(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	167 set_next_link(NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	168 set_alloc_count(0);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	169 TRACE_SET_KLASS_TRACE_ID(this, 0);
0 a61af66fc99e Initial load duke parents: diff changeset	170
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	171 set_prototype_header(markOopDesc::prototype());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	172 set_biased_lock_revocation_count(0);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	173 set_last_biased_lock_bulk_revocation_time(0);
0 a61af66fc99e Initial load duke parents: diff changeset	174
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	175 // 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	176 clear_modified_oops();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	177 clear_accumulated_modified_oops();
0 a61af66fc99e Initial load duke parents: diff changeset	178 }
a61af66fc99e Initial load duke parents: diff changeset	179
a61af66fc99e Initial load duke parents: diff changeset	180 jint Klass::array_layout_helper(BasicType etype) {
a61af66fc99e Initial load duke parents: diff changeset	181 assert(etype >= T_BOOLEAN && etype <= T_OBJECT, "valid etype");
a61af66fc99e Initial load duke parents: diff changeset	182 // Note that T_ARRAY is not allowed here.
a61af66fc99e Initial load duke parents: diff changeset	183 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	184 int esize = type2aelembytes(etype);
0 a61af66fc99e Initial load duke parents: diff changeset	185 bool isobj = (etype == T_OBJECT);
a61af66fc99e Initial load duke parents: diff changeset	186 int tag = isobj ? _lh_array_tag_obj_value : _lh_array_tag_type_value;
a61af66fc99e Initial load duke parents: diff changeset	187 int lh = array_layout_helper(tag, hsize, etype, exact_log2(esize));
a61af66fc99e Initial load duke parents: diff changeset	188
a61af66fc99e Initial load duke parents: diff changeset	189 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	190 assert(layout_helper_is_array(lh), "correct kind");
0 a61af66fc99e Initial load duke parents: diff changeset	191 assert(layout_helper_is_objArray(lh) == isobj, "correct kind");
a61af66fc99e Initial load duke parents: diff changeset	192 assert(layout_helper_is_typeArray(lh) == !isobj, "correct kind");
a61af66fc99e Initial load duke parents: diff changeset	193 assert(layout_helper_header_size(lh) == hsize, "correct decode");
a61af66fc99e Initial load duke parents: diff changeset	194 assert(layout_helper_element_type(lh) == etype, "correct decode");
a61af66fc99e Initial load duke parents: diff changeset	195 assert(1 << layout_helper_log2_element_size(lh) == esize, "correct decode");
a61af66fc99e Initial load duke parents: diff changeset	196
a61af66fc99e Initial load duke parents: diff changeset	197 return lh;
a61af66fc99e Initial load duke parents: diff changeset	198 }
a61af66fc99e Initial load duke parents: diff changeset	199
a61af66fc99e Initial load duke parents: diff changeset	200 bool Klass::can_be_primary_super_slow() const {
a61af66fc99e Initial load duke parents: diff changeset	201 if (super() == NULL)
a61af66fc99e Initial load duke parents: diff changeset	202 return true;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	203 else if (super()->super_depth() >= primary_super_limit()-1)
0 a61af66fc99e Initial load duke parents: diff changeset	204 return false;
a61af66fc99e Initial load duke parents: diff changeset	205 else
a61af66fc99e Initial load duke parents: diff changeset	206 return true;
a61af66fc99e Initial load duke parents: diff changeset	207 }
a61af66fc99e Initial load duke parents: diff changeset	208
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	209 void Klass::initialize_supers(Klass* k, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	210 if (FastSuperclassLimit == 0) {
a61af66fc99e Initial load duke parents: diff changeset	211 // None of the other machinery matters.
a61af66fc99e Initial load duke parents: diff changeset	212 set_super(k);
a61af66fc99e Initial load duke parents: diff changeset	213 return;
a61af66fc99e Initial load duke parents: diff changeset	214 }
a61af66fc99e Initial load duke parents: diff changeset	215 if (k == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	216 set_super(NULL);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	217 _primary_supers[0] = this;
0 a61af66fc99e Initial load duke parents: diff changeset	218 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	219 } else if (k != super() \|\| k == SystemDictionary::Object_klass()) {
4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1039 diff changeset	220 assert(super() == NULL \|\| super() == SystemDictionary::Object_klass(),
0 a61af66fc99e Initial load duke parents: diff changeset	221 "initialize this only once to a non-trivial value");
a61af66fc99e Initial load duke parents: diff changeset	222 set_super(k);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	223 Klass* sup = k;
0 a61af66fc99e Initial load duke parents: diff changeset	224 int sup_depth = sup->super_depth();
a61af66fc99e Initial load duke parents: diff changeset	225 juint my_depth = MIN2(sup_depth + 1, (int)primary_super_limit());
a61af66fc99e Initial load duke parents: diff changeset	226 if (!can_be_primary_super_slow())
a61af66fc99e Initial load duke parents: diff changeset	227 my_depth = primary_super_limit();
a61af66fc99e Initial load duke parents: diff changeset	228 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	229 _primary_supers[i] = sup->_primary_supers[i];
0 a61af66fc99e Initial load duke parents: diff changeset	230 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	231 Klass* *super_check_cell;
0 a61af66fc99e Initial load duke parents: diff changeset	232 if (my_depth < primary_super_limit()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	233 _primary_supers[my_depth] = this;
0 a61af66fc99e Initial load duke parents: diff changeset	234 super_check_cell = &_primary_supers[my_depth];
a61af66fc99e Initial load duke parents: diff changeset	235 } else {
a61af66fc99e Initial load duke parents: diff changeset	236 // Overflow of the primary_supers array forces me to be secondary.
a61af66fc99e Initial load duke parents: diff changeset	237 super_check_cell = &_secondary_super_cache;
a61af66fc99e Initial load duke parents: diff changeset	238 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	239 set_super_check_offset((address)super_check_cell - (address) this);
0 a61af66fc99e Initial load duke parents: diff changeset	240
a61af66fc99e Initial load duke parents: diff changeset	241 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	242 {
a61af66fc99e Initial load duke parents: diff changeset	243 juint j = super_depth();
a61af66fc99e Initial load duke parents: diff changeset	244 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	245 Klass* t = this;
0 a61af66fc99e Initial load duke parents: diff changeset	246 while (!Klass::cast(t)->can_be_primary_super()) {
a61af66fc99e Initial load duke parents: diff changeset	247 t = Klass::cast(t)->super();
a61af66fc99e Initial load duke parents: diff changeset	248 j = Klass::cast(t)->super_depth();
a61af66fc99e Initial load duke parents: diff changeset	249 }
a61af66fc99e Initial load duke parents: diff changeset	250 for (juint j1 = j+1; j1 < primary_super_limit(); j1++) {
a61af66fc99e Initial load duke parents: diff changeset	251 assert(primary_super_of_depth(j1) == NULL, "super list padding");
a61af66fc99e Initial load duke parents: diff changeset	252 }
a61af66fc99e Initial load duke parents: diff changeset	253 while (t != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	254 assert(primary_super_of_depth(j) == t, "super list initialization");
a61af66fc99e Initial load duke parents: diff changeset	255 t = Klass::cast(t)->super();
a61af66fc99e Initial load duke parents: diff changeset	256 --j;
a61af66fc99e Initial load duke parents: diff changeset	257 }
a61af66fc99e Initial load duke parents: diff changeset	258 assert(j == (juint)-1, "correct depth count");
a61af66fc99e Initial load duke parents: diff changeset	259 }
a61af66fc99e Initial load duke parents: diff changeset	260 #endif
a61af66fc99e Initial load duke parents: diff changeset	261 }
a61af66fc99e Initial load duke parents: diff changeset	262
a61af66fc99e Initial load duke parents: diff changeset	263 if (secondary_supers() == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	264 KlassHandle this_kh (THREAD, this);
a61af66fc99e Initial load duke parents: diff changeset	265
a61af66fc99e Initial load duke parents: diff changeset	266 // Now compute the list of secondary supertypes.
a61af66fc99e Initial load duke parents: diff changeset	267 // Secondaries can occasionally be on the super chain,
a61af66fc99e Initial load duke parents: diff changeset	268 // if the inline "_primary_supers" array overflows.
a61af66fc99e Initial load duke parents: diff changeset	269 int extras = 0;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	270 Klass* p;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	271 for (p = super(); !(p == NULL \|\| p->can_be_primary_super()); p = p->super()) {
0 a61af66fc99e Initial load duke parents: diff changeset	272 ++extras;
a61af66fc99e Initial load duke parents: diff changeset	273 }
a61af66fc99e Initial load duke parents: diff changeset	274
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	275 ResourceMark rm(THREAD); // need to reclaim GrowableArrays allocated below
0 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 // Compute the "real" non-extra secondaries.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	278 GrowableArray<Klass> secondaries = compute_secondary_supers(extras);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	279 if (secondaries == NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	280 // secondary_supers set by compute_secondary_supers
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	281 return;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	282 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	283
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	284 GrowableArray<Klass> primaries = new GrowableArray<Klass*>(extras);
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 for (p = this_kh->super(); !(p == NULL \|\| p->can_be_primary_super()); p = p->super()) {
0 a61af66fc99e Initial load duke parents: diff changeset	287 int i; // Scan for overflow primaries being duplicates of 2nd'arys
a61af66fc99e Initial load duke parents: diff changeset	288
a61af66fc99e Initial load duke parents: diff changeset	289 // This happens frequently for very deeply nested arrays: the
a61af66fc99e Initial load duke parents: diff changeset	290 // primary superclass chain overflows into the secondary. The
a61af66fc99e Initial load duke parents: diff changeset	291 // secondary list contains the element_klass's secondaries with
a61af66fc99e Initial load duke parents: diff changeset	292 // an extra array dimension added. If the element_klass's
a61af66fc99e Initial load duke parents: diff changeset	293 // secondary list already contains some primary overflows, they
a61af66fc99e Initial load duke parents: diff changeset	294 // (with the extra level of array-ness) will collide with the
a61af66fc99e Initial load duke parents: diff changeset	295 // normal primary superclass overflows.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	296 for( i = 0; i < secondaries->length(); i++ ) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	297 if( secondaries->at(i) == p )
0 a61af66fc99e Initial load duke parents: diff changeset	298 break;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	299 }
0 a61af66fc99e Initial load duke parents: diff changeset	300 if( i < secondaries->length() )
a61af66fc99e Initial load duke parents: diff changeset	301 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	302 primaries->push(p);
0 a61af66fc99e Initial load duke parents: diff changeset	303 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	304 // 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	305 // 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	306 int new_length = primaries->length() + secondaries->length();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	307 Array<Klass> s2 = MetadataFactory::new_array<Klass*>(
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	308 class_loader_data(), new_length, CHECK);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	309 int fill_p = primaries->length();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	310 for (int j = 0; j < fill_p; j++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	311 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	312 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	313 for( int j = 0; j < secondaries->length(); j++ ) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	314 s2->at_put(j+fill_p, secondaries->at(j)); // add secondaries on the end.
0 a61af66fc99e Initial load duke parents: diff changeset	315 }
a61af66fc99e Initial load duke parents: diff changeset	316
a61af66fc99e Initial load duke parents: diff changeset	317 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	318 // 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	319 for (int j = 0; j < s2->length(); j++) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	320 assert(s2->at(j) != NULL, "correct bootstrapping order");
0 a61af66fc99e Initial load duke parents: diff changeset	321 }
a61af66fc99e Initial load duke parents: diff changeset	322 #endif
a61af66fc99e Initial load duke parents: diff changeset	323
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	324 this_kh->set_secondary_supers(s2);
0 a61af66fc99e Initial load duke parents: diff changeset	325 }
a61af66fc99e Initial load duke parents: diff changeset	326 }
a61af66fc99e Initial load duke parents: diff changeset	327
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	328 GrowableArray<Klass> Klass::compute_secondary_supers(int num_extra_slots) {
0 a61af66fc99e Initial load duke parents: diff changeset	329 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	330 set_secondary_supers(Universe::the_empty_klass_array());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	331 return NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	332 }
a61af66fc99e Initial load duke parents: diff changeset	333
a61af66fc99e Initial load duke parents: diff changeset	334
a61af66fc99e Initial load duke parents: diff changeset	335 Klass* Klass::subklass() const {
a61af66fc99e Initial load duke parents: diff changeset	336 return _subklass == NULL ? NULL : Klass::cast(_subklass);
a61af66fc99e Initial load duke parents: diff changeset	337 }
a61af66fc99e Initial load duke parents: diff changeset	338
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	339 InstanceKlass* Klass::superklass() const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	340 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	341 return _super == NULL ? NULL : InstanceKlass::cast(_super);
0 a61af66fc99e Initial load duke parents: diff changeset	342 }
a61af66fc99e Initial load duke parents: diff changeset	343
a61af66fc99e Initial load duke parents: diff changeset	344 Klass* Klass::next_sibling() const {
a61af66fc99e Initial load duke parents: diff changeset	345 return _next_sibling == NULL ? NULL : Klass::cast(_next_sibling);
a61af66fc99e Initial load duke parents: diff changeset	346 }
a61af66fc99e Initial load duke parents: diff changeset	347
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	348 void Klass::set_subklass(Klass* s) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	349 assert(s != this, "sanity check");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	350 _subklass = s;
0 a61af66fc99e Initial load duke parents: diff changeset	351 }
a61af66fc99e Initial load duke parents: diff changeset	352
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	353 void Klass::set_next_sibling(Klass* s) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	354 assert(s != this, "sanity check");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	355 _next_sibling = s;
0 a61af66fc99e Initial load duke parents: diff changeset	356 }
a61af66fc99e Initial load duke parents: diff changeset	357
a61af66fc99e Initial load duke parents: diff changeset	358 void Klass::append_to_sibling_list() {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	359 debug_only(if (!SharedSkipVerify) verify();)
0 a61af66fc99e Initial load duke parents: diff changeset	360 // add ourselves to superklass' subklass list
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	361 InstanceKlass* super = superklass();
0 a61af66fc99e Initial load duke parents: diff changeset	362 if (super == NULL) return; // special case: class Object
a61af66fc99e Initial load duke parents: diff changeset	363 assert(SharedSkipVerify \|\|
a61af66fc99e Initial load duke parents: diff changeset	364 (!super->is_interface() // interfaces cannot be supers
a61af66fc99e Initial load duke parents: diff changeset	365 && (super->superklass() == NULL \|\| !is_interface())),
a61af66fc99e Initial load duke parents: diff changeset	366 "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	367 Klass* prev_first_subklass = super->subklass_oop();
0 a61af66fc99e Initial load duke parents: diff changeset	368 if (prev_first_subklass != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	369 // set our sibling to be the superklass' previous first subklass
a61af66fc99e Initial load duke parents: diff changeset	370 set_next_sibling(prev_first_subklass);
a61af66fc99e Initial load duke parents: diff changeset	371 }
a61af66fc99e Initial load duke parents: diff changeset	372 // make ourselves the superklass' first subklass
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	373 super->set_subklass(this);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	374 debug_only(if (!SharedSkipVerify) verify();)
0 a61af66fc99e Initial load duke parents: diff changeset	375 }
a61af66fc99e Initial load duke parents: diff changeset	376
a61af66fc99e Initial load duke parents: diff changeset	377 void Klass::remove_from_sibling_list() {
a61af66fc99e Initial load duke parents: diff changeset	378 // remove receiver from sibling list
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	379 InstanceKlass* super = superklass();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	380 assert(super != NULL \|\| this == SystemDictionary::Object_klass(), "should have super");
0 a61af66fc99e Initial load duke parents: diff changeset	381 if (super == NULL) return; // special case: class Object
a61af66fc99e Initial load duke parents: diff changeset	382 if (super->subklass() == this) {
a61af66fc99e Initial load duke parents: diff changeset	383 // first subklass
a61af66fc99e Initial load duke parents: diff changeset	384 super->set_subklass(_next_sibling);
a61af66fc99e Initial load duke parents: diff changeset	385 } else {
a61af66fc99e Initial load duke parents: diff changeset	386 Klass* sib = super->subklass();
a61af66fc99e Initial load duke parents: diff changeset	387 while (sib->next_sibling() != this) {
a61af66fc99e Initial load duke parents: diff changeset	388 sib = sib->next_sibling();
a61af66fc99e Initial load duke parents: diff changeset	389 };
a61af66fc99e Initial load duke parents: diff changeset	390 sib->set_next_sibling(_next_sibling);
a61af66fc99e Initial load duke parents: diff changeset	391 }
a61af66fc99e Initial load duke parents: diff changeset	392 }
a61af66fc99e Initial load duke parents: diff changeset	393
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	394 bool Klass::is_loader_alive(BoolObjectClosure* is_alive) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	395 assert(is_metadata(), "p is not meta-data");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	396 assert(ClassLoaderDataGraph::contains((address)this), "is in the metaspace");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	397 // 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	398 oop loader = class_loader();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	399 return (loader == NULL) \|\| is_alive->do_object_b(loader);
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
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	402 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	403 if (!ClassUnloading) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	404 return;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	405 }
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 Klass* root = SystemDictionary::Object_klass();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	408 Stack<Klass*, mtGC> stack;
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 stack.push(root);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	411 while (!stack.is_empty()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	412 Klass* current = stack.pop();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	413
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	414 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	415
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	416 // Find and set the first alive subklass
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	417 Klass* sub = current->subklass_oop();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	418 while (sub != NULL && !sub->is_loader_alive(is_alive)) {
0 a61af66fc99e Initial load duke parents: diff changeset	419 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	420 if (TraceClassUnloading && WizardMode) {
a61af66fc99e Initial load duke parents: diff changeset	421 ResourceMark rm;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	422 tty->print_cr("[Unlinking class (subclass) %s]", sub->external_name());
0 a61af66fc99e Initial load duke parents: diff changeset	423 }
a61af66fc99e Initial load duke parents: diff changeset	424 #endif
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	425 sub = sub->next_sibling_oop();
0 a61af66fc99e Initial load duke parents: diff changeset	426 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	427 current->set_subklass(sub);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	428 if (sub != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	429 stack.push(sub);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	430 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	431
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	432 // Find and set the first alive sibling
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	433 Klass* sibling = current->next_sibling_oop();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	434 while (sibling != NULL && !sibling->is_loader_alive(is_alive)) {
0 a61af66fc99e Initial load duke parents: diff changeset	435 if (TraceClassUnloading && WizardMode) {
a61af66fc99e Initial load duke parents: diff changeset	436 ResourceMark rm;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	437 tty->print_cr("[Unlinking class (sibling) %s]", sibling->external_name());
0 a61af66fc99e Initial load duke parents: diff changeset	438 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	439 sibling = sibling->next_sibling_oop();
0 a61af66fc99e Initial load duke parents: diff changeset	440 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	441 current->set_next_sibling(sibling);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	442 if (sibling != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	443 stack.push(sibling);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	444 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	445
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	446 // Clean the implementors list and method data.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	447 if (current->oop_is_instance()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	448 InstanceKlass* ik = InstanceKlass::cast(current);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	449 ik->clean_implementors_list(is_alive);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	450 ik->clean_method_data(is_alive);
0 a61af66fc99e Initial load duke parents: diff changeset	451 }
a61af66fc99e Initial load duke parents: diff changeset	452 }
a61af66fc99e Initial load duke parents: diff changeset	453 }
a61af66fc99e Initial load duke parents: diff changeset	454
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	455 void Klass::klass_update_barrier_set(oop v) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	456 record_modified_oops();
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
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	459 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	460 // 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	461 // 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	462 // 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	463 // 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	464 // do anything here.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	465 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	466
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	467 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	468 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	469 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	470
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	471 // do the store
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	472 if (always_do_update_barrier) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	473 klass_oop_store((volatile oop*)p, v);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	474 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	475 klass_update_barrier_set_pre((void*)p, v);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	476 *p = v;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	477 klass_update_barrier_set(v);
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 }
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::klass_oop_store(volatile oop* p, oop v) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	482 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	483 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	484
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	485 klass_update_barrier_set_pre((void*)p, v);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	486 OrderAccess::release_store_ptr(p, v);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	487 klass_update_barrier_set(v);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	488 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	489
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	490 void Klass::oops_do(OopClosure* cl) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	491 cl->do_oop(&_java_mirror);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	492 }
0 a61af66fc99e Initial load duke parents: diff changeset	493
a61af66fc99e Initial load duke parents: diff changeset	494 void Klass::remove_unshareable_info() {
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) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 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) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 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, "");
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	558 intptr_t hash = ik->java_mirror()->identity_hash();
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	559 char hash_buf[40];
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	560 sprintf(hash_buf, "/" UINTX_FORMAT, (uintx)hash);
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	561 size_t hash_len = strlen(hash_buf);
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	562
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	563 size_t result_len = name()->utf8_length();
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	564 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	565 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	566 assert(strlen(result) == result_len, "");
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	567 strcpy(result + result_len, hash_buf);
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	568 assert(strlen(result) == result_len + hash_len, "");
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	569 return result;
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	570 }
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	571 }
1039 987e948ebbc8 6815692: method handle code needs some cleanup (post-6655638) jrose parents: 605 diff changeset	572 if (name() == NULL) return "<unknown>";
0 a61af66fc99e Initial load duke parents: diff changeset	573 return name()->as_klass_external_name();
a61af66fc99e Initial load duke parents: diff changeset	574 }
a61af66fc99e Initial load duke parents: diff changeset	575
a61af66fc99e Initial load duke parents: diff changeset	576
1039 987e948ebbc8 6815692: method handle code needs some cleanup (post-6655638) jrose parents: 605 diff changeset	577 const char* Klass::signature_name() const {
987e948ebbc8 6815692: method handle code needs some cleanup (post-6655638) jrose parents: 605 diff changeset	578 if (name() == NULL) return "<unknown>";
0 a61af66fc99e Initial load duke parents: diff changeset	579 return name()->as_C_string();
a61af66fc99e Initial load duke parents: diff changeset	580 }
a61af66fc99e Initial load duke parents: diff changeset	581
a61af66fc99e Initial load duke parents: diff changeset	582 // Unless overridden, modifier_flags is 0.
a61af66fc99e Initial load duke parents: diff changeset	583 jint Klass::compute_modifier_flags(TRAPS) const {
a61af66fc99e Initial load duke parents: diff changeset	584 return 0;
a61af66fc99e Initial load duke parents: diff changeset	585 }
a61af66fc99e Initial load duke parents: diff changeset	586
a61af66fc99e Initial load duke parents: diff changeset	587 int Klass::atomic_incr_biased_lock_revocation_count() {
a61af66fc99e Initial load duke parents: diff changeset	588 return (int) Atomic::add(1, &_biased_lock_revocation_count);
a61af66fc99e Initial load duke parents: diff changeset	589 }
a61af66fc99e Initial load duke parents: diff changeset	590
a61af66fc99e Initial load duke parents: diff changeset	591 // Unless overridden, jvmti_class_status has no flags set.
a61af66fc99e Initial load duke parents: diff changeset	592 jint Klass::jvmti_class_status() const {
a61af66fc99e Initial load duke parents: diff changeset	593 return 0;
a61af66fc99e Initial load duke parents: diff changeset	594 }
a61af66fc99e Initial load duke parents: diff changeset	595
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	596
0 a61af66fc99e Initial load duke parents: diff changeset	597 // Printing
a61af66fc99e Initial load duke parents: diff changeset	598
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	599 void Klass::print_on(outputStream* st) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	600 ResourceMark rm;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	601 // print title
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	602 st->print("%s", internal_name());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	603 print_address_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	604 st->cr();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	605 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	606
0 a61af66fc99e Initial load duke parents: diff changeset	607 void Klass::oop_print_on(oop obj, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	608 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	609 // print title
a61af66fc99e Initial load duke parents: diff changeset	610 st->print_cr("%s ", internal_name());
a61af66fc99e Initial load duke parents: diff changeset	611 obj->print_address_on(st);
a61af66fc99e Initial load duke parents: diff changeset	612
a61af66fc99e Initial load duke parents: diff changeset	613 if (WizardMode) {
a61af66fc99e Initial load duke parents: diff changeset	614 // print header
a61af66fc99e Initial load duke parents: diff changeset	615 obj->mark()->print_on(st);
a61af66fc99e Initial load duke parents: diff changeset	616 }
a61af66fc99e Initial load duke parents: diff changeset	617
a61af66fc99e Initial load duke parents: diff changeset	618 // print class
a61af66fc99e Initial load duke parents: diff changeset	619 st->print(" - klass: ");
a61af66fc99e Initial load duke parents: diff changeset	620 obj->klass()->print_value_on(st);
a61af66fc99e Initial load duke parents: diff changeset	621 st->cr();
a61af66fc99e Initial load duke parents: diff changeset	622 }
a61af66fc99e Initial load duke parents: diff changeset	623
a61af66fc99e Initial load duke parents: diff changeset	624 void Klass::oop_print_value_on(oop obj, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	625 // print title
a61af66fc99e Initial load duke parents: diff changeset	626 ResourceMark rm; // Cannot print in debug mode without this
a61af66fc99e Initial load duke parents: diff changeset	627 st->print("%s", internal_name());
a61af66fc99e Initial load duke parents: diff changeset	628 obj->print_address_on(st);
a61af66fc99e Initial load duke parents: diff changeset	629 }
a61af66fc99e Initial load duke parents: diff changeset	630
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	631
0 a61af66fc99e Initial load duke parents: diff changeset	632 // Verification
a61af66fc99e Initial load duke parents: diff changeset	633
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	634 void Klass::verify_on(outputStream* st) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	635 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	636 guarantee(this->is_metadata(), "should be in metaspace");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	637
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	638 assert(ClassLoaderDataGraph::contains((address)this), "Should be");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	639
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	640 guarantee(this->is_klass(),"should be klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	641
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	642 if (super() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	643 guarantee(super()->is_metadata(), "should be in metaspace");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	644 guarantee(super()->is_klass(), "should be klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	645 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	646 if (secondary_super_cache() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	647 Klass* ko = secondary_super_cache();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	648 guarantee(ko->is_metadata(), "should be in metaspace");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	649 guarantee(ko->is_klass(), "should be klass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	650 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	651 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	652 Klass* ko = _primary_supers[i];
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	653 if (ko != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	654 guarantee(ko->is_metadata(), "should be in metaspace");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	655 guarantee(ko->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 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	658
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	659 if (java_mirror() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	660 guarantee(java_mirror()->is_oop(), "should be instance");
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
0 a61af66fc99e Initial load duke parents: diff changeset	664 void Klass::oop_verify_on(oop obj, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	665 guarantee(obj->is_oop(), "should be oop");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	666 guarantee(obj->klass()->is_metadata(), "should not be in Java heap");
0 a61af66fc99e Initial load duke parents: diff changeset	667 guarantee(obj->klass()->is_klass(), "klass field is not a klass");
a61af66fc99e Initial load duke parents: diff changeset	668 }
a61af66fc99e Initial load duke parents: diff changeset	669
a61af66fc99e Initial load duke parents: diff changeset	670 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	671
a61af66fc99e Initial load duke parents: diff changeset	672 void Klass::verify_vtable_index(int i) {
a61af66fc99e Initial load duke parents: diff changeset	673 if (oop_is_instance()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	674 assert(i>=0 && i<((InstanceKlass*)this)->vtable_length()/vtableEntry::size(), "index out of bounds");
0 a61af66fc99e Initial load duke parents: diff changeset	675 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	676 assert(oop_is_array(), "Must be");
0 a61af66fc99e Initial load duke parents: diff changeset	677 assert(i>=0 && i<((arrayKlass*)this)->vtable_length()/vtableEntry::size(), "index out of bounds");
a61af66fc99e Initial load duke parents: diff changeset	678 }
a61af66fc99e Initial load duke parents: diff changeset	679 }
a61af66fc99e Initial load duke parents: diff changeset	680
a61af66fc99e Initial load duke parents: diff changeset	681 #endif

Mercurial > hg > truffle

annotate src/share/vm/oops/klass.cpp @ 6862:8a5ea0a9ccc4