| changeset 51417 | b08c2a94cce1 |
| parent 51388 | 0dcd27526967 |
| child 51425 | 4e9667589c43 |
| 51416:8c2faee50bc4 | 51417:b08c2a94cce1 |
|---|---|
207 |
207 |
208 initialized = true; |
208 initialized = true; |
209 } |
209 } |
210 |
210 |
211 #if INCLUDE_CDS |
211 #if INCLUDE_CDS |
212 void java_lang_String::serialize(SerializeClosure* f) { |
212 void java_lang_String::serialize_offsets(SerializeClosure* f) { |
213 STRING_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
213 STRING_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
214 f->do_u4((u4*)&initialized); |
214 f->do_u4((u4*)&initialized); |
215 } |
215 } |
216 #endif |
216 #endif |
217 |
217 |
1532 |
1532 |
1533 CLASS_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET); |
1533 CLASS_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET); |
1534 } |
1534 } |
1535 |
1535 |
1536 #if INCLUDE_CDS |
1536 #if INCLUDE_CDS |
1537 void java_lang_Class::serialize(SerializeClosure* f) { |
1537 void java_lang_Class::serialize_offsets(SerializeClosure* f) { |
1538 f->do_u4((u4*)&offsets_computed); |
1538 f->do_u4((u4*)&offsets_computed); |
1539 f->do_u4((u4*)&_init_lock_offset); |
1539 f->do_u4((u4*)&_init_lock_offset); |
1540 |
1540 |
1541 CLASS_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
1541 CLASS_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
1542 |
1542 |
1606 InstanceKlass* k = SystemDictionary::Thread_klass(); |
1606 InstanceKlass* k = SystemDictionary::Thread_klass(); |
1607 THREAD_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
1607 THREAD_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
1608 } |
1608 } |
1609 |
1609 |
1610 #if INCLUDE_CDS |
1610 #if INCLUDE_CDS |
1611 void java_lang_Thread::serialize(SerializeClosure* f) { |
1611 void java_lang_Thread::serialize_offsets(SerializeClosure* f) { |
1612 THREAD_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
1612 THREAD_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
1613 } |
1613 } |
1614 #endif |
1614 #endif |
1615 |
1615 |
1616 JavaThread* java_lang_Thread::thread(oop java_thread) { |
1616 JavaThread* java_lang_Thread::thread(oop java_thread) { |
1858 InstanceKlass* k = SystemDictionary::ThreadGroup_klass(); |
1858 InstanceKlass* k = SystemDictionary::ThreadGroup_klass(); |
1859 THREADGROUP_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
1859 THREADGROUP_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
1860 } |
1860 } |
1861 |
1861 |
1862 #if INCLUDE_CDS |
1862 #if INCLUDE_CDS |
1863 void java_lang_ThreadGroup::serialize(SerializeClosure* f) { |
1863 void java_lang_ThreadGroup::serialize_offsets(SerializeClosure* f) { |
1864 THREADGROUP_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
1864 THREADGROUP_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
1865 } |
1865 } |
1866 #endif |
1866 #endif |
1867 |
1867 |
1868 #define THROWABLE_FIELDS_DO(macro) \ |
1868 #define THROWABLE_FIELDS_DO(macro) \ |
1876 InstanceKlass* k = SystemDictionary::Throwable_klass(); |
1876 InstanceKlass* k = SystemDictionary::Throwable_klass(); |
1877 THROWABLE_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
1877 THROWABLE_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
1878 } |
1878 } |
1879 |
1879 |
1880 #if INCLUDE_CDS |
1880 #if INCLUDE_CDS |
1881 void java_lang_Throwable::serialize(SerializeClosure* f) { |
1881 void java_lang_Throwable::serialize_offsets(SerializeClosure* f) { |
1882 THROWABLE_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
1882 THROWABLE_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
1883 } |
1883 } |
1884 #endif |
1884 #endif |
1885 |
1885 |
1886 oop java_lang_Throwable::unassigned_stacktrace() { |
1886 oop java_lang_Throwable::unassigned_stacktrace() { |
2652 STACKFRAMEINFO_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
2652 STACKFRAMEINFO_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
2653 STACKFRAMEINFO_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET); |
2653 STACKFRAMEINFO_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET); |
2654 } |
2654 } |
2655 |
2655 |
2656 #if INCLUDE_CDS |
2656 #if INCLUDE_CDS |
2657 void java_lang_StackFrameInfo::serialize(SerializeClosure* f) { |
2657 void java_lang_StackFrameInfo::serialize_offsets(SerializeClosure* f) { |
2658 STACKFRAMEINFO_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
2658 STACKFRAMEINFO_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
2659 STACKFRAMEINFO_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET); |
2659 STACKFRAMEINFO_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET); |
2660 } |
2660 } |
2661 #endif |
2661 #endif |
2662 |
2662 |
2670 InstanceKlass* k = SystemDictionary::LiveStackFrameInfo_klass(); |
2670 InstanceKlass* k = SystemDictionary::LiveStackFrameInfo_klass(); |
2671 LIVESTACKFRAMEINFO_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
2671 LIVESTACKFRAMEINFO_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
2672 } |
2672 } |
2673 |
2673 |
2674 #if INCLUDE_CDS |
2674 #if INCLUDE_CDS |
2675 void java_lang_LiveStackFrameInfo::serialize(SerializeClosure* f) { |
2675 void java_lang_LiveStackFrameInfo::serialize_offsets(SerializeClosure* f) { |
2676 LIVESTACKFRAMEINFO_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
2676 LIVESTACKFRAMEINFO_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
2677 } |
2677 } |
2678 #endif |
2678 #endif |
2679 |
2679 |
2680 #define ACCESSIBLEOBJECT_FIELDS_DO(macro) \ |
2680 #define ACCESSIBLEOBJECT_FIELDS_DO(macro) \ |
2684 InstanceKlass* k = SystemDictionary::reflect_AccessibleObject_klass(); |
2684 InstanceKlass* k = SystemDictionary::reflect_AccessibleObject_klass(); |
2685 ACCESSIBLEOBJECT_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
2685 ACCESSIBLEOBJECT_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
2686 } |
2686 } |
2687 |
2687 |
2688 #if INCLUDE_CDS |
2688 #if INCLUDE_CDS |
2689 void java_lang_reflect_AccessibleObject::serialize(SerializeClosure* f) { |
2689 void java_lang_reflect_AccessibleObject::serialize_offsets(SerializeClosure* f) { |
2690 ACCESSIBLEOBJECT_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
2690 ACCESSIBLEOBJECT_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
2691 } |
2691 } |
2692 #endif |
2692 #endif |
2693 |
2693 |
2694 jboolean java_lang_reflect_AccessibleObject::override(oop reflect) { |
2694 jboolean java_lang_reflect_AccessibleObject::override(oop reflect) { |
2725 type_annotations_offset = -1; |
2725 type_annotations_offset = -1; |
2726 METHOD_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
2726 METHOD_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
2727 } |
2727 } |
2728 |
2728 |
2729 #if INCLUDE_CDS |
2729 #if INCLUDE_CDS |
2730 void java_lang_reflect_Method::serialize(SerializeClosure* f) { |
2730 void java_lang_reflect_Method::serialize_offsets(SerializeClosure* f) { |
2731 METHOD_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
2731 METHOD_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
2732 } |
2732 } |
2733 #endif |
2733 #endif |
2734 |
2734 |
2735 Handle java_lang_reflect_Method::create(TRAPS) { |
2735 Handle java_lang_reflect_Method::create(TRAPS) { |
2912 type_annotations_offset = -1; |
2912 type_annotations_offset = -1; |
2913 CONSTRUCTOR_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
2913 CONSTRUCTOR_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
2914 } |
2914 } |
2915 |
2915 |
2916 #if INCLUDE_CDS |
2916 #if INCLUDE_CDS |
2917 void java_lang_reflect_Constructor::serialize(SerializeClosure* f) { |
2917 void java_lang_reflect_Constructor::serialize_offsets(SerializeClosure* f) { |
2918 CONSTRUCTOR_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
2918 CONSTRUCTOR_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
2919 } |
2919 } |
2920 #endif |
2920 #endif |
2921 |
2921 |
2922 Handle java_lang_reflect_Constructor::create(TRAPS) { |
2922 Handle java_lang_reflect_Constructor::create(TRAPS) { |
3061 type_annotations_offset = -1; |
3061 type_annotations_offset = -1; |
3062 FIELD_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3062 FIELD_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3063 } |
3063 } |
3064 |
3064 |
3065 #if INCLUDE_CDS |
3065 #if INCLUDE_CDS |
3066 void java_lang_reflect_Field::serialize(SerializeClosure* f) { |
3066 void java_lang_reflect_Field::serialize_offsets(SerializeClosure* f) { |
3067 FIELD_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3067 FIELD_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3068 } |
3068 } |
3069 #endif |
3069 #endif |
3070 |
3070 |
3071 Handle java_lang_reflect_Field::create(TRAPS) { |
3071 Handle java_lang_reflect_Field::create(TRAPS) { |
3184 // The field is called ConstantPool* in the sun.reflect.ConstantPool class. |
3184 // The field is called ConstantPool* in the sun.reflect.ConstantPool class. |
3185 CONSTANTPOOL_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3185 CONSTANTPOOL_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3186 } |
3186 } |
3187 |
3187 |
3188 #if INCLUDE_CDS |
3188 #if INCLUDE_CDS |
3189 void reflect_ConstantPool::serialize(SerializeClosure* f) { |
3189 void reflect_ConstantPool::serialize_offsets(SerializeClosure* f) { |
3190 CONSTANTPOOL_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3190 CONSTANTPOOL_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3191 } |
3191 } |
3192 #endif |
3192 #endif |
3193 |
3193 |
3194 #define PARAMETER_FIELDS_DO(macro) \ |
3194 #define PARAMETER_FIELDS_DO(macro) \ |
3201 InstanceKlass* k = SystemDictionary::reflect_Parameter_klass(); |
3201 InstanceKlass* k = SystemDictionary::reflect_Parameter_klass(); |
3202 PARAMETER_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3202 PARAMETER_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3203 } |
3203 } |
3204 |
3204 |
3205 #if INCLUDE_CDS |
3205 #if INCLUDE_CDS |
3206 void java_lang_reflect_Parameter::serialize(SerializeClosure* f) { |
3206 void java_lang_reflect_Parameter::serialize_offsets(SerializeClosure* f) { |
3207 PARAMETER_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3207 PARAMETER_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3208 } |
3208 } |
3209 #endif |
3209 #endif |
3210 |
3210 |
3211 Handle java_lang_reflect_Parameter::create(TRAPS) { |
3211 Handle java_lang_reflect_Parameter::create(TRAPS) { |
3279 MODULE_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3279 MODULE_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3280 MODULE_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET); |
3280 MODULE_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET); |
3281 } |
3281 } |
3282 |
3282 |
3283 #if INCLUDE_CDS |
3283 #if INCLUDE_CDS |
3284 void java_lang_Module::serialize(SerializeClosure* f) { |
3284 void java_lang_Module::serialize_offsets(SerializeClosure* f) { |
3285 MODULE_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3285 MODULE_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3286 MODULE_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET); |
3286 MODULE_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET); |
3287 } |
3287 } |
3288 #endif |
3288 #endif |
3289 |
3289 |
3369 InstanceKlass* k = SystemDictionary::reflect_UnsafeStaticFieldAccessorImpl_klass(); |
3369 InstanceKlass* k = SystemDictionary::reflect_UnsafeStaticFieldAccessorImpl_klass(); |
3370 UNSAFESTATICFIELDACCESSORIMPL_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3370 UNSAFESTATICFIELDACCESSORIMPL_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3371 } |
3371 } |
3372 |
3372 |
3373 #if INCLUDE_CDS |
3373 #if INCLUDE_CDS |
3374 void reflect_UnsafeStaticFieldAccessorImpl::serialize(SerializeClosure* f) { |
3374 void reflect_UnsafeStaticFieldAccessorImpl::serialize_offsets(SerializeClosure* f) { |
3375 UNSAFESTATICFIELDACCESSORIMPL_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3375 UNSAFESTATICFIELDACCESSORIMPL_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3376 } |
3376 } |
3377 #endif |
3377 #endif |
3378 |
3378 |
3379 oop java_lang_boxing_object::initialize_and_allocate(BasicType type, TRAPS) { |
3379 oop java_lang_boxing_object::initialize_and_allocate(BasicType type, TRAPS) { |
3541 InstanceKlass* k = SystemDictionary::SoftReference_klass(); |
3541 InstanceKlass* k = SystemDictionary::SoftReference_klass(); |
3542 SOFTREFERENCE_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3542 SOFTREFERENCE_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3543 } |
3543 } |
3544 |
3544 |
3545 #if INCLUDE_CDS |
3545 #if INCLUDE_CDS |
3546 void java_lang_ref_SoftReference::serialize(SerializeClosure* f) { |
3546 void java_lang_ref_SoftReference::serialize_offsets(SerializeClosure* f) { |
3547 SOFTREFERENCE_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3547 SOFTREFERENCE_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3548 } |
3548 } |
3549 #endif |
3549 #endif |
3550 |
3550 |
3551 jlong java_lang_ref_SoftReference::timestamp(oop ref) { |
3551 jlong java_lang_ref_SoftReference::timestamp(oop ref) { |
3582 InstanceKlass* k = SystemDictionary::DirectMethodHandle_klass(); |
3582 InstanceKlass* k = SystemDictionary::DirectMethodHandle_klass(); |
3583 DIRECTMETHODHANDLE_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3583 DIRECTMETHODHANDLE_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3584 } |
3584 } |
3585 |
3585 |
3586 #if INCLUDE_CDS |
3586 #if INCLUDE_CDS |
3587 void java_lang_invoke_DirectMethodHandle::serialize(SerializeClosure* f) { |
3587 void java_lang_invoke_DirectMethodHandle::serialize_offsets(SerializeClosure* f) { |
3588 DIRECTMETHODHANDLE_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3588 DIRECTMETHODHANDLE_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3589 } |
3589 } |
3590 #endif |
3590 #endif |
3591 |
3591 |
3592 // Support for java_lang_invoke_MethodHandle |
3592 // Support for java_lang_invoke_MethodHandle |
3614 InstanceKlass* k = SystemDictionary::MethodHandle_klass(); |
3614 InstanceKlass* k = SystemDictionary::MethodHandle_klass(); |
3615 METHODHANDLE_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3615 METHODHANDLE_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3616 } |
3616 } |
3617 |
3617 |
3618 #if INCLUDE_CDS |
3618 #if INCLUDE_CDS |
3619 void java_lang_invoke_MethodHandle::serialize(SerializeClosure* f) { |
3619 void java_lang_invoke_MethodHandle::serialize_offsets(SerializeClosure* f) { |
3620 METHODHANDLE_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3620 METHODHANDLE_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3621 } |
3621 } |
3622 #endif |
3622 #endif |
3623 |
3623 |
3624 #define MEMBERNAME_FIELDS_DO(macro) \ |
3624 #define MEMBERNAME_FIELDS_DO(macro) \ |
3633 MEMBERNAME_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3633 MEMBERNAME_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3634 MEMBERNAME_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET); |
3634 MEMBERNAME_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET); |
3635 } |
3635 } |
3636 |
3636 |
3637 #if INCLUDE_CDS |
3637 #if INCLUDE_CDS |
3638 void java_lang_invoke_MemberName::serialize(SerializeClosure* f) { |
3638 void java_lang_invoke_MemberName::serialize_offsets(SerializeClosure* f) { |
3639 MEMBERNAME_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3639 MEMBERNAME_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3640 MEMBERNAME_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET); |
3640 MEMBERNAME_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET); |
3641 } |
3641 } |
3642 #endif |
3642 #endif |
3643 |
3643 |
3646 assert(k != NULL, "jdk mismatch"); |
3646 assert(k != NULL, "jdk mismatch"); |
3647 RESOLVEDMETHOD_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET); |
3647 RESOLVEDMETHOD_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET); |
3648 } |
3648 } |
3649 |
3649 |
3650 #if INCLUDE_CDS |
3650 #if INCLUDE_CDS |
3651 void java_lang_invoke_ResolvedMethodName::serialize(SerializeClosure* f) { |
3651 void java_lang_invoke_ResolvedMethodName::serialize_offsets(SerializeClosure* f) { |
3652 RESOLVEDMETHOD_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET); |
3652 RESOLVEDMETHOD_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET); |
3653 } |
3653 } |
3654 #endif |
3654 #endif |
3655 |
3655 |
3656 #define LAMBDAFORM_FIELDS_DO(macro) \ |
3656 #define LAMBDAFORM_FIELDS_DO(macro) \ |
3661 assert (k != NULL, "jdk mismatch"); |
3661 assert (k != NULL, "jdk mismatch"); |
3662 LAMBDAFORM_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3662 LAMBDAFORM_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3663 } |
3663 } |
3664 |
3664 |
3665 #if INCLUDE_CDS |
3665 #if INCLUDE_CDS |
3666 void java_lang_invoke_LambdaForm::serialize(SerializeClosure* f) { |
3666 void java_lang_invoke_LambdaForm::serialize_offsets(SerializeClosure* f) { |
3667 LAMBDAFORM_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3667 LAMBDAFORM_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3668 } |
3668 } |
3669 #endif |
3669 #endif |
3670 |
3670 |
3671 bool java_lang_invoke_LambdaForm::is_instance(oop obj) { |
3671 bool java_lang_invoke_LambdaForm::is_instance(oop obj) { |
3813 InstanceKlass* k = SystemDictionary::MethodType_klass(); |
3813 InstanceKlass* k = SystemDictionary::MethodType_klass(); |
3814 METHODTYPE_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3814 METHODTYPE_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3815 } |
3815 } |
3816 |
3816 |
3817 #if INCLUDE_CDS |
3817 #if INCLUDE_CDS |
3818 void java_lang_invoke_MethodType::serialize(SerializeClosure* f) { |
3818 void java_lang_invoke_MethodType::serialize_offsets(SerializeClosure* f) { |
3819 METHODTYPE_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3819 METHODTYPE_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3820 } |
3820 } |
3821 #endif |
3821 #endif |
3822 |
3822 |
3823 void java_lang_invoke_MethodType::print_signature(oop mt, outputStream* st) { |
3823 void java_lang_invoke_MethodType::print_signature(oop mt, outputStream* st) { |
3907 InstanceKlass* k = SystemDictionary::CallSite_klass(); |
3907 InstanceKlass* k = SystemDictionary::CallSite_klass(); |
3908 CALLSITE_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3908 CALLSITE_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3909 } |
3909 } |
3910 |
3910 |
3911 #if INCLUDE_CDS |
3911 #if INCLUDE_CDS |
3912 void java_lang_invoke_CallSite::serialize(SerializeClosure* f) { |
3912 void java_lang_invoke_CallSite::serialize_offsets(SerializeClosure* f) { |
3913 CALLSITE_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3913 CALLSITE_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3914 } |
3914 } |
3915 #endif |
3915 #endif |
3916 |
3916 |
3917 oop java_lang_invoke_CallSite::context(oop call_site) { |
3917 oop java_lang_invoke_CallSite::context(oop call_site) { |
3929 InstanceKlass* k = SystemDictionary::Context_klass(); |
3929 InstanceKlass* k = SystemDictionary::Context_klass(); |
3930 CALLSITECONTEXT_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET); |
3930 CALLSITECONTEXT_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET); |
3931 } |
3931 } |
3932 |
3932 |
3933 #if INCLUDE_CDS |
3933 #if INCLUDE_CDS |
3934 void java_lang_invoke_MethodHandleNatives_CallSiteContext::serialize(SerializeClosure* f) { |
3934 void java_lang_invoke_MethodHandleNatives_CallSiteContext::serialize_offsets(SerializeClosure* f) { |
3935 CALLSITECONTEXT_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET); |
3935 CALLSITECONTEXT_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET); |
3936 } |
3936 } |
3937 #endif |
3937 #endif |
3938 |
3938 |
3939 DependencyContext java_lang_invoke_MethodHandleNatives_CallSiteContext::vmdependencies(oop call_site) { |
3939 DependencyContext java_lang_invoke_MethodHandleNatives_CallSiteContext::vmdependencies(oop call_site) { |
3961 InstanceKlass* k = SystemDictionary::AccessControlContext_klass(); |
3961 InstanceKlass* k = SystemDictionary::AccessControlContext_klass(); |
3962 ACCESSCONTROLCONTEXT_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3962 ACCESSCONTROLCONTEXT_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
3963 } |
3963 } |
3964 |
3964 |
3965 #if INCLUDE_CDS |
3965 #if INCLUDE_CDS |
3966 void java_security_AccessControlContext::serialize(SerializeClosure* f) { |
3966 void java_security_AccessControlContext::serialize_offsets(SerializeClosure* f) { |
3967 ACCESSCONTROLCONTEXT_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3967 ACCESSCONTROLCONTEXT_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
3968 } |
3968 } |
3969 #endif |
3969 #endif |
3970 |
3970 |
3971 bool java_security_AccessControlContext::is_authorized(Handle context) { |
3971 bool java_security_AccessControlContext::is_authorized(Handle context) { |
4027 |
4027 |
4028 CLASSLOADER_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET); |
4028 CLASSLOADER_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET); |
4029 } |
4029 } |
4030 |
4030 |
4031 #if INCLUDE_CDS |
4031 #if INCLUDE_CDS |
4032 void java_lang_ClassLoader::serialize(SerializeClosure* f) { |
4032 void java_lang_ClassLoader::serialize_offsets(SerializeClosure* f) { |
4033 CLASSLOADER_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
4033 CLASSLOADER_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
4034 CLASSLOADER_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET); |
4034 CLASSLOADER_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET); |
4035 } |
4035 } |
4036 #endif |
4036 #endif |
4037 |
4037 |
4141 InstanceKlass* k = SystemDictionary::System_klass(); |
4141 InstanceKlass* k = SystemDictionary::System_klass(); |
4142 SYSTEM_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
4142 SYSTEM_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
4143 } |
4143 } |
4144 |
4144 |
4145 #if INCLUDE_CDS |
4145 #if INCLUDE_CDS |
4146 void java_lang_System::serialize(SerializeClosure* f) { |
4146 void java_lang_System::serialize_offsets(SerializeClosure* f) { |
4147 SYSTEM_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
4147 SYSTEM_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
4148 } |
4148 } |
4149 #endif |
4149 #endif |
4150 |
4150 |
4151 int java_lang_System::in_offset_in_bytes() { return static_in_offset; } |
4151 int java_lang_System::in_offset_in_bytes() { return static_in_offset; } |
4272 InstanceKlass* k = SystemDictionary::StackTraceElement_klass(); |
4272 InstanceKlass* k = SystemDictionary::StackTraceElement_klass(); |
4273 STACKTRACEELEMENT_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
4273 STACKTRACEELEMENT_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
4274 } |
4274 } |
4275 |
4275 |
4276 #if INCLUDE_CDS |
4276 #if INCLUDE_CDS |
4277 void java_lang_StackTraceElement::serialize(SerializeClosure* f) { |
4277 void java_lang_StackTraceElement::serialize_offsets(SerializeClosure* f) { |
4278 STACKTRACEELEMENT_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
4278 STACKTRACEELEMENT_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
4279 } |
4279 } |
4280 #endif |
4280 #endif |
4281 |
4281 |
4282 void java_lang_StackTraceElement::set_fileName(oop element, oop value) { |
4282 void java_lang_StackTraceElement::set_fileName(oop element, oop value) { |
4347 InstanceKlass* k = SystemDictionary::AssertionStatusDirectives_klass(); |
4347 InstanceKlass* k = SystemDictionary::AssertionStatusDirectives_klass(); |
4348 ASSERTIONSTATUSDIRECTIVES_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
4348 ASSERTIONSTATUSDIRECTIVES_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
4349 } |
4349 } |
4350 |
4350 |
4351 #if INCLUDE_CDS |
4351 #if INCLUDE_CDS |
4352 void java_lang_AssertionStatusDirectives::serialize(SerializeClosure* f) { |
4352 void java_lang_AssertionStatusDirectives::serialize_offsets(SerializeClosure* f) { |
4353 ASSERTIONSTATUSDIRECTIVES_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
4353 ASSERTIONSTATUSDIRECTIVES_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
4354 } |
4354 } |
4355 #endif |
4355 #endif |
4356 |
4356 |
4357 void java_lang_AssertionStatusDirectives::set_classes(oop o, oop val) { |
4357 void java_lang_AssertionStatusDirectives::set_classes(oop o, oop val) { |
4388 assert(k != NULL, "must be loaded in 1.4+"); |
4388 assert(k != NULL, "must be loaded in 1.4+"); |
4389 BUFFER_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
4389 BUFFER_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
4390 } |
4390 } |
4391 |
4391 |
4392 #if INCLUDE_CDS |
4392 #if INCLUDE_CDS |
4393 void java_nio_Buffer::serialize(SerializeClosure* f) { |
4393 void java_nio_Buffer::serialize_offsets(SerializeClosure* f) { |
4394 BUFFER_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
4394 BUFFER_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
4395 } |
4395 } |
4396 #endif |
4396 #endif |
4397 |
4397 |
4398 #define AOS_FIELDS_DO(macro) \ |
4398 #define AOS_FIELDS_DO(macro) \ |
4407 assert(_owner_offset != 0, "Must be initialized"); |
4407 assert(_owner_offset != 0, "Must be initialized"); |
4408 return obj->obj_field(_owner_offset); |
4408 return obj->obj_field(_owner_offset); |
4409 } |
4409 } |
4410 |
4410 |
4411 #if INCLUDE_CDS |
4411 #if INCLUDE_CDS |
4412 void java_util_concurrent_locks_AbstractOwnableSynchronizer::serialize(SerializeClosure* f) { |
4412 void java_util_concurrent_locks_AbstractOwnableSynchronizer::serialize_offsets(SerializeClosure* f) { |
4413 AOS_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
4413 AOS_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
4414 } |
4414 } |
4415 #endif |
4415 #endif |
4416 |
4416 |
4417 static int member_offset(int hardcoded_offset) { |
4417 static int member_offset(int hardcoded_offset) { |
4426 assert(k != NULL, "must be loaded"); |
4426 assert(k != NULL, "must be loaded"); |
4427 INTEGERCACHE_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
4427 INTEGERCACHE_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
4428 } |
4428 } |
4429 |
4429 |
4430 #if INCLUDE_CDS |
4430 #if INCLUDE_CDS |
4431 void java_lang_Integer_IntegerCache::serialize(SerializeClosure* f) { |
4431 void java_lang_Integer_IntegerCache::serialize_offsets(SerializeClosure* f) { |
4432 INTEGERCACHE_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
4432 INTEGERCACHE_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
4433 } |
4433 } |
4434 #endif |
4434 #endif |
4435 |
4435 |
4436 #define ARCHIVEDMODULEGRAPH_FIELDS_DO(macro) \ |
4436 #define ARCHIVEDMODULEGRAPH_FIELDS_DO(macro) \ |
4444 assert(k != NULL, "must be loaded"); |
4444 assert(k != NULL, "must be loaded"); |
4445 ARCHIVEDMODULEGRAPH_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
4445 ARCHIVEDMODULEGRAPH_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
4446 } |
4446 } |
4447 |
4447 |
4448 #if INCLUDE_CDS |
4448 #if INCLUDE_CDS |
4449 void jdk_internal_module_ArchivedModuleGraph::serialize(SerializeClosure* f) { |
4449 void jdk_internal_module_ArchivedModuleGraph::serialize_offsets(SerializeClosure* f) { |
4450 ARCHIVEDMODULEGRAPH_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
4450 ARCHIVEDMODULEGRAPH_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
4451 } |
4451 } |
4452 #endif |
4452 #endif |
4453 |
4453 |
4454 #define CONFIGURATION_FIELDS_DO(macro) \ |
4454 #define CONFIGURATION_FIELDS_DO(macro) \ |
4459 assert(k != NULL, "must be loaded"); |
4459 assert(k != NULL, "must be loaded"); |
4460 CONFIGURATION_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
4460 CONFIGURATION_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
4461 } |
4461 } |
4462 |
4462 |
4463 #if INCLUDE_CDS |
4463 #if INCLUDE_CDS |
4464 void java_lang_module_Configuration::serialize(SerializeClosure* f) { |
4464 void java_lang_module_Configuration::serialize_offsets(SerializeClosure* f) { |
4465 CONFIGURATION_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
4465 CONFIGURATION_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
4466 } |
4466 } |
4467 #endif |
4467 #endif |
4468 |
4468 |
4469 #define LISTN_FIELDS_DO(macro) \ |
4469 #define LISTN_FIELDS_DO(macro) \ |
4474 assert(k != NULL, "must be loaded"); |
4474 assert(k != NULL, "must be loaded"); |
4475 LISTN_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
4475 LISTN_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
4476 } |
4476 } |
4477 |
4477 |
4478 #if INCLUDE_CDS |
4478 #if INCLUDE_CDS |
4479 void java_util_ImmutableCollections_ListN::serialize(SerializeClosure* f) { |
4479 void java_util_ImmutableCollections_ListN::serialize_offsets(SerializeClosure* f) { |
4480 LISTN_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
4480 LISTN_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
4481 } |
4481 } |
4482 #endif |
4482 #endif |
4483 |
4483 |
4484 #define SETN_FIELDS_DO(macro) \ |
4484 #define SETN_FIELDS_DO(macro) \ |
4489 assert(k != NULL, "must be loaded"); |
4489 assert(k != NULL, "must be loaded"); |
4490 SETN_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
4490 SETN_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
4491 } |
4491 } |
4492 |
4492 |
4493 #if INCLUDE_CDS |
4493 #if INCLUDE_CDS |
4494 void java_util_ImmutableCollections_SetN::serialize(SerializeClosure* f) { |
4494 void java_util_ImmutableCollections_SetN::serialize_offsets(SerializeClosure* f) { |
4495 SETN_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
4495 SETN_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
4496 } |
4496 } |
4497 #endif |
4497 #endif |
4498 |
4498 |
4499 #define MAPN_FIELDS_DO(macro) \ |
4499 #define MAPN_FIELDS_DO(macro) \ |
4504 assert(k != NULL, "must be loaded"); |
4504 assert(k != NULL, "must be loaded"); |
4505 MAPN_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
4505 MAPN_FIELDS_DO(FIELD_COMPUTE_OFFSET); |
4506 } |
4506 } |
4507 |
4507 |
4508 #if INCLUDE_CDS |
4508 #if INCLUDE_CDS |
4509 void java_util_ImmutableCollections_MapN::serialize(SerializeClosure* f) { |
4509 void java_util_ImmutableCollections_MapN::serialize_offsets(SerializeClosure* f) { |
4510 MAPN_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
4510 MAPN_FIELDS_DO(FIELD_SERIALIZE_OFFSET); |
4511 } |
4511 } |
4512 #endif |
4512 #endif |
4513 |
4513 |
4514 // Compute hard-coded offsets |
4514 // Compute hard-coded offsets |
4525 java_lang_ref_Reference::queue_offset = member_offset(java_lang_ref_Reference::hc_queue_offset); |
4525 java_lang_ref_Reference::queue_offset = member_offset(java_lang_ref_Reference::hc_queue_offset); |
4526 java_lang_ref_Reference::next_offset = member_offset(java_lang_ref_Reference::hc_next_offset); |
4526 java_lang_ref_Reference::next_offset = member_offset(java_lang_ref_Reference::hc_next_offset); |
4527 java_lang_ref_Reference::discovered_offset = member_offset(java_lang_ref_Reference::hc_discovered_offset); |
4527 java_lang_ref_Reference::discovered_offset = member_offset(java_lang_ref_Reference::hc_discovered_offset); |
4528 } |
4528 } |
4529 |
4529 |
4530 #define DO_COMPUTE_OFFSETS(k) k::compute_offsets(); |
|
4530 |
4531 |
4531 // Compute non-hard-coded field offsets of all the classes in this file |
4532 // Compute non-hard-coded field offsets of all the classes in this file |
4532 void JavaClasses::compute_offsets() { |
4533 void JavaClasses::compute_offsets() { |
4533 if (UseSharedSpaces) { |
4534 if (UseSharedSpaces) { |
4534 return; // field offsets are loaded from archive |
4535 return; // field offsets are loaded from archive |
4535 } |
4536 } |
4536 |
4537 |
4537 // java_lang_Class::compute_offsets was called earlier in bootstrap |
4538 // We have already called the compute_offsets() of the |
4538 java_lang_System::compute_offsets(); |
4539 // BASIC_JAVA_CLASSES_DO_PART1 classes (java_lang_String and java_lang_Class) |
4539 java_lang_ClassLoader::compute_offsets(); |
4540 // earlier inside SystemDictionary::resolve_preloaded_classes() |
4540 java_lang_Throwable::compute_offsets(); |
4541 BASIC_JAVA_CLASSES_DO_PART2(DO_COMPUTE_OFFSETS); |
4541 java_lang_Thread::compute_offsets(); |
|
4542 java_lang_ThreadGroup::compute_offsets(); |
|
4543 java_lang_AssertionStatusDirectives::compute_offsets(); |
|
4544 java_lang_ref_SoftReference::compute_offsets(); |
|
4545 java_lang_invoke_MethodHandle::compute_offsets(); |
|
4546 java_lang_invoke_DirectMethodHandle::compute_offsets(); |
|
4547 java_lang_invoke_MemberName::compute_offsets(); |
|
4548 java_lang_invoke_ResolvedMethodName::compute_offsets(); |
|
4549 java_lang_invoke_LambdaForm::compute_offsets(); |
|
4550 java_lang_invoke_MethodType::compute_offsets(); |
|
4551 java_lang_invoke_CallSite::compute_offsets(); |
|
4552 java_lang_invoke_MethodHandleNatives_CallSiteContext::compute_offsets(); |
|
4553 java_security_AccessControlContext::compute_offsets(); |
|
4554 // Initialize reflection classes. The layouts of these classes |
|
4555 // changed with the new reflection implementation in JDK 1.4, and |
|
4556 // since the Universe doesn't know what JDK version it is until this |
|
4557 // point we defer computation of these offsets until now. |
|
4558 java_lang_reflect_AccessibleObject::compute_offsets(); |
|
4559 java_lang_reflect_Method::compute_offsets(); |
|
4560 java_lang_reflect_Constructor::compute_offsets(); |
|
4561 java_lang_reflect_Field::compute_offsets(); |
|
4562 java_nio_Buffer::compute_offsets(); |
|
4563 reflect_ConstantPool::compute_offsets(); |
|
4564 reflect_UnsafeStaticFieldAccessorImpl::compute_offsets(); |
|
4565 java_lang_reflect_Parameter::compute_offsets(); |
|
4566 java_lang_Module::compute_offsets(); |
|
4567 java_lang_StackTraceElement::compute_offsets(); |
|
4568 java_lang_StackFrameInfo::compute_offsets(); |
|
4569 java_lang_LiveStackFrameInfo::compute_offsets(); |
|
4570 java_util_concurrent_locks_AbstractOwnableSynchronizer::compute_offsets(); |
|
4571 |
|
4572 java_lang_Integer_IntegerCache::compute_offsets(); |
|
4573 java_lang_module_Configuration::compute_offsets(); |
|
4574 java_util_ImmutableCollections_ListN::compute_offsets(); |
|
4575 java_util_ImmutableCollections_MapN::compute_offsets(); |
|
4576 java_util_ImmutableCollections_SetN::compute_offsets(); |
|
4577 jdk_internal_module_ArchivedModuleGraph::compute_offsets(); |
|
4578 |
4542 |
4579 // generated interpreter code wants to know about the offsets we just computed: |
4543 // generated interpreter code wants to know about the offsets we just computed: |
4580 AbstractAssembler::update_delayed_values(); |
4544 AbstractAssembler::update_delayed_values(); |
4581 } |
4545 } |
4546 |
|
4547 #if INCLUDE_CDS |
|
4548 #define DO_SERIALIZE_OFFSETS(k) k::serialize_offsets(soc); |
|
4549 |
|
4550 void JavaClasses::serialize_offsets(SerializeClosure* soc) { |
|
4551 BASIC_JAVA_CLASSES_DO(DO_SERIALIZE_OFFSETS); |
|
4552 } |
|
4553 #endif |
|
4554 |
|
4582 |
4555 |
4583 #ifndef PRODUCT |
4556 #ifndef PRODUCT |
4584 |
4557 |
4585 // These functions exist to assert the validity of hard-coded field offsets to guard |
4558 // These functions exist to assert the validity of hard-coded field offsets to guard |
4586 // against changes in the class files |
4559 // against changes in the class files |