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

annotate src/share/vm/oops/constantPoolKlass.cpp @ 3762:5c0a3c1858b1

7048782: CMS: assert(last_chunk_index_to_check<= last_chunk_index) failed: parCardTableModRefBS.cpp:359 Summary: The LNC array is sized before the start of a scavenge, while the heap may expand during a scavenge. With CMS, the last block of an arbitrary suffice of the LNC array may expand due to coalition with the expansion delta. We now take care not to attempt access past the end of the LNC array. LNC array code will be cleaned up and suitably encapsulated as part of the forthcoming performance RFE 7043675. Reviewed-by: brutisso

author	ysr
date	Thu, 02 Jun 2011 10:23:36 -0700
parents	69c94f488271
children	81d815b05abb

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
2227 e5383553fd4e 7014851: Remove unused parallel compaction code stefank parents: 2226 diff changeset	2 * Copyright (c) 1997, 2011, 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: 1913 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	26 #include "classfile/javaClasses.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	27 #include "gc_implementation/shared/markSweep.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	28 #include "gc_interface/collectedHeap.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	29 #include "memory/oopFactory.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	30 #include "memory/permGen.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	31 #include "memory/universe.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	32 #include "oops/constantPoolKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	33 #include "oops/constantPoolOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	34 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	35 #include "oops/oop.inline2.hpp"
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	36 #include "oops/symbol.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	37 #include "runtime/handles.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	38 #ifdef TARGET_OS_FAMILY_linux
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	39 # include "thread_linux.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	40 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	41 #ifdef TARGET_OS_FAMILY_solaris
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	42 # include "thread_solaris.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	43 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	44 #ifdef TARGET_OS_FAMILY_windows
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	45 # include "thread_windows.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	46 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	47 #ifndef SERIALGC
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	48 #include "gc_implementation/parNew/parOopClosures.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	49 #include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	50 #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	51 #include "memory/cardTableRS.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	52 #include "oops/oop.pcgc.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	53 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	54
518 0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark" jmasa parents: 431 diff changeset	55 constantPoolOop constantPoolKlass::allocate(int length, bool is_conc_safe, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	56 int size = constantPoolOopDesc::object_size(length);
a61af66fc99e Initial load duke parents: diff changeset	57 KlassHandle klass (THREAD, as_klassOop());
2229 183658a2d0b3 7018302: newly added assert related to size of constantPoolOop causes secondary assertions or crashes ysr parents: 2227 diff changeset	58 assert(klass()->is_oop(), "Can't be null, else handlizing of c below won't work");
183658a2d0b3 7018302: newly added assert related to size of constantPoolOop causes secondary assertions or crashes ysr parents: 2227 diff changeset	59 constantPoolHandle pool;
183658a2d0b3 7018302: newly added assert related to size of constantPoolOop causes secondary assertions or crashes ysr parents: 2227 diff changeset	60 {
183658a2d0b3 7018302: newly added assert related to size of constantPoolOop causes secondary assertions or crashes ysr parents: 2227 diff changeset	61 constantPoolOop c =
183658a2d0b3 7018302: newly added assert related to size of constantPoolOop causes secondary assertions or crashes ysr parents: 2227 diff changeset	62 (constantPoolOop)CollectedHeap::permanent_obj_allocate(klass, size, CHECK_NULL);
183658a2d0b3 7018302: newly added assert related to size of constantPoolOop causes secondary assertions or crashes ysr parents: 2227 diff changeset	63 assert(c->klass_or_null() != NULL, "Handlizing below won't work");
183658a2d0b3 7018302: newly added assert related to size of constantPoolOop causes secondary assertions or crashes ysr parents: 2227 diff changeset	64 pool = constantPoolHandle(THREAD, c);
183658a2d0b3 7018302: newly added assert related to size of constantPoolOop causes secondary assertions or crashes ysr parents: 2227 diff changeset	65 }
0 a61af66fc99e Initial load duke parents: diff changeset	66
2229 183658a2d0b3 7018302: newly added assert related to size of constantPoolOop causes secondary assertions or crashes ysr parents: 2227 diff changeset	67 pool->set_length(length);
183658a2d0b3 7018302: newly added assert related to size of constantPoolOop causes secondary assertions or crashes ysr parents: 2227 diff changeset	68 pool->set_tags(NULL);
183658a2d0b3 7018302: newly added assert related to size of constantPoolOop causes secondary assertions or crashes ysr parents: 2227 diff changeset	69 pool->set_cache(NULL);
183658a2d0b3 7018302: newly added assert related to size of constantPoolOop causes secondary assertions or crashes ysr parents: 2227 diff changeset	70 pool->set_operands(NULL);
183658a2d0b3 7018302: newly added assert related to size of constantPoolOop causes secondary assertions or crashes ysr parents: 2227 diff changeset	71 pool->set_pool_holder(NULL);
183658a2d0b3 7018302: newly added assert related to size of constantPoolOop causes secondary assertions or crashes ysr parents: 2227 diff changeset	72 pool->set_flags(0);
0 a61af66fc99e Initial load duke parents: diff changeset	73 // only set to non-zero if constant pool is merged by RedefineClasses
2229 183658a2d0b3 7018302: newly added assert related to size of constantPoolOop causes secondary assertions or crashes ysr parents: 2227 diff changeset	74 pool->set_orig_length(0);
518 0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark" jmasa parents: 431 diff changeset	75 // if constant pool may change during RedefineClasses, it is created
0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark" jmasa parents: 431 diff changeset	76 // unsafe for GC concurrent processing.
2229 183658a2d0b3 7018302: newly added assert related to size of constantPoolOop causes secondary assertions or crashes ysr parents: 2227 diff changeset	77 pool->set_is_conc_safe(is_conc_safe);
0 a61af66fc99e Initial load duke parents: diff changeset	78 // all fields are initialized; needed for GC
a61af66fc99e Initial load duke parents: diff changeset	79
2226 c5a923563727 6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?") ysr parents: 2177 diff changeset	80 // Note: because we may be in this "conc_unsafe" state when allocating
c5a923563727 6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?") ysr parents: 2177 diff changeset	81 // t_oop below, which may in turn cause a GC, it is imperative that our
c5a923563727 6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?") ysr parents: 2177 diff changeset	82 // size be correct, consistent and henceforth stable, at this stage.
2229 183658a2d0b3 7018302: newly added assert related to size of constantPoolOop causes secondary assertions or crashes ysr parents: 2227 diff changeset	83 assert(pool->is_oop() && pool->is_parsable(), "Else size() below is unreliable");
183658a2d0b3 7018302: newly added assert related to size of constantPoolOop causes secondary assertions or crashes ysr parents: 2227 diff changeset	84 assert(size == pool->size(), "size() is wrong");
2226 c5a923563727 6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?") ysr parents: 2177 diff changeset	85
0 a61af66fc99e Initial load duke parents: diff changeset	86 // initialize tag array
a61af66fc99e Initial load duke parents: diff changeset	87 typeArrayOop t_oop = oopFactory::new_permanent_byteArray(length, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	88 typeArrayHandle tags (THREAD, t_oop);
a61af66fc99e Initial load duke parents: diff changeset	89 for (int index = 0; index < length; index++) {
a61af66fc99e Initial load duke parents: diff changeset	90 tags()->byte_at_put(index, JVM_CONSTANT_Invalid);
a61af66fc99e Initial load duke parents: diff changeset	91 }
a61af66fc99e Initial load duke parents: diff changeset	92 pool->set_tags(tags());
a61af66fc99e Initial load duke parents: diff changeset	93
2226 c5a923563727 6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?") ysr parents: 2177 diff changeset	94 // Check that our size was stable at its old value.
2229 183658a2d0b3 7018302: newly added assert related to size of constantPoolOop causes secondary assertions or crashes ysr parents: 2227 diff changeset	95 assert(size == pool->size(), "size() changed");
0 a61af66fc99e Initial load duke parents: diff changeset	96 return pool();
a61af66fc99e Initial load duke parents: diff changeset	97 }
a61af66fc99e Initial load duke parents: diff changeset	98
a61af66fc99e Initial load duke parents: diff changeset	99 klassOop constantPoolKlass::create_klass(TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	100 constantPoolKlass o;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	101 KlassHandle h_this_klass(THREAD, Universe::klassKlassObj());
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	102 KlassHandle k = base_create_klass(h_this_klass, header_size(), o.vtbl_value(), CHECK_NULL);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	103 // Make sure size calculation is right
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	104 assert(k()->size() == align_object_size(header_size()), "wrong size for object");
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	105 java_lang_Class::create_mirror(k, CHECK_NULL); // Allocate mirror
0 a61af66fc99e Initial load duke parents: diff changeset	106 return k();
a61af66fc99e Initial load duke parents: diff changeset	107 }
a61af66fc99e Initial load duke parents: diff changeset	108
a61af66fc99e Initial load duke parents: diff changeset	109 int constantPoolKlass::oop_size(oop obj) const {
a61af66fc99e Initial load duke parents: diff changeset	110 assert(obj->is_constantPool(), "must be constantPool");
a61af66fc99e Initial load duke parents: diff changeset	111 return constantPoolOop(obj)->object_size();
a61af66fc99e Initial load duke parents: diff changeset	112 }
a61af66fc99e Initial load duke parents: diff changeset	113
a61af66fc99e Initial load duke parents: diff changeset	114
a61af66fc99e Initial load duke parents: diff changeset	115 void constantPoolKlass::oop_follow_contents(oop obj) {
a61af66fc99e Initial load duke parents: diff changeset	116 assert (obj->is_constantPool(), "obj must be constant pool");
a61af66fc99e Initial load duke parents: diff changeset	117 constantPoolOop cp = (constantPoolOop) obj;
a61af66fc99e Initial load duke parents: diff changeset	118 // Performance tweak: We skip iterating over the klass pointer since we
a61af66fc99e Initial load duke parents: diff changeset	119 // know that Universe::constantPoolKlassObj never moves.
a61af66fc99e Initial load duke parents: diff changeset	120
a61af66fc99e Initial load duke parents: diff changeset	121 // If the tags array is null we are in the middle of allocating this constant pool
a61af66fc99e Initial load duke parents: diff changeset	122 if (cp->tags() != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	123 // gc of constant pool contents
a61af66fc99e Initial load duke parents: diff changeset	124 oop* base = (oop*)cp->base();
a61af66fc99e Initial load duke parents: diff changeset	125 for (int i = 0; i < cp->length(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	126 if (cp->is_pointer_entry(i)) {
a61af66fc99e Initial load duke parents: diff changeset	127 if (*base != NULL) MarkSweep::mark_and_push(base);
a61af66fc99e Initial load duke parents: diff changeset	128 }
a61af66fc99e Initial load duke parents: diff changeset	129 base++;
a61af66fc99e Initial load duke parents: diff changeset	130 }
a61af66fc99e Initial load duke parents: diff changeset	131 // gc of constant pool instance variables
a61af66fc99e Initial load duke parents: diff changeset	132 MarkSweep::mark_and_push(cp->tags_addr());
a61af66fc99e Initial load duke parents: diff changeset	133 MarkSweep::mark_and_push(cp->cache_addr());
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1713 diff changeset	134 MarkSweep::mark_and_push(cp->operands_addr());
0 a61af66fc99e Initial load duke parents: diff changeset	135 MarkSweep::mark_and_push(cp->pool_holder_addr());
a61af66fc99e Initial load duke parents: diff changeset	136 }
a61af66fc99e Initial load duke parents: diff changeset	137 }
a61af66fc99e Initial load duke parents: diff changeset	138
a61af66fc99e Initial load duke parents: diff changeset	139 #ifndef SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	140 void constantPoolKlass::oop_follow_contents(ParCompactionManager* cm,
a61af66fc99e Initial load duke parents: diff changeset	141 oop obj) {
a61af66fc99e Initial load duke parents: diff changeset	142 assert (obj->is_constantPool(), "obj must be constant pool");
a61af66fc99e Initial load duke parents: diff changeset	143 constantPoolOop cp = (constantPoolOop) obj;
a61af66fc99e Initial load duke parents: diff changeset	144 // Performance tweak: We skip iterating over the klass pointer since we
a61af66fc99e Initial load duke parents: diff changeset	145 // know that Universe::constantPoolKlassObj never moves.
a61af66fc99e Initial load duke parents: diff changeset	146
a61af66fc99e Initial load duke parents: diff changeset	147 // If the tags array is null we are in the middle of allocating this constant
a61af66fc99e Initial load duke parents: diff changeset	148 // pool.
a61af66fc99e Initial load duke parents: diff changeset	149 if (cp->tags() != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	150 // gc of constant pool contents
a61af66fc99e Initial load duke parents: diff changeset	151 oop* base = (oop*)cp->base();
a61af66fc99e Initial load duke parents: diff changeset	152 for (int i = 0; i < cp->length(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	153 if (cp->is_pointer_entry(i)) {
a61af66fc99e Initial load duke parents: diff changeset	154 if (*base != NULL) PSParallelCompact::mark_and_push(cm, base);
a61af66fc99e Initial load duke parents: diff changeset	155 }
a61af66fc99e Initial load duke parents: diff changeset	156 base++;
a61af66fc99e Initial load duke parents: diff changeset	157 }
a61af66fc99e Initial load duke parents: diff changeset	158 // gc of constant pool instance variables
a61af66fc99e Initial load duke parents: diff changeset	159 PSParallelCompact::mark_and_push(cm, cp->tags_addr());
a61af66fc99e Initial load duke parents: diff changeset	160 PSParallelCompact::mark_and_push(cm, cp->cache_addr());
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1713 diff changeset	161 PSParallelCompact::mark_and_push(cm, cp->operands_addr());
0 a61af66fc99e Initial load duke parents: diff changeset	162 PSParallelCompact::mark_and_push(cm, cp->pool_holder_addr());
a61af66fc99e Initial load duke parents: diff changeset	163 }
a61af66fc99e Initial load duke parents: diff changeset	164 }
a61af66fc99e Initial load duke parents: diff changeset	165 #endif // SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	166
a61af66fc99e Initial load duke parents: diff changeset	167
a61af66fc99e Initial load duke parents: diff changeset	168 int constantPoolKlass::oop_adjust_pointers(oop obj) {
a61af66fc99e Initial load duke parents: diff changeset	169 assert (obj->is_constantPool(), "obj must be constant pool");
a61af66fc99e Initial load duke parents: diff changeset	170 constantPoolOop cp = (constantPoolOop) obj;
a61af66fc99e Initial load duke parents: diff changeset	171 // Get size before changing pointers.
a61af66fc99e Initial load duke parents: diff changeset	172 // Don't call size() or oop_size() since that is a virtual call.
a61af66fc99e Initial load duke parents: diff changeset	173 int size = cp->object_size();
a61af66fc99e Initial load duke parents: diff changeset	174 // Performance tweak: We skip iterating over the klass pointer since we
a61af66fc99e Initial load duke parents: diff changeset	175 // know that Universe::constantPoolKlassObj never moves.
a61af66fc99e Initial load duke parents: diff changeset	176
a61af66fc99e Initial load duke parents: diff changeset	177 // If the tags array is null we are in the middle of allocating this constant
a61af66fc99e Initial load duke parents: diff changeset	178 // pool.
a61af66fc99e Initial load duke parents: diff changeset	179 if (cp->tags() != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	180 oop* base = (oop*)cp->base();
a61af66fc99e Initial load duke parents: diff changeset	181 for (int i = 0; i< cp->length(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	182 if (cp->is_pointer_entry(i)) {
a61af66fc99e Initial load duke parents: diff changeset	183 MarkSweep::adjust_pointer(base);
a61af66fc99e Initial load duke parents: diff changeset	184 }
a61af66fc99e Initial load duke parents: diff changeset	185 base++;
a61af66fc99e Initial load duke parents: diff changeset	186 }
a61af66fc99e Initial load duke parents: diff changeset	187 }
a61af66fc99e Initial load duke parents: diff changeset	188 MarkSweep::adjust_pointer(cp->tags_addr());
a61af66fc99e Initial load duke parents: diff changeset	189 MarkSweep::adjust_pointer(cp->cache_addr());
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1713 diff changeset	190 MarkSweep::adjust_pointer(cp->operands_addr());
0 a61af66fc99e Initial load duke parents: diff changeset	191 MarkSweep::adjust_pointer(cp->pool_holder_addr());
a61af66fc99e Initial load duke parents: diff changeset	192 return size;
a61af66fc99e Initial load duke parents: diff changeset	193 }
a61af66fc99e Initial load duke parents: diff changeset	194
a61af66fc99e Initial load duke parents: diff changeset	195
a61af66fc99e Initial load duke parents: diff changeset	196 int constantPoolKlass::oop_oop_iterate(oop obj, OopClosure* blk) {
a61af66fc99e Initial load duke parents: diff changeset	197 assert (obj->is_constantPool(), "obj must be constant pool");
a61af66fc99e Initial load duke parents: diff changeset	198 // Performance tweak: We skip iterating over the klass pointer since we
a61af66fc99e Initial load duke parents: diff changeset	199 // know that Universe::constantPoolKlassObj never moves.
a61af66fc99e Initial load duke parents: diff changeset	200 constantPoolOop cp = (constantPoolOop) obj;
a61af66fc99e Initial load duke parents: diff changeset	201 // Get size before changing pointers.
a61af66fc99e Initial load duke parents: diff changeset	202 // Don't call size() or oop_size() since that is a virtual call.
a61af66fc99e Initial load duke parents: diff changeset	203 int size = cp->object_size();
a61af66fc99e Initial load duke parents: diff changeset	204
a61af66fc99e Initial load duke parents: diff changeset	205 // If the tags array is null we are in the middle of allocating this constant
a61af66fc99e Initial load duke parents: diff changeset	206 // pool.
a61af66fc99e Initial load duke parents: diff changeset	207 if (cp->tags() != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	208 oop* base = (oop*)cp->base();
a61af66fc99e Initial load duke parents: diff changeset	209 for (int i = 0; i < cp->length(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	210 if (cp->is_pointer_entry(i)) {
a61af66fc99e Initial load duke parents: diff changeset	211 blk->do_oop(base);
a61af66fc99e Initial load duke parents: diff changeset	212 }
a61af66fc99e Initial load duke parents: diff changeset	213 base++;
a61af66fc99e Initial load duke parents: diff changeset	214 }
a61af66fc99e Initial load duke parents: diff changeset	215 }
a61af66fc99e Initial load duke parents: diff changeset	216 blk->do_oop(cp->tags_addr());
a61af66fc99e Initial load duke parents: diff changeset	217 blk->do_oop(cp->cache_addr());
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1713 diff changeset	218 blk->do_oop(cp->operands_addr());
0 a61af66fc99e Initial load duke parents: diff changeset	219 blk->do_oop(cp->pool_holder_addr());
a61af66fc99e Initial load duke parents: diff changeset	220 return size;
a61af66fc99e Initial load duke parents: diff changeset	221 }
a61af66fc99e Initial load duke parents: diff changeset	222
a61af66fc99e Initial load duke parents: diff changeset	223
a61af66fc99e Initial load duke parents: diff changeset	224 int constantPoolKlass::oop_oop_iterate_m(oop obj, OopClosure* blk, MemRegion mr) {
a61af66fc99e Initial load duke parents: diff changeset	225 assert (obj->is_constantPool(), "obj must be constant pool");
a61af66fc99e Initial load duke parents: diff changeset	226 // Performance tweak: We skip iterating over the klass pointer since we
a61af66fc99e Initial load duke parents: diff changeset	227 // know that Universe::constantPoolKlassObj never moves.
a61af66fc99e Initial load duke parents: diff changeset	228 constantPoolOop cp = (constantPoolOop) obj;
a61af66fc99e Initial load duke parents: diff changeset	229 // Get size before changing pointers.
a61af66fc99e Initial load duke parents: diff changeset	230 // Don't call size() or oop_size() since that is a virtual call.
a61af66fc99e Initial load duke parents: diff changeset	231 int size = cp->object_size();
a61af66fc99e Initial load duke parents: diff changeset	232
a61af66fc99e Initial load duke parents: diff changeset	233 // If the tags array is null we are in the middle of allocating this constant
a61af66fc99e Initial load duke parents: diff changeset	234 // pool.
a61af66fc99e Initial load duke parents: diff changeset	235 if (cp->tags() != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	236 oop* base = (oop*)cp->base();
a61af66fc99e Initial load duke parents: diff changeset	237 for (int i = 0; i < cp->length(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	238 if (mr.contains(base)) {
a61af66fc99e Initial load duke parents: diff changeset	239 if (cp->is_pointer_entry(i)) {
a61af66fc99e Initial load duke parents: diff changeset	240 blk->do_oop(base);
a61af66fc99e Initial load duke parents: diff changeset	241 }
a61af66fc99e Initial load duke parents: diff changeset	242 }
a61af66fc99e Initial load duke parents: diff changeset	243 base++;
a61af66fc99e Initial load duke parents: diff changeset	244 }
a61af66fc99e Initial load duke parents: diff changeset	245 }
a61af66fc99e Initial load duke parents: diff changeset	246 oop* addr;
a61af66fc99e Initial load duke parents: diff changeset	247 addr = cp->tags_addr();
2427 a0de1dfd1933 7030435: Some oop_oop_iterate_m() methods iterate outside of specified memory bounds ysr parents: 2379 diff changeset	248 if (mr.contains(addr)) blk->do_oop(addr);
0 a61af66fc99e Initial load duke parents: diff changeset	249 addr = cp->cache_addr();
2427 a0de1dfd1933 7030435: Some oop_oop_iterate_m() methods iterate outside of specified memory bounds ysr parents: 2379 diff changeset	250 if (mr.contains(addr)) blk->do_oop(addr);
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1713 diff changeset	251 addr = cp->operands_addr();
2427 a0de1dfd1933 7030435: Some oop_oop_iterate_m() methods iterate outside of specified memory bounds ysr parents: 2379 diff changeset	252 if (mr.contains(addr)) blk->do_oop(addr);
0 a61af66fc99e Initial load duke parents: diff changeset	253 addr = cp->pool_holder_addr();
2427 a0de1dfd1933 7030435: Some oop_oop_iterate_m() methods iterate outside of specified memory bounds ysr parents: 2379 diff changeset	254 if (mr.contains(addr)) blk->do_oop(addr);
0 a61af66fc99e Initial load duke parents: diff changeset	255 return size;
a61af66fc99e Initial load duke parents: diff changeset	256 }
a61af66fc99e Initial load duke parents: diff changeset	257
518 0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark" jmasa parents: 431 diff changeset	258 bool constantPoolKlass::oop_is_conc_safe(oop obj) const {
0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark" jmasa parents: 431 diff changeset	259 assert(obj->is_constantPool(), "must be constantPool");
0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark" jmasa parents: 431 diff changeset	260 return constantPoolOop(obj)->is_conc_safe();
0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark" jmasa parents: 431 diff changeset	261 }
0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark" jmasa parents: 431 diff changeset	262
0 a61af66fc99e Initial load duke parents: diff changeset	263 #ifndef SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	264 int constantPoolKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
a61af66fc99e Initial load duke parents: diff changeset	265 assert (obj->is_constantPool(), "obj must be constant pool");
a61af66fc99e Initial load duke parents: diff changeset	266 constantPoolOop cp = (constantPoolOop) obj;
a61af66fc99e Initial load duke parents: diff changeset	267
a61af66fc99e Initial load duke parents: diff changeset	268 // If the tags array is null we are in the middle of allocating this constant
a61af66fc99e Initial load duke parents: diff changeset	269 // pool.
a61af66fc99e Initial load duke parents: diff changeset	270 if (cp->tags() != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	271 oop* base = (oop*)cp->base();
a61af66fc99e Initial load duke parents: diff changeset	272 for (int i = 0; i < cp->length(); ++i, ++base) {
a61af66fc99e Initial load duke parents: diff changeset	273 if (cp->is_pointer_entry(i)) {
a61af66fc99e Initial load duke parents: diff changeset	274 PSParallelCompact::adjust_pointer(base);
a61af66fc99e Initial load duke parents: diff changeset	275 }
a61af66fc99e Initial load duke parents: diff changeset	276 }
a61af66fc99e Initial load duke parents: diff changeset	277 }
a61af66fc99e Initial load duke parents: diff changeset	278 PSParallelCompact::adjust_pointer(cp->tags_addr());
a61af66fc99e Initial load duke parents: diff changeset	279 PSParallelCompact::adjust_pointer(cp->cache_addr());
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1713 diff changeset	280 PSParallelCompact::adjust_pointer(cp->operands_addr());
0 a61af66fc99e Initial load duke parents: diff changeset	281 PSParallelCompact::adjust_pointer(cp->pool_holder_addr());
a61af66fc99e Initial load duke parents: diff changeset	282 return cp->object_size();
a61af66fc99e Initial load duke parents: diff changeset	283 }
a61af66fc99e Initial load duke parents: diff changeset	284
a61af66fc99e Initial load duke parents: diff changeset	285 void constantPoolKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
a61af66fc99e Initial load duke parents: diff changeset	286 assert(obj->is_constantPool(), "should be constant pool");
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	287 constantPoolOop cp = (constantPoolOop) obj;
3368 69c94f488271 7043040: JSR292: JRuby bench/shootout/binarytrees.ruby-2.ruby SEGV: constantPoolKlass::oop_follow_contents never parents: 2468 diff changeset	288 if (cp->tags() != NULL) {
2379 b099aaf51bf8 6962931: move interned strings out of the perm gen jcoomes parents: 2229 diff changeset	289 for (int i = 1; i < cp->length(); ++i) {
3368 69c94f488271 7043040: JSR292: JRuby bench/shootout/binarytrees.ruby-2.ruby SEGV: constantPoolKlass::oop_follow_contents never parents: 2468 diff changeset	290 if (cp->is_pointer_entry(i)) {
2379 b099aaf51bf8 6962931: move interned strings out of the perm gen jcoomes parents: 2229 diff changeset	291 oop* base = cp->obj_at_addr_raw(i);
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	292 if (PSScavenge::should_scavenge(base)) {
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	293 pm->claim_or_forward_depth(base);
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	294 }
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	295 }
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	296 }
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	297 }
0 a61af66fc99e Initial load duke parents: diff changeset	298 }
a61af66fc99e Initial load duke parents: diff changeset	299 #endif // SERIALGC
a61af66fc99e Initial load duke parents: diff changeset	300
a61af66fc99e Initial load duke parents: diff changeset	301 // Printing
a61af66fc99e Initial load duke parents: diff changeset	302
a61af66fc99e Initial load duke parents: diff changeset	303 void constantPoolKlass::oop_print_on(oop obj, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	304 EXCEPTION_MARK;
a61af66fc99e Initial load duke parents: diff changeset	305 oop anObj;
a61af66fc99e Initial load duke parents: diff changeset	306 assert(obj->is_constantPool(), "must be constantPool");
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	307 Klass::oop_print_on(obj, st);
0 a61af66fc99e Initial load duke parents: diff changeset	308 constantPoolOop cp = constantPoolOop(obj);
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	309 if (cp->flags() != 0) {
1573 beb77f0d41b3 6957004: MethodComparator uses the wrong CP index accessor jrose parents: 1155 diff changeset	310 st->print(" - flags: 0x%x", cp->flags());
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	311 if (cp->has_pseudo_string()) st->print(" has_pseudo_string");
726 be93aad57795 6655646: dynamic languages need dynamically linked call sites jrose parents: 579 diff changeset	312 if (cp->has_invokedynamic()) st->print(" has_invokedynamic");
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	313 st->cr();
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	314 }
1573 beb77f0d41b3 6957004: MethodComparator uses the wrong CP index accessor jrose parents: 1155 diff changeset	315 st->print_cr(" - cache: " INTPTR_FORMAT, cp->cache());
0 a61af66fc99e Initial load duke parents: diff changeset	316
a61af66fc99e Initial load duke parents: diff changeset	317 for (int index = 1; index < cp->length(); index++) { // Index 0 is unused
a61af66fc99e Initial load duke parents: diff changeset	318 st->print(" - %3d : ", index);
a61af66fc99e Initial load duke parents: diff changeset	319 cp->tag_at(index).print_on(st);
a61af66fc99e Initial load duke parents: diff changeset	320 st->print(" : ");
a61af66fc99e Initial load duke parents: diff changeset	321 switch (cp->tag_at(index).value()) {
a61af66fc99e Initial load duke parents: diff changeset	322 case JVM_CONSTANT_Class :
a61af66fc99e Initial load duke parents: diff changeset	323 { anObj = cp->klass_at(index, CATCH);
a61af66fc99e Initial load duke parents: diff changeset	324 anObj->print_value_on(st);
a61af66fc99e Initial load duke parents: diff changeset	325 st->print(" {0x%lx}", (address)anObj);
a61af66fc99e Initial load duke parents: diff changeset	326 }
a61af66fc99e Initial load duke parents: diff changeset	327 break;
a61af66fc99e Initial load duke parents: diff changeset	328 case JVM_CONSTANT_Fieldref :
a61af66fc99e Initial load duke parents: diff changeset	329 case JVM_CONSTANT_Methodref :
a61af66fc99e Initial load duke parents: diff changeset	330 case JVM_CONSTANT_InterfaceMethodref :
1573 beb77f0d41b3 6957004: MethodComparator uses the wrong CP index accessor jrose parents: 1155 diff changeset	331 st->print("klass_index=%d", cp->uncached_klass_ref_index_at(index));
beb77f0d41b3 6957004: MethodComparator uses the wrong CP index accessor jrose parents: 1155 diff changeset	332 st->print(" name_and_type_index=%d", cp->uncached_name_and_type_ref_index_at(index));
0 a61af66fc99e Initial load duke parents: diff changeset	333 break;
a61af66fc99e Initial load duke parents: diff changeset	334 case JVM_CONSTANT_UnresolvedString :
a61af66fc99e Initial load duke parents: diff changeset	335 case JVM_CONSTANT_String :
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	336 if (cp->is_pseudo_string_at(index)) {
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	337 anObj = cp->pseudo_string_at(index);
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	338 } else {
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	339 anObj = cp->string_at(index, CATCH);
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	340 }
0 a61af66fc99e Initial load duke parents: diff changeset	341 anObj->print_value_on(st);
a61af66fc99e Initial load duke parents: diff changeset	342 st->print(" {0x%lx}", (address)anObj);
a61af66fc99e Initial load duke parents: diff changeset	343 break;
3368 69c94f488271 7043040: JSR292: JRuby bench/shootout/binarytrees.ruby-2.ruby SEGV: constantPoolKlass::oop_follow_contents never parents: 2468 diff changeset	344 case JVM_CONSTANT_Object :
69c94f488271 7043040: JSR292: JRuby bench/shootout/binarytrees.ruby-2.ruby SEGV: constantPoolKlass::oop_follow_contents never parents: 2468 diff changeset	345 anObj = cp->object_at(index);
69c94f488271 7043040: JSR292: JRuby bench/shootout/binarytrees.ruby-2.ruby SEGV: constantPoolKlass::oop_follow_contents never parents: 2468 diff changeset	346 anObj->print_value_on(st);
69c94f488271 7043040: JSR292: JRuby bench/shootout/binarytrees.ruby-2.ruby SEGV: constantPoolKlass::oop_follow_contents never parents: 2468 diff changeset	347 st->print(" {0x%lx}", (address)anObj);
69c94f488271 7043040: JSR292: JRuby bench/shootout/binarytrees.ruby-2.ruby SEGV: constantPoolKlass::oop_follow_contents never parents: 2468 diff changeset	348 break;
0 a61af66fc99e Initial load duke parents: diff changeset	349 case JVM_CONSTANT_Integer :
a61af66fc99e Initial load duke parents: diff changeset	350 st->print("%d", cp->int_at(index));
a61af66fc99e Initial load duke parents: diff changeset	351 break;
a61af66fc99e Initial load duke parents: diff changeset	352 case JVM_CONSTANT_Float :
a61af66fc99e Initial load duke parents: diff changeset	353 st->print("%f", cp->float_at(index));
a61af66fc99e Initial load duke parents: diff changeset	354 break;
a61af66fc99e Initial load duke parents: diff changeset	355 case JVM_CONSTANT_Long :
a61af66fc99e Initial load duke parents: diff changeset	356 st->print_jlong(cp->long_at(index));
a61af66fc99e Initial load duke parents: diff changeset	357 index++; // Skip entry following eigth-byte constant
a61af66fc99e Initial load duke parents: diff changeset	358 break;
a61af66fc99e Initial load duke parents: diff changeset	359 case JVM_CONSTANT_Double :
a61af66fc99e Initial load duke parents: diff changeset	360 st->print("%lf", cp->double_at(index));
a61af66fc99e Initial load duke parents: diff changeset	361 index++; // Skip entry following eigth-byte constant
a61af66fc99e Initial load duke parents: diff changeset	362 break;
a61af66fc99e Initial load duke parents: diff changeset	363 case JVM_CONSTANT_NameAndType :
a61af66fc99e Initial load duke parents: diff changeset	364 st->print("name_index=%d", cp->name_ref_index_at(index));
a61af66fc99e Initial load duke parents: diff changeset	365 st->print(" signature_index=%d", cp->signature_ref_index_at(index));
a61af66fc99e Initial load duke parents: diff changeset	366 break;
a61af66fc99e Initial load duke parents: diff changeset	367 case JVM_CONSTANT_Utf8 :
a61af66fc99e Initial load duke parents: diff changeset	368 cp->symbol_at(index)->print_value_on(st);
a61af66fc99e Initial load duke parents: diff changeset	369 break;
a61af66fc99e Initial load duke parents: diff changeset	370 case JVM_CONSTANT_UnresolvedClass : // fall-through
a61af66fc99e Initial load duke parents: diff changeset	371 case JVM_CONSTANT_UnresolvedClassInError: {
a61af66fc99e Initial load duke parents: diff changeset	372 // unresolved_klass_at requires lock or safe world.
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	373 CPSlot entry = cp->slot_at(index);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	374 if (entry.is_oop()) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	375 entry.get_oop()->print_value_on(st);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	376 } else {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	377 entry.get_symbol()->print_value_on(st);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	378 }
0 a61af66fc99e Initial load duke parents: diff changeset	379 }
a61af66fc99e Initial load duke parents: diff changeset	380 break;
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	381 case JVM_CONSTANT_MethodHandle :
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	382 st->print("ref_kind=%d", cp->method_handle_ref_kind_at(index));
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	383 st->print(" ref_index=%d", cp->method_handle_index_at(index));
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	384 break;
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	385 case JVM_CONSTANT_MethodType :
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	386 st->print("signature_index=%d", cp->method_type_index_at(index));
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1579 diff changeset	387 break;
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	388 case JVM_CONSTANT_InvokeDynamic :
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1713 diff changeset	389 {
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1713 diff changeset	390 st->print("bootstrap_method_index=%d", cp->invoke_dynamic_bootstrap_method_ref_index_at(index));
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1713 diff changeset	391 st->print(" name_and_type_index=%d", cp->invoke_dynamic_name_and_type_ref_index_at(index));
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1713 diff changeset	392 int argc = cp->invoke_dynamic_argument_count_at(index);
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1713 diff changeset	393 if (argc > 0) {
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1713 diff changeset	394 for (int arg_i = 0; arg_i < argc; arg_i++) {
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1713 diff changeset	395 int arg = cp->invoke_dynamic_argument_index_at(index, arg_i);
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1713 diff changeset	396 st->print((arg_i == 0 ? " arguments={%d" : ", %d"), arg);
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1713 diff changeset	397 }
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1713 diff changeset	398 st->print("}");
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1713 diff changeset	399 }
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1713 diff changeset	400 }
1660 083fde3b838e 6964498: JSR 292 invokedynamic sites need local bootstrap methods jrose parents: 1602 diff changeset	401 break;
0 a61af66fc99e Initial load duke parents: diff changeset	402 default:
a61af66fc99e Initial load duke parents: diff changeset	403 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	404 break;
a61af66fc99e Initial load duke parents: diff changeset	405 }
a61af66fc99e Initial load duke parents: diff changeset	406 st->cr();
a61af66fc99e Initial load duke parents: diff changeset	407 }
a61af66fc99e Initial load duke parents: diff changeset	408 st->cr();
a61af66fc99e Initial load duke parents: diff changeset	409 }
a61af66fc99e Initial load duke parents: diff changeset	410
1155 4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 726 diff changeset	411 void constantPoolKlass::oop_print_value_on(oop obj, outputStream* st) {
4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 726 diff changeset	412 assert(obj->is_constantPool(), "must be constantPool");
4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 726 diff changeset	413 constantPoolOop cp = constantPoolOop(obj);
4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 726 diff changeset	414 st->print("constant pool [%d]", cp->length());
4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 726 diff changeset	415 if (cp->has_pseudo_string()) st->print("/pseudo_string");
4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 726 diff changeset	416 if (cp->has_invokedynamic()) st->print("/invokedynamic");
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1713 diff changeset	417 if (cp->operands() != NULL) st->print("/operands[%d]", cp->operands()->length());
1155 4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 726 diff changeset	418 cp->print_address_on(st);
4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 726 diff changeset	419 st->print(" for ");
4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 726 diff changeset	420 cp->pool_holder()->print_value_on(st);
1573 beb77f0d41b3 6957004: MethodComparator uses the wrong CP index accessor jrose parents: 1155 diff changeset	421 if (cp->cache() != NULL) {
beb77f0d41b3 6957004: MethodComparator uses the wrong CP index accessor jrose parents: 1155 diff changeset	422 st->print(" cache=" PTR_FORMAT, cp->cache());
beb77f0d41b3 6957004: MethodComparator uses the wrong CP index accessor jrose parents: 1155 diff changeset	423 }
1155 4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 726 diff changeset	424 }
0 a61af66fc99e Initial load duke parents: diff changeset	425
a61af66fc99e Initial load duke parents: diff changeset	426 const char* constantPoolKlass::internal_name() const {
a61af66fc99e Initial load duke parents: diff changeset	427 return "{constant pool}";
a61af66fc99e Initial load duke parents: diff changeset	428 }
a61af66fc99e Initial load duke parents: diff changeset	429
a61af66fc99e Initial load duke parents: diff changeset	430 // Verification
a61af66fc99e Initial load duke parents: diff changeset	431
a61af66fc99e Initial load duke parents: diff changeset	432 void constantPoolKlass::oop_verify_on(oop obj, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	433 Klass::oop_verify_on(obj, st);
a61af66fc99e Initial load duke parents: diff changeset	434 guarantee(obj->is_constantPool(), "object must be constant pool");
a61af66fc99e Initial load duke parents: diff changeset	435 constantPoolOop cp = constantPoolOop(obj);
a61af66fc99e Initial load duke parents: diff changeset	436 guarantee(cp->is_perm(), "should be in permspace");
a61af66fc99e Initial load duke parents: diff changeset	437 if (!cp->partially_loaded()) {
a61af66fc99e Initial load duke parents: diff changeset	438 for (int i = 0; i< cp->length(); i++) {
3368 69c94f488271 7043040: JSR292: JRuby bench/shootout/binarytrees.ruby-2.ruby SEGV: constantPoolKlass::oop_follow_contents never parents: 2468 diff changeset	439 constantTag tag = cp->tag_at(i);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	440 CPSlot entry = cp->slot_at(i);
3368 69c94f488271 7043040: JSR292: JRuby bench/shootout/binarytrees.ruby-2.ruby SEGV: constantPoolKlass::oop_follow_contents never parents: 2468 diff changeset	441 if (tag.is_klass()) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	442 if (entry.is_oop()) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	443 guarantee(entry.get_oop()->is_perm(), "should be in permspace");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	444 guarantee(entry.get_oop()->is_klass(), "should be klass");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	445 }
3368 69c94f488271 7043040: JSR292: JRuby bench/shootout/binarytrees.ruby-2.ruby SEGV: constantPoolKlass::oop_follow_contents never parents: 2468 diff changeset	446 } else if (tag.is_unresolved_klass()) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	447 if (entry.is_oop()) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	448 guarantee(entry.get_oop()->is_perm(), "should be in permspace");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	449 guarantee(entry.get_oop()->is_klass(), "should be klass");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	450 }
3368 69c94f488271 7043040: JSR292: JRuby bench/shootout/binarytrees.ruby-2.ruby SEGV: constantPoolKlass::oop_follow_contents never parents: 2468 diff changeset	451 } else if (tag.is_symbol()) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	452 guarantee(entry.get_symbol()->refcount() != 0, "should have nonzero reference count");
3368 69c94f488271 7043040: JSR292: JRuby bench/shootout/binarytrees.ruby-2.ruby SEGV: constantPoolKlass::oop_follow_contents never parents: 2468 diff changeset	453 } else if (tag.is_unresolved_string()) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	454 if (entry.is_oop()) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	455 guarantee(entry.get_oop()->is_perm(), "should be in permspace");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	456 guarantee(entry.get_oop()->is_instance(), "should be instance");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	457 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	458 else {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	459 guarantee(entry.get_symbol()->refcount() != 0, "should have nonzero reference count");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	460 }
3368 69c94f488271 7043040: JSR292: JRuby bench/shootout/binarytrees.ruby-2.ruby SEGV: constantPoolKlass::oop_follow_contents never parents: 2468 diff changeset	461 } else if (tag.is_string()) {
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	462 if (!cp->has_pseudo_string()) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	463 if (entry.is_oop()) {
2379 b099aaf51bf8 6962931: move interned strings out of the perm gen jcoomes parents: 2229 diff changeset	464 guarantee(!JavaObjectsInPerm \|\| entry.get_oop()->is_perm(),
b099aaf51bf8 6962931: move interned strings out of the perm gen jcoomes parents: 2229 diff changeset	465 "should be in permspace");
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	466 guarantee(entry.get_oop()->is_instance(), "should be instance");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2011 diff changeset	467 }
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	468 } else {
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	469 // can be non-perm, can be non-instance (array)
a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 196 diff changeset	470 }
3368 69c94f488271 7043040: JSR292: JRuby bench/shootout/binarytrees.ruby-2.ruby SEGV: constantPoolKlass::oop_follow_contents never parents: 2468 diff changeset	471 } else if (tag.is_object()) {
69c94f488271 7043040: JSR292: JRuby bench/shootout/binarytrees.ruby-2.ruby SEGV: constantPoolKlass::oop_follow_contents never parents: 2468 diff changeset	472 assert(entry.get_oop()->is_oop(), "should be some valid oop");
69c94f488271 7043040: JSR292: JRuby bench/shootout/binarytrees.ruby-2.ruby SEGV: constantPoolKlass::oop_follow_contents never parents: 2468 diff changeset	473 } else {
69c94f488271 7043040: JSR292: JRuby bench/shootout/binarytrees.ruby-2.ruby SEGV: constantPoolKlass::oop_follow_contents never parents: 2468 diff changeset	474 assert(!cp->is_pointer_entry(i), "unhandled oop type in constantPoolKlass::verify_on");
0 a61af66fc99e Initial load duke parents: diff changeset	475 }
a61af66fc99e Initial load duke parents: diff changeset	476 }
a61af66fc99e Initial load duke parents: diff changeset	477 guarantee(cp->tags()->is_perm(), "should be in permspace");
a61af66fc99e Initial load duke parents: diff changeset	478 guarantee(cp->tags()->is_typeArray(), "should be type array");
a61af66fc99e Initial load duke parents: diff changeset	479 if (cp->cache() != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	480 // Note: cache() can be NULL before a class is completely setup or
a61af66fc99e Initial load duke parents: diff changeset	481 // in temporary constant pools used during constant pool merging
a61af66fc99e Initial load duke parents: diff changeset	482 guarantee(cp->cache()->is_perm(), "should be in permspace");
a61af66fc99e Initial load duke parents: diff changeset	483 guarantee(cp->cache()->is_constantPoolCache(), "should be constant pool cache");
a61af66fc99e Initial load duke parents: diff changeset	484 }
1913 3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1713 diff changeset	485 if (cp->operands() != NULL) {
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1713 diff changeset	486 guarantee(cp->operands()->is_perm(), "should be in permspace");
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1713 diff changeset	487 guarantee(cp->operands()->is_typeArray(), "should be type array");
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters jrose parents: 1713 diff changeset	488 }
0 a61af66fc99e Initial load duke parents: diff changeset	489 if (cp->pool_holder() != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	490 // Note: pool_holder() can be NULL in temporary constant pools
a61af66fc99e Initial load duke parents: diff changeset	491 // used during constant pool merging
a61af66fc99e Initial load duke parents: diff changeset	492 guarantee(cp->pool_holder()->is_perm(), "should be in permspace");
a61af66fc99e Initial load duke parents: diff changeset	493 guarantee(cp->pool_holder()->is_klass(), "should be klass");
a61af66fc99e Initial load duke parents: diff changeset	494 }
a61af66fc99e Initial load duke parents: diff changeset	495 }
a61af66fc99e Initial load duke parents: diff changeset	496 }
a61af66fc99e Initial load duke parents: diff changeset	497
a61af66fc99e Initial load duke parents: diff changeset	498 bool constantPoolKlass::oop_partially_loaded(oop obj) const {
a61af66fc99e Initial load duke parents: diff changeset	499 assert(obj->is_constantPool(), "object must be constant pool");
a61af66fc99e Initial load duke parents: diff changeset	500 constantPoolOop cp = constantPoolOop(obj);
a61af66fc99e Initial load duke parents: diff changeset	501 return cp->tags() == NULL \|\| cp->pool_holder() == (klassOop) cp; // Check whether pool holder points to self
a61af66fc99e Initial load duke parents: diff changeset	502 }
a61af66fc99e Initial load duke parents: diff changeset	503
a61af66fc99e Initial load duke parents: diff changeset	504
a61af66fc99e Initial load duke parents: diff changeset	505 void constantPoolKlass::oop_set_partially_loaded(oop obj) {
a61af66fc99e Initial load duke parents: diff changeset	506 assert(obj->is_constantPool(), "object must be constant pool");
a61af66fc99e Initial load duke parents: diff changeset	507 constantPoolOop cp = constantPoolOop(obj);
a61af66fc99e Initial load duke parents: diff changeset	508 assert(cp->pool_holder() == NULL, "just checking");
a61af66fc99e Initial load duke parents: diff changeset	509 cp->set_pool_holder((klassOop) cp); // Temporarily set pool holder to point to self
a61af66fc99e Initial load duke parents: diff changeset	510 }
a61af66fc99e Initial load duke parents: diff changeset	511
a61af66fc99e Initial load duke parents: diff changeset	512 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	513 // CompileTheWorld support. Preload all classes loaded references in the passed in constantpool
a61af66fc99e Initial load duke parents: diff changeset	514 void constantPoolKlass::preload_and_initialize_all_classes(oop obj, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	515 guarantee(obj->is_constantPool(), "object must be constant pool");
a61af66fc99e Initial load duke parents: diff changeset	516 constantPoolHandle cp(THREAD, (constantPoolOop)obj);
a61af66fc99e Initial load duke parents: diff changeset	517 guarantee(!cp->partially_loaded(), "must be fully loaded");
a61af66fc99e Initial load duke parents: diff changeset	518
a61af66fc99e Initial load duke parents: diff changeset	519 for (int i = 0; i< cp->length(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	520 if (cp->tag_at(i).is_unresolved_klass()) {
a61af66fc99e Initial load duke parents: diff changeset	521 // This will force loading of the class
a61af66fc99e Initial load duke parents: diff changeset	522 klassOop klass = cp->klass_at(i, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	523 if (klass->is_instance()) {
a61af66fc99e Initial load duke parents: diff changeset	524 // Force initialization of class
a61af66fc99e Initial load duke parents: diff changeset	525 instanceKlass::cast(klass)->initialize(CHECK);
a61af66fc99e Initial load duke parents: diff changeset	526 }
a61af66fc99e Initial load duke parents: diff changeset	527 }
a61af66fc99e Initial load duke parents: diff changeset	528 }
a61af66fc99e Initial load duke parents: diff changeset	529 }
a61af66fc99e Initial load duke parents: diff changeset	530
a61af66fc99e Initial load duke parents: diff changeset	531 #endif

Mercurial > hg > truffle

annotate src/share/vm/oops/constantPoolKlass.cpp @ 3762:5c0a3c1858b1