Tue, 10 May 2011 17:44:14 -0700
7043040: JSR292: JRuby bench/shootout/binarytrees.ruby-2.ruby SEGV: constantPoolKlass::oop_follow_contents
Reviewed-by: kvn, ysr
1 /*
2 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
25 #include "precompiled.hpp"
26 #include "classfile/javaClasses.hpp"
27 #include "gc_implementation/shared/markSweep.inline.hpp"
28 #include "gc_interface/collectedHeap.inline.hpp"
29 #include "memory/oopFactory.hpp"
30 #include "memory/permGen.hpp"
31 #include "memory/universe.inline.hpp"
32 #include "oops/constantPoolKlass.hpp"
33 #include "oops/constantPoolOop.hpp"
34 #include "oops/oop.inline.hpp"
35 #include "oops/oop.inline2.hpp"
36 #include "oops/symbol.hpp"
37 #include "runtime/handles.inline.hpp"
38 #ifdef TARGET_OS_FAMILY_linux
39 # include "thread_linux.inline.hpp"
40 #endif
41 #ifdef TARGET_OS_FAMILY_solaris
42 # include "thread_solaris.inline.hpp"
43 #endif
44 #ifdef TARGET_OS_FAMILY_windows
45 # include "thread_windows.inline.hpp"
46 #endif
47 #ifndef SERIALGC
48 #include "gc_implementation/parNew/parOopClosures.inline.hpp"
49 #include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"
50 #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp"
51 #include "memory/cardTableRS.hpp"
52 #include "oops/oop.pcgc.inline.hpp"
53 #endif
55 constantPoolOop constantPoolKlass::allocate(int length, bool is_conc_safe, TRAPS) {
56 int size = constantPoolOopDesc::object_size(length);
57 KlassHandle klass (THREAD, as_klassOop());
58 assert(klass()->is_oop(), "Can't be null, else handlizing of c below won't work");
59 constantPoolHandle pool;
60 {
61 constantPoolOop c =
62 (constantPoolOop)CollectedHeap::permanent_obj_allocate(klass, size, CHECK_NULL);
63 assert(c->klass_or_null() != NULL, "Handlizing below won't work");
64 pool = constantPoolHandle(THREAD, c);
65 }
67 pool->set_length(length);
68 pool->set_tags(NULL);
69 pool->set_cache(NULL);
70 pool->set_operands(NULL);
71 pool->set_pool_holder(NULL);
72 pool->set_flags(0);
73 // only set to non-zero if constant pool is merged by RedefineClasses
74 pool->set_orig_length(0);
75 // if constant pool may change during RedefineClasses, it is created
76 // unsafe for GC concurrent processing.
77 pool->set_is_conc_safe(is_conc_safe);
78 // all fields are initialized; needed for GC
80 // Note: because we may be in this "conc_unsafe" state when allocating
81 // t_oop below, which may in turn cause a GC, it is imperative that our
82 // size be correct, consistent and henceforth stable, at this stage.
83 assert(pool->is_oop() && pool->is_parsable(), "Else size() below is unreliable");
84 assert(size == pool->size(), "size() is wrong");
86 // initialize tag array
87 typeArrayOop t_oop = oopFactory::new_permanent_byteArray(length, CHECK_NULL);
88 typeArrayHandle tags (THREAD, t_oop);
89 for (int index = 0; index < length; index++) {
90 tags()->byte_at_put(index, JVM_CONSTANT_Invalid);
91 }
92 pool->set_tags(tags());
94 // Check that our size was stable at its old value.
95 assert(size == pool->size(), "size() changed");
96 return pool();
97 }
99 klassOop constantPoolKlass::create_klass(TRAPS) {
100 constantPoolKlass o;
101 KlassHandle h_this_klass(THREAD, Universe::klassKlassObj());
102 KlassHandle k = base_create_klass(h_this_klass, header_size(), o.vtbl_value(), CHECK_NULL);
103 // Make sure size calculation is right
104 assert(k()->size() == align_object_size(header_size()), "wrong size for object");
105 java_lang_Class::create_mirror(k, CHECK_NULL); // Allocate mirror
106 return k();
107 }
109 int constantPoolKlass::oop_size(oop obj) const {
110 assert(obj->is_constantPool(), "must be constantPool");
111 return constantPoolOop(obj)->object_size();
112 }
115 void constantPoolKlass::oop_follow_contents(oop obj) {
116 assert (obj->is_constantPool(), "obj must be constant pool");
117 constantPoolOop cp = (constantPoolOop) obj;
118 // Performance tweak: We skip iterating over the klass pointer since we
119 // know that Universe::constantPoolKlassObj never moves.
121 // If the tags array is null we are in the middle of allocating this constant pool
122 if (cp->tags() != NULL) {
123 // gc of constant pool contents
124 oop* base = (oop*)cp->base();
125 for (int i = 0; i < cp->length(); i++) {
126 if (cp->is_pointer_entry(i)) {
127 if (*base != NULL) MarkSweep::mark_and_push(base);
128 }
129 base++;
130 }
131 // gc of constant pool instance variables
132 MarkSweep::mark_and_push(cp->tags_addr());
133 MarkSweep::mark_and_push(cp->cache_addr());
134 MarkSweep::mark_and_push(cp->operands_addr());
135 MarkSweep::mark_and_push(cp->pool_holder_addr());
136 }
137 }
139 #ifndef SERIALGC
140 void constantPoolKlass::oop_follow_contents(ParCompactionManager* cm,
141 oop obj) {
142 assert (obj->is_constantPool(), "obj must be constant pool");
143 constantPoolOop cp = (constantPoolOop) obj;
144 // Performance tweak: We skip iterating over the klass pointer since we
145 // know that Universe::constantPoolKlassObj never moves.
147 // If the tags array is null we are in the middle of allocating this constant
148 // pool.
149 if (cp->tags() != NULL) {
150 // gc of constant pool contents
151 oop* base = (oop*)cp->base();
152 for (int i = 0; i < cp->length(); i++) {
153 if (cp->is_pointer_entry(i)) {
154 if (*base != NULL) PSParallelCompact::mark_and_push(cm, base);
155 }
156 base++;
157 }
158 // gc of constant pool instance variables
159 PSParallelCompact::mark_and_push(cm, cp->tags_addr());
160 PSParallelCompact::mark_and_push(cm, cp->cache_addr());
161 PSParallelCompact::mark_and_push(cm, cp->operands_addr());
162 PSParallelCompact::mark_and_push(cm, cp->pool_holder_addr());
163 }
164 }
165 #endif // SERIALGC
168 int constantPoolKlass::oop_adjust_pointers(oop obj) {
169 assert (obj->is_constantPool(), "obj must be constant pool");
170 constantPoolOop cp = (constantPoolOop) obj;
171 // Get size before changing pointers.
172 // Don't call size() or oop_size() since that is a virtual call.
173 int size = cp->object_size();
174 // Performance tweak: We skip iterating over the klass pointer since we
175 // know that Universe::constantPoolKlassObj never moves.
177 // If the tags array is null we are in the middle of allocating this constant
178 // pool.
179 if (cp->tags() != NULL) {
180 oop* base = (oop*)cp->base();
181 for (int i = 0; i< cp->length(); i++) {
182 if (cp->is_pointer_entry(i)) {
183 MarkSweep::adjust_pointer(base);
184 }
185 base++;
186 }
187 }
188 MarkSweep::adjust_pointer(cp->tags_addr());
189 MarkSweep::adjust_pointer(cp->cache_addr());
190 MarkSweep::adjust_pointer(cp->operands_addr());
191 MarkSweep::adjust_pointer(cp->pool_holder_addr());
192 return size;
193 }
196 int constantPoolKlass::oop_oop_iterate(oop obj, OopClosure* blk) {
197 assert (obj->is_constantPool(), "obj must be constant pool");
198 // Performance tweak: We skip iterating over the klass pointer since we
199 // know that Universe::constantPoolKlassObj never moves.
200 constantPoolOop cp = (constantPoolOop) obj;
201 // Get size before changing pointers.
202 // Don't call size() or oop_size() since that is a virtual call.
203 int size = cp->object_size();
205 // If the tags array is null we are in the middle of allocating this constant
206 // pool.
207 if (cp->tags() != NULL) {
208 oop* base = (oop*)cp->base();
209 for (int i = 0; i < cp->length(); i++) {
210 if (cp->is_pointer_entry(i)) {
211 blk->do_oop(base);
212 }
213 base++;
214 }
215 }
216 blk->do_oop(cp->tags_addr());
217 blk->do_oop(cp->cache_addr());
218 blk->do_oop(cp->operands_addr());
219 blk->do_oop(cp->pool_holder_addr());
220 return size;
221 }
224 int constantPoolKlass::oop_oop_iterate_m(oop obj, OopClosure* blk, MemRegion mr) {
225 assert (obj->is_constantPool(), "obj must be constant pool");
226 // Performance tweak: We skip iterating over the klass pointer since we
227 // know that Universe::constantPoolKlassObj never moves.
228 constantPoolOop cp = (constantPoolOop) obj;
229 // Get size before changing pointers.
230 // Don't call size() or oop_size() since that is a virtual call.
231 int size = cp->object_size();
233 // If the tags array is null we are in the middle of allocating this constant
234 // pool.
235 if (cp->tags() != NULL) {
236 oop* base = (oop*)cp->base();
237 for (int i = 0; i < cp->length(); i++) {
238 if (mr.contains(base)) {
239 if (cp->is_pointer_entry(i)) {
240 blk->do_oop(base);
241 }
242 }
243 base++;
244 }
245 }
246 oop* addr;
247 addr = cp->tags_addr();
248 if (mr.contains(addr)) blk->do_oop(addr);
249 addr = cp->cache_addr();
250 if (mr.contains(addr)) blk->do_oop(addr);
251 addr = cp->operands_addr();
252 if (mr.contains(addr)) blk->do_oop(addr);
253 addr = cp->pool_holder_addr();
254 if (mr.contains(addr)) blk->do_oop(addr);
255 return size;
256 }
258 bool constantPoolKlass::oop_is_conc_safe(oop obj) const {
259 assert(obj->is_constantPool(), "must be constantPool");
260 return constantPoolOop(obj)->is_conc_safe();
261 }
263 #ifndef SERIALGC
264 int constantPoolKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
265 assert (obj->is_constantPool(), "obj must be constant pool");
266 constantPoolOop cp = (constantPoolOop) obj;
268 // If the tags array is null we are in the middle of allocating this constant
269 // pool.
270 if (cp->tags() != NULL) {
271 oop* base = (oop*)cp->base();
272 for (int i = 0; i < cp->length(); ++i, ++base) {
273 if (cp->is_pointer_entry(i)) {
274 PSParallelCompact::adjust_pointer(base);
275 }
276 }
277 }
278 PSParallelCompact::adjust_pointer(cp->tags_addr());
279 PSParallelCompact::adjust_pointer(cp->cache_addr());
280 PSParallelCompact::adjust_pointer(cp->operands_addr());
281 PSParallelCompact::adjust_pointer(cp->pool_holder_addr());
282 return cp->object_size();
283 }
285 void constantPoolKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
286 assert(obj->is_constantPool(), "should be constant pool");
287 constantPoolOop cp = (constantPoolOop) obj;
288 if (cp->tags() != NULL) {
289 for (int i = 1; i < cp->length(); ++i) {
290 if (cp->is_pointer_entry(i)) {
291 oop* base = cp->obj_at_addr_raw(i);
292 if (PSScavenge::should_scavenge(base)) {
293 pm->claim_or_forward_depth(base);
294 }
295 }
296 }
297 }
298 }
299 #endif // SERIALGC
301 // Printing
303 void constantPoolKlass::oop_print_on(oop obj, outputStream* st) {
304 EXCEPTION_MARK;
305 oop anObj;
306 assert(obj->is_constantPool(), "must be constantPool");
307 Klass::oop_print_on(obj, st);
308 constantPoolOop cp = constantPoolOop(obj);
309 if (cp->flags() != 0) {
310 st->print(" - flags: 0x%x", cp->flags());
311 if (cp->has_pseudo_string()) st->print(" has_pseudo_string");
312 if (cp->has_invokedynamic()) st->print(" has_invokedynamic");
313 st->cr();
314 }
315 st->print_cr(" - cache: " INTPTR_FORMAT, cp->cache());
317 for (int index = 1; index < cp->length(); index++) { // Index 0 is unused
318 st->print(" - %3d : ", index);
319 cp->tag_at(index).print_on(st);
320 st->print(" : ");
321 switch (cp->tag_at(index).value()) {
322 case JVM_CONSTANT_Class :
323 { anObj = cp->klass_at(index, CATCH);
324 anObj->print_value_on(st);
325 st->print(" {0x%lx}", (address)anObj);
326 }
327 break;
328 case JVM_CONSTANT_Fieldref :
329 case JVM_CONSTANT_Methodref :
330 case JVM_CONSTANT_InterfaceMethodref :
331 st->print("klass_index=%d", cp->uncached_klass_ref_index_at(index));
332 st->print(" name_and_type_index=%d", cp->uncached_name_and_type_ref_index_at(index));
333 break;
334 case JVM_CONSTANT_UnresolvedString :
335 case JVM_CONSTANT_String :
336 if (cp->is_pseudo_string_at(index)) {
337 anObj = cp->pseudo_string_at(index);
338 } else {
339 anObj = cp->string_at(index, CATCH);
340 }
341 anObj->print_value_on(st);
342 st->print(" {0x%lx}", (address)anObj);
343 break;
344 case JVM_CONSTANT_Object :
345 anObj = cp->object_at(index);
346 anObj->print_value_on(st);
347 st->print(" {0x%lx}", (address)anObj);
348 break;
349 case JVM_CONSTANT_Integer :
350 st->print("%d", cp->int_at(index));
351 break;
352 case JVM_CONSTANT_Float :
353 st->print("%f", cp->float_at(index));
354 break;
355 case JVM_CONSTANT_Long :
356 st->print_jlong(cp->long_at(index));
357 index++; // Skip entry following eigth-byte constant
358 break;
359 case JVM_CONSTANT_Double :
360 st->print("%lf", cp->double_at(index));
361 index++; // Skip entry following eigth-byte constant
362 break;
363 case JVM_CONSTANT_NameAndType :
364 st->print("name_index=%d", cp->name_ref_index_at(index));
365 st->print(" signature_index=%d", cp->signature_ref_index_at(index));
366 break;
367 case JVM_CONSTANT_Utf8 :
368 cp->symbol_at(index)->print_value_on(st);
369 break;
370 case JVM_CONSTANT_UnresolvedClass : // fall-through
371 case JVM_CONSTANT_UnresolvedClassInError: {
372 // unresolved_klass_at requires lock or safe world.
373 CPSlot entry = cp->slot_at(index);
374 if (entry.is_oop()) {
375 entry.get_oop()->print_value_on(st);
376 } else {
377 entry.get_symbol()->print_value_on(st);
378 }
379 }
380 break;
381 case JVM_CONSTANT_MethodHandle :
382 st->print("ref_kind=%d", cp->method_handle_ref_kind_at(index));
383 st->print(" ref_index=%d", cp->method_handle_index_at(index));
384 break;
385 case JVM_CONSTANT_MethodType :
386 st->print("signature_index=%d", cp->method_type_index_at(index));
387 break;
388 case JVM_CONSTANT_InvokeDynamic :
389 {
390 st->print("bootstrap_method_index=%d", cp->invoke_dynamic_bootstrap_method_ref_index_at(index));
391 st->print(" name_and_type_index=%d", cp->invoke_dynamic_name_and_type_ref_index_at(index));
392 int argc = cp->invoke_dynamic_argument_count_at(index);
393 if (argc > 0) {
394 for (int arg_i = 0; arg_i < argc; arg_i++) {
395 int arg = cp->invoke_dynamic_argument_index_at(index, arg_i);
396 st->print((arg_i == 0 ? " arguments={%d" : ", %d"), arg);
397 }
398 st->print("}");
399 }
400 }
401 break;
402 default:
403 ShouldNotReachHere();
404 break;
405 }
406 st->cr();
407 }
408 st->cr();
409 }
411 void constantPoolKlass::oop_print_value_on(oop obj, outputStream* st) {
412 assert(obj->is_constantPool(), "must be constantPool");
413 constantPoolOop cp = constantPoolOop(obj);
414 st->print("constant pool [%d]", cp->length());
415 if (cp->has_pseudo_string()) st->print("/pseudo_string");
416 if (cp->has_invokedynamic()) st->print("/invokedynamic");
417 if (cp->operands() != NULL) st->print("/operands[%d]", cp->operands()->length());
418 cp->print_address_on(st);
419 st->print(" for ");
420 cp->pool_holder()->print_value_on(st);
421 if (cp->cache() != NULL) {
422 st->print(" cache=" PTR_FORMAT, cp->cache());
423 }
424 }
426 const char* constantPoolKlass::internal_name() const {
427 return "{constant pool}";
428 }
430 // Verification
432 void constantPoolKlass::oop_verify_on(oop obj, outputStream* st) {
433 Klass::oop_verify_on(obj, st);
434 guarantee(obj->is_constantPool(), "object must be constant pool");
435 constantPoolOop cp = constantPoolOop(obj);
436 guarantee(cp->is_perm(), "should be in permspace");
437 if (!cp->partially_loaded()) {
438 for (int i = 0; i< cp->length(); i++) {
439 constantTag tag = cp->tag_at(i);
440 CPSlot entry = cp->slot_at(i);
441 if (tag.is_klass()) {
442 if (entry.is_oop()) {
443 guarantee(entry.get_oop()->is_perm(), "should be in permspace");
444 guarantee(entry.get_oop()->is_klass(), "should be klass");
445 }
446 } else if (tag.is_unresolved_klass()) {
447 if (entry.is_oop()) {
448 guarantee(entry.get_oop()->is_perm(), "should be in permspace");
449 guarantee(entry.get_oop()->is_klass(), "should be klass");
450 }
451 } else if (tag.is_symbol()) {
452 guarantee(entry.get_symbol()->refcount() != 0, "should have nonzero reference count");
453 } else if (tag.is_unresolved_string()) {
454 if (entry.is_oop()) {
455 guarantee(entry.get_oop()->is_perm(), "should be in permspace");
456 guarantee(entry.get_oop()->is_instance(), "should be instance");
457 }
458 else {
459 guarantee(entry.get_symbol()->refcount() != 0, "should have nonzero reference count");
460 }
461 } else if (tag.is_string()) {
462 if (!cp->has_pseudo_string()) {
463 if (entry.is_oop()) {
464 guarantee(!JavaObjectsInPerm || entry.get_oop()->is_perm(),
465 "should be in permspace");
466 guarantee(entry.get_oop()->is_instance(), "should be instance");
467 }
468 } else {
469 // can be non-perm, can be non-instance (array)
470 }
471 } else if (tag.is_object()) {
472 assert(entry.get_oop()->is_oop(), "should be some valid oop");
473 } else {
474 assert(!cp->is_pointer_entry(i), "unhandled oop type in constantPoolKlass::verify_on");
475 }
476 }
477 guarantee(cp->tags()->is_perm(), "should be in permspace");
478 guarantee(cp->tags()->is_typeArray(), "should be type array");
479 if (cp->cache() != NULL) {
480 // Note: cache() can be NULL before a class is completely setup or
481 // in temporary constant pools used during constant pool merging
482 guarantee(cp->cache()->is_perm(), "should be in permspace");
483 guarantee(cp->cache()->is_constantPoolCache(), "should be constant pool cache");
484 }
485 if (cp->operands() != NULL) {
486 guarantee(cp->operands()->is_perm(), "should be in permspace");
487 guarantee(cp->operands()->is_typeArray(), "should be type array");
488 }
489 if (cp->pool_holder() != NULL) {
490 // Note: pool_holder() can be NULL in temporary constant pools
491 // used during constant pool merging
492 guarantee(cp->pool_holder()->is_perm(), "should be in permspace");
493 guarantee(cp->pool_holder()->is_klass(), "should be klass");
494 }
495 }
496 }
498 bool constantPoolKlass::oop_partially_loaded(oop obj) const {
499 assert(obj->is_constantPool(), "object must be constant pool");
500 constantPoolOop cp = constantPoolOop(obj);
501 return cp->tags() == NULL || cp->pool_holder() == (klassOop) cp; // Check whether pool holder points to self
502 }
505 void constantPoolKlass::oop_set_partially_loaded(oop obj) {
506 assert(obj->is_constantPool(), "object must be constant pool");
507 constantPoolOop cp = constantPoolOop(obj);
508 assert(cp->pool_holder() == NULL, "just checking");
509 cp->set_pool_holder((klassOop) cp); // Temporarily set pool holder to point to self
510 }
512 #ifndef PRODUCT
513 // CompileTheWorld support. Preload all classes loaded references in the passed in constantpool
514 void constantPoolKlass::preload_and_initialize_all_classes(oop obj, TRAPS) {
515 guarantee(obj->is_constantPool(), "object must be constant pool");
516 constantPoolHandle cp(THREAD, (constantPoolOop)obj);
517 guarantee(!cp->partially_loaded(), "must be fully loaded");
519 for (int i = 0; i< cp->length(); i++) {
520 if (cp->tag_at(i).is_unresolved_klass()) {
521 // This will force loading of the class
522 klassOop klass = cp->klass_at(i, CHECK);
523 if (klass->is_instance()) {
524 // Force initialization of class
525 instanceKlass::cast(klass)->initialize(CHECK);
526 }
527 }
528 }
529 }
531 #endif