414 THROW_MSG(vmSymbols::java_lang_ClassFormatError(),
415 "Illegal ConstantValue attribute in class file");
416 }
417 }
418 }
419
420
421 // During bootstrap, java.lang.Class wasn't loaded so static field
422 // offsets were computed without the size added it. Go back and
423 // update all the static field offsets to included the size.
424 static void fixup_static_field(fieldDescriptor* fd, TRAPS) {
425 if (fd->is_static()) {
426 int real_offset = fd->offset() + instanceMirrorKlass::offset_of_static_fields();
427 typeArrayOop fields = instanceKlass::cast(fd->field_holder())->fields();
428 fields->short_at_put(fd->index() + instanceKlass::low_offset, extract_low_short_from_int(real_offset));
429 fields->short_at_put(fd->index() + instanceKlass::high_offset, extract_high_short_from_int(real_offset));
430 }
431 }
432
433 oop java_lang_Class::fixup_mirror(KlassHandle k, TRAPS) {
434 // Cache the start of the static fields
435 if (instanceMirrorKlass::offset_of_static_fields() == 0) {
436 instanceMirrorKlass::set_offset_of_static_fields(instanceMirrorKlass::cast(SystemDictionary::Class_klass())->size_helper() << LogHeapWordSize);
437 }
438
439 if (k->oop_is_instance()) {
440 // Fixup the offsets
441 instanceKlass::cast(k())->do_local_static_fields(&fixup_static_field, CHECK_NULL);
442 }
443 create_mirror(k, CHECK_NULL);
444 }
445
446 oop java_lang_Class::create_mirror(KlassHandle k, TRAPS) {
447 assert(k->java_mirror() == NULL, "should only assign mirror once");
448 // Use this moment of initialization to cache modifier_flags also,
449 // to support Class.getModifiers(). Instance classes recalculate
450 // the cached flags after the class file is parsed, but before the
451 // class is put into the system dictionary.
452 int computed_modifiers = k->compute_modifier_flags(CHECK_0);
453 k->set_modifier_flags(computed_modifiers);
454 if (SystemDictionary::Class_klass_loaded() && (k->oop_is_instance() || k->oop_is_javaArray())) {
455 // Allocate mirror (java.lang.Class instance)
456 Handle mirror = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_permanent_instance(k, CHECK_0);
457 // Setup indirections
458 mirror->obj_field_put(klass_offset, k());
459 k->set_java_mirror(mirror());
460
461 instanceMirrorKlass* mk = instanceMirrorKlass::cast(mirror->klass());
462 java_lang_Class::set_oop_size(mirror(), mk->instance_size(k));
463 java_lang_Class::set_static_oop_field_size(mirror(), mk->compute_static_oop_field_size(mirror()));
464
465 // It might also have a component mirror. This mirror must already exist.
466 if (k->oop_is_javaArray()) {
467 Handle comp_mirror;
468 if (k->oop_is_typeArray()) {
469 BasicType type = typeArrayKlass::cast(k->as_klassOop())->element_type();
470 comp_mirror = Universe::java_mirror(type);
471 assert(comp_mirror.not_null(), "must have primitive mirror");
472 } else if (k->oop_is_objArray()) {
473 klassOop element_klass = objArrayKlass::cast(k->as_klassOop())->element_klass();
474 if (element_klass != NULL
475 && (Klass::cast(element_klass)->oop_is_instance() ||
476 Klass::cast(element_klass)->oop_is_javaArray())) {
481 }
482 if (comp_mirror.not_null()) {
483 // Two-way link between the array klass and its component mirror:
484 arrayKlass::cast(k->as_klassOop())->set_component_mirror(comp_mirror());
485 set_array_klass(comp_mirror(), k->as_klassOop());
486 }
487 }
488 if (k->oop_is_instance()) {
489 // Initialize static fields
490 instanceKlass::cast(k())->do_local_static_fields(&initialize_static_field, CHECK_NULL);
491 }
492 return mirror();
493 } else {
494 return NULL;
495 }
496 }
497
498
499
500 int java_lang_Class::oop_size(oop java_class) {
501 return java_class->int_field(oop_size_offset);
502 }
503 void java_lang_Class::set_oop_size(oop java_class, int size) {
504 java_class->int_field_put(oop_size_offset, size);
505 }
506 int java_lang_Class::static_oop_field_size(oop java_class) {
507 return java_class->int_field(static_oop_field_size_offset);
508 }
509 void java_lang_Class::set_static_oop_field_size(oop java_class, int size) {
510 java_class->int_field_put(static_oop_field_size_offset, size);
511 }
512
513
514
515
516 oop java_lang_Class::create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS) {
517 // This should be improved by adding a field at the Java level or by
518 // introducing a new VM klass (see comment in ClassFileParser)
519 oop java_class = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_permanent_instance((oop)NULL, CHECK_0);
520 if (type != T_VOID) {
521 klassOop aklass = Universe::typeArrayKlassObj(type);
522 assert(aklass != NULL, "correct bootstrap");
523 set_array_klass(java_class, aklass);
524 }
525 instanceMirrorKlass* mk = instanceMirrorKlass::cast(SystemDictionary::Class_klass());
526 java_lang_Class::set_oop_size(java_class, mk->instance_size(oop(NULL)));
527 java_lang_Class::set_static_oop_field_size(java_class, 0);
528 return java_class;
529 }
530
531
532 klassOop java_lang_Class::as_klassOop(oop java_class) {
533 //%note memory_2
534 assert(java_lang_Class::is_instance(java_class), "must be a Class object");
535 klassOop k = klassOop(java_class->obj_field(klass_offset));
536 assert(k == NULL || k->is_klass(), "type check");
537 return k;
538 }
539
2890 }
2891
2892 oop java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(oop obj) {
2893 assert(_owner_offset != 0, "Must be initialized");
2894 return obj->obj_field(_owner_offset);
2895 }
2896
2897 // Compute hard-coded offsets
2898 // Invoked before SystemDictionary::initialize, so pre-loaded classes
2899 // are not available to determine the offset_of_static_fields.
2900 void JavaClasses::compute_hard_coded_offsets() {
2901 const int x = heapOopSize;
2902 const int header = instanceOopDesc::base_offset_in_bytes();
2903
2904 // Do the String Class
2905 java_lang_String::value_offset = java_lang_String::hc_value_offset * x + header;
2906 java_lang_String::offset_offset = java_lang_String::hc_offset_offset * x + header;
2907 java_lang_String::count_offset = java_lang_String::offset_offset + sizeof (jint);
2908 java_lang_String::hash_offset = java_lang_String::count_offset + sizeof (jint);
2909
2910 // Do the Class Class
2911 java_lang_Class::klass_offset = java_lang_Class::hc_klass_offset * x + header;
2912 java_lang_Class::array_klass_offset = java_lang_Class::hc_array_klass_offset * x + header;
2913 java_lang_Class::resolved_constructor_offset = java_lang_Class::hc_resolved_constructor_offset * x + header;
2914
2915 // This is NOT an offset
2916 java_lang_Class::number_of_fake_oop_fields = java_lang_Class::hc_number_of_fake_oop_fields;
2917
2918 // Throwable Class
2919 java_lang_Throwable::backtrace_offset = java_lang_Throwable::hc_backtrace_offset * x + header;
2920 java_lang_Throwable::detailMessage_offset = java_lang_Throwable::hc_detailMessage_offset * x + header;
2921 java_lang_Throwable::cause_offset = java_lang_Throwable::hc_cause_offset * x + header;
2922 java_lang_Throwable::stackTrace_offset = java_lang_Throwable::hc_stackTrace_offset * x + header;
2923
2924 // java_lang_boxing_object
2925 java_lang_boxing_object::value_offset = java_lang_boxing_object::hc_value_offset + header;
2926 java_lang_boxing_object::long_value_offset = align_size_up((java_lang_boxing_object::hc_value_offset + header), BytesPerLong);
2927
2928 // java_lang_ref_Reference:
2929 java_lang_ref_Reference::referent_offset = java_lang_ref_Reference::hc_referent_offset * x + header;
2930 java_lang_ref_Reference::queue_offset = java_lang_ref_Reference::hc_queue_offset * x + header;
2931 java_lang_ref_Reference::next_offset = java_lang_ref_Reference::hc_next_offset * x + header;
2932 java_lang_ref_Reference::discovered_offset = java_lang_ref_Reference::hc_discovered_offset * x + header;
2933 java_lang_ref_Reference::static_lock_offset = java_lang_ref_Reference::hc_static_lock_offset * x;
|
414 THROW_MSG(vmSymbols::java_lang_ClassFormatError(),
415 "Illegal ConstantValue attribute in class file");
416 }
417 }
418 }
419
420
421 // During bootstrap, java.lang.Class wasn't loaded so static field
422 // offsets were computed without the size added it. Go back and
423 // update all the static field offsets to included the size.
424 static void fixup_static_field(fieldDescriptor* fd, TRAPS) {
425 if (fd->is_static()) {
426 int real_offset = fd->offset() + instanceMirrorKlass::offset_of_static_fields();
427 typeArrayOop fields = instanceKlass::cast(fd->field_holder())->fields();
428 fields->short_at_put(fd->index() + instanceKlass::low_offset, extract_low_short_from_int(real_offset));
429 fields->short_at_put(fd->index() + instanceKlass::high_offset, extract_high_short_from_int(real_offset));
430 }
431 }
432
433 oop java_lang_Class::fixup_mirror(KlassHandle k, TRAPS) {
434 assert(instanceMirrorKlass::offset_of_static_fields() != 0, "must have been computed already");
435
436 if (k->oop_is_instance()) {
437 // Fixup the offsets
438 instanceKlass::cast(k())->do_local_static_fields(&fixup_static_field, CHECK_NULL);
439 }
440 create_mirror(k, CHECK_NULL);
441 }
442
443 oop java_lang_Class::create_mirror(KlassHandle k, TRAPS) {
444 assert(k->java_mirror() == NULL, "should only assign mirror once");
445 // Use this moment of initialization to cache modifier_flags also,
446 // to support Class.getModifiers(). Instance classes recalculate
447 // the cached flags after the class file is parsed, but before the
448 // class is put into the system dictionary.
449 int computed_modifiers = k->compute_modifier_flags(CHECK_0);
450 k->set_modifier_flags(computed_modifiers);
451 if (SystemDictionary::Class_klass_loaded() && (k->oop_is_instance() || k->oop_is_javaArray())) {
452 // Allocate mirror (java.lang.Class instance)
453 Handle mirror = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(k, CHECK_0);
454 // Setup indirections
455 mirror->obj_field_put(klass_offset, k());
456 k->set_java_mirror(mirror());
457
458 instanceMirrorKlass* mk = instanceMirrorKlass::cast(mirror->klass());
459 java_lang_Class::set_oop_size(mirror(), mk->instance_size(k));
460 java_lang_Class::set_static_oop_field_size(mirror(), mk->compute_static_oop_field_size(mirror()));
461
462 // It might also have a component mirror. This mirror must already exist.
463 if (k->oop_is_javaArray()) {
464 Handle comp_mirror;
465 if (k->oop_is_typeArray()) {
466 BasicType type = typeArrayKlass::cast(k->as_klassOop())->element_type();
467 comp_mirror = Universe::java_mirror(type);
468 assert(comp_mirror.not_null(), "must have primitive mirror");
469 } else if (k->oop_is_objArray()) {
470 klassOop element_klass = objArrayKlass::cast(k->as_klassOop())->element_klass();
471 if (element_klass != NULL
472 && (Klass::cast(element_klass)->oop_is_instance() ||
473 Klass::cast(element_klass)->oop_is_javaArray())) {
478 }
479 if (comp_mirror.not_null()) {
480 // Two-way link between the array klass and its component mirror:
481 arrayKlass::cast(k->as_klassOop())->set_component_mirror(comp_mirror());
482 set_array_klass(comp_mirror(), k->as_klassOop());
483 }
484 }
485 if (k->oop_is_instance()) {
486 // Initialize static fields
487 instanceKlass::cast(k())->do_local_static_fields(&initialize_static_field, CHECK_NULL);
488 }
489 return mirror();
490 } else {
491 return NULL;
492 }
493 }
494
495
496
497 int java_lang_Class::oop_size(oop java_class) {
498 assert(oop_size_offset != 0, "must be set");
499 return java_class->int_field(oop_size_offset);
500 }
501 void java_lang_Class::set_oop_size(oop java_class, int size) {
502 assert(oop_size_offset != 0, "must be set");
503 java_class->int_field_put(oop_size_offset, size);
504 }
505 int java_lang_Class::static_oop_field_size(oop java_class) {
506 assert(static_oop_field_size_offset != 0, "must be set");
507 return java_class->int_field(static_oop_field_size_offset);
508 }
509 void java_lang_Class::set_static_oop_field_size(oop java_class, int size) {
510 assert(static_oop_field_size_offset != 0, "must be set");
511 java_class->int_field_put(static_oop_field_size_offset, size);
512 }
513
514
515
516
517 oop java_lang_Class::create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS) {
518 // This should be improved by adding a field at the Java level or by
519 // introducing a new VM klass (see comment in ClassFileParser)
520 oop java_class = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance((oop)NULL, CHECK_0);
521 if (type != T_VOID) {
522 klassOop aklass = Universe::typeArrayKlassObj(type);
523 assert(aklass != NULL, "correct bootstrap");
524 set_array_klass(java_class, aklass);
525 }
526 instanceMirrorKlass* mk = instanceMirrorKlass::cast(SystemDictionary::Class_klass());
527 java_lang_Class::set_oop_size(java_class, mk->instance_size(oop(NULL)));
528 java_lang_Class::set_static_oop_field_size(java_class, 0);
529 return java_class;
530 }
531
532
533 klassOop java_lang_Class::as_klassOop(oop java_class) {
534 //%note memory_2
535 assert(java_lang_Class::is_instance(java_class), "must be a Class object");
536 klassOop k = klassOop(java_class->obj_field(klass_offset));
537 assert(k == NULL || k->is_klass(), "type check");
538 return k;
539 }
540
2891 }
2892
2893 oop java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(oop obj) {
2894 assert(_owner_offset != 0, "Must be initialized");
2895 return obj->obj_field(_owner_offset);
2896 }
2897
2898 // Compute hard-coded offsets
2899 // Invoked before SystemDictionary::initialize, so pre-loaded classes
2900 // are not available to determine the offset_of_static_fields.
2901 void JavaClasses::compute_hard_coded_offsets() {
2902 const int x = heapOopSize;
2903 const int header = instanceOopDesc::base_offset_in_bytes();
2904
2905 // Do the String Class
2906 java_lang_String::value_offset = java_lang_String::hc_value_offset * x + header;
2907 java_lang_String::offset_offset = java_lang_String::hc_offset_offset * x + header;
2908 java_lang_String::count_offset = java_lang_String::offset_offset + sizeof (jint);
2909 java_lang_String::hash_offset = java_lang_String::count_offset + sizeof (jint);
2910
2911 {
2912 // Do the Class Class
2913 int offset = header;
2914 java_lang_Class::oop_size_offset = header;
2915 offset += BytesPerInt;
2916 java_lang_Class::static_oop_field_size_offset = offset;
2917 offset = align_size_up(offset + BytesPerInt, x);
2918 java_lang_Class::klass_offset = offset;
2919 offset += x;
2920 java_lang_Class::array_klass_offset = offset;
2921 offset += x;
2922 java_lang_Class::resolved_constructor_offset = offset;
2923 }
2924
2925 // This is NOT an offset
2926 java_lang_Class::number_of_fake_oop_fields = java_lang_Class::hc_number_of_fake_oop_fields;
2927
2928 // Throwable Class
2929 java_lang_Throwable::backtrace_offset = java_lang_Throwable::hc_backtrace_offset * x + header;
2930 java_lang_Throwable::detailMessage_offset = java_lang_Throwable::hc_detailMessage_offset * x + header;
2931 java_lang_Throwable::cause_offset = java_lang_Throwable::hc_cause_offset * x + header;
2932 java_lang_Throwable::stackTrace_offset = java_lang_Throwable::hc_stackTrace_offset * x + header;
2933
2934 // java_lang_boxing_object
2935 java_lang_boxing_object::value_offset = java_lang_boxing_object::hc_value_offset + header;
2936 java_lang_boxing_object::long_value_offset = align_size_up((java_lang_boxing_object::hc_value_offset + header), BytesPerLong);
2937
2938 // java_lang_ref_Reference:
2939 java_lang_ref_Reference::referent_offset = java_lang_ref_Reference::hc_referent_offset * x + header;
2940 java_lang_ref_Reference::queue_offset = java_lang_ref_Reference::hc_queue_offset * x + header;
2941 java_lang_ref_Reference::next_offset = java_lang_ref_Reference::hc_next_offset * x + header;
2942 java_lang_ref_Reference::discovered_offset = java_lang_ref_Reference::hc_discovered_offset * x + header;
2943 java_lang_ref_Reference::static_lock_offset = java_lang_ref_Reference::hc_static_lock_offset * x;
|