Sat, 10 Sep 2011 17:29:02 -0700
7086585: make Java field injection more flexible
Reviewed-by: jrose, twisti, kvn, coleenp
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 if (cp->has_preresolution()) st->print(" has_preresolution");
314 st->cr();
315 }
316 if (cp->pool_holder() != NULL) {
317 bool extra = (instanceKlass::cast(cp->pool_holder())->constants() != cp);
318 st->print_cr(" - holder: " INTPTR_FORMAT "%s", cp->pool_holder(), (extra? " (extra)" : ""));
319 }
320 st->print_cr(" - cache: " INTPTR_FORMAT, cp->cache());
321 for (int index = 1; index < cp->length(); index++) { // Index 0 is unused
322 st->print(" - %3d : ", index);
323 cp->tag_at(index).print_on(st);
324 st->print(" : ");
325 switch (cp->tag_at(index).value()) {
326 case JVM_CONSTANT_Class :
327 { anObj = cp->klass_at(index, CATCH);
328 anObj->print_value_on(st);
329 st->print(" {0x%lx}", (address)anObj);
330 }
331 break;
332 case JVM_CONSTANT_Fieldref :
333 case JVM_CONSTANT_Methodref :
334 case JVM_CONSTANT_InterfaceMethodref :
335 st->print("klass_index=%d", cp->uncached_klass_ref_index_at(index));
336 st->print(" name_and_type_index=%d", cp->uncached_name_and_type_ref_index_at(index));
337 break;
338 case JVM_CONSTANT_UnresolvedString :
339 case JVM_CONSTANT_String :
340 if (cp->is_pseudo_string_at(index)) {
341 anObj = cp->pseudo_string_at(index);
342 } else {
343 anObj = cp->string_at(index, CATCH);
344 }
345 anObj->print_value_on(st);
346 st->print(" {0x%lx}", (address)anObj);
347 break;
348 case JVM_CONSTANT_Object :
349 anObj = cp->object_at(index);
350 anObj->print_value_on(st);
351 st->print(" {0x%lx}", (address)anObj);
352 break;
353 case JVM_CONSTANT_Integer :
354 st->print("%d", cp->int_at(index));
355 break;
356 case JVM_CONSTANT_Float :
357 st->print("%f", cp->float_at(index));
358 break;
359 case JVM_CONSTANT_Long :
360 st->print_jlong(cp->long_at(index));
361 index++; // Skip entry following eigth-byte constant
362 break;
363 case JVM_CONSTANT_Double :
364 st->print("%lf", cp->double_at(index));
365 index++; // Skip entry following eigth-byte constant
366 break;
367 case JVM_CONSTANT_NameAndType :
368 st->print("name_index=%d", cp->name_ref_index_at(index));
369 st->print(" signature_index=%d", cp->signature_ref_index_at(index));
370 break;
371 case JVM_CONSTANT_Utf8 :
372 cp->symbol_at(index)->print_value_on(st);
373 break;
374 case JVM_CONSTANT_UnresolvedClass : // fall-through
375 case JVM_CONSTANT_UnresolvedClassInError: {
376 // unresolved_klass_at requires lock or safe world.
377 CPSlot entry = cp->slot_at(index);
378 if (entry.is_oop()) {
379 entry.get_oop()->print_value_on(st);
380 } else {
381 entry.get_symbol()->print_value_on(st);
382 }
383 }
384 break;
385 case JVM_CONSTANT_MethodHandle :
386 st->print("ref_kind=%d", cp->method_handle_ref_kind_at(index));
387 st->print(" ref_index=%d", cp->method_handle_index_at(index));
388 break;
389 case JVM_CONSTANT_MethodType :
390 st->print("signature_index=%d", cp->method_type_index_at(index));
391 break;
392 case JVM_CONSTANT_InvokeDynamic :
393 {
394 st->print("bootstrap_method_index=%d", cp->invoke_dynamic_bootstrap_method_ref_index_at(index));
395 st->print(" name_and_type_index=%d", cp->invoke_dynamic_name_and_type_ref_index_at(index));
396 int argc = cp->invoke_dynamic_argument_count_at(index);
397 if (argc > 0) {
398 for (int arg_i = 0; arg_i < argc; arg_i++) {
399 int arg = cp->invoke_dynamic_argument_index_at(index, arg_i);
400 st->print((arg_i == 0 ? " arguments={%d" : ", %d"), arg);
401 }
402 st->print("}");
403 }
404 }
405 break;
406 default:
407 ShouldNotReachHere();
408 break;
409 }
410 st->cr();
411 }
412 st->cr();
413 }
415 void constantPoolKlass::oop_print_value_on(oop obj, outputStream* st) {
416 assert(obj->is_constantPool(), "must be constantPool");
417 constantPoolOop cp = constantPoolOop(obj);
418 st->print("constant pool [%d]", cp->length());
419 if (cp->has_pseudo_string()) st->print("/pseudo_string");
420 if (cp->has_invokedynamic()) st->print("/invokedynamic");
421 if (cp->has_preresolution()) st->print("/preresolution");
422 if (cp->operands() != NULL) st->print("/operands[%d]", cp->operands()->length());
423 cp->print_address_on(st);
424 st->print(" for ");
425 cp->pool_holder()->print_value_on(st);
426 if (cp->pool_holder() != NULL) {
427 bool extra = (instanceKlass::cast(cp->pool_holder())->constants() != cp);
428 if (extra) st->print(" (extra)");
429 }
430 if (cp->cache() != NULL) {
431 st->print(" cache=" PTR_FORMAT, cp->cache());
432 }
433 }
435 const char* constantPoolKlass::internal_name() const {
436 return "{constant pool}";
437 }
439 // Verification
441 void constantPoolKlass::oop_verify_on(oop obj, outputStream* st) {
442 Klass::oop_verify_on(obj, st);
443 guarantee(obj->is_constantPool(), "object must be constant pool");
444 constantPoolOop cp = constantPoolOop(obj);
445 guarantee(cp->is_perm(), "should be in permspace");
446 if (!cp->partially_loaded()) {
447 for (int i = 0; i< cp->length(); i++) {
448 constantTag tag = cp->tag_at(i);
449 CPSlot entry = cp->slot_at(i);
450 if (tag.is_klass()) {
451 if (entry.is_oop()) {
452 guarantee(entry.get_oop()->is_perm(), "should be in permspace");
453 guarantee(entry.get_oop()->is_klass(), "should be klass");
454 }
455 } else if (tag.is_unresolved_klass()) {
456 if (entry.is_oop()) {
457 guarantee(entry.get_oop()->is_perm(), "should be in permspace");
458 guarantee(entry.get_oop()->is_klass(), "should be klass");
459 }
460 } else if (tag.is_symbol()) {
461 guarantee(entry.get_symbol()->refcount() != 0, "should have nonzero reference count");
462 } else if (tag.is_unresolved_string()) {
463 if (entry.is_oop()) {
464 guarantee(entry.get_oop()->is_perm(), "should be in permspace");
465 guarantee(entry.get_oop()->is_instance(), "should be instance");
466 }
467 else {
468 guarantee(entry.get_symbol()->refcount() != 0, "should have nonzero reference count");
469 }
470 } else if (tag.is_string()) {
471 if (!cp->has_pseudo_string()) {
472 if (entry.is_oop()) {
473 guarantee(!JavaObjectsInPerm || entry.get_oop()->is_perm(),
474 "should be in permspace");
475 guarantee(entry.get_oop()->is_instance(), "should be instance");
476 }
477 } else {
478 // can be non-perm, can be non-instance (array)
479 }
480 } else if (tag.is_object()) {
481 assert(entry.get_oop()->is_oop(), "should be some valid oop");
482 } else {
483 assert(!cp->is_pointer_entry(i), "unhandled oop type in constantPoolKlass::verify_on");
484 }
485 }
486 guarantee(cp->tags()->is_perm(), "should be in permspace");
487 guarantee(cp->tags()->is_typeArray(), "should be type array");
488 if (cp->cache() != NULL) {
489 // Note: cache() can be NULL before a class is completely setup or
490 // in temporary constant pools used during constant pool merging
491 guarantee(cp->cache()->is_perm(), "should be in permspace");
492 guarantee(cp->cache()->is_constantPoolCache(), "should be constant pool cache");
493 }
494 if (cp->operands() != NULL) {
495 guarantee(cp->operands()->is_perm(), "should be in permspace");
496 guarantee(cp->operands()->is_typeArray(), "should be type array");
497 }
498 if (cp->pool_holder() != NULL) {
499 // Note: pool_holder() can be NULL in temporary constant pools
500 // used during constant pool merging
501 guarantee(cp->pool_holder()->is_perm(), "should be in permspace");
502 guarantee(cp->pool_holder()->is_klass(), "should be klass");
503 }
504 }
505 }
507 bool constantPoolKlass::oop_partially_loaded(oop obj) const {
508 assert(obj->is_constantPool(), "object must be constant pool");
509 constantPoolOop cp = constantPoolOop(obj);
510 return cp->tags() == NULL || cp->pool_holder() == (klassOop) cp; // Check whether pool holder points to self
511 }
514 void constantPoolKlass::oop_set_partially_loaded(oop obj) {
515 assert(obj->is_constantPool(), "object must be constant pool");
516 constantPoolOop cp = constantPoolOop(obj);
517 assert(cp->pool_holder() == NULL, "just checking");
518 cp->set_pool_holder((klassOop) cp); // Temporarily set pool holder to point to self
519 }
521 #ifndef PRODUCT
522 // CompileTheWorld support. Preload all classes loaded references in the passed in constantpool
523 void constantPoolKlass::preload_and_initialize_all_classes(oop obj, TRAPS) {
524 guarantee(obj->is_constantPool(), "object must be constant pool");
525 constantPoolHandle cp(THREAD, (constantPoolOop)obj);
526 guarantee(!cp->partially_loaded(), "must be fully loaded");
528 for (int i = 0; i< cp->length(); i++) {
529 if (cp->tag_at(i).is_unresolved_klass()) {
530 // This will force loading of the class
531 klassOop klass = cp->klass_at(i, CHECK);
532 if (klass->is_instance()) {
533 // Force initialization of class
534 instanceKlass::cast(klass)->initialize(CHECK);
535 }
536 }
537 }
538 }
540 #endif