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 */
24
25 #include "precompiled.hpp"
26 #include "classfile/javaClasses.hpp"
27 #include "classfile/symbolTable.hpp"
28 #include "classfile/vmSymbols.hpp"
29 #include "code/debugInfo.hpp"
30 #include "code/pcDesc.hpp"
31 #include "compiler/compilerOracle.hpp"
32 #include "interpreter/interpreter.hpp"
33 #include "memory/oopFactory.hpp"
34 #include "memory/resourceArea.hpp"
35 #include "memory/universe.inline.hpp"
36 #include "oops/instanceKlass.hpp"
37 #include "oops/instanceMirrorKlass.hpp"
38 #include "oops/klass.hpp"
39 #include "oops/klassOop.hpp"
40 #include "oops/methodOop.hpp"
41 #include "oops/symbol.hpp"
42 #include "oops/typeArrayOop.hpp"
43 #include "runtime/fieldDescriptor.hpp"
44 #include "runtime/handles.inline.hpp"
45 #include "runtime/interfaceSupport.hpp"
46 #include "runtime/java.hpp"
47 #include "runtime/javaCalls.hpp"
48 #include "runtime/safepoint.hpp"
49 #include "runtime/vframe.hpp"
50 #include "utilities/preserveException.hpp"
51 #ifdef TARGET_OS_FAMILY_linux
52 # include "thread_linux.inline.hpp"
53 #endif
54 #ifdef TARGET_OS_FAMILY_solaris
55 # include "thread_solaris.inline.hpp"
56 #endif
57 #ifdef TARGET_OS_FAMILY_windows
58 # include "thread_windows.inline.hpp"
59 #endif
60
61 static bool find_field(instanceKlass* ik,
62 Symbol* name_symbol, Symbol* signature_symbol,
63 fieldDescriptor* fd,
64 bool allow_super = false) {
65 if (allow_super)
66 return ik->find_field(name_symbol, signature_symbol, fd) != NULL;
67 else
68 return ik->find_local_field(name_symbol, signature_symbol, fd);
69 }
70
71 // Helpful routine for computing field offsets at run time rather than hardcoding them
72 static void
73 compute_offset(int &dest_offset,
74 klassOop klass_oop, Symbol* name_symbol, Symbol* signature_symbol,
75 bool allow_super = false) {
76 fieldDescriptor fd;
77 instanceKlass* ik = instanceKlass::cast(klass_oop);
78 if (!find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) {
79 ResourceMark rm;
80 tty->print_cr("Invalid layout of %s at %s", ik->external_name(), name_symbol->as_C_string());
411 mirror()->long_field_put(fd->offset(), fd->long_initial_value());
412 break;
413 case T_OBJECT:
414 {
415 #ifdef ASSERT
416 TempNewSymbol sym = SymbolTable::new_symbol("Ljava/lang/String;", CHECK);
417 assert(fd->signature() == sym, "just checking");
418 #endif
419 oop string = fd->string_initial_value(CHECK);
420 mirror()->obj_field_put(fd->offset(), string);
421 }
422 break;
423 default:
424 THROW_MSG(vmSymbols::java_lang_ClassFormatError(),
425 "Illegal ConstantValue attribute in class file");
426 }
427 }
428 }
429
430
431 // During bootstrap, java.lang.Class wasn't loaded so static field
432 // offsets were computed without the size added it. Go back and
433 // update all the static field offsets to included the size.
434 static void fixup_static_field(fieldDescriptor* fd, TRAPS) {
435 if (fd->is_static()) {
436 int real_offset = fd->offset() + instanceMirrorKlass::offset_of_static_fields();
437 typeArrayOop fields = instanceKlass::cast(fd->field_holder())->fields();
438 fields->short_at_put(fd->index() + instanceKlass::low_offset, extract_low_short_from_int(real_offset));
439 fields->short_at_put(fd->index() + instanceKlass::high_offset, extract_high_short_from_int(real_offset));
440 }
441 }
442
443 void java_lang_Class::fixup_mirror(KlassHandle k, TRAPS) {
444 assert(instanceMirrorKlass::offset_of_static_fields() != 0, "must have been computed already");
445
446 if (k->oop_is_instance()) {
447 // Fixup the offsets
448 instanceKlass::cast(k())->do_local_static_fields(&fixup_static_field, CHECK);
449 }
450 create_mirror(k, CHECK);
451 }
452
453 oop java_lang_Class::create_mirror(KlassHandle k, TRAPS) {
454 assert(k->java_mirror() == NULL, "should only assign mirror once");
455 // Use this moment of initialization to cache modifier_flags also,
456 // to support Class.getModifiers(). Instance classes recalculate
457 // the cached flags after the class file is parsed, but before the
458 // class is put into the system dictionary.
459 int computed_modifiers = k->compute_modifier_flags(CHECK_0);
460 k->set_modifier_flags(computed_modifiers);
461 if (SystemDictionary::Class_klass_loaded() && (k->oop_is_instance() || k->oop_is_javaArray())) {
462 // Allocate mirror (java.lang.Class instance)
463 Handle mirror = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(k, CHECK_0);
464 // Setup indirections
465 mirror->obj_field_put(klass_offset, k());
466 k->set_java_mirror(mirror());
467
468 instanceMirrorKlass* mk = instanceMirrorKlass::cast(mirror->klass());
469 java_lang_Class::set_oop_size(mirror(), mk->instance_size(k));
470 java_lang_Class::set_static_oop_field_count(mirror(), mk->compute_static_oop_field_count(mirror()));
471
472 // It might also have a component mirror. This mirror must already exist.
473 if (k->oop_is_javaArray()) {
474 Handle comp_mirror;
475 if (k->oop_is_typeArray()) {
476 BasicType type = typeArrayKlass::cast(k->as_klassOop())->element_type();
477 comp_mirror = Universe::java_mirror(type);
478 assert(comp_mirror.not_null(), "must have primitive mirror");
479 } else if (k->oop_is_objArray()) {
480 klassOop element_klass = objArrayKlass::cast(k->as_klassOop())->element_klass();
481 if (element_klass != NULL
482 && (Klass::cast(element_klass)->oop_is_instance() ||
483 Klass::cast(element_klass)->oop_is_javaArray())) {
484 comp_mirror = Klass::cast(element_klass)->java_mirror();
485 assert(comp_mirror.not_null(), "must have element mirror");
487 // else some object array internal to the VM, like systemObjArrayKlassObj
488 }
489 if (comp_mirror.not_null()) {
490 // Two-way link between the array klass and its component mirror:
491 arrayKlass::cast(k->as_klassOop())->set_component_mirror(comp_mirror());
492 set_array_klass(comp_mirror(), k->as_klassOop());
493 }
494 } else if (k->oop_is_instance()) {
495 // Initialize static fields
496 instanceKlass::cast(k())->do_local_static_fields(&initialize_static_field, CHECK_NULL);
497 }
498 return mirror();
499 } else {
500 return NULL;
501 }
502 }
503
504
505
506 int java_lang_Class::oop_size(oop java_class) {
507 assert(oop_size_offset != 0, "must be set");
508 return java_class->int_field(oop_size_offset);
509 }
510 void java_lang_Class::set_oop_size(oop java_class, int size) {
511 assert(oop_size_offset != 0, "must be set");
512 java_class->int_field_put(oop_size_offset, size);
513 }
514 int java_lang_Class::static_oop_field_count(oop java_class) {
515 assert(static_oop_field_count_offset != 0, "must be set");
516 return java_class->int_field(static_oop_field_count_offset);
517 }
518 void java_lang_Class::set_static_oop_field_count(oop java_class, int size) {
519 assert(static_oop_field_count_offset != 0, "must be set");
520 java_class->int_field_put(static_oop_field_count_offset, size);
521 }
522
523
524
525
526 oop java_lang_Class::create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS) {
527 // This should be improved by adding a field at the Java level or by
528 // introducing a new VM klass (see comment in ClassFileParser)
529 oop java_class = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance((oop)NULL, CHECK_0);
530 if (type != T_VOID) {
531 klassOop aklass = Universe::typeArrayKlassObj(type);
532 assert(aklass != NULL, "correct bootstrap");
533 set_array_klass(java_class, aklass);
534 }
535 instanceMirrorKlass* mk = instanceMirrorKlass::cast(SystemDictionary::Class_klass());
536 java_lang_Class::set_oop_size(java_class, mk->instance_size(oop(NULL)));
537 java_lang_Class::set_static_oop_field_count(java_class, 0);
538 return java_class;
539 }
540
541
542 klassOop java_lang_Class::as_klassOop(oop java_class) {
543 //%note memory_2
544 assert(java_lang_Class::is_instance(java_class), "must be a Class object");
545 klassOop k = klassOop(java_class->obj_field(klass_offset));
546 assert(k == NULL || k->is_klass(), "type check");
547 return k;
548 }
549
550
551 void java_lang_Class::print_signature(oop java_class, outputStream* st) {
552 assert(java_lang_Class::is_instance(java_class), "must be a Class object");
553 Symbol* name = NULL;
554 bool is_instance = false;
555 if (is_primitive(java_class)) {
556 name = vmSymbols::type_signature(primitive_type(java_class));
557 } else {
558 klassOop k = as_klassOop(java_class);
559 is_instance = Klass::cast(k)->oop_is_instance();
560 name = Klass::cast(k)->name();
561 }
562 if (name == NULL) {
563 st->print("<null>");
564 return;
565 }
581 klassOop k = as_klassOop(java_class);
582 if (!Klass::cast(k)->oop_is_instance()) {
583 name = Klass::cast(k)->name();
584 name->increment_refcount();
585 } else {
586 ResourceMark rm;
587 const char* sigstr = Klass::cast(k)->signature_name();
588 int siglen = (int) strlen(sigstr);
589 if (!intern_if_not_found) {
590 name = SymbolTable::probe(sigstr, siglen);
591 } else {
592 name = SymbolTable::new_symbol(sigstr, siglen, THREAD);
593 }
594 }
595 }
596 return name;
597 }
598
599
600 klassOop java_lang_Class::array_klass(oop java_class) {
601 klassOop k = klassOop(java_class->obj_field(array_klass_offset));
602 assert(k == NULL || k->is_klass() && Klass::cast(k)->oop_is_javaArray(), "should be array klass");
603 return k;
604 }
605
606
607 void java_lang_Class::set_array_klass(oop java_class, klassOop klass) {
608 assert(klass->is_klass() && Klass::cast(klass)->oop_is_javaArray(), "should be array klass");
609 java_class->obj_field_put(array_klass_offset, klass);
610 }
611
612
613 methodOop java_lang_Class::resolved_constructor(oop java_class) {
614 oop constructor = java_class->obj_field(resolved_constructor_offset);
615 assert(constructor == NULL || constructor->is_method(), "should be method");
616 return methodOop(constructor);
617 }
618
619
620 void java_lang_Class::set_resolved_constructor(oop java_class, methodOop constructor) {
621 assert(constructor->is_method(), "should be method");
622 java_class->obj_field_put(resolved_constructor_offset, constructor);
623 }
624
625
626 bool java_lang_Class::is_primitive(oop java_class) {
627 // should assert:
628 //assert(java_lang_Class::is_instance(java_class), "must be a Class object");
629 klassOop k = klassOop(java_class->obj_field(klass_offset));
630 return k == NULL;
631 }
632
633
634 BasicType java_lang_Class::primitive_type(oop java_class) {
635 assert(java_lang_Class::is_primitive(java_class), "just checking");
636 klassOop ak = klassOop(java_class->obj_field(array_klass_offset));
637 BasicType type = T_VOID;
638 if (ak != NULL) {
639 // Note: create_basic_type_mirror above initializes ak to a non-null value.
640 type = arrayKlass::cast(ak)->element_type();
641 } else {
642 assert(java_class == Universe::void_mirror(), "only valid non-array primitive");
643 }
644 assert(Universe::java_mirror(type) == java_class, "must be consistent");
645 return type;
646 }
647
648 BasicType java_lang_Class::as_BasicType(oop java_class, klassOop* reference_klass) {
649 assert(java_lang_Class::is_instance(java_class), "must be a Class object");
650 if (is_primitive(java_class)) {
651 if (reference_klass != NULL)
652 (*reference_klass) = NULL;
653 return primitive_type(java_class);
654 } else {
655 if (reference_klass != NULL)
656 (*reference_klass) = as_klassOop(java_class);
657 return T_OBJECT;
658 }
659 }
660
661
662 oop java_lang_Class::primitive_mirror(BasicType t) {
663 oop mirror = Universe::java_mirror(t);
664 assert(mirror != NULL && mirror->is_a(SystemDictionary::Class_klass()), "must be a Class");
665 assert(java_lang_Class::is_primitive(mirror), "must be primitive");
666 return mirror;
667 }
668
669 bool java_lang_Class::offsets_computed = false;
670 int java_lang_Class::classRedefinedCount_offset = -1;
671 int java_lang_Class::parallelCapable_offset = -1;
672
673 void java_lang_Class::compute_offsets() {
674 assert(!offsets_computed, "offsets should be initialized only once");
675 offsets_computed = true;
676
677 klassOop k = SystemDictionary::Class_klass();
678 // The classRedefinedCount field is only present starting in 1.5,
679 // so don't go fatal.
680 compute_optional_offset(classRedefinedCount_offset,
681 k, vmSymbols::classRedefinedCount_name(), vmSymbols::int_signature());
682
683 // The field indicating parallelCapable (parallelLockMap) is only present starting in 7,
684 klassOop k1 = SystemDictionary::ClassLoader_klass();
685 compute_optional_offset(parallelCapable_offset,
686 k1, vmSymbols::parallelCapable_name(), vmSymbols::concurrenthashmap_signature());
687 }
688
689 // For class loader classes, parallelCapable defined
690 // based on non-null field
691 // Written to by java.lang.ClassLoader, vm only reads this field, doesn't set it
692 bool java_lang_Class::parallelCapable(oop class_loader) {
693 if (!JDK_Version::is_gte_jdk17x_version()
694 || parallelCapable_offset == -1) {
695 // Default for backward compatibility is false
696 return false;
697 }
698 return (class_loader->obj_field(parallelCapable_offset) != NULL);
699 }
700
701 int java_lang_Class::classRedefinedCount(oop the_class_mirror) {
702 if (!JDK_Version::is_gte_jdk15x_version()
703 || classRedefinedCount_offset == -1) {
704 // The classRedefinedCount field is only present starting in 1.5.
705 // If we don't have an offset for it then just return -1 as a marker.
706 return -1;
707 }
708
709 return the_class_mirror->int_field(classRedefinedCount_offset);
710 }
711
712 void java_lang_Class::set_classRedefinedCount(oop the_class_mirror, int value) {
713 if (!JDK_Version::is_gte_jdk15x_version()
714 || classRedefinedCount_offset == -1) {
715 // The classRedefinedCount field is only present starting in 1.5.
716 // If we don't have an offset for it then nothing to set.
717 return;
718 }
719
720 the_class_mirror->int_field_put(classRedefinedCount_offset, value);
2291 }
2292
2293 jlong java_lang_ref_SoftReference::clock() {
2294 instanceKlass* ik = instanceKlass::cast(SystemDictionary::SoftReference_klass());
2295 jlong* offset = (jlong*)ik->static_field_addr(static_clock_offset);
2296 return *offset;
2297 }
2298
2299 void java_lang_ref_SoftReference::set_clock(jlong value) {
2300 instanceKlass* ik = instanceKlass::cast(SystemDictionary::SoftReference_klass());
2301 jlong* offset = (jlong*)ik->static_field_addr(static_clock_offset);
2302 *offset = value;
2303 }
2304
2305
2306 // Support for java_lang_invoke_MethodHandle
2307
2308 int java_lang_invoke_MethodHandle::_type_offset;
2309 int java_lang_invoke_MethodHandle::_vmtarget_offset;
2310 int java_lang_invoke_MethodHandle::_vmentry_offset;
2311 int java_lang_invoke_MethodHandle::_vmslots_offset;
2312
2313 int java_lang_invoke_MemberName::_clazz_offset;
2314 int java_lang_invoke_MemberName::_name_offset;
2315 int java_lang_invoke_MemberName::_type_offset;
2316 int java_lang_invoke_MemberName::_flags_offset;
2317 int java_lang_invoke_MemberName::_vmtarget_offset;
2318 int java_lang_invoke_MemberName::_vmindex_offset;
2319
2320 int java_lang_invoke_DirectMethodHandle::_vmindex_offset;
2321
2322 int java_lang_invoke_BoundMethodHandle::_argument_offset;
2323 int java_lang_invoke_BoundMethodHandle::_vmargslot_offset;
2324
2325 int java_lang_invoke_AdapterMethodHandle::_conversion_offset;
2326
2327 int java_lang_invoke_CountingMethodHandle::_vmcount_offset;
2328
2329 void java_lang_invoke_MethodHandle::compute_offsets() {
2330 klassOop k = SystemDictionary::MethodHandle_klass();
2331 if (k != NULL && EnableInvokeDynamic) {
2332 bool allow_super = false;
2333 compute_offset(_type_offset, k, vmSymbols::type_name(), vmSymbols::java_lang_invoke_MethodType_signature(), allow_super);
2334 compute_offset(_vmtarget_offset, k, vmSymbols::vmtarget_name(), vmSymbols::object_signature(), allow_super);
2335 compute_offset(_vmentry_offset, k, vmSymbols::vmentry_name(), vmSymbols::machine_word_signature(), allow_super);
2336
2337 // Note: MH.vmslots (if it is present) is a hoisted copy of MH.type.form.vmslots.
2338 // It is optional pending experiments to keep or toss.
2339 compute_optional_offset(_vmslots_offset, k, vmSymbols::vmslots_name(), vmSymbols::int_signature(), allow_super);
2340 }
2341 }
2342
2343 void java_lang_invoke_MemberName::compute_offsets() {
2344 klassOop k = SystemDictionary::MemberName_klass();
2345 if (k != NULL && EnableInvokeDynamic) {
2346 compute_offset(_clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature());
2347 compute_offset(_name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature());
2348 compute_offset(_type_offset, k, vmSymbols::type_name(), vmSymbols::object_signature());
2349 compute_offset(_flags_offset, k, vmSymbols::flags_name(), vmSymbols::int_signature());
2350 compute_offset(_vmtarget_offset, k, vmSymbols::vmtarget_name(), vmSymbols::object_signature());
2351 compute_offset(_vmindex_offset, k, vmSymbols::vmindex_name(), vmSymbols::int_signature());
2352 }
2353 }
2354
2355 void java_lang_invoke_DirectMethodHandle::compute_offsets() {
2356 klassOop k = SystemDictionary::DirectMethodHandle_klass();
2357 if (k != NULL && EnableInvokeDynamic) {
2358 compute_offset(_vmindex_offset, k, vmSymbols::vmindex_name(), vmSymbols::int_signature(), true);
2359 }
2360 }
2361
2362 void java_lang_invoke_BoundMethodHandle::compute_offsets() {
2363 klassOop k = SystemDictionary::BoundMethodHandle_klass();
2364 if (k != NULL && EnableInvokeDynamic) {
2365 compute_offset(_vmargslot_offset, k, vmSymbols::vmargslot_name(), vmSymbols::int_signature(), true);
2366 compute_offset(_argument_offset, k, vmSymbols::argument_name(), vmSymbols::object_signature(), true);
2367 }
2368 }
2369
2370 void java_lang_invoke_AdapterMethodHandle::compute_offsets() {
2371 klassOop k = SystemDictionary::AdapterMethodHandle_klass();
2372 if (k != NULL && EnableInvokeDynamic) {
2373 compute_offset(_conversion_offset, k, vmSymbols::conversion_name(), vmSymbols::int_signature(), true);
2374 }
2375 }
2376
2377 void java_lang_invoke_CountingMethodHandle::compute_offsets() {
2378 klassOop k = SystemDictionary::CountingMethodHandle_klass();
2382 }
2383
2384 int java_lang_invoke_CountingMethodHandle::vmcount(oop mh) {
2385 assert(is_instance(mh), "CMH only");
2386 return mh->int_field(_vmcount_offset);
2387 }
2388
2389 void java_lang_invoke_CountingMethodHandle::set_vmcount(oop mh, int count) {
2390 assert(is_instance(mh), "CMH only");
2391 mh->int_field_put(_vmcount_offset, count);
2392 }
2393
2394 oop java_lang_invoke_MethodHandle::type(oop mh) {
2395 return mh->obj_field(_type_offset);
2396 }
2397
2398 void java_lang_invoke_MethodHandle::set_type(oop mh, oop mtype) {
2399 mh->obj_field_put(_type_offset, mtype);
2400 }
2401
2402 int java_lang_invoke_MethodHandle::vmslots(oop mh) {
2403 int vmslots_offset = _vmslots_offset;
2404 if (vmslots_offset != 0) {
2405 #ifdef ASSERT
2406 int x = mh->int_field(vmslots_offset);
2407 int y = compute_vmslots(mh);
2408 assert(x == y, "correct hoisted value");
2409 #endif
2410 return mh->int_field(vmslots_offset);
2411 } else {
2412 return compute_vmslots(mh);
2413 }
2414 }
2415
2416 // if MH.vmslots exists, hoist into it the value of type.form.vmslots
2417 void java_lang_invoke_MethodHandle::init_vmslots(oop mh) {
2418 int vmslots_offset = _vmslots_offset;
2419 if (vmslots_offset != 0) {
2420 mh->int_field_put(vmslots_offset, compute_vmslots(mh));
2421 }
2422 }
2423
2424 // fetch type.form.vmslots, which is the number of JVM stack slots
2425 // required to carry the arguments of this MH
2426 int java_lang_invoke_MethodHandle::compute_vmslots(oop mh) {
2427 oop mtype = type(mh);
2428 if (mtype == NULL) return 0; // Java code would get NPE
2429 oop form = java_lang_invoke_MethodType::form(mtype);
2430 if (form == NULL) return 0; // Java code would get NPE
2431 return java_lang_invoke_MethodTypeForm::vmslots(form);
2432 }
2433
2434 // fetch the low-level entry point for this mh
2435 MethodHandleEntry* java_lang_invoke_MethodHandle::vmentry(oop mh) {
2436 return (MethodHandleEntry*) mh->address_field(_vmentry_offset);
2437 }
2438
2439 void java_lang_invoke_MethodHandle::set_vmentry(oop mh, MethodHandleEntry* me) {
2440 assert(_vmentry_offset != 0, "must be present");
2441
2442 // This is always the final step that initializes a valid method handle:
2443 mh->release_address_field_put(_vmentry_offset, (address) me);
2444
2445 // There should be enough memory barriers on exit from native methods
2446 // to ensure that the MH is fully initialized to all threads before
2626 return ptypes(mt)->length();
2627 }
2628
2629
2630
2631 // Support for java_lang_invoke_MethodTypeForm
2632
2633 int java_lang_invoke_MethodTypeForm::_vmslots_offset;
2634 int java_lang_invoke_MethodTypeForm::_vmlayout_offset;
2635 int java_lang_invoke_MethodTypeForm::_erasedType_offset;
2636 int java_lang_invoke_MethodTypeForm::_genericInvoker_offset;
2637
2638 void java_lang_invoke_MethodTypeForm::compute_offsets() {
2639 klassOop k = SystemDictionary::MethodTypeForm_klass();
2640 if (k != NULL) {
2641 compute_optional_offset(_vmslots_offset, k, vmSymbols::vmslots_name(), vmSymbols::int_signature(), true);
2642 compute_optional_offset(_vmlayout_offset, k, vmSymbols::vmlayout_name(), vmSymbols::object_signature());
2643 compute_optional_offset(_erasedType_offset, k, vmSymbols::erasedType_name(), vmSymbols::java_lang_invoke_MethodType_signature(), true);
2644 compute_optional_offset(_genericInvoker_offset, k, vmSymbols::genericInvoker_name(), vmSymbols::java_lang_invoke_MethodHandle_signature(), true);
2645 if (_genericInvoker_offset == 0) _genericInvoker_offset = -1; // set to explicit "empty" value
2646 }
2647 }
2648
2649 int java_lang_invoke_MethodTypeForm::vmslots(oop mtform) {
2650 assert(mtform->klass() == SystemDictionary::MethodTypeForm_klass(), "MTForm only");
2651 assert(_vmslots_offset > 0, "");
2652 return mtform->int_field(_vmslots_offset);
2653 }
2654
2655 oop java_lang_invoke_MethodTypeForm::vmlayout(oop mtform) {
2656 assert(mtform->klass() == SystemDictionary::MethodTypeForm_klass(), "MTForm only");
2657 assert(_vmlayout_offset > 0, "");
2658 return mtform->obj_field(_vmlayout_offset);
2659 }
2660
2661 oop java_lang_invoke_MethodTypeForm::init_vmlayout(oop mtform, oop cookie) {
2662 assert(mtform->klass() == SystemDictionary::MethodTypeForm_klass(), "MTForm only");
2663 oop previous = vmlayout(mtform);
2664 if (previous != NULL) {
2665 return previous; // someone else beat us to it
2734 }
2735 _isPrivileged_offset = fd.offset();
2736 }
2737
2738
2739 oop java_security_AccessControlContext::create(objArrayHandle context, bool isPrivileged, Handle privileged_context, TRAPS) {
2740 assert(_isPrivileged_offset != 0, "offsets should have been initialized");
2741 // Ensure klass is initialized
2742 instanceKlass::cast(SystemDictionary::AccessControlContext_klass())->initialize(CHECK_0);
2743 // Allocate result
2744 oop result = instanceKlass::cast(SystemDictionary::AccessControlContext_klass())->allocate_instance(CHECK_0);
2745 // Fill in values
2746 result->obj_field_put(_context_offset, context());
2747 result->obj_field_put(_privilegedContext_offset, privileged_context());
2748 result->bool_field_put(_isPrivileged_offset, isPrivileged);
2749 return result;
2750 }
2751
2752
2753 // Support for java_lang_ClassLoader
2754
2755 oop java_lang_ClassLoader::parent(oop loader) {
2756 assert(loader->is_oop(), "loader must be oop");
2757 return loader->obj_field(parent_offset);
2758 }
2759
2760
2761 bool java_lang_ClassLoader::is_trusted_loader(oop loader) {
2762 // Fix for 4474172; see evaluation for more details
2763 loader = non_reflection_class_loader(loader);
2764
2765 oop cl = SystemDictionary::java_system_loader();
2766 while(cl != NULL) {
2767 if (cl == loader) return true;
2768 cl = parent(cl);
2769 }
2770 return false;
2771 }
2772
2773 oop java_lang_ClassLoader::non_reflection_class_loader(oop loader) {
2774 if (loader != NULL) {
2775 // See whether this is one of the class loaders associated with
2776 // the generated bytecodes for reflection, and if so, "magically"
2777 // delegate to its parent to prevent class loading from occurring
2778 // in places where applications using reflection didn't expect it.
2779 klassOop delegating_cl_class = SystemDictionary::reflect_DelegatingClassLoader_klass();
2780 // This might be null in non-1.4 JDKs
2790 int java_lang_System::in_offset_in_bytes() {
2791 return (instanceMirrorKlass::offset_of_static_fields() + static_in_offset);
2792 }
2793
2794
2795 int java_lang_System::out_offset_in_bytes() {
2796 return (instanceMirrorKlass::offset_of_static_fields() + static_out_offset);
2797 }
2798
2799
2800 int java_lang_System::err_offset_in_bytes() {
2801 return (instanceMirrorKlass::offset_of_static_fields() + static_err_offset);
2802 }
2803
2804
2805
2806 int java_lang_String::value_offset;
2807 int java_lang_String::offset_offset;
2808 int java_lang_String::count_offset;
2809 int java_lang_String::hash_offset;
2810 int java_lang_Class::klass_offset;
2811 int java_lang_Class::array_klass_offset;
2812 int java_lang_Class::resolved_constructor_offset;
2813 int java_lang_Class::number_of_fake_oop_fields;
2814 int java_lang_Class::oop_size_offset;
2815 int java_lang_Class::static_oop_field_count_offset;
2816 int java_lang_Throwable::backtrace_offset;
2817 int java_lang_Throwable::detailMessage_offset;
2818 int java_lang_Throwable::cause_offset;
2819 int java_lang_Throwable::stackTrace_offset;
2820 int java_lang_Throwable::static_unassigned_stacktrace_offset;
2821 int java_lang_reflect_AccessibleObject::override_offset;
2822 int java_lang_reflect_Method::clazz_offset;
2823 int java_lang_reflect_Method::name_offset;
2824 int java_lang_reflect_Method::returnType_offset;
2825 int java_lang_reflect_Method::parameterTypes_offset;
2826 int java_lang_reflect_Method::exceptionTypes_offset;
2827 int java_lang_reflect_Method::slot_offset;
2828 int java_lang_reflect_Method::modifiers_offset;
2829 int java_lang_reflect_Method::signature_offset;
2830 int java_lang_reflect_Method::annotations_offset;
2831 int java_lang_reflect_Method::parameter_annotations_offset;
2832 int java_lang_reflect_Method::annotation_default_offset;
2833 int java_lang_reflect_Constructor::clazz_offset;
2834 int java_lang_reflect_Constructor::parameterTypes_offset;
2835 int java_lang_reflect_Constructor::exceptionTypes_offset;
2908 void java_lang_AssertionStatusDirectives::set_packages(oop o, oop val) {
2909 o->obj_field_put(packages_offset, val);
2910 }
2911
2912 void java_lang_AssertionStatusDirectives::set_packageEnabled(oop o, oop val) {
2913 o->obj_field_put(packageEnabled_offset, val);
2914 }
2915
2916 void java_lang_AssertionStatusDirectives::set_deflt(oop o, bool val) {
2917 o->bool_field_put(deflt_offset, val);
2918 }
2919
2920
2921 // Support for intrinsification of java.nio.Buffer.checkIndex
2922 int java_nio_Buffer::limit_offset() {
2923 return _limit_offset;
2924 }
2925
2926
2927 void java_nio_Buffer::compute_offsets() {
2928 klassOop k = SystemDictionary::java_nio_Buffer_klass();
2929 assert(k != NULL, "must be loaded in 1.4+");
2930 compute_offset(_limit_offset, k, vmSymbols::limit_name(), vmSymbols::int_signature());
2931 }
2932
2933 // Support for intrinsification of sun.misc.AtomicLongCSImpl.attemptUpdate
2934 int sun_misc_AtomicLongCSImpl::value_offset() {
2935 assert(SystemDictionary::sun_misc_AtomicLongCSImpl_klass() != NULL, "can't call this");
2936 return _value_offset;
2937 }
2938
2939
2940 void sun_misc_AtomicLongCSImpl::compute_offsets() {
2941 klassOop k = SystemDictionary::sun_misc_AtomicLongCSImpl_klass();
2942 // If this class is not present, its value field offset won't be referenced.
2943 if (k != NULL) {
2944 compute_offset(_value_offset, k, vmSymbols::value_name(), vmSymbols::long_signature());
2945 }
2946 }
2947
2948 void java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(TRAPS) {
2949 if (_owner_offset != 0) return;
2950
2951 assert(JDK_Version::is_gte_jdk16x_version(), "Must be JDK 1.6 or later");
2952 SystemDictionary::load_abstract_ownable_synchronizer_klass(CHECK);
2953 klassOop k = SystemDictionary::abstract_ownable_synchronizer_klass();
2954 compute_offset(_owner_offset, k,
2955 vmSymbols::exclusive_owner_thread_name(), vmSymbols::thread_signature());
2956 }
2957
2958 oop java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(oop obj) {
2959 assert(_owner_offset != 0, "Must be initialized");
2960 return obj->obj_field(_owner_offset);
2961 }
2962
2963 // Compute hard-coded offsets
2964 // Invoked before SystemDictionary::initialize, so pre-loaded classes
2965 // are not available to determine the offset_of_static_fields.
2966 void JavaClasses::compute_hard_coded_offsets() {
2967 const int x = heapOopSize;
2968 const int header = instanceOopDesc::base_offset_in_bytes();
2969
2970 // Do the String Class
2971 java_lang_String::value_offset = java_lang_String::hc_value_offset * x + header;
2972 java_lang_String::offset_offset = java_lang_String::hc_offset_offset * x + header;
2973 java_lang_String::count_offset = java_lang_String::offset_offset + sizeof (jint);
2974 java_lang_String::hash_offset = java_lang_String::count_offset + sizeof (jint);
2975
2976 {
2977 // Do the Class Class
2978 int offset = header;
2979 java_lang_Class::oop_size_offset = header;
2980 offset += BytesPerInt;
2981 java_lang_Class::static_oop_field_count_offset = offset;
2982 offset = align_size_up(offset + BytesPerInt, x);
2983 java_lang_Class::klass_offset = offset;
2984 offset += x;
2985 java_lang_Class::array_klass_offset = offset;
2986 offset += x;
2987 java_lang_Class::resolved_constructor_offset = offset;
2988 }
2989
2990 // This is NOT an offset
2991 java_lang_Class::number_of_fake_oop_fields = java_lang_Class::hc_number_of_fake_oop_fields;
2992
2993 // Throwable Class
2994 java_lang_Throwable::backtrace_offset = java_lang_Throwable::hc_backtrace_offset * x + header;
2995 java_lang_Throwable::detailMessage_offset = java_lang_Throwable::hc_detailMessage_offset * x + header;
2996 java_lang_Throwable::cause_offset = java_lang_Throwable::hc_cause_offset * x + header;
2997 java_lang_Throwable::stackTrace_offset = java_lang_Throwable::hc_stackTrace_offset * x + header;
2998 java_lang_Throwable::static_unassigned_stacktrace_offset = java_lang_Throwable::hc_static_unassigned_stacktrace_offset * x;
2999
3000 // java_lang_boxing_object
3001 java_lang_boxing_object::value_offset = java_lang_boxing_object::hc_value_offset + header;
3002 java_lang_boxing_object::long_value_offset = align_size_up((java_lang_boxing_object::hc_value_offset + header), BytesPerLong);
3003
3004 // java_lang_ref_Reference:
3005 java_lang_ref_Reference::referent_offset = java_lang_ref_Reference::hc_referent_offset * x + header;
3006 java_lang_ref_Reference::queue_offset = java_lang_ref_Reference::hc_queue_offset * x + header;
3007 java_lang_ref_Reference::next_offset = java_lang_ref_Reference::hc_next_offset * x + header;
3008 java_lang_ref_Reference::discovered_offset = java_lang_ref_Reference::hc_discovered_offset * x + header;
3009 java_lang_ref_Reference::static_lock_offset = java_lang_ref_Reference::hc_static_lock_offset * x;
3010 java_lang_ref_Reference::static_pending_offset = java_lang_ref_Reference::hc_static_pending_offset * x;
3011 // Artificial fields for java_lang_ref_Reference
3012 // The first field is for the discovered field added in 1.4
3024 java_lang_System::static_in_offset = java_lang_System::hc_static_in_offset * x;
3025 java_lang_System::static_out_offset = java_lang_System::hc_static_out_offset * x;
3026 java_lang_System::static_err_offset = java_lang_System::hc_static_err_offset * x;
3027
3028 // java_lang_StackTraceElement
3029 java_lang_StackTraceElement::declaringClass_offset = java_lang_StackTraceElement::hc_declaringClass_offset * x + header;
3030 java_lang_StackTraceElement::methodName_offset = java_lang_StackTraceElement::hc_methodName_offset * x + header;
3031 java_lang_StackTraceElement::fileName_offset = java_lang_StackTraceElement::hc_fileName_offset * x + header;
3032 java_lang_StackTraceElement::lineNumber_offset = java_lang_StackTraceElement::hc_lineNumber_offset * x + header;
3033 java_lang_AssertionStatusDirectives::classes_offset = java_lang_AssertionStatusDirectives::hc_classes_offset * x + header;
3034 java_lang_AssertionStatusDirectives::classEnabled_offset = java_lang_AssertionStatusDirectives::hc_classEnabled_offset * x + header;
3035 java_lang_AssertionStatusDirectives::packages_offset = java_lang_AssertionStatusDirectives::hc_packages_offset * x + header;
3036 java_lang_AssertionStatusDirectives::packageEnabled_offset = java_lang_AssertionStatusDirectives::hc_packageEnabled_offset * x + header;
3037 java_lang_AssertionStatusDirectives::deflt_offset = java_lang_AssertionStatusDirectives::hc_deflt_offset * x + header;
3038
3039 }
3040
3041
3042 // Compute non-hard-coded field offsets of all the classes in this file
3043 void JavaClasses::compute_offsets() {
3044
3045 java_lang_Class::compute_offsets();
3046 java_lang_Thread::compute_offsets();
3047 java_lang_ThreadGroup::compute_offsets();
3048 if (EnableInvokeDynamic) {
3049 java_lang_invoke_MethodHandle::compute_offsets();
3050 java_lang_invoke_MemberName::compute_offsets();
3051 java_lang_invoke_DirectMethodHandle::compute_offsets();
3052 java_lang_invoke_BoundMethodHandle::compute_offsets();
3053 java_lang_invoke_AdapterMethodHandle::compute_offsets();
3054 java_lang_invoke_MethodType::compute_offsets();
3055 java_lang_invoke_MethodTypeForm::compute_offsets();
3056 java_lang_invoke_CallSite::compute_offsets();
3057 java_lang_invoke_CountingMethodHandle::compute_offsets();
3058 }
3059 java_security_AccessControlContext::compute_offsets();
3060 // Initialize reflection classes. The layouts of these classes
3061 // changed with the new reflection implementation in JDK 1.4, and
3062 // since the Universe doesn't know what JDK version it is until this
3063 // point we defer computation of these offsets until now.
3064 java_lang_reflect_AccessibleObject::compute_offsets();
3065 java_lang_reflect_Method::compute_offsets();
3250 // The CheckAssertionStatusDirectives boolean can be removed from here and
3251 // globals.hpp after the AssertionStatusDirectives class has been integrated
3252 // into merlin "for some time." Without it, the vm will fail with early
3253 // merlin builds.
3254
3255 if (CheckAssertionStatusDirectives && JDK_Version::is_gte_jdk14x_version()) {
3256 const char* nm = "java/lang/AssertionStatusDirectives";
3257 const char* sig = "[Ljava/lang/String;";
3258 CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, classes, sig);
3259 CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, classEnabled, "[Z");
3260 CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, packages, sig);
3261 CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, packageEnabled, "[Z");
3262 CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, deflt, "Z");
3263 }
3264
3265 if (!valid) vm_exit_during_initialization("Hard-coded field offset verification failed");
3266 }
3267
3268 #endif // PRODUCT
3269
3270 void javaClasses_init() {
3271 JavaClasses::compute_offsets();
3272 JavaClasses::check_offsets();
3273 FilteredFieldsMap::initialize(); // must be done after computing offsets.
3274 }
|
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 */
24
25 #include "precompiled.hpp"
26 #include "classfile/javaClasses.hpp"
27 #include "classfile/symbolTable.hpp"
28 #include "classfile/vmSymbols.hpp"
29 #include "code/debugInfo.hpp"
30 #include "code/pcDesc.hpp"
31 #include "compiler/compilerOracle.hpp"
32 #include "interpreter/interpreter.hpp"
33 #include "memory/oopFactory.hpp"
34 #include "memory/resourceArea.hpp"
35 #include "memory/universe.inline.hpp"
36 #include "oops/fieldStreams.hpp"
37 #include "oops/instanceKlass.hpp"
38 #include "oops/instanceMirrorKlass.hpp"
39 #include "oops/klass.hpp"
40 #include "oops/klassOop.hpp"
41 #include "oops/methodOop.hpp"
42 #include "oops/symbol.hpp"
43 #include "oops/typeArrayOop.hpp"
44 #include "runtime/fieldDescriptor.hpp"
45 #include "runtime/handles.inline.hpp"
46 #include "runtime/interfaceSupport.hpp"
47 #include "runtime/java.hpp"
48 #include "runtime/javaCalls.hpp"
49 #include "runtime/safepoint.hpp"
50 #include "runtime/vframe.hpp"
51 #include "utilities/preserveException.hpp"
52 #ifdef TARGET_OS_FAMILY_linux
53 # include "thread_linux.inline.hpp"
54 #endif
55 #ifdef TARGET_OS_FAMILY_solaris
56 # include "thread_solaris.inline.hpp"
57 #endif
58 #ifdef TARGET_OS_FAMILY_windows
59 # include "thread_windows.inline.hpp"
60 #endif
61
62 #define INJECTED_FIELD_COMPUTE_OFFSET(klass, name, signature, may_be_java) \
63 klass::_##name##_offset = JavaClasses::compute_injected_offset(JavaClasses::klass##_##name##_enum);
64
65 #define DECLARE_INJECTED_FIELD(klass, name, signature, may_be_java) \
66 { SystemDictionary::WK_KLASS_ENUM_NAME(klass), vmSymbols::VM_SYMBOL_ENUM_NAME(name##_name), vmSymbols::VM_SYMBOL_ENUM_NAME(signature), may_be_java },
67
68 InjectedField JavaClasses::_injected_fields[] = {
69 ALL_INJECTED_FIELDS(DECLARE_INJECTED_FIELD)
70 };
71
72 int JavaClasses::compute_injected_offset(InjectedFieldID id) {
73 return _injected_fields[id].compute_offset();
74 }
75
76
77 InjectedField* JavaClasses::get_injected(Symbol* class_name, int* field_count) {
78 *field_count = 0;
79
80 vmSymbols::SID sid = vmSymbols::find_sid(class_name);
81 if (sid == vmSymbols::NO_SID) {
82 // Only well known classes can inject fields
83 return NULL;
84 }
85
86 int count = 0;
87 int start = -1;
88
89 #define LOOKUP_INJECTED_FIELD(klass, name, signature, may_be_java) \
90 if (sid == vmSymbols::VM_SYMBOL_ENUM_NAME(klass)) { \
91 count++; \
92 if (start == -1) start = klass##_##name##_enum; \
93 }
94 ALL_INJECTED_FIELDS(LOOKUP_INJECTED_FIELD);
95 #undef LOOKUP_INJECTED_FIELD
96
97 if (start != -1) {
98 *field_count = count;
99 return _injected_fields + start;
100 }
101 return NULL;
102 }
103
104
105 static bool find_field(instanceKlass* ik,
106 Symbol* name_symbol, Symbol* signature_symbol,
107 fieldDescriptor* fd,
108 bool allow_super = false) {
109 if (allow_super)
110 return ik->find_field(name_symbol, signature_symbol, fd) != NULL;
111 else
112 return ik->find_local_field(name_symbol, signature_symbol, fd);
113 }
114
115 // Helpful routine for computing field offsets at run time rather than hardcoding them
116 static void
117 compute_offset(int &dest_offset,
118 klassOop klass_oop, Symbol* name_symbol, Symbol* signature_symbol,
119 bool allow_super = false) {
120 fieldDescriptor fd;
121 instanceKlass* ik = instanceKlass::cast(klass_oop);
122 if (!find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) {
123 ResourceMark rm;
124 tty->print_cr("Invalid layout of %s at %s", ik->external_name(), name_symbol->as_C_string());
455 mirror()->long_field_put(fd->offset(), fd->long_initial_value());
456 break;
457 case T_OBJECT:
458 {
459 #ifdef ASSERT
460 TempNewSymbol sym = SymbolTable::new_symbol("Ljava/lang/String;", CHECK);
461 assert(fd->signature() == sym, "just checking");
462 #endif
463 oop string = fd->string_initial_value(CHECK);
464 mirror()->obj_field_put(fd->offset(), string);
465 }
466 break;
467 default:
468 THROW_MSG(vmSymbols::java_lang_ClassFormatError(),
469 "Illegal ConstantValue attribute in class file");
470 }
471 }
472 }
473
474
475 void java_lang_Class::fixup_mirror(KlassHandle k, TRAPS) {
476 assert(instanceMirrorKlass::offset_of_static_fields() != 0, "must have been computed already");
477
478 if (k->oop_is_instance()) {
479 // During bootstrap, java.lang.Class wasn't loaded so static field
480 // offsets were computed without the size added it. Go back and
481 // update all the static field offsets to included the size.
482 for (JavaFieldStream fs(instanceKlass::cast(k())); !fs.done(); fs.next()) {
483 if (fs.access_flags().is_static()) {
484 int real_offset = fs.offset() + instanceMirrorKlass::offset_of_static_fields();
485 fs.set_offset(real_offset);
486 }
487 }
488 }
489 create_mirror(k, CHECK);
490 }
491
492 oop java_lang_Class::create_mirror(KlassHandle k, TRAPS) {
493 assert(k->java_mirror() == NULL, "should only assign mirror once");
494 // Use this moment of initialization to cache modifier_flags also,
495 // to support Class.getModifiers(). Instance classes recalculate
496 // the cached flags after the class file is parsed, but before the
497 // class is put into the system dictionary.
498 int computed_modifiers = k->compute_modifier_flags(CHECK_0);
499 k->set_modifier_flags(computed_modifiers);
500 if (SystemDictionary::Class_klass_loaded() && (k->oop_is_instance() || k->oop_is_javaArray())) {
501 // Allocate mirror (java.lang.Class instance)
502 Handle mirror = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(k, CHECK_0);
503 // Setup indirections
504 mirror->obj_field_put(_klass_offset, k());
505 k->set_java_mirror(mirror());
506
507 instanceMirrorKlass* mk = instanceMirrorKlass::cast(mirror->klass());
508 java_lang_Class::set_oop_size(mirror(), mk->instance_size(k));
509 java_lang_Class::set_static_oop_field_count(mirror(), mk->compute_static_oop_field_count(mirror()));
510
511 // It might also have a component mirror. This mirror must already exist.
512 if (k->oop_is_javaArray()) {
513 Handle comp_mirror;
514 if (k->oop_is_typeArray()) {
515 BasicType type = typeArrayKlass::cast(k->as_klassOop())->element_type();
516 comp_mirror = Universe::java_mirror(type);
517 assert(comp_mirror.not_null(), "must have primitive mirror");
518 } else if (k->oop_is_objArray()) {
519 klassOop element_klass = objArrayKlass::cast(k->as_klassOop())->element_klass();
520 if (element_klass != NULL
521 && (Klass::cast(element_klass)->oop_is_instance() ||
522 Klass::cast(element_klass)->oop_is_javaArray())) {
523 comp_mirror = Klass::cast(element_klass)->java_mirror();
524 assert(comp_mirror.not_null(), "must have element mirror");
526 // else some object array internal to the VM, like systemObjArrayKlassObj
527 }
528 if (comp_mirror.not_null()) {
529 // Two-way link between the array klass and its component mirror:
530 arrayKlass::cast(k->as_klassOop())->set_component_mirror(comp_mirror());
531 set_array_klass(comp_mirror(), k->as_klassOop());
532 }
533 } else if (k->oop_is_instance()) {
534 // Initialize static fields
535 instanceKlass::cast(k())->do_local_static_fields(&initialize_static_field, CHECK_NULL);
536 }
537 return mirror();
538 } else {
539 return NULL;
540 }
541 }
542
543
544
545 int java_lang_Class::oop_size(oop java_class) {
546 assert(_oop_size_offset != 0, "must be set");
547 return java_class->int_field(_oop_size_offset);
548 }
549 void java_lang_Class::set_oop_size(oop java_class, int size) {
550 assert(_oop_size_offset != 0, "must be set");
551 java_class->int_field_put(_oop_size_offset, size);
552 }
553 int java_lang_Class::static_oop_field_count(oop java_class) {
554 assert(_static_oop_field_count_offset != 0, "must be set");
555 return java_class->int_field(_static_oop_field_count_offset);
556 }
557 void java_lang_Class::set_static_oop_field_count(oop java_class, int size) {
558 assert(_static_oop_field_count_offset != 0, "must be set");
559 java_class->int_field_put(_static_oop_field_count_offset, size);
560 }
561
562 oop java_lang_Class::create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS) {
563 // This should be improved by adding a field at the Java level or by
564 // introducing a new VM klass (see comment in ClassFileParser)
565 oop java_class = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance((oop)NULL, CHECK_0);
566 if (type != T_VOID) {
567 klassOop aklass = Universe::typeArrayKlassObj(type);
568 assert(aklass != NULL, "correct bootstrap");
569 set_array_klass(java_class, aklass);
570 }
571 instanceMirrorKlass* mk = instanceMirrorKlass::cast(SystemDictionary::Class_klass());
572 java_lang_Class::set_oop_size(java_class, mk->instance_size(oop(NULL)));
573 java_lang_Class::set_static_oop_field_count(java_class, 0);
574 return java_class;
575 }
576
577
578 klassOop java_lang_Class::as_klassOop(oop java_class) {
579 //%note memory_2
580 assert(java_lang_Class::is_instance(java_class), "must be a Class object");
581 klassOop k = klassOop(java_class->obj_field(_klass_offset));
582 assert(k == NULL || k->is_klass(), "type check");
583 return k;
584 }
585
586
587 void java_lang_Class::print_signature(oop java_class, outputStream* st) {
588 assert(java_lang_Class::is_instance(java_class), "must be a Class object");
589 Symbol* name = NULL;
590 bool is_instance = false;
591 if (is_primitive(java_class)) {
592 name = vmSymbols::type_signature(primitive_type(java_class));
593 } else {
594 klassOop k = as_klassOop(java_class);
595 is_instance = Klass::cast(k)->oop_is_instance();
596 name = Klass::cast(k)->name();
597 }
598 if (name == NULL) {
599 st->print("<null>");
600 return;
601 }
617 klassOop k = as_klassOop(java_class);
618 if (!Klass::cast(k)->oop_is_instance()) {
619 name = Klass::cast(k)->name();
620 name->increment_refcount();
621 } else {
622 ResourceMark rm;
623 const char* sigstr = Klass::cast(k)->signature_name();
624 int siglen = (int) strlen(sigstr);
625 if (!intern_if_not_found) {
626 name = SymbolTable::probe(sigstr, siglen);
627 } else {
628 name = SymbolTable::new_symbol(sigstr, siglen, THREAD);
629 }
630 }
631 }
632 return name;
633 }
634
635
636 klassOop java_lang_Class::array_klass(oop java_class) {
637 klassOop k = klassOop(java_class->obj_field(_array_klass_offset));
638 assert(k == NULL || k->is_klass() && Klass::cast(k)->oop_is_javaArray(), "should be array klass");
639 return k;
640 }
641
642
643 void java_lang_Class::set_array_klass(oop java_class, klassOop klass) {
644 assert(klass->is_klass() && Klass::cast(klass)->oop_is_javaArray(), "should be array klass");
645 java_class->obj_field_put(_array_klass_offset, klass);
646 }
647
648
649 methodOop java_lang_Class::resolved_constructor(oop java_class) {
650 oop constructor = java_class->obj_field(_resolved_constructor_offset);
651 assert(constructor == NULL || constructor->is_method(), "should be method");
652 return methodOop(constructor);
653 }
654
655
656 void java_lang_Class::set_resolved_constructor(oop java_class, methodOop constructor) {
657 assert(constructor->is_method(), "should be method");
658 java_class->obj_field_put(_resolved_constructor_offset, constructor);
659 }
660
661
662 bool java_lang_Class::is_primitive(oop java_class) {
663 // should assert:
664 //assert(java_lang_Class::is_instance(java_class), "must be a Class object");
665 klassOop k = klassOop(java_class->obj_field(_klass_offset));
666 return k == NULL;
667 }
668
669
670 BasicType java_lang_Class::primitive_type(oop java_class) {
671 assert(java_lang_Class::is_primitive(java_class), "just checking");
672 klassOop ak = klassOop(java_class->obj_field(_array_klass_offset));
673 BasicType type = T_VOID;
674 if (ak != NULL) {
675 // Note: create_basic_type_mirror above initializes ak to a non-null value.
676 type = arrayKlass::cast(ak)->element_type();
677 } else {
678 assert(java_class == Universe::void_mirror(), "only valid non-array primitive");
679 }
680 assert(Universe::java_mirror(type) == java_class, "must be consistent");
681 return type;
682 }
683
684 BasicType java_lang_Class::as_BasicType(oop java_class, klassOop* reference_klass) {
685 assert(java_lang_Class::is_instance(java_class), "must be a Class object");
686 if (is_primitive(java_class)) {
687 if (reference_klass != NULL)
688 (*reference_klass) = NULL;
689 return primitive_type(java_class);
690 } else {
691 if (reference_klass != NULL)
692 (*reference_klass) = as_klassOop(java_class);
693 return T_OBJECT;
694 }
695 }
696
697
698 oop java_lang_Class::primitive_mirror(BasicType t) {
699 oop mirror = Universe::java_mirror(t);
700 assert(mirror != NULL && mirror->is_a(SystemDictionary::Class_klass()), "must be a Class");
701 assert(java_lang_Class::is_primitive(mirror), "must be primitive");
702 return mirror;
703 }
704
705 bool java_lang_Class::offsets_computed = false;
706 int java_lang_Class::classRedefinedCount_offset = -1;
707
708 void java_lang_Class::compute_offsets() {
709 assert(!offsets_computed, "offsets should be initialized only once");
710 offsets_computed = true;
711
712 klassOop klass_oop = SystemDictionary::Class_klass();
713 // The classRedefinedCount field is only present starting in 1.5,
714 // so don't go fatal.
715 compute_optional_offset(classRedefinedCount_offset,
716 klass_oop, vmSymbols::classRedefinedCount_name(), vmSymbols::int_signature());
717
718 CLASS_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
719 }
720
721 int java_lang_Class::classRedefinedCount(oop the_class_mirror) {
722 if (!JDK_Version::is_gte_jdk15x_version()
723 || classRedefinedCount_offset == -1) {
724 // The classRedefinedCount field is only present starting in 1.5.
725 // If we don't have an offset for it then just return -1 as a marker.
726 return -1;
727 }
728
729 return the_class_mirror->int_field(classRedefinedCount_offset);
730 }
731
732 void java_lang_Class::set_classRedefinedCount(oop the_class_mirror, int value) {
733 if (!JDK_Version::is_gte_jdk15x_version()
734 || classRedefinedCount_offset == -1) {
735 // The classRedefinedCount field is only present starting in 1.5.
736 // If we don't have an offset for it then nothing to set.
737 return;
738 }
739
740 the_class_mirror->int_field_put(classRedefinedCount_offset, value);
2311 }
2312
2313 jlong java_lang_ref_SoftReference::clock() {
2314 instanceKlass* ik = instanceKlass::cast(SystemDictionary::SoftReference_klass());
2315 jlong* offset = (jlong*)ik->static_field_addr(static_clock_offset);
2316 return *offset;
2317 }
2318
2319 void java_lang_ref_SoftReference::set_clock(jlong value) {
2320 instanceKlass* ik = instanceKlass::cast(SystemDictionary::SoftReference_klass());
2321 jlong* offset = (jlong*)ik->static_field_addr(static_clock_offset);
2322 *offset = value;
2323 }
2324
2325
2326 // Support for java_lang_invoke_MethodHandle
2327
2328 int java_lang_invoke_MethodHandle::_type_offset;
2329 int java_lang_invoke_MethodHandle::_vmtarget_offset;
2330 int java_lang_invoke_MethodHandle::_vmentry_offset;
2331
2332 int java_lang_invoke_MemberName::_clazz_offset;
2333 int java_lang_invoke_MemberName::_name_offset;
2334 int java_lang_invoke_MemberName::_type_offset;
2335 int java_lang_invoke_MemberName::_flags_offset;
2336 int java_lang_invoke_MemberName::_vmtarget_offset;
2337 int java_lang_invoke_MemberName::_vmindex_offset;
2338
2339 int java_lang_invoke_DirectMethodHandle::_vmindex_offset;
2340
2341 int java_lang_invoke_BoundMethodHandle::_argument_offset;
2342 int java_lang_invoke_BoundMethodHandle::_vmargslot_offset;
2343
2344 int java_lang_invoke_AdapterMethodHandle::_conversion_offset;
2345
2346 int java_lang_invoke_CountingMethodHandle::_vmcount_offset;
2347
2348 void java_lang_invoke_MethodHandle::compute_offsets() {
2349 klassOop klass_oop = SystemDictionary::MethodHandle_klass();
2350 if (klass_oop != NULL && EnableInvokeDynamic) {
2351 bool allow_super = false;
2352 compute_offset(_type_offset, klass_oop, vmSymbols::type_name(), vmSymbols::java_lang_invoke_MethodType_signature(), allow_super);
2353 METHODHANDLE_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
2354 }
2355 }
2356
2357 void java_lang_invoke_MemberName::compute_offsets() {
2358 klassOop klass_oop = SystemDictionary::MemberName_klass();
2359 if (klass_oop != NULL && EnableInvokeDynamic) {
2360 compute_offset(_clazz_offset, klass_oop, vmSymbols::clazz_name(), vmSymbols::class_signature());
2361 compute_offset(_name_offset, klass_oop, vmSymbols::name_name(), vmSymbols::string_signature());
2362 compute_offset(_type_offset, klass_oop, vmSymbols::type_name(), vmSymbols::object_signature());
2363 compute_offset(_flags_offset, klass_oop, vmSymbols::flags_name(), vmSymbols::int_signature());
2364 compute_offset(_vmindex_offset, klass_oop, vmSymbols::vmindex_name(), vmSymbols::int_signature());
2365 MEMBERNAME_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
2366 }
2367 }
2368
2369 void java_lang_invoke_DirectMethodHandle::compute_offsets() {
2370 klassOop k = SystemDictionary::DirectMethodHandle_klass();
2371 if (k != NULL && EnableInvokeDynamic) {
2372 DIRECTMETHODHANDLE_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
2373 }
2374 }
2375
2376 void java_lang_invoke_BoundMethodHandle::compute_offsets() {
2377 klassOop k = SystemDictionary::BoundMethodHandle_klass();
2378 if (k != NULL && EnableInvokeDynamic) {
2379 compute_offset(_vmargslot_offset, k, vmSymbols::vmargslot_name(), vmSymbols::int_signature(), true);
2380 compute_offset(_argument_offset, k, vmSymbols::argument_name(), vmSymbols::object_signature(), true);
2381 }
2382 }
2383
2384 void java_lang_invoke_AdapterMethodHandle::compute_offsets() {
2385 klassOop k = SystemDictionary::AdapterMethodHandle_klass();
2386 if (k != NULL && EnableInvokeDynamic) {
2387 compute_offset(_conversion_offset, k, vmSymbols::conversion_name(), vmSymbols::int_signature(), true);
2388 }
2389 }
2390
2391 void java_lang_invoke_CountingMethodHandle::compute_offsets() {
2392 klassOop k = SystemDictionary::CountingMethodHandle_klass();
2396 }
2397
2398 int java_lang_invoke_CountingMethodHandle::vmcount(oop mh) {
2399 assert(is_instance(mh), "CMH only");
2400 return mh->int_field(_vmcount_offset);
2401 }
2402
2403 void java_lang_invoke_CountingMethodHandle::set_vmcount(oop mh, int count) {
2404 assert(is_instance(mh), "CMH only");
2405 mh->int_field_put(_vmcount_offset, count);
2406 }
2407
2408 oop java_lang_invoke_MethodHandle::type(oop mh) {
2409 return mh->obj_field(_type_offset);
2410 }
2411
2412 void java_lang_invoke_MethodHandle::set_type(oop mh, oop mtype) {
2413 mh->obj_field_put(_type_offset, mtype);
2414 }
2415
2416 // fetch type.form.vmslots, which is the number of JVM stack slots
2417 // required to carry the arguments of this MH
2418 int java_lang_invoke_MethodHandle::vmslots(oop mh) {
2419 oop mtype = type(mh);
2420 if (mtype == NULL) return 0; // Java code would get NPE
2421 oop form = java_lang_invoke_MethodType::form(mtype);
2422 if (form == NULL) return 0; // Java code would get NPE
2423 return java_lang_invoke_MethodTypeForm::vmslots(form);
2424 }
2425
2426 // fetch the low-level entry point for this mh
2427 MethodHandleEntry* java_lang_invoke_MethodHandle::vmentry(oop mh) {
2428 return (MethodHandleEntry*) mh->address_field(_vmentry_offset);
2429 }
2430
2431 void java_lang_invoke_MethodHandle::set_vmentry(oop mh, MethodHandleEntry* me) {
2432 assert(_vmentry_offset != 0, "must be present");
2433
2434 // This is always the final step that initializes a valid method handle:
2435 mh->release_address_field_put(_vmentry_offset, (address) me);
2436
2437 // There should be enough memory barriers on exit from native methods
2438 // to ensure that the MH is fully initialized to all threads before
2618 return ptypes(mt)->length();
2619 }
2620
2621
2622
2623 // Support for java_lang_invoke_MethodTypeForm
2624
2625 int java_lang_invoke_MethodTypeForm::_vmslots_offset;
2626 int java_lang_invoke_MethodTypeForm::_vmlayout_offset;
2627 int java_lang_invoke_MethodTypeForm::_erasedType_offset;
2628 int java_lang_invoke_MethodTypeForm::_genericInvoker_offset;
2629
2630 void java_lang_invoke_MethodTypeForm::compute_offsets() {
2631 klassOop k = SystemDictionary::MethodTypeForm_klass();
2632 if (k != NULL) {
2633 compute_optional_offset(_vmslots_offset, k, vmSymbols::vmslots_name(), vmSymbols::int_signature(), true);
2634 compute_optional_offset(_vmlayout_offset, k, vmSymbols::vmlayout_name(), vmSymbols::object_signature());
2635 compute_optional_offset(_erasedType_offset, k, vmSymbols::erasedType_name(), vmSymbols::java_lang_invoke_MethodType_signature(), true);
2636 compute_optional_offset(_genericInvoker_offset, k, vmSymbols::genericInvoker_name(), vmSymbols::java_lang_invoke_MethodHandle_signature(), true);
2637 if (_genericInvoker_offset == 0) _genericInvoker_offset = -1; // set to explicit "empty" value
2638 METHODTYPEFORM_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
2639 }
2640 }
2641
2642 int java_lang_invoke_MethodTypeForm::vmslots(oop mtform) {
2643 assert(mtform->klass() == SystemDictionary::MethodTypeForm_klass(), "MTForm only");
2644 assert(_vmslots_offset > 0, "");
2645 return mtform->int_field(_vmslots_offset);
2646 }
2647
2648 oop java_lang_invoke_MethodTypeForm::vmlayout(oop mtform) {
2649 assert(mtform->klass() == SystemDictionary::MethodTypeForm_klass(), "MTForm only");
2650 assert(_vmlayout_offset > 0, "");
2651 return mtform->obj_field(_vmlayout_offset);
2652 }
2653
2654 oop java_lang_invoke_MethodTypeForm::init_vmlayout(oop mtform, oop cookie) {
2655 assert(mtform->klass() == SystemDictionary::MethodTypeForm_klass(), "MTForm only");
2656 oop previous = vmlayout(mtform);
2657 if (previous != NULL) {
2658 return previous; // someone else beat us to it
2727 }
2728 _isPrivileged_offset = fd.offset();
2729 }
2730
2731
2732 oop java_security_AccessControlContext::create(objArrayHandle context, bool isPrivileged, Handle privileged_context, TRAPS) {
2733 assert(_isPrivileged_offset != 0, "offsets should have been initialized");
2734 // Ensure klass is initialized
2735 instanceKlass::cast(SystemDictionary::AccessControlContext_klass())->initialize(CHECK_0);
2736 // Allocate result
2737 oop result = instanceKlass::cast(SystemDictionary::AccessControlContext_klass())->allocate_instance(CHECK_0);
2738 // Fill in values
2739 result->obj_field_put(_context_offset, context());
2740 result->obj_field_put(_privilegedContext_offset, privileged_context());
2741 result->bool_field_put(_isPrivileged_offset, isPrivileged);
2742 return result;
2743 }
2744
2745
2746 // Support for java_lang_ClassLoader
2747 bool java_lang_ClassLoader::offsets_computed = false;
2748 int java_lang_ClassLoader::parallelCapable_offset = -1;
2749
2750 void java_lang_ClassLoader::compute_offsets() {
2751 assert(!offsets_computed, "offsets should be initialized only once");
2752 offsets_computed = true;
2753
2754 // The field indicating parallelCapable (parallelLockMap) is only present starting in 7,
2755 klassOop k1 = SystemDictionary::ClassLoader_klass();
2756 compute_optional_offset(parallelCapable_offset,
2757 k1, vmSymbols::parallelCapable_name(), vmSymbols::concurrenthashmap_signature());
2758 }
2759
2760 oop java_lang_ClassLoader::parent(oop loader) {
2761 assert(loader->is_oop(), "loader must be oop");
2762 return loader->obj_field(parent_offset);
2763 }
2764
2765
2766 // For class loader classes, parallelCapable defined
2767 // based on non-null field
2768 // Written to by java.lang.ClassLoader, vm only reads this field, doesn't set it
2769 bool java_lang_ClassLoader::parallelCapable(oop class_loader) {
2770 if (!JDK_Version::is_gte_jdk17x_version()
2771 || parallelCapable_offset == -1) {
2772 // Default for backward compatibility is false
2773 return false;
2774 }
2775 return (class_loader->obj_field(parallelCapable_offset) != NULL);
2776 }
2777
2778 bool java_lang_ClassLoader::is_trusted_loader(oop loader) {
2779 // Fix for 4474172; see evaluation for more details
2780 loader = non_reflection_class_loader(loader);
2781
2782 oop cl = SystemDictionary::java_system_loader();
2783 while(cl != NULL) {
2784 if (cl == loader) return true;
2785 cl = parent(cl);
2786 }
2787 return false;
2788 }
2789
2790 oop java_lang_ClassLoader::non_reflection_class_loader(oop loader) {
2791 if (loader != NULL) {
2792 // See whether this is one of the class loaders associated with
2793 // the generated bytecodes for reflection, and if so, "magically"
2794 // delegate to its parent to prevent class loading from occurring
2795 // in places where applications using reflection didn't expect it.
2796 klassOop delegating_cl_class = SystemDictionary::reflect_DelegatingClassLoader_klass();
2797 // This might be null in non-1.4 JDKs
2807 int java_lang_System::in_offset_in_bytes() {
2808 return (instanceMirrorKlass::offset_of_static_fields() + static_in_offset);
2809 }
2810
2811
2812 int java_lang_System::out_offset_in_bytes() {
2813 return (instanceMirrorKlass::offset_of_static_fields() + static_out_offset);
2814 }
2815
2816
2817 int java_lang_System::err_offset_in_bytes() {
2818 return (instanceMirrorKlass::offset_of_static_fields() + static_err_offset);
2819 }
2820
2821
2822
2823 int java_lang_String::value_offset;
2824 int java_lang_String::offset_offset;
2825 int java_lang_String::count_offset;
2826 int java_lang_String::hash_offset;
2827 int java_lang_Class::_klass_offset;
2828 int java_lang_Class::_array_klass_offset;
2829 int java_lang_Class::_resolved_constructor_offset;
2830 int java_lang_Class::_oop_size_offset;
2831 int java_lang_Class::_static_oop_field_count_offset;
2832 int java_lang_Throwable::backtrace_offset;
2833 int java_lang_Throwable::detailMessage_offset;
2834 int java_lang_Throwable::cause_offset;
2835 int java_lang_Throwable::stackTrace_offset;
2836 int java_lang_Throwable::static_unassigned_stacktrace_offset;
2837 int java_lang_reflect_AccessibleObject::override_offset;
2838 int java_lang_reflect_Method::clazz_offset;
2839 int java_lang_reflect_Method::name_offset;
2840 int java_lang_reflect_Method::returnType_offset;
2841 int java_lang_reflect_Method::parameterTypes_offset;
2842 int java_lang_reflect_Method::exceptionTypes_offset;
2843 int java_lang_reflect_Method::slot_offset;
2844 int java_lang_reflect_Method::modifiers_offset;
2845 int java_lang_reflect_Method::signature_offset;
2846 int java_lang_reflect_Method::annotations_offset;
2847 int java_lang_reflect_Method::parameter_annotations_offset;
2848 int java_lang_reflect_Method::annotation_default_offset;
2849 int java_lang_reflect_Constructor::clazz_offset;
2850 int java_lang_reflect_Constructor::parameterTypes_offset;
2851 int java_lang_reflect_Constructor::exceptionTypes_offset;
2924 void java_lang_AssertionStatusDirectives::set_packages(oop o, oop val) {
2925 o->obj_field_put(packages_offset, val);
2926 }
2927
2928 void java_lang_AssertionStatusDirectives::set_packageEnabled(oop o, oop val) {
2929 o->obj_field_put(packageEnabled_offset, val);
2930 }
2931
2932 void java_lang_AssertionStatusDirectives::set_deflt(oop o, bool val) {
2933 o->bool_field_put(deflt_offset, val);
2934 }
2935
2936
2937 // Support for intrinsification of java.nio.Buffer.checkIndex
2938 int java_nio_Buffer::limit_offset() {
2939 return _limit_offset;
2940 }
2941
2942
2943 void java_nio_Buffer::compute_offsets() {
2944 klassOop k = SystemDictionary::nio_Buffer_klass();
2945 assert(k != NULL, "must be loaded in 1.4+");
2946 compute_offset(_limit_offset, k, vmSymbols::limit_name(), vmSymbols::int_signature());
2947 }
2948
2949 // Support for intrinsification of sun.misc.AtomicLongCSImpl.attemptUpdate
2950 int sun_misc_AtomicLongCSImpl::value_offset() {
2951 assert(SystemDictionary::AtomicLongCSImpl_klass() != NULL, "can't call this");
2952 return _value_offset;
2953 }
2954
2955
2956 void sun_misc_AtomicLongCSImpl::compute_offsets() {
2957 klassOop k = SystemDictionary::AtomicLongCSImpl_klass();
2958 // If this class is not present, its value field offset won't be referenced.
2959 if (k != NULL) {
2960 compute_offset(_value_offset, k, vmSymbols::value_name(), vmSymbols::long_signature());
2961 }
2962 }
2963
2964 void java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(TRAPS) {
2965 if (_owner_offset != 0) return;
2966
2967 assert(JDK_Version::is_gte_jdk16x_version(), "Must be JDK 1.6 or later");
2968 SystemDictionary::load_abstract_ownable_synchronizer_klass(CHECK);
2969 klassOop k = SystemDictionary::abstract_ownable_synchronizer_klass();
2970 compute_offset(_owner_offset, k,
2971 vmSymbols::exclusive_owner_thread_name(), vmSymbols::thread_signature());
2972 }
2973
2974 oop java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(oop obj) {
2975 assert(_owner_offset != 0, "Must be initialized");
2976 return obj->obj_field(_owner_offset);
2977 }
2978
2979 // Compute hard-coded offsets
2980 // Invoked before SystemDictionary::initialize, so pre-loaded classes
2981 // are not available to determine the offset_of_static_fields.
2982 void JavaClasses::compute_hard_coded_offsets() {
2983 const int x = heapOopSize;
2984 const int header = instanceOopDesc::base_offset_in_bytes();
2985
2986 // Do the String Class
2987 java_lang_String::value_offset = java_lang_String::hc_value_offset * x + header;
2988 java_lang_String::offset_offset = java_lang_String::hc_offset_offset * x + header;
2989 java_lang_String::count_offset = java_lang_String::offset_offset + sizeof (jint);
2990 java_lang_String::hash_offset = java_lang_String::count_offset + sizeof (jint);
2991
2992 // Throwable Class
2993 java_lang_Throwable::backtrace_offset = java_lang_Throwable::hc_backtrace_offset * x + header;
2994 java_lang_Throwable::detailMessage_offset = java_lang_Throwable::hc_detailMessage_offset * x + header;
2995 java_lang_Throwable::cause_offset = java_lang_Throwable::hc_cause_offset * x + header;
2996 java_lang_Throwable::stackTrace_offset = java_lang_Throwable::hc_stackTrace_offset * x + header;
2997 java_lang_Throwable::static_unassigned_stacktrace_offset = java_lang_Throwable::hc_static_unassigned_stacktrace_offset * x;
2998
2999 // java_lang_boxing_object
3000 java_lang_boxing_object::value_offset = java_lang_boxing_object::hc_value_offset + header;
3001 java_lang_boxing_object::long_value_offset = align_size_up((java_lang_boxing_object::hc_value_offset + header), BytesPerLong);
3002
3003 // java_lang_ref_Reference:
3004 java_lang_ref_Reference::referent_offset = java_lang_ref_Reference::hc_referent_offset * x + header;
3005 java_lang_ref_Reference::queue_offset = java_lang_ref_Reference::hc_queue_offset * x + header;
3006 java_lang_ref_Reference::next_offset = java_lang_ref_Reference::hc_next_offset * x + header;
3007 java_lang_ref_Reference::discovered_offset = java_lang_ref_Reference::hc_discovered_offset * x + header;
3008 java_lang_ref_Reference::static_lock_offset = java_lang_ref_Reference::hc_static_lock_offset * x;
3009 java_lang_ref_Reference::static_pending_offset = java_lang_ref_Reference::hc_static_pending_offset * x;
3010 // Artificial fields for java_lang_ref_Reference
3011 // The first field is for the discovered field added in 1.4
3023 java_lang_System::static_in_offset = java_lang_System::hc_static_in_offset * x;
3024 java_lang_System::static_out_offset = java_lang_System::hc_static_out_offset * x;
3025 java_lang_System::static_err_offset = java_lang_System::hc_static_err_offset * x;
3026
3027 // java_lang_StackTraceElement
3028 java_lang_StackTraceElement::declaringClass_offset = java_lang_StackTraceElement::hc_declaringClass_offset * x + header;
3029 java_lang_StackTraceElement::methodName_offset = java_lang_StackTraceElement::hc_methodName_offset * x + header;
3030 java_lang_StackTraceElement::fileName_offset = java_lang_StackTraceElement::hc_fileName_offset * x + header;
3031 java_lang_StackTraceElement::lineNumber_offset = java_lang_StackTraceElement::hc_lineNumber_offset * x + header;
3032 java_lang_AssertionStatusDirectives::classes_offset = java_lang_AssertionStatusDirectives::hc_classes_offset * x + header;
3033 java_lang_AssertionStatusDirectives::classEnabled_offset = java_lang_AssertionStatusDirectives::hc_classEnabled_offset * x + header;
3034 java_lang_AssertionStatusDirectives::packages_offset = java_lang_AssertionStatusDirectives::hc_packages_offset * x + header;
3035 java_lang_AssertionStatusDirectives::packageEnabled_offset = java_lang_AssertionStatusDirectives::hc_packageEnabled_offset * x + header;
3036 java_lang_AssertionStatusDirectives::deflt_offset = java_lang_AssertionStatusDirectives::hc_deflt_offset * x + header;
3037
3038 }
3039
3040
3041 // Compute non-hard-coded field offsets of all the classes in this file
3042 void JavaClasses::compute_offsets() {
3043 // java_lang_Class::compute_offsets was called earlier in bootstrap
3044 java_lang_ClassLoader::compute_offsets();
3045 java_lang_Thread::compute_offsets();
3046 java_lang_ThreadGroup::compute_offsets();
3047 if (EnableInvokeDynamic) {
3048 java_lang_invoke_MethodHandle::compute_offsets();
3049 java_lang_invoke_MemberName::compute_offsets();
3050 java_lang_invoke_DirectMethodHandle::compute_offsets();
3051 java_lang_invoke_BoundMethodHandle::compute_offsets();
3052 java_lang_invoke_AdapterMethodHandle::compute_offsets();
3053 java_lang_invoke_MethodType::compute_offsets();
3054 java_lang_invoke_MethodTypeForm::compute_offsets();
3055 java_lang_invoke_CallSite::compute_offsets();
3056 java_lang_invoke_CountingMethodHandle::compute_offsets();
3057 }
3058 java_security_AccessControlContext::compute_offsets();
3059 // Initialize reflection classes. The layouts of these classes
3060 // changed with the new reflection implementation in JDK 1.4, and
3061 // since the Universe doesn't know what JDK version it is until this
3062 // point we defer computation of these offsets until now.
3063 java_lang_reflect_AccessibleObject::compute_offsets();
3064 java_lang_reflect_Method::compute_offsets();
3249 // The CheckAssertionStatusDirectives boolean can be removed from here and
3250 // globals.hpp after the AssertionStatusDirectives class has been integrated
3251 // into merlin "for some time." Without it, the vm will fail with early
3252 // merlin builds.
3253
3254 if (CheckAssertionStatusDirectives && JDK_Version::is_gte_jdk14x_version()) {
3255 const char* nm = "java/lang/AssertionStatusDirectives";
3256 const char* sig = "[Ljava/lang/String;";
3257 CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, classes, sig);
3258 CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, classEnabled, "[Z");
3259 CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, packages, sig);
3260 CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, packageEnabled, "[Z");
3261 CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, deflt, "Z");
3262 }
3263
3264 if (!valid) vm_exit_during_initialization("Hard-coded field offset verification failed");
3265 }
3266
3267 #endif // PRODUCT
3268
3269 int InjectedField::compute_offset() {
3270 klassOop klass_oop = klass();
3271 for (AllFieldStream fs(instanceKlass::cast(klass_oop)); !fs.done(); fs.next()) {
3272 if (!may_be_java && !fs.access_flags().is_internal()) {
3273 // Only look at injected fields
3274 continue;
3275 }
3276 if (fs.name() == name() && fs.signature() == signature()) {
3277 return fs.offset();
3278 }
3279 }
3280 ResourceMark rm;
3281 tty->print_cr("Invalid layout of %s at %s", instanceKlass::cast(klass_oop)->external_name(), name()->as_C_string());
3282 fatal("Invalid layout of preloaded class");
3283 return -1;
3284 }
3285
3286 void javaClasses_init() {
3287 JavaClasses::compute_offsets();
3288 JavaClasses::check_offsets();
3289 FilteredFieldsMap::initialize(); // must be done after computing offsets.
3290 }
|