192 #define FIELD_COMPUTE_OFFSET_OPTIONAL(offset, klass, name, signature) \
193 compute_optional_offset(offset, klass, name, vmSymbols::signature())
194
195 #define STRING_FIELDS_DO(macro) \
196 macro(value_offset, k, vmSymbols::value_name(), byte_array_signature, false); \
197 macro(hash_offset, k, "hash", int_signature, false); \
198 macro(coder_offset, k, "coder", byte_signature, false)
199
200 void java_lang_String::compute_offsets() {
201 if (initialized) {
202 return;
203 }
204
205 InstanceKlass* k = SystemDictionary::String_klass();
206 STRING_FIELDS_DO(FIELD_COMPUTE_OFFSET);
207
208 initialized = true;
209 }
210
211 #if INCLUDE_CDS
212 void java_lang_String::serialize(SerializeClosure* f) {
213 STRING_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
214 f->do_u4((u4*)&initialized);
215 }
216 #endif
217
218 class CompactStringsFixup : public FieldClosure {
219 private:
220 bool _value;
221
222 public:
223 CompactStringsFixup(bool value) : _value(value) {}
224
225 void do_field(fieldDescriptor* fd) {
226 if (fd->name() == vmSymbols::compact_strings_name()) {
227 oop mirror = fd->field_holder()->java_mirror();
228 assert(fd->field_holder() == SystemDictionary::String_klass(), "Should be String");
229 assert(mirror != NULL, "String must have mirror already");
230 mirror->bool_field_put(fd->offset(), _value);
231 }
232 }
1517
1518 void java_lang_Class::compute_offsets() {
1519 if (offsets_computed) {
1520 return;
1521 }
1522
1523 offsets_computed = true;
1524
1525 InstanceKlass* k = SystemDictionary::Class_klass();
1526 CLASS_FIELDS_DO(FIELD_COMPUTE_OFFSET);
1527
1528 // Init lock is a C union with component_mirror. Only instanceKlass mirrors have
1529 // init_lock and only ArrayKlass mirrors have component_mirror. Since both are oops
1530 // GC treats them the same.
1531 _init_lock_offset = _component_mirror_offset;
1532
1533 CLASS_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
1534 }
1535
1536 #if INCLUDE_CDS
1537 void java_lang_Class::serialize(SerializeClosure* f) {
1538 f->do_u4((u4*)&offsets_computed);
1539 f->do_u4((u4*)&_init_lock_offset);
1540
1541 CLASS_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
1542
1543 CLASS_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET);
1544 }
1545 #endif
1546
1547 int java_lang_Class::classRedefinedCount(oop the_class_mirror) {
1548 if (classRedefinedCount_offset == -1) {
1549 // If we don't have an offset for it then just return -1 as a marker.
1550 return -1;
1551 }
1552
1553 return the_class_mirror->int_field(classRedefinedCount_offset);
1554 }
1555
1556 void java_lang_Class::set_classRedefinedCount(oop the_class_mirror, int value) {
1557 if (classRedefinedCount_offset == -1) {
1591 macro(_contextClassLoader_offset, k, vmSymbols::contextClassLoader_name(), classloader_signature, false); \
1592 macro(_inheritedAccessControlContext_offset, k, vmSymbols::inheritedAccessControlContext_name(), accesscontrolcontext_signature, false); \
1593 macro(_priority_offset, k, vmSymbols::priority_name(), int_signature, false); \
1594 macro(_daemon_offset, k, vmSymbols::daemon_name(), bool_signature, false); \
1595 macro(_eetop_offset, k, "eetop", long_signature, false); \
1596 macro(_stillborn_offset, k, "stillborn", bool_signature, false); \
1597 macro(_stackSize_offset, k, "stackSize", long_signature, false); \
1598 macro(_tid_offset, k, "tid", long_signature, false); \
1599 macro(_thread_status_offset, k, "threadStatus", int_signature, false); \
1600 macro(_park_blocker_offset, k, "parkBlocker", object_signature, false); \
1601 macro(_park_event_offset, k, "nativeParkEventPointer", long_signature, false)
1602
1603 void java_lang_Thread::compute_offsets() {
1604 assert(_group_offset == 0, "offsets should be initialized only once");
1605
1606 InstanceKlass* k = SystemDictionary::Thread_klass();
1607 THREAD_FIELDS_DO(FIELD_COMPUTE_OFFSET);
1608 }
1609
1610 #if INCLUDE_CDS
1611 void java_lang_Thread::serialize(SerializeClosure* f) {
1612 THREAD_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
1613 }
1614 #endif
1615
1616 JavaThread* java_lang_Thread::thread(oop java_thread) {
1617 return (JavaThread*)java_thread->address_field(_eetop_offset);
1618 }
1619
1620
1621 void java_lang_Thread::set_thread(oop java_thread, JavaThread* thread) {
1622 java_thread->address_field_put(_eetop_offset, (address)thread);
1623 }
1624
1625
1626 oop java_lang_Thread::name(oop java_thread) {
1627 return java_thread->obj_field(_name_offset);
1628 }
1629
1630
1631 void java_lang_Thread::set_name(oop java_thread, oop name) {
1843
1844 #define THREADGROUP_FIELDS_DO(macro) \
1845 macro(_parent_offset, k, vmSymbols::parent_name(), threadgroup_signature, false); \
1846 macro(_name_offset, k, vmSymbols::name_name(), string_signature, false); \
1847 macro(_threads_offset, k, vmSymbols::threads_name(), thread_array_signature, false); \
1848 macro(_groups_offset, k, vmSymbols::groups_name(), threadgroup_array_signature, false); \
1849 macro(_maxPriority_offset, k, vmSymbols::maxPriority_name(), int_signature, false); \
1850 macro(_destroyed_offset, k, vmSymbols::destroyed_name(), bool_signature, false); \
1851 macro(_daemon_offset, k, vmSymbols::daemon_name(), bool_signature, false); \
1852 macro(_nthreads_offset, k, vmSymbols::nthreads_name(), int_signature, false); \
1853 macro(_ngroups_offset, k, vmSymbols::ngroups_name(), int_signature, false)
1854
1855 void java_lang_ThreadGroup::compute_offsets() {
1856 assert(_parent_offset == 0, "offsets should be initialized only once");
1857
1858 InstanceKlass* k = SystemDictionary::ThreadGroup_klass();
1859 THREADGROUP_FIELDS_DO(FIELD_COMPUTE_OFFSET);
1860 }
1861
1862 #if INCLUDE_CDS
1863 void java_lang_ThreadGroup::serialize(SerializeClosure* f) {
1864 THREADGROUP_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
1865 }
1866 #endif
1867
1868 #define THROWABLE_FIELDS_DO(macro) \
1869 macro(backtrace_offset, k, "backtrace", object_signature, false); \
1870 macro(detailMessage_offset, k, "detailMessage", string_signature, false); \
1871 macro(stackTrace_offset, k, "stackTrace", java_lang_StackTraceElement_array, false); \
1872 macro(depth_offset, k, "depth", int_signature, false); \
1873 macro(static_unassigned_stacktrace_offset, k, "UNASSIGNED_STACK", java_lang_StackTraceElement_array, true)
1874
1875 void java_lang_Throwable::compute_offsets() {
1876 InstanceKlass* k = SystemDictionary::Throwable_klass();
1877 THROWABLE_FIELDS_DO(FIELD_COMPUTE_OFFSET);
1878 }
1879
1880 #if INCLUDE_CDS
1881 void java_lang_Throwable::serialize(SerializeClosure* f) {
1882 THROWABLE_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
1883 }
1884 #endif
1885
1886 oop java_lang_Throwable::unassigned_stacktrace() {
1887 InstanceKlass* ik = SystemDictionary::Throwable_klass();
1888 oop base = ik->static_field_base_raw();
1889 return base->obj_field(static_unassigned_stacktrace_offset);
1890 }
1891
1892 oop java_lang_Throwable::backtrace(oop throwable) {
1893 return throwable->obj_field_acquire(backtrace_offset);
1894 }
1895
1896
1897 void java_lang_Throwable::set_backtrace(oop throwable, oop value) {
1898 throwable->release_obj_field_put(backtrace_offset, value);
1899 }
1900
1901 int java_lang_Throwable::depth(oop throwable) {
2637 InstanceKlass* holder = InstanceKlass::cast(clazz);
2638 Method* method = java_lang_StackFrameInfo::get_method(stackFrame, holder, CHECK);
2639
2640 short version = stackFrame->short_field(_version_offset);
2641 short bci = stackFrame->short_field(_bci_offset);
2642 Symbol* name = method->name();
2643 java_lang_StackTraceElement::fill_in(stack_trace_element, holder, method, version, bci, name, CHECK);
2644 }
2645
2646 #define STACKFRAMEINFO_FIELDS_DO(macro) \
2647 macro(_memberName_offset, k, "memberName", object_signature, false); \
2648 macro(_bci_offset, k, "bci", short_signature, false)
2649
2650 void java_lang_StackFrameInfo::compute_offsets() {
2651 InstanceKlass* k = SystemDictionary::StackFrameInfo_klass();
2652 STACKFRAMEINFO_FIELDS_DO(FIELD_COMPUTE_OFFSET);
2653 STACKFRAMEINFO_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
2654 }
2655
2656 #if INCLUDE_CDS
2657 void java_lang_StackFrameInfo::serialize(SerializeClosure* f) {
2658 STACKFRAMEINFO_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
2659 STACKFRAMEINFO_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET);
2660 }
2661 #endif
2662
2663 #define LIVESTACKFRAMEINFO_FIELDS_DO(macro) \
2664 macro(_monitors_offset, k, "monitors", object_array_signature, false); \
2665 macro(_locals_offset, k, "locals", object_array_signature, false); \
2666 macro(_operands_offset, k, "operands", object_array_signature, false); \
2667 macro(_mode_offset, k, "mode", int_signature, false)
2668
2669 void java_lang_LiveStackFrameInfo::compute_offsets() {
2670 InstanceKlass* k = SystemDictionary::LiveStackFrameInfo_klass();
2671 LIVESTACKFRAMEINFO_FIELDS_DO(FIELD_COMPUTE_OFFSET);
2672 }
2673
2674 #if INCLUDE_CDS
2675 void java_lang_LiveStackFrameInfo::serialize(SerializeClosure* f) {
2676 LIVESTACKFRAMEINFO_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
2677 }
2678 #endif
2679
2680 #define ACCESSIBLEOBJECT_FIELDS_DO(macro) \
2681 macro(override_offset, k, "override", bool_signature, false)
2682
2683 void java_lang_reflect_AccessibleObject::compute_offsets() {
2684 InstanceKlass* k = SystemDictionary::reflect_AccessibleObject_klass();
2685 ACCESSIBLEOBJECT_FIELDS_DO(FIELD_COMPUTE_OFFSET);
2686 }
2687
2688 #if INCLUDE_CDS
2689 void java_lang_reflect_AccessibleObject::serialize(SerializeClosure* f) {
2690 ACCESSIBLEOBJECT_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
2691 }
2692 #endif
2693
2694 jboolean java_lang_reflect_AccessibleObject::override(oop reflect) {
2695 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
2696 return (jboolean) reflect->bool_field(override_offset);
2697 }
2698
2699 void java_lang_reflect_AccessibleObject::set_override(oop reflect, jboolean value) {
2700 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
2701 reflect->bool_field_put(override_offset, (int) value);
2702 }
2703
2704 #define METHOD_FIELDS_DO(macro) \
2705 macro(clazz_offset, k, vmSymbols::clazz_name(), class_signature, false); \
2706 macro(name_offset, k, vmSymbols::name_name(), string_signature, false); \
2707 macro(returnType_offset, k, vmSymbols::returnType_name(), class_signature, false); \
2708 macro(parameterTypes_offset, k, vmSymbols::parameterTypes_name(), class_array_signature, false); \
2709 macro(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), class_array_signature, false); \
2710 macro(slot_offset, k, vmSymbols::slot_name(), int_signature, false); \
2711 macro(modifiers_offset, k, vmSymbols::modifiers_name(), int_signature, false); \
2712 macro##_OPTIONAL(signature_offset, k, vmSymbols::signature_name(), string_signature); \
2713 macro##_OPTIONAL(annotations_offset, k, vmSymbols::annotations_name(), byte_array_signature); \
2714 macro##_OPTIONAL(parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), byte_array_signature); \
2715 macro##_OPTIONAL(annotation_default_offset, k, vmSymbols::annotation_default_name(), byte_array_signature); \
2716 macro##_OPTIONAL(type_annotations_offset, k, vmSymbols::type_annotations_name(), byte_array_signature)
2717
2718 void java_lang_reflect_Method::compute_offsets() {
2719 InstanceKlass* k = SystemDictionary::reflect_Method_klass();
2720 // The generic signature and annotations fields are only present in 1.5
2721 signature_offset = -1;
2722 annotations_offset = -1;
2723 parameter_annotations_offset = -1;
2724 annotation_default_offset = -1;
2725 type_annotations_offset = -1;
2726 METHOD_FIELDS_DO(FIELD_COMPUTE_OFFSET);
2727 }
2728
2729 #if INCLUDE_CDS
2730 void java_lang_reflect_Method::serialize(SerializeClosure* f) {
2731 METHOD_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
2732 }
2733 #endif
2734
2735 Handle java_lang_reflect_Method::create(TRAPS) {
2736 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
2737 Klass* klass = SystemDictionary::reflect_Method_klass();
2738 // This class is eagerly initialized during VM initialization, since we keep a refence
2739 // to one of the methods
2740 assert(InstanceKlass::cast(klass)->is_initialized(), "must be initialized");
2741 return InstanceKlass::cast(klass)->allocate_instance_handle(THREAD);
2742 }
2743
2744 oop java_lang_reflect_Method::clazz(oop reflect) {
2745 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
2746 return reflect->obj_field(clazz_offset);
2747 }
2748
2749 void java_lang_reflect_Method::set_clazz(oop reflect, oop value) {
2750 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
2897 macro(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), class_array_signature, false); \
2898 macro(slot_offset, k, vmSymbols::slot_name(), int_signature, false); \
2899 macro(modifiers_offset, k, vmSymbols::modifiers_name(), int_signature, false); \
2900 macro##_OPTIONAL(signature_offset, k, vmSymbols::signature_name(), string_signature); \
2901 macro##_OPTIONAL(annotations_offset, k, vmSymbols::annotations_name(), byte_array_signature); \
2902 macro##_OPTIONAL(parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), byte_array_signature); \
2903 macro##_OPTIONAL(type_annotations_offset, k, vmSymbols::type_annotations_name(), byte_array_signature)
2904
2905
2906 void java_lang_reflect_Constructor::compute_offsets() {
2907 InstanceKlass* k = SystemDictionary::reflect_Constructor_klass();
2908 // The generic signature and annotations fields are only present in 1.5
2909 signature_offset = -1;
2910 annotations_offset = -1;
2911 parameter_annotations_offset = -1;
2912 type_annotations_offset = -1;
2913 CONSTRUCTOR_FIELDS_DO(FIELD_COMPUTE_OFFSET);
2914 }
2915
2916 #if INCLUDE_CDS
2917 void java_lang_reflect_Constructor::serialize(SerializeClosure* f) {
2918 CONSTRUCTOR_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
2919 }
2920 #endif
2921
2922 Handle java_lang_reflect_Constructor::create(TRAPS) {
2923 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
2924 Symbol* name = vmSymbols::java_lang_reflect_Constructor();
2925 Klass* k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH);
2926 InstanceKlass* ik = InstanceKlass::cast(k);
2927 // Ensure it is initialized
2928 ik->initialize(CHECK_NH);
2929 return ik->allocate_instance_handle(THREAD);
2930 }
2931
2932 oop java_lang_reflect_Constructor::clazz(oop reflect) {
2933 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
2934 return reflect->obj_field(clazz_offset);
2935 }
2936
2937 void java_lang_reflect_Constructor::set_clazz(oop reflect, oop value) {
3046 #define FIELD_FIELDS_DO(macro) \
3047 macro(clazz_offset, k, vmSymbols::clazz_name(), class_signature, false); \
3048 macro(name_offset, k, vmSymbols::name_name(), string_signature, false); \
3049 macro(type_offset, k, vmSymbols::type_name(), class_signature, false); \
3050 macro(slot_offset, k, vmSymbols::slot_name(), int_signature, false); \
3051 macro(modifiers_offset, k, vmSymbols::modifiers_name(), int_signature, false); \
3052 macro##_OPTIONAL(signature_offset, k, vmSymbols::signature_name(), string_signature); \
3053 macro##_OPTIONAL(annotations_offset, k, vmSymbols::annotations_name(), byte_array_signature); \
3054 macro##_OPTIONAL(type_annotations_offset, k, vmSymbols::type_annotations_name(), byte_array_signature)
3055
3056 void java_lang_reflect_Field::compute_offsets() {
3057 InstanceKlass* k = SystemDictionary::reflect_Field_klass();
3058 // The generic signature and annotations fields are only present in 1.5
3059 signature_offset = -1;
3060 annotations_offset = -1;
3061 type_annotations_offset = -1;
3062 FIELD_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3063 }
3064
3065 #if INCLUDE_CDS
3066 void java_lang_reflect_Field::serialize(SerializeClosure* f) {
3067 FIELD_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3068 }
3069 #endif
3070
3071 Handle java_lang_reflect_Field::create(TRAPS) {
3072 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3073 Symbol* name = vmSymbols::java_lang_reflect_Field();
3074 Klass* k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH);
3075 InstanceKlass* ik = InstanceKlass::cast(k);
3076 // Ensure it is initialized
3077 ik->initialize(CHECK_NH);
3078 return ik->allocate_instance_handle(THREAD);
3079 }
3080
3081 oop java_lang_reflect_Field::clazz(oop reflect) {
3082 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3083 return reflect->obj_field(clazz_offset);
3084 }
3085
3086 void java_lang_reflect_Field::set_clazz(oop reflect, oop value) {
3169 assert(has_type_annotations_field(), "type_annotations field must be present");
3170 return field->obj_field(type_annotations_offset);
3171 }
3172
3173 void java_lang_reflect_Field::set_type_annotations(oop field, oop value) {
3174 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3175 assert(has_type_annotations_field(), "type_annotations field must be present");
3176 field->obj_field_put(type_annotations_offset, value);
3177 }
3178
3179 #define CONSTANTPOOL_FIELDS_DO(macro) \
3180 macro(_oop_offset, k, "constantPoolOop", object_signature, false)
3181
3182 void reflect_ConstantPool::compute_offsets() {
3183 InstanceKlass* k = SystemDictionary::reflect_ConstantPool_klass();
3184 // The field is called ConstantPool* in the sun.reflect.ConstantPool class.
3185 CONSTANTPOOL_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3186 }
3187
3188 #if INCLUDE_CDS
3189 void reflect_ConstantPool::serialize(SerializeClosure* f) {
3190 CONSTANTPOOL_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3191 }
3192 #endif
3193
3194 #define PARAMETER_FIELDS_DO(macro) \
3195 macro(name_offset, k, vmSymbols::name_name(), string_signature, false); \
3196 macro(modifiers_offset, k, vmSymbols::modifiers_name(), int_signature, false); \
3197 macro(index_offset, k, vmSymbols::index_name(), int_signature, false); \
3198 macro(executable_offset, k, vmSymbols::executable_name(), executable_signature, false)
3199
3200 void java_lang_reflect_Parameter::compute_offsets() {
3201 InstanceKlass* k = SystemDictionary::reflect_Parameter_klass();
3202 PARAMETER_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3203 }
3204
3205 #if INCLUDE_CDS
3206 void java_lang_reflect_Parameter::serialize(SerializeClosure* f) {
3207 PARAMETER_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3208 }
3209 #endif
3210
3211 Handle java_lang_reflect_Parameter::create(TRAPS) {
3212 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3213 Symbol* name = vmSymbols::java_lang_reflect_Parameter();
3214 Klass* k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH);
3215 InstanceKlass* ik = InstanceKlass::cast(k);
3216 // Ensure it is initialized
3217 ik->initialize(CHECK_NH);
3218 return ik->allocate_instance_handle(THREAD);
3219 }
3220
3221 oop java_lang_reflect_Parameter::name(oop param) {
3222 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3223 return param->obj_field(name_offset);
3224 }
3225
3226 void java_lang_reflect_Parameter::set_name(oop param, oop value) {
3264 int java_lang_Module::_module_entry_offset = -1;
3265
3266 Handle java_lang_Module::create(Handle loader, Handle module_name, TRAPS) {
3267 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3268 return JavaCalls::construct_new_instance(SystemDictionary::Module_klass(),
3269 vmSymbols::java_lang_module_init_signature(),
3270 loader, module_name, CHECK_NH);
3271 }
3272
3273 #define MODULE_FIELDS_DO(macro) \
3274 macro(loader_offset, k, vmSymbols::loader_name(), classloader_signature, false); \
3275 macro(name_offset, k, vmSymbols::name_name(), string_signature, false)
3276
3277 void java_lang_Module::compute_offsets() {
3278 InstanceKlass* k = SystemDictionary::Module_klass();
3279 MODULE_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3280 MODULE_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
3281 }
3282
3283 #if INCLUDE_CDS
3284 void java_lang_Module::serialize(SerializeClosure* f) {
3285 MODULE_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3286 MODULE_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET);
3287 }
3288 #endif
3289
3290 oop java_lang_Module::loader(oop module) {
3291 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3292 return module->obj_field(loader_offset);
3293 }
3294
3295 void java_lang_Module::set_loader(oop module, oop value) {
3296 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3297 module->obj_field_put(loader_offset, value);
3298 }
3299
3300 oop java_lang_Module::name(oop module) {
3301 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3302 return module->obj_field(name_offset);
3303 }
3304
3354 Klass* k = java_lang_Class::as_Klass(mirror);
3355 assert(k->is_instance_klass(), "Must be");
3356
3357 // Get the constant pool back from the klass. Since class redefinition
3358 // merges the new constant pool into the old, this is essentially the
3359 // same constant pool as the original. If constant pool merging is
3360 // no longer done in the future, this will have to change to save
3361 // the original.
3362 return InstanceKlass::cast(k)->constants();
3363 }
3364
3365 #define UNSAFESTATICFIELDACCESSORIMPL_FIELDS_DO(macro) \
3366 macro(_base_offset, k, "base", object_signature, false)
3367
3368 void reflect_UnsafeStaticFieldAccessorImpl::compute_offsets() {
3369 InstanceKlass* k = SystemDictionary::reflect_UnsafeStaticFieldAccessorImpl_klass();
3370 UNSAFESTATICFIELDACCESSORIMPL_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3371 }
3372
3373 #if INCLUDE_CDS
3374 void reflect_UnsafeStaticFieldAccessorImpl::serialize(SerializeClosure* f) {
3375 UNSAFESTATICFIELDACCESSORIMPL_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3376 }
3377 #endif
3378
3379 oop java_lang_boxing_object::initialize_and_allocate(BasicType type, TRAPS) {
3380 Klass* k = SystemDictionary::box_klass(type);
3381 if (k == NULL) return NULL;
3382 InstanceKlass* ik = InstanceKlass::cast(k);
3383 if (!ik->is_initialized()) ik->initialize(CHECK_0);
3384 return ik->allocate_instance(THREAD);
3385 }
3386
3387
3388 oop java_lang_boxing_object::create(BasicType type, jvalue* value, TRAPS) {
3389 oop box = initialize_and_allocate(type, CHECK_0);
3390 if (box == NULL) return NULL;
3391 switch (type) {
3392 case T_BOOLEAN:
3393 box->bool_field_put(value_offset, value->z);
3394 break;
3526
3527 InstanceKlass* ik = InstanceKlass::cast(obj->klass());
3528 bool is_reference = ik->reference_type() != REF_NONE;
3529 assert(!is_reference || ik->is_subclass_of(SystemDictionary::Reference_klass()), "sanity");
3530 return is_reference;
3531 }
3532
3533 // Support for java_lang_ref_SoftReference
3534 //
3535
3536 #define SOFTREFERENCE_FIELDS_DO(macro) \
3537 macro(timestamp_offset, k, "timestamp", long_signature, false); \
3538 macro(static_clock_offset, k, "clock", long_signature, true)
3539
3540 void java_lang_ref_SoftReference::compute_offsets() {
3541 InstanceKlass* k = SystemDictionary::SoftReference_klass();
3542 SOFTREFERENCE_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3543 }
3544
3545 #if INCLUDE_CDS
3546 void java_lang_ref_SoftReference::serialize(SerializeClosure* f) {
3547 SOFTREFERENCE_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3548 }
3549 #endif
3550
3551 jlong java_lang_ref_SoftReference::timestamp(oop ref) {
3552 return ref->long_field(timestamp_offset);
3553 }
3554
3555 jlong java_lang_ref_SoftReference::clock() {
3556 InstanceKlass* ik = SystemDictionary::SoftReference_klass();
3557 oop base = ik->static_field_base_raw();
3558 return base->long_field(static_clock_offset);
3559 }
3560
3561 void java_lang_ref_SoftReference::set_clock(jlong value) {
3562 InstanceKlass* ik = SystemDictionary::SoftReference_klass();
3563 oop base = ik->static_field_base_raw();
3564 base->long_field_put(static_clock_offset, value);
3565 }
3566
3567 // Support for java_lang_invoke_DirectMethodHandle
3568
3569 int java_lang_invoke_DirectMethodHandle::_member_offset;
3570
3571 oop java_lang_invoke_DirectMethodHandle::member(oop dmh) {
3572 oop member_name = NULL;
3573 assert(oopDesc::is_oop(dmh) && java_lang_invoke_DirectMethodHandle::is_instance(dmh),
3574 "a DirectMethodHandle oop is expected");
3575 return dmh->obj_field(member_offset_in_bytes());
3576 }
3577
3578 #define DIRECTMETHODHANDLE_FIELDS_DO(macro) \
3579 macro(_member_offset, k, "member", java_lang_invoke_MemberName_signature, false)
3580
3581 void java_lang_invoke_DirectMethodHandle::compute_offsets() {
3582 InstanceKlass* k = SystemDictionary::DirectMethodHandle_klass();
3583 DIRECTMETHODHANDLE_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3584 }
3585
3586 #if INCLUDE_CDS
3587 void java_lang_invoke_DirectMethodHandle::serialize(SerializeClosure* f) {
3588 DIRECTMETHODHANDLE_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3589 }
3590 #endif
3591
3592 // Support for java_lang_invoke_MethodHandle
3593
3594 int java_lang_invoke_MethodHandle::_type_offset;
3595 int java_lang_invoke_MethodHandle::_form_offset;
3596
3597 int java_lang_invoke_MemberName::_clazz_offset;
3598 int java_lang_invoke_MemberName::_name_offset;
3599 int java_lang_invoke_MemberName::_type_offset;
3600 int java_lang_invoke_MemberName::_flags_offset;
3601 int java_lang_invoke_MemberName::_method_offset;
3602 int java_lang_invoke_MemberName::_vmindex_offset;
3603
3604 int java_lang_invoke_ResolvedMethodName::_vmtarget_offset;
3605 int java_lang_invoke_ResolvedMethodName::_vmholder_offset;
3606
3607 int java_lang_invoke_LambdaForm::_vmentry_offset;
3608
3609 #define METHODHANDLE_FIELDS_DO(macro) \
3610 macro(_type_offset, k, vmSymbols::type_name(), java_lang_invoke_MethodType_signature, false); \
3611 macro(_form_offset, k, "form", java_lang_invoke_LambdaForm_signature, false)
3612
3613 void java_lang_invoke_MethodHandle::compute_offsets() {
3614 InstanceKlass* k = SystemDictionary::MethodHandle_klass();
3615 METHODHANDLE_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3616 }
3617
3618 #if INCLUDE_CDS
3619 void java_lang_invoke_MethodHandle::serialize(SerializeClosure* f) {
3620 METHODHANDLE_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3621 }
3622 #endif
3623
3624 #define MEMBERNAME_FIELDS_DO(macro) \
3625 macro(_clazz_offset, k, vmSymbols::clazz_name(), class_signature, false); \
3626 macro(_name_offset, k, vmSymbols::name_name(), string_signature, false); \
3627 macro(_type_offset, k, vmSymbols::type_name(), object_signature, false); \
3628 macro(_flags_offset, k, vmSymbols::flags_name(), int_signature, false); \
3629 macro(_method_offset, k, vmSymbols::method_name(), java_lang_invoke_ResolvedMethodName_signature, false)
3630
3631 void java_lang_invoke_MemberName::compute_offsets() {
3632 InstanceKlass* k = SystemDictionary::MemberName_klass();
3633 MEMBERNAME_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3634 MEMBERNAME_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
3635 }
3636
3637 #if INCLUDE_CDS
3638 void java_lang_invoke_MemberName::serialize(SerializeClosure* f) {
3639 MEMBERNAME_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3640 MEMBERNAME_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET);
3641 }
3642 #endif
3643
3644 void java_lang_invoke_ResolvedMethodName::compute_offsets() {
3645 InstanceKlass* k = SystemDictionary::ResolvedMethodName_klass();
3646 assert(k != NULL, "jdk mismatch");
3647 RESOLVEDMETHOD_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
3648 }
3649
3650 #if INCLUDE_CDS
3651 void java_lang_invoke_ResolvedMethodName::serialize(SerializeClosure* f) {
3652 RESOLVEDMETHOD_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET);
3653 }
3654 #endif
3655
3656 #define LAMBDAFORM_FIELDS_DO(macro) \
3657 macro(_vmentry_offset, k, "vmentry", java_lang_invoke_MemberName_signature, false)
3658
3659 void java_lang_invoke_LambdaForm::compute_offsets() {
3660 InstanceKlass* k = SystemDictionary::LambdaForm_klass();
3661 assert (k != NULL, "jdk mismatch");
3662 LAMBDAFORM_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3663 }
3664
3665 #if INCLUDE_CDS
3666 void java_lang_invoke_LambdaForm::serialize(SerializeClosure* f) {
3667 LAMBDAFORM_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3668 }
3669 #endif
3670
3671 bool java_lang_invoke_LambdaForm::is_instance(oop obj) {
3672 return obj != NULL && is_subclass(obj->klass());
3673 }
3674
3675
3676 oop java_lang_invoke_MethodHandle::type(oop mh) {
3677 return mh->obj_field(_type_offset);
3678 }
3679
3680 void java_lang_invoke_MethodHandle::set_type(oop mh, oop mtype) {
3681 mh->obj_field_put(_type_offset, mtype);
3682 }
3683
3684 oop java_lang_invoke_MethodHandle::form(oop mh) {
3685 assert(_form_offset != 0, "");
3686 return mh->obj_field(_form_offset);
3798 assert(is_instance(lform), "wrong type");
3799 return lform->obj_field(_vmentry_offset);
3800 }
3801
3802
3803 // Support for java_lang_invoke_MethodType
3804
3805 int java_lang_invoke_MethodType::_rtype_offset;
3806 int java_lang_invoke_MethodType::_ptypes_offset;
3807
3808 #define METHODTYPE_FIELDS_DO(macro) \
3809 macro(_rtype_offset, k, "rtype", class_signature, false); \
3810 macro(_ptypes_offset, k, "ptypes", class_array_signature, false)
3811
3812 void java_lang_invoke_MethodType::compute_offsets() {
3813 InstanceKlass* k = SystemDictionary::MethodType_klass();
3814 METHODTYPE_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3815 }
3816
3817 #if INCLUDE_CDS
3818 void java_lang_invoke_MethodType::serialize(SerializeClosure* f) {
3819 METHODTYPE_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3820 }
3821 #endif
3822
3823 void java_lang_invoke_MethodType::print_signature(oop mt, outputStream* st) {
3824 st->print("(");
3825 objArrayOop pts = ptypes(mt);
3826 for (int i = 0, limit = pts->length(); i < limit; i++) {
3827 java_lang_Class::print_signature(pts->obj_at(i), st);
3828 }
3829 st->print(")");
3830 java_lang_Class::print_signature(rtype(mt), st);
3831 }
3832
3833 Symbol* java_lang_invoke_MethodType::as_signature(oop mt, bool intern_if_not_found, TRAPS) {
3834 ResourceMark rm;
3835 stringStream buffer(128);
3836 print_signature(mt, &buffer);
3837 const char* sigstr = buffer.base();
3838 int siglen = (int) buffer.size();
3892 BasicType bt = java_lang_Class::as_BasicType(rtype(mt));
3893 return type2size[bt];
3894 }
3895
3896
3897 // Support for java_lang_invoke_CallSite
3898
3899 int java_lang_invoke_CallSite::_target_offset;
3900 int java_lang_invoke_CallSite::_context_offset;
3901
3902 #define CALLSITE_FIELDS_DO(macro) \
3903 macro(_target_offset, k, "target", java_lang_invoke_MethodHandle_signature, false); \
3904 macro(_context_offset, k, "context", java_lang_invoke_MethodHandleNatives_CallSiteContext_signature, false)
3905
3906 void java_lang_invoke_CallSite::compute_offsets() {
3907 InstanceKlass* k = SystemDictionary::CallSite_klass();
3908 CALLSITE_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3909 }
3910
3911 #if INCLUDE_CDS
3912 void java_lang_invoke_CallSite::serialize(SerializeClosure* f) {
3913 CALLSITE_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3914 }
3915 #endif
3916
3917 oop java_lang_invoke_CallSite::context(oop call_site) {
3918 assert(java_lang_invoke_CallSite::is_instance(call_site), "");
3919
3920 oop dep_oop = call_site->obj_field(_context_offset);
3921 return dep_oop;
3922 }
3923
3924 // Support for java_lang_invoke_MethodHandleNatives_CallSiteContext
3925
3926 int java_lang_invoke_MethodHandleNatives_CallSiteContext::_vmdependencies_offset;
3927
3928 void java_lang_invoke_MethodHandleNatives_CallSiteContext::compute_offsets() {
3929 InstanceKlass* k = SystemDictionary::Context_klass();
3930 CALLSITECONTEXT_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
3931 }
3932
3933 #if INCLUDE_CDS
3934 void java_lang_invoke_MethodHandleNatives_CallSiteContext::serialize(SerializeClosure* f) {
3935 CALLSITECONTEXT_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET);
3936 }
3937 #endif
3938
3939 DependencyContext java_lang_invoke_MethodHandleNatives_CallSiteContext::vmdependencies(oop call_site) {
3940 assert(java_lang_invoke_MethodHandleNatives_CallSiteContext::is_instance(call_site), "");
3941 intptr_t* vmdeps_addr = (intptr_t*)call_site->field_addr(_vmdependencies_offset);
3942 DependencyContext dep_ctx(vmdeps_addr);
3943 return dep_ctx;
3944 }
3945
3946 // Support for java_security_AccessControlContext
3947
3948 int java_security_AccessControlContext::_context_offset = 0;
3949 int java_security_AccessControlContext::_privilegedContext_offset = 0;
3950 int java_security_AccessControlContext::_isPrivileged_offset = 0;
3951 int java_security_AccessControlContext::_isAuthorized_offset = -1;
3952
3953 #define ACCESSCONTROLCONTEXT_FIELDS_DO(macro) \
3954 macro(_context_offset, k, "context", protectiondomain_signature, false); \
3955 macro(_privilegedContext_offset, k, "privilegedContext", accesscontrolcontext_signature, false); \
3956 macro(_isPrivileged_offset, k, "isPrivileged", bool_signature, false); \
3957 macro(_isAuthorized_offset, k, "isAuthorized", bool_signature, false)
3958
3959 void java_security_AccessControlContext::compute_offsets() {
3960 assert(_isPrivileged_offset == 0, "offsets should be initialized only once");
3961 InstanceKlass* k = SystemDictionary::AccessControlContext_klass();
3962 ACCESSCONTROLCONTEXT_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3963 }
3964
3965 #if INCLUDE_CDS
3966 void java_security_AccessControlContext::serialize(SerializeClosure* f) {
3967 ACCESSCONTROLCONTEXT_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3968 }
3969 #endif
3970
3971 bool java_security_AccessControlContext::is_authorized(Handle context) {
3972 assert(context.not_null() && context->klass() == SystemDictionary::AccessControlContext_klass(), "Invalid type");
3973 assert(_isAuthorized_offset != -1, "should be set");
3974 return context->bool_field(_isAuthorized_offset) != 0;
3975 }
3976
3977 oop java_security_AccessControlContext::create(objArrayHandle context, bool isPrivileged, Handle privileged_context, TRAPS) {
3978 assert(_isPrivileged_offset != 0, "offsets should have been initialized");
3979 // Ensure klass is initialized
3980 SystemDictionary::AccessControlContext_klass()->initialize(CHECK_0);
3981 // Allocate result
3982 oop result = SystemDictionary::AccessControlContext_klass()->allocate_instance(CHECK_0);
3983 // Fill in values
3984 result->obj_field_put(_context_offset, context());
3985 result->obj_field_put(_privilegedContext_offset, privileged_context());
3986 result->bool_field_put(_isPrivileged_offset, isPrivileged);
4012 }
4013
4014 #define CLASSLOADER_FIELDS_DO(macro) \
4015 macro(parallelCapable_offset, k1, "parallelLockMap", concurrenthashmap_signature, false); \
4016 macro(name_offset, k1, vmSymbols::name_name(), string_signature, false); \
4017 macro(nameAndId_offset, k1, "nameAndId", string_signature, false); \
4018 macro(unnamedModule_offset, k1, "unnamedModule", module_signature, false); \
4019 macro(parent_offset, k1, "parent", classloader_signature, false)
4020
4021 void java_lang_ClassLoader::compute_offsets() {
4022 assert(!offsets_computed, "offsets should be initialized only once");
4023 offsets_computed = true;
4024
4025 InstanceKlass* k1 = SystemDictionary::ClassLoader_klass();
4026 CLASSLOADER_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4027
4028 CLASSLOADER_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
4029 }
4030
4031 #if INCLUDE_CDS
4032 void java_lang_ClassLoader::serialize(SerializeClosure* f) {
4033 CLASSLOADER_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4034 CLASSLOADER_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET);
4035 }
4036 #endif
4037
4038 oop java_lang_ClassLoader::parent(oop loader) {
4039 assert(is_instance(loader), "loader must be oop");
4040 return loader->obj_field(parent_offset);
4041 }
4042
4043 // Returns the name field of this class loader. If the name field has not
4044 // been set, null will be returned.
4045 oop java_lang_ClassLoader::name(oop loader) {
4046 assert(is_instance(loader), "loader must be oop");
4047 return loader->obj_field(name_offset);
4048 }
4049
4050 // Returns the nameAndId field of this class loader. The format is
4051 // as follows:
4052 // If the defining loader has a name explicitly set then '<loader-name>' @<id>
4126
4127 oop java_lang_ClassLoader::unnamedModule(oop loader) {
4128 assert(is_instance(loader), "loader must be oop");
4129 return loader->obj_field(unnamedModule_offset);
4130 }
4131
4132 // Support for java_lang_System
4133 //
4134 #define SYSTEM_FIELDS_DO(macro) \
4135 macro(static_in_offset, k, "in", input_stream_signature, true); \
4136 macro(static_out_offset, k, "out", print_stream_signature, true); \
4137 macro(static_err_offset, k, "err", print_stream_signature, true); \
4138 macro(static_security_offset, k, "security", security_manager_signature, true)
4139
4140 void java_lang_System::compute_offsets() {
4141 InstanceKlass* k = SystemDictionary::System_klass();
4142 SYSTEM_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4143 }
4144
4145 #if INCLUDE_CDS
4146 void java_lang_System::serialize(SerializeClosure* f) {
4147 SYSTEM_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4148 }
4149 #endif
4150
4151 int java_lang_System::in_offset_in_bytes() { return static_in_offset; }
4152 int java_lang_System::out_offset_in_bytes() { return static_out_offset; }
4153 int java_lang_System::err_offset_in_bytes() { return static_err_offset; }
4154
4155
4156 bool java_lang_System::has_security_manager() {
4157 InstanceKlass* ik = SystemDictionary::System_klass();
4158 oop base = ik->static_field_base_raw();
4159 return base->obj_field(static_security_offset) != NULL;
4160 }
4161
4162 int java_lang_Class::_klass_offset;
4163 int java_lang_Class::_array_klass_offset;
4164 int java_lang_Class::_oop_size_offset;
4165 int java_lang_Class::_static_oop_field_count_offset;
4166 int java_lang_Class::_class_loader_offset;
4257 int java_util_ImmutableCollections_SetN::_EMPTY_SET_offset;
4258 int java_util_ImmutableCollections_MapN::_EMPTY_MAP_offset;
4259
4260 #define STACKTRACEELEMENT_FIELDS_DO(macro) \
4261 macro(declaringClassObject_offset, k, "declaringClassObject", class_signature, false); \
4262 macro(classLoaderName_offset, k, "classLoaderName", string_signature, false); \
4263 macro(moduleName_offset, k, "moduleName", string_signature, false); \
4264 macro(moduleVersion_offset, k, "moduleVersion", string_signature, false); \
4265 macro(declaringClass_offset, k, "declaringClass", string_signature, false); \
4266 macro(methodName_offset, k, "methodName", string_signature, false); \
4267 macro(fileName_offset, k, "fileName", string_signature, false); \
4268 macro(lineNumber_offset, k, "lineNumber", int_signature, false)
4269
4270 // Support for java_lang_StackTraceElement
4271 void java_lang_StackTraceElement::compute_offsets() {
4272 InstanceKlass* k = SystemDictionary::StackTraceElement_klass();
4273 STACKTRACEELEMENT_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4274 }
4275
4276 #if INCLUDE_CDS
4277 void java_lang_StackTraceElement::serialize(SerializeClosure* f) {
4278 STACKTRACEELEMENT_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4279 }
4280 #endif
4281
4282 void java_lang_StackTraceElement::set_fileName(oop element, oop value) {
4283 element->obj_field_put(fileName_offset, value);
4284 }
4285
4286 void java_lang_StackTraceElement::set_declaringClass(oop element, oop value) {
4287 element->obj_field_put(declaringClass_offset, value);
4288 }
4289
4290 void java_lang_StackTraceElement::set_methodName(oop element, oop value) {
4291 element->obj_field_put(methodName_offset, value);
4292 }
4293
4294 void java_lang_StackTraceElement::set_lineNumber(oop element, int value) {
4295 element->int_field_put(lineNumber_offset, value);
4296 }
4297
4332 }
4333
4334 void java_lang_LiveStackFrameInfo::set_mode(oop element, int value) {
4335 element->int_field_put(_mode_offset, value);
4336 }
4337
4338 // Support for java Assertions - java_lang_AssertionStatusDirectives.
4339 #define ASSERTIONSTATUSDIRECTIVES_FIELDS_DO(macro) \
4340 macro(classes_offset, k, "classes", string_array_signature, false); \
4341 macro(classEnabled_offset, k, "classEnabled", bool_array_signature, false); \
4342 macro(packages_offset, k, "packages", string_array_signature, false); \
4343 macro(packageEnabled_offset, k, "packageEnabled", bool_array_signature, false); \
4344 macro(deflt_offset, k, "deflt", bool_signature, false)
4345
4346 void java_lang_AssertionStatusDirectives::compute_offsets() {
4347 InstanceKlass* k = SystemDictionary::AssertionStatusDirectives_klass();
4348 ASSERTIONSTATUSDIRECTIVES_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4349 }
4350
4351 #if INCLUDE_CDS
4352 void java_lang_AssertionStatusDirectives::serialize(SerializeClosure* f) {
4353 ASSERTIONSTATUSDIRECTIVES_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4354 }
4355 #endif
4356
4357 void java_lang_AssertionStatusDirectives::set_classes(oop o, oop val) {
4358 o->obj_field_put(classes_offset, val);
4359 }
4360
4361 void java_lang_AssertionStatusDirectives::set_classEnabled(oop o, oop val) {
4362 o->obj_field_put(classEnabled_offset, val);
4363 }
4364
4365 void java_lang_AssertionStatusDirectives::set_packages(oop o, oop val) {
4366 o->obj_field_put(packages_offset, val);
4367 }
4368
4369 void java_lang_AssertionStatusDirectives::set_packageEnabled(oop o, oop val) {
4370 o->obj_field_put(packageEnabled_offset, val);
4371 }
4372
4373 void java_lang_AssertionStatusDirectives::set_deflt(oop o, bool val) {
4374 o->bool_field_put(deflt_offset, val);
4375 }
4376
4377
4378 // Support for intrinsification of java.nio.Buffer.checkIndex
4379 int java_nio_Buffer::limit_offset() {
4380 return _limit_offset;
4381 }
4382
4383 #define BUFFER_FIELDS_DO(macro) \
4384 macro(_limit_offset, k, "limit", int_signature, false)
4385
4386 void java_nio_Buffer::compute_offsets() {
4387 InstanceKlass* k = SystemDictionary::nio_Buffer_klass();
4388 assert(k != NULL, "must be loaded in 1.4+");
4389 BUFFER_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4390 }
4391
4392 #if INCLUDE_CDS
4393 void java_nio_Buffer::serialize(SerializeClosure* f) {
4394 BUFFER_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4395 }
4396 #endif
4397
4398 #define AOS_FIELDS_DO(macro) \
4399 macro(_owner_offset, k, "exclusiveOwnerThread", thread_signature, false)
4400
4401 void java_util_concurrent_locks_AbstractOwnableSynchronizer::compute_offsets() {
4402 InstanceKlass* k = SystemDictionary::java_util_concurrent_locks_AbstractOwnableSynchronizer_klass();
4403 AOS_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4404 }
4405
4406 oop java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(oop obj) {
4407 assert(_owner_offset != 0, "Must be initialized");
4408 return obj->obj_field(_owner_offset);
4409 }
4410
4411 #if INCLUDE_CDS
4412 void java_util_concurrent_locks_AbstractOwnableSynchronizer::serialize(SerializeClosure* f) {
4413 AOS_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4414 }
4415 #endif
4416
4417 static int member_offset(int hardcoded_offset) {
4418 return (hardcoded_offset * heapOopSize) + instanceOopDesc::base_offset_in_bytes();
4419 }
4420
4421 #define INTEGERCACHE_FIELDS_DO(macro) \
4422 macro(_archivedCache_offset, k, "archivedCache", java_lang_Integer_array_signature, true)
4423
4424 void java_lang_Integer_IntegerCache::compute_offsets() {
4425 InstanceKlass* k = SystemDictionary::Integer_IntegerCache_klass();
4426 assert(k != NULL, "must be loaded");
4427 INTEGERCACHE_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4428 }
4429
4430 #if INCLUDE_CDS
4431 void java_lang_Integer_IntegerCache::serialize(SerializeClosure* f) {
4432 INTEGERCACHE_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4433 }
4434 #endif
4435
4436 #define ARCHIVEDMODULEGRAPH_FIELDS_DO(macro) \
4437 macro(_archivedSystemModules_offset, k, "archivedSystemModules", systemModules_signature, true); \
4438 macro(_archivedModuleFinder_offset, k, "archivedModuleFinder", moduleFinder_signature, true); \
4439 macro(_archivedMainModule_offset, k, "archivedMainModule", string_signature, true); \
4440 macro(_archivedConfiguration_offset, k, "archivedConfiguration", configuration_signature, true)
4441
4442 void jdk_internal_module_ArchivedModuleGraph::compute_offsets() {
4443 InstanceKlass* k = SystemDictionary::ArchivedModuleGraph_klass();
4444 assert(k != NULL, "must be loaded");
4445 ARCHIVEDMODULEGRAPH_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4446 }
4447
4448 #if INCLUDE_CDS
4449 void jdk_internal_module_ArchivedModuleGraph::serialize(SerializeClosure* f) {
4450 ARCHIVEDMODULEGRAPH_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4451 }
4452 #endif
4453
4454 #define CONFIGURATION_FIELDS_DO(macro) \
4455 macro(_EMPTY_CONFIGURATION_offset, k, "EMPTY_CONFIGURATION", configuration_signature, true)
4456
4457 void java_lang_module_Configuration::compute_offsets() {
4458 InstanceKlass* k = SystemDictionary::Configuration_klass();
4459 assert(k != NULL, "must be loaded");
4460 CONFIGURATION_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4461 }
4462
4463 #if INCLUDE_CDS
4464 void java_lang_module_Configuration::serialize(SerializeClosure* f) {
4465 CONFIGURATION_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4466 }
4467 #endif
4468
4469 #define LISTN_FIELDS_DO(macro) \
4470 macro(_EMPTY_LIST_offset, k, "EMPTY_LIST", list_signature, true)
4471
4472 void java_util_ImmutableCollections_ListN::compute_offsets() {
4473 InstanceKlass* k = SystemDictionary::ImmutableCollections_ListN_klass();
4474 assert(k != NULL, "must be loaded");
4475 LISTN_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4476 }
4477
4478 #if INCLUDE_CDS
4479 void java_util_ImmutableCollections_ListN::serialize(SerializeClosure* f) {
4480 LISTN_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4481 }
4482 #endif
4483
4484 #define SETN_FIELDS_DO(macro) \
4485 macro(_EMPTY_SET_offset, k, "EMPTY_SET", set_signature, true)
4486
4487 void java_util_ImmutableCollections_SetN::compute_offsets() {
4488 InstanceKlass* k = SystemDictionary::ImmutableCollections_SetN_klass();
4489 assert(k != NULL, "must be loaded");
4490 SETN_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4491 }
4492
4493 #if INCLUDE_CDS
4494 void java_util_ImmutableCollections_SetN::serialize(SerializeClosure* f) {
4495 SETN_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4496 }
4497 #endif
4498
4499 #define MAPN_FIELDS_DO(macro) \
4500 macro(_EMPTY_MAP_offset, k, "EMPTY_MAP", map_signature, true)
4501
4502 void java_util_ImmutableCollections_MapN::compute_offsets() {
4503 InstanceKlass* k = SystemDictionary::ImmutableCollections_MapN_klass();
4504 assert(k != NULL, "must be loaded");
4505 MAPN_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4506 }
4507
4508 #if INCLUDE_CDS
4509 void java_util_ImmutableCollections_MapN::serialize(SerializeClosure* f) {
4510 MAPN_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4511 }
4512 #endif
4513
4514 // Compute hard-coded offsets
4515 // Invoked before SystemDictionary::initialize, so pre-loaded classes
4516 // are not available to determine the offset_of_static_fields.
4517 void JavaClasses::compute_hard_coded_offsets() {
4518
4519 // java_lang_boxing_object
4520 java_lang_boxing_object::value_offset = member_offset(java_lang_boxing_object::hc_value_offset);
4521 java_lang_boxing_object::long_value_offset = align_up(member_offset(java_lang_boxing_object::hc_value_offset), BytesPerLong);
4522
4523 // java_lang_ref_Reference
4524 java_lang_ref_Reference::referent_offset = member_offset(java_lang_ref_Reference::hc_referent_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);
4527 java_lang_ref_Reference::discovered_offset = member_offset(java_lang_ref_Reference::hc_discovered_offset);
4528 }
4529
4530
4531 // Compute non-hard-coded field offsets of all the classes in this file
4532 void JavaClasses::compute_offsets() {
4533 if (UseSharedSpaces) {
4534 return; // field offsets are loaded from archive
4535 }
4536
4537 // java_lang_Class::compute_offsets was called earlier in bootstrap
4538 java_lang_System::compute_offsets();
4539 java_lang_ClassLoader::compute_offsets();
4540 java_lang_Throwable::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
4579 // generated interpreter code wants to know about the offsets we just computed:
4580 AbstractAssembler::update_delayed_values();
4581 }
4582
4583 #ifndef PRODUCT
4584
4585 // These functions exist to assert the validity of hard-coded field offsets to guard
4586 // against changes in the class files
4587
4588 bool JavaClasses::check_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) {
4589 EXCEPTION_MARK;
4590 fieldDescriptor fd;
4591 TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH);
4592 Klass* k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH);
4593 InstanceKlass* ik = InstanceKlass::cast(k);
4594 TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH);
4595 TempNewSymbol f_sig = SymbolTable::new_symbol(field_sig, CATCH);
4596 if (!ik->find_local_field(f_name, f_sig, &fd)) {
4597 tty->print_cr("Nonstatic field %s.%s not found", klass_name, field_name);
4598 return false;
4599 }
4600 if (fd.is_static()) {
4601 tty->print_cr("Nonstatic field %s.%s appears to be static", klass_name, field_name);
|
192 #define FIELD_COMPUTE_OFFSET_OPTIONAL(offset, klass, name, signature) \
193 compute_optional_offset(offset, klass, name, vmSymbols::signature())
194
195 #define STRING_FIELDS_DO(macro) \
196 macro(value_offset, k, vmSymbols::value_name(), byte_array_signature, false); \
197 macro(hash_offset, k, "hash", int_signature, false); \
198 macro(coder_offset, k, "coder", byte_signature, false)
199
200 void java_lang_String::compute_offsets() {
201 if (initialized) {
202 return;
203 }
204
205 InstanceKlass* k = SystemDictionary::String_klass();
206 STRING_FIELDS_DO(FIELD_COMPUTE_OFFSET);
207
208 initialized = true;
209 }
210
211 #if INCLUDE_CDS
212 void java_lang_String::serialize_offsets(SerializeClosure* f) {
213 STRING_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
214 f->do_u4((u4*)&initialized);
215 }
216 #endif
217
218 class CompactStringsFixup : public FieldClosure {
219 private:
220 bool _value;
221
222 public:
223 CompactStringsFixup(bool value) : _value(value) {}
224
225 void do_field(fieldDescriptor* fd) {
226 if (fd->name() == vmSymbols::compact_strings_name()) {
227 oop mirror = fd->field_holder()->java_mirror();
228 assert(fd->field_holder() == SystemDictionary::String_klass(), "Should be String");
229 assert(mirror != NULL, "String must have mirror already");
230 mirror->bool_field_put(fd->offset(), _value);
231 }
232 }
1517
1518 void java_lang_Class::compute_offsets() {
1519 if (offsets_computed) {
1520 return;
1521 }
1522
1523 offsets_computed = true;
1524
1525 InstanceKlass* k = SystemDictionary::Class_klass();
1526 CLASS_FIELDS_DO(FIELD_COMPUTE_OFFSET);
1527
1528 // Init lock is a C union with component_mirror. Only instanceKlass mirrors have
1529 // init_lock and only ArrayKlass mirrors have component_mirror. Since both are oops
1530 // GC treats them the same.
1531 _init_lock_offset = _component_mirror_offset;
1532
1533 CLASS_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
1534 }
1535
1536 #if INCLUDE_CDS
1537 void java_lang_Class::serialize_offsets(SerializeClosure* f) {
1538 f->do_u4((u4*)&offsets_computed);
1539 f->do_u4((u4*)&_init_lock_offset);
1540
1541 CLASS_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
1542
1543 CLASS_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET);
1544 }
1545 #endif
1546
1547 int java_lang_Class::classRedefinedCount(oop the_class_mirror) {
1548 if (classRedefinedCount_offset == -1) {
1549 // If we don't have an offset for it then just return -1 as a marker.
1550 return -1;
1551 }
1552
1553 return the_class_mirror->int_field(classRedefinedCount_offset);
1554 }
1555
1556 void java_lang_Class::set_classRedefinedCount(oop the_class_mirror, int value) {
1557 if (classRedefinedCount_offset == -1) {
1591 macro(_contextClassLoader_offset, k, vmSymbols::contextClassLoader_name(), classloader_signature, false); \
1592 macro(_inheritedAccessControlContext_offset, k, vmSymbols::inheritedAccessControlContext_name(), accesscontrolcontext_signature, false); \
1593 macro(_priority_offset, k, vmSymbols::priority_name(), int_signature, false); \
1594 macro(_daemon_offset, k, vmSymbols::daemon_name(), bool_signature, false); \
1595 macro(_eetop_offset, k, "eetop", long_signature, false); \
1596 macro(_stillborn_offset, k, "stillborn", bool_signature, false); \
1597 macro(_stackSize_offset, k, "stackSize", long_signature, false); \
1598 macro(_tid_offset, k, "tid", long_signature, false); \
1599 macro(_thread_status_offset, k, "threadStatus", int_signature, false); \
1600 macro(_park_blocker_offset, k, "parkBlocker", object_signature, false); \
1601 macro(_park_event_offset, k, "nativeParkEventPointer", long_signature, false)
1602
1603 void java_lang_Thread::compute_offsets() {
1604 assert(_group_offset == 0, "offsets should be initialized only once");
1605
1606 InstanceKlass* k = SystemDictionary::Thread_klass();
1607 THREAD_FIELDS_DO(FIELD_COMPUTE_OFFSET);
1608 }
1609
1610 #if INCLUDE_CDS
1611 void java_lang_Thread::serialize_offsets(SerializeClosure* f) {
1612 THREAD_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
1613 }
1614 #endif
1615
1616 JavaThread* java_lang_Thread::thread(oop java_thread) {
1617 return (JavaThread*)java_thread->address_field(_eetop_offset);
1618 }
1619
1620
1621 void java_lang_Thread::set_thread(oop java_thread, JavaThread* thread) {
1622 java_thread->address_field_put(_eetop_offset, (address)thread);
1623 }
1624
1625
1626 oop java_lang_Thread::name(oop java_thread) {
1627 return java_thread->obj_field(_name_offset);
1628 }
1629
1630
1631 void java_lang_Thread::set_name(oop java_thread, oop name) {
1843
1844 #define THREADGROUP_FIELDS_DO(macro) \
1845 macro(_parent_offset, k, vmSymbols::parent_name(), threadgroup_signature, false); \
1846 macro(_name_offset, k, vmSymbols::name_name(), string_signature, false); \
1847 macro(_threads_offset, k, vmSymbols::threads_name(), thread_array_signature, false); \
1848 macro(_groups_offset, k, vmSymbols::groups_name(), threadgroup_array_signature, false); \
1849 macro(_maxPriority_offset, k, vmSymbols::maxPriority_name(), int_signature, false); \
1850 macro(_destroyed_offset, k, vmSymbols::destroyed_name(), bool_signature, false); \
1851 macro(_daemon_offset, k, vmSymbols::daemon_name(), bool_signature, false); \
1852 macro(_nthreads_offset, k, vmSymbols::nthreads_name(), int_signature, false); \
1853 macro(_ngroups_offset, k, vmSymbols::ngroups_name(), int_signature, false)
1854
1855 void java_lang_ThreadGroup::compute_offsets() {
1856 assert(_parent_offset == 0, "offsets should be initialized only once");
1857
1858 InstanceKlass* k = SystemDictionary::ThreadGroup_klass();
1859 THREADGROUP_FIELDS_DO(FIELD_COMPUTE_OFFSET);
1860 }
1861
1862 #if INCLUDE_CDS
1863 void java_lang_ThreadGroup::serialize_offsets(SerializeClosure* f) {
1864 THREADGROUP_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
1865 }
1866 #endif
1867
1868 #define THROWABLE_FIELDS_DO(macro) \
1869 macro(backtrace_offset, k, "backtrace", object_signature, false); \
1870 macro(detailMessage_offset, k, "detailMessage", string_signature, false); \
1871 macro(stackTrace_offset, k, "stackTrace", java_lang_StackTraceElement_array, false); \
1872 macro(depth_offset, k, "depth", int_signature, false); \
1873 macro(static_unassigned_stacktrace_offset, k, "UNASSIGNED_STACK", java_lang_StackTraceElement_array, true)
1874
1875 void java_lang_Throwable::compute_offsets() {
1876 InstanceKlass* k = SystemDictionary::Throwable_klass();
1877 THROWABLE_FIELDS_DO(FIELD_COMPUTE_OFFSET);
1878 }
1879
1880 #if INCLUDE_CDS
1881 void java_lang_Throwable::serialize_offsets(SerializeClosure* f) {
1882 THROWABLE_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
1883 }
1884 #endif
1885
1886 oop java_lang_Throwable::unassigned_stacktrace() {
1887 InstanceKlass* ik = SystemDictionary::Throwable_klass();
1888 oop base = ik->static_field_base_raw();
1889 return base->obj_field(static_unassigned_stacktrace_offset);
1890 }
1891
1892 oop java_lang_Throwable::backtrace(oop throwable) {
1893 return throwable->obj_field_acquire(backtrace_offset);
1894 }
1895
1896
1897 void java_lang_Throwable::set_backtrace(oop throwable, oop value) {
1898 throwable->release_obj_field_put(backtrace_offset, value);
1899 }
1900
1901 int java_lang_Throwable::depth(oop throwable) {
2637 InstanceKlass* holder = InstanceKlass::cast(clazz);
2638 Method* method = java_lang_StackFrameInfo::get_method(stackFrame, holder, CHECK);
2639
2640 short version = stackFrame->short_field(_version_offset);
2641 short bci = stackFrame->short_field(_bci_offset);
2642 Symbol* name = method->name();
2643 java_lang_StackTraceElement::fill_in(stack_trace_element, holder, method, version, bci, name, CHECK);
2644 }
2645
2646 #define STACKFRAMEINFO_FIELDS_DO(macro) \
2647 macro(_memberName_offset, k, "memberName", object_signature, false); \
2648 macro(_bci_offset, k, "bci", short_signature, false)
2649
2650 void java_lang_StackFrameInfo::compute_offsets() {
2651 InstanceKlass* k = SystemDictionary::StackFrameInfo_klass();
2652 STACKFRAMEINFO_FIELDS_DO(FIELD_COMPUTE_OFFSET);
2653 STACKFRAMEINFO_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
2654 }
2655
2656 #if INCLUDE_CDS
2657 void java_lang_StackFrameInfo::serialize_offsets(SerializeClosure* f) {
2658 STACKFRAMEINFO_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
2659 STACKFRAMEINFO_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET);
2660 }
2661 #endif
2662
2663 #define LIVESTACKFRAMEINFO_FIELDS_DO(macro) \
2664 macro(_monitors_offset, k, "monitors", object_array_signature, false); \
2665 macro(_locals_offset, k, "locals", object_array_signature, false); \
2666 macro(_operands_offset, k, "operands", object_array_signature, false); \
2667 macro(_mode_offset, k, "mode", int_signature, false)
2668
2669 void java_lang_LiveStackFrameInfo::compute_offsets() {
2670 InstanceKlass* k = SystemDictionary::LiveStackFrameInfo_klass();
2671 LIVESTACKFRAMEINFO_FIELDS_DO(FIELD_COMPUTE_OFFSET);
2672 }
2673
2674 #if INCLUDE_CDS
2675 void java_lang_LiveStackFrameInfo::serialize_offsets(SerializeClosure* f) {
2676 LIVESTACKFRAMEINFO_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
2677 }
2678 #endif
2679
2680 #define ACCESSIBLEOBJECT_FIELDS_DO(macro) \
2681 macro(override_offset, k, "override", bool_signature, false)
2682
2683 void java_lang_reflect_AccessibleObject::compute_offsets() {
2684 InstanceKlass* k = SystemDictionary::reflect_AccessibleObject_klass();
2685 ACCESSIBLEOBJECT_FIELDS_DO(FIELD_COMPUTE_OFFSET);
2686 }
2687
2688 #if INCLUDE_CDS
2689 void java_lang_reflect_AccessibleObject::serialize_offsets(SerializeClosure* f) {
2690 ACCESSIBLEOBJECT_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
2691 }
2692 #endif
2693
2694 jboolean java_lang_reflect_AccessibleObject::override(oop reflect) {
2695 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
2696 return (jboolean) reflect->bool_field(override_offset);
2697 }
2698
2699 void java_lang_reflect_AccessibleObject::set_override(oop reflect, jboolean value) {
2700 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
2701 reflect->bool_field_put(override_offset, (int) value);
2702 }
2703
2704 #define METHOD_FIELDS_DO(macro) \
2705 macro(clazz_offset, k, vmSymbols::clazz_name(), class_signature, false); \
2706 macro(name_offset, k, vmSymbols::name_name(), string_signature, false); \
2707 macro(returnType_offset, k, vmSymbols::returnType_name(), class_signature, false); \
2708 macro(parameterTypes_offset, k, vmSymbols::parameterTypes_name(), class_array_signature, false); \
2709 macro(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), class_array_signature, false); \
2710 macro(slot_offset, k, vmSymbols::slot_name(), int_signature, false); \
2711 macro(modifiers_offset, k, vmSymbols::modifiers_name(), int_signature, false); \
2712 macro##_OPTIONAL(signature_offset, k, vmSymbols::signature_name(), string_signature); \
2713 macro##_OPTIONAL(annotations_offset, k, vmSymbols::annotations_name(), byte_array_signature); \
2714 macro##_OPTIONAL(parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), byte_array_signature); \
2715 macro##_OPTIONAL(annotation_default_offset, k, vmSymbols::annotation_default_name(), byte_array_signature); \
2716 macro##_OPTIONAL(type_annotations_offset, k, vmSymbols::type_annotations_name(), byte_array_signature)
2717
2718 void java_lang_reflect_Method::compute_offsets() {
2719 InstanceKlass* k = SystemDictionary::reflect_Method_klass();
2720 // The generic signature and annotations fields are only present in 1.5
2721 signature_offset = -1;
2722 annotations_offset = -1;
2723 parameter_annotations_offset = -1;
2724 annotation_default_offset = -1;
2725 type_annotations_offset = -1;
2726 METHOD_FIELDS_DO(FIELD_COMPUTE_OFFSET);
2727 }
2728
2729 #if INCLUDE_CDS
2730 void java_lang_reflect_Method::serialize_offsets(SerializeClosure* f) {
2731 METHOD_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
2732 }
2733 #endif
2734
2735 Handle java_lang_reflect_Method::create(TRAPS) {
2736 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
2737 Klass* klass = SystemDictionary::reflect_Method_klass();
2738 // This class is eagerly initialized during VM initialization, since we keep a refence
2739 // to one of the methods
2740 assert(InstanceKlass::cast(klass)->is_initialized(), "must be initialized");
2741 return InstanceKlass::cast(klass)->allocate_instance_handle(THREAD);
2742 }
2743
2744 oop java_lang_reflect_Method::clazz(oop reflect) {
2745 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
2746 return reflect->obj_field(clazz_offset);
2747 }
2748
2749 void java_lang_reflect_Method::set_clazz(oop reflect, oop value) {
2750 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
2897 macro(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), class_array_signature, false); \
2898 macro(slot_offset, k, vmSymbols::slot_name(), int_signature, false); \
2899 macro(modifiers_offset, k, vmSymbols::modifiers_name(), int_signature, false); \
2900 macro##_OPTIONAL(signature_offset, k, vmSymbols::signature_name(), string_signature); \
2901 macro##_OPTIONAL(annotations_offset, k, vmSymbols::annotations_name(), byte_array_signature); \
2902 macro##_OPTIONAL(parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), byte_array_signature); \
2903 macro##_OPTIONAL(type_annotations_offset, k, vmSymbols::type_annotations_name(), byte_array_signature)
2904
2905
2906 void java_lang_reflect_Constructor::compute_offsets() {
2907 InstanceKlass* k = SystemDictionary::reflect_Constructor_klass();
2908 // The generic signature and annotations fields are only present in 1.5
2909 signature_offset = -1;
2910 annotations_offset = -1;
2911 parameter_annotations_offset = -1;
2912 type_annotations_offset = -1;
2913 CONSTRUCTOR_FIELDS_DO(FIELD_COMPUTE_OFFSET);
2914 }
2915
2916 #if INCLUDE_CDS
2917 void java_lang_reflect_Constructor::serialize_offsets(SerializeClosure* f) {
2918 CONSTRUCTOR_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
2919 }
2920 #endif
2921
2922 Handle java_lang_reflect_Constructor::create(TRAPS) {
2923 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
2924 Symbol* name = vmSymbols::java_lang_reflect_Constructor();
2925 Klass* k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH);
2926 InstanceKlass* ik = InstanceKlass::cast(k);
2927 // Ensure it is initialized
2928 ik->initialize(CHECK_NH);
2929 return ik->allocate_instance_handle(THREAD);
2930 }
2931
2932 oop java_lang_reflect_Constructor::clazz(oop reflect) {
2933 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
2934 return reflect->obj_field(clazz_offset);
2935 }
2936
2937 void java_lang_reflect_Constructor::set_clazz(oop reflect, oop value) {
3046 #define FIELD_FIELDS_DO(macro) \
3047 macro(clazz_offset, k, vmSymbols::clazz_name(), class_signature, false); \
3048 macro(name_offset, k, vmSymbols::name_name(), string_signature, false); \
3049 macro(type_offset, k, vmSymbols::type_name(), class_signature, false); \
3050 macro(slot_offset, k, vmSymbols::slot_name(), int_signature, false); \
3051 macro(modifiers_offset, k, vmSymbols::modifiers_name(), int_signature, false); \
3052 macro##_OPTIONAL(signature_offset, k, vmSymbols::signature_name(), string_signature); \
3053 macro##_OPTIONAL(annotations_offset, k, vmSymbols::annotations_name(), byte_array_signature); \
3054 macro##_OPTIONAL(type_annotations_offset, k, vmSymbols::type_annotations_name(), byte_array_signature)
3055
3056 void java_lang_reflect_Field::compute_offsets() {
3057 InstanceKlass* k = SystemDictionary::reflect_Field_klass();
3058 // The generic signature and annotations fields are only present in 1.5
3059 signature_offset = -1;
3060 annotations_offset = -1;
3061 type_annotations_offset = -1;
3062 FIELD_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3063 }
3064
3065 #if INCLUDE_CDS
3066 void java_lang_reflect_Field::serialize_offsets(SerializeClosure* f) {
3067 FIELD_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3068 }
3069 #endif
3070
3071 Handle java_lang_reflect_Field::create(TRAPS) {
3072 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3073 Symbol* name = vmSymbols::java_lang_reflect_Field();
3074 Klass* k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH);
3075 InstanceKlass* ik = InstanceKlass::cast(k);
3076 // Ensure it is initialized
3077 ik->initialize(CHECK_NH);
3078 return ik->allocate_instance_handle(THREAD);
3079 }
3080
3081 oop java_lang_reflect_Field::clazz(oop reflect) {
3082 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3083 return reflect->obj_field(clazz_offset);
3084 }
3085
3086 void java_lang_reflect_Field::set_clazz(oop reflect, oop value) {
3169 assert(has_type_annotations_field(), "type_annotations field must be present");
3170 return field->obj_field(type_annotations_offset);
3171 }
3172
3173 void java_lang_reflect_Field::set_type_annotations(oop field, oop value) {
3174 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3175 assert(has_type_annotations_field(), "type_annotations field must be present");
3176 field->obj_field_put(type_annotations_offset, value);
3177 }
3178
3179 #define CONSTANTPOOL_FIELDS_DO(macro) \
3180 macro(_oop_offset, k, "constantPoolOop", object_signature, false)
3181
3182 void reflect_ConstantPool::compute_offsets() {
3183 InstanceKlass* k = SystemDictionary::reflect_ConstantPool_klass();
3184 // The field is called ConstantPool* in the sun.reflect.ConstantPool class.
3185 CONSTANTPOOL_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3186 }
3187
3188 #if INCLUDE_CDS
3189 void reflect_ConstantPool::serialize_offsets(SerializeClosure* f) {
3190 CONSTANTPOOL_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3191 }
3192 #endif
3193
3194 #define PARAMETER_FIELDS_DO(macro) \
3195 macro(name_offset, k, vmSymbols::name_name(), string_signature, false); \
3196 macro(modifiers_offset, k, vmSymbols::modifiers_name(), int_signature, false); \
3197 macro(index_offset, k, vmSymbols::index_name(), int_signature, false); \
3198 macro(executable_offset, k, vmSymbols::executable_name(), executable_signature, false)
3199
3200 void java_lang_reflect_Parameter::compute_offsets() {
3201 InstanceKlass* k = SystemDictionary::reflect_Parameter_klass();
3202 PARAMETER_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3203 }
3204
3205 #if INCLUDE_CDS
3206 void java_lang_reflect_Parameter::serialize_offsets(SerializeClosure* f) {
3207 PARAMETER_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3208 }
3209 #endif
3210
3211 Handle java_lang_reflect_Parameter::create(TRAPS) {
3212 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3213 Symbol* name = vmSymbols::java_lang_reflect_Parameter();
3214 Klass* k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH);
3215 InstanceKlass* ik = InstanceKlass::cast(k);
3216 // Ensure it is initialized
3217 ik->initialize(CHECK_NH);
3218 return ik->allocate_instance_handle(THREAD);
3219 }
3220
3221 oop java_lang_reflect_Parameter::name(oop param) {
3222 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3223 return param->obj_field(name_offset);
3224 }
3225
3226 void java_lang_reflect_Parameter::set_name(oop param, oop value) {
3264 int java_lang_Module::_module_entry_offset = -1;
3265
3266 Handle java_lang_Module::create(Handle loader, Handle module_name, TRAPS) {
3267 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3268 return JavaCalls::construct_new_instance(SystemDictionary::Module_klass(),
3269 vmSymbols::java_lang_module_init_signature(),
3270 loader, module_name, CHECK_NH);
3271 }
3272
3273 #define MODULE_FIELDS_DO(macro) \
3274 macro(loader_offset, k, vmSymbols::loader_name(), classloader_signature, false); \
3275 macro(name_offset, k, vmSymbols::name_name(), string_signature, false)
3276
3277 void java_lang_Module::compute_offsets() {
3278 InstanceKlass* k = SystemDictionary::Module_klass();
3279 MODULE_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3280 MODULE_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
3281 }
3282
3283 #if INCLUDE_CDS
3284 void java_lang_Module::serialize_offsets(SerializeClosure* f) {
3285 MODULE_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3286 MODULE_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET);
3287 }
3288 #endif
3289
3290 oop java_lang_Module::loader(oop module) {
3291 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3292 return module->obj_field(loader_offset);
3293 }
3294
3295 void java_lang_Module::set_loader(oop module, oop value) {
3296 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3297 module->obj_field_put(loader_offset, value);
3298 }
3299
3300 oop java_lang_Module::name(oop module) {
3301 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3302 return module->obj_field(name_offset);
3303 }
3304
3354 Klass* k = java_lang_Class::as_Klass(mirror);
3355 assert(k->is_instance_klass(), "Must be");
3356
3357 // Get the constant pool back from the klass. Since class redefinition
3358 // merges the new constant pool into the old, this is essentially the
3359 // same constant pool as the original. If constant pool merging is
3360 // no longer done in the future, this will have to change to save
3361 // the original.
3362 return InstanceKlass::cast(k)->constants();
3363 }
3364
3365 #define UNSAFESTATICFIELDACCESSORIMPL_FIELDS_DO(macro) \
3366 macro(_base_offset, k, "base", object_signature, false)
3367
3368 void reflect_UnsafeStaticFieldAccessorImpl::compute_offsets() {
3369 InstanceKlass* k = SystemDictionary::reflect_UnsafeStaticFieldAccessorImpl_klass();
3370 UNSAFESTATICFIELDACCESSORIMPL_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3371 }
3372
3373 #if INCLUDE_CDS
3374 void reflect_UnsafeStaticFieldAccessorImpl::serialize_offsets(SerializeClosure* f) {
3375 UNSAFESTATICFIELDACCESSORIMPL_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3376 }
3377 #endif
3378
3379 oop java_lang_boxing_object::initialize_and_allocate(BasicType type, TRAPS) {
3380 Klass* k = SystemDictionary::box_klass(type);
3381 if (k == NULL) return NULL;
3382 InstanceKlass* ik = InstanceKlass::cast(k);
3383 if (!ik->is_initialized()) ik->initialize(CHECK_0);
3384 return ik->allocate_instance(THREAD);
3385 }
3386
3387
3388 oop java_lang_boxing_object::create(BasicType type, jvalue* value, TRAPS) {
3389 oop box = initialize_and_allocate(type, CHECK_0);
3390 if (box == NULL) return NULL;
3391 switch (type) {
3392 case T_BOOLEAN:
3393 box->bool_field_put(value_offset, value->z);
3394 break;
3526
3527 InstanceKlass* ik = InstanceKlass::cast(obj->klass());
3528 bool is_reference = ik->reference_type() != REF_NONE;
3529 assert(!is_reference || ik->is_subclass_of(SystemDictionary::Reference_klass()), "sanity");
3530 return is_reference;
3531 }
3532
3533 // Support for java_lang_ref_SoftReference
3534 //
3535
3536 #define SOFTREFERENCE_FIELDS_DO(macro) \
3537 macro(timestamp_offset, k, "timestamp", long_signature, false); \
3538 macro(static_clock_offset, k, "clock", long_signature, true)
3539
3540 void java_lang_ref_SoftReference::compute_offsets() {
3541 InstanceKlass* k = SystemDictionary::SoftReference_klass();
3542 SOFTREFERENCE_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3543 }
3544
3545 #if INCLUDE_CDS
3546 void java_lang_ref_SoftReference::serialize_offsets(SerializeClosure* f) {
3547 SOFTREFERENCE_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3548 }
3549 #endif
3550
3551 jlong java_lang_ref_SoftReference::timestamp(oop ref) {
3552 return ref->long_field(timestamp_offset);
3553 }
3554
3555 jlong java_lang_ref_SoftReference::clock() {
3556 InstanceKlass* ik = SystemDictionary::SoftReference_klass();
3557 oop base = ik->static_field_base_raw();
3558 return base->long_field(static_clock_offset);
3559 }
3560
3561 void java_lang_ref_SoftReference::set_clock(jlong value) {
3562 InstanceKlass* ik = SystemDictionary::SoftReference_klass();
3563 oop base = ik->static_field_base_raw();
3564 base->long_field_put(static_clock_offset, value);
3565 }
3566
3567 // Support for java_lang_invoke_DirectMethodHandle
3568
3569 int java_lang_invoke_DirectMethodHandle::_member_offset;
3570
3571 oop java_lang_invoke_DirectMethodHandle::member(oop dmh) {
3572 oop member_name = NULL;
3573 assert(oopDesc::is_oop(dmh) && java_lang_invoke_DirectMethodHandle::is_instance(dmh),
3574 "a DirectMethodHandle oop is expected");
3575 return dmh->obj_field(member_offset_in_bytes());
3576 }
3577
3578 #define DIRECTMETHODHANDLE_FIELDS_DO(macro) \
3579 macro(_member_offset, k, "member", java_lang_invoke_MemberName_signature, false)
3580
3581 void java_lang_invoke_DirectMethodHandle::compute_offsets() {
3582 InstanceKlass* k = SystemDictionary::DirectMethodHandle_klass();
3583 DIRECTMETHODHANDLE_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3584 }
3585
3586 #if INCLUDE_CDS
3587 void java_lang_invoke_DirectMethodHandle::serialize_offsets(SerializeClosure* f) {
3588 DIRECTMETHODHANDLE_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3589 }
3590 #endif
3591
3592 // Support for java_lang_invoke_MethodHandle
3593
3594 int java_lang_invoke_MethodHandle::_type_offset;
3595 int java_lang_invoke_MethodHandle::_form_offset;
3596
3597 int java_lang_invoke_MemberName::_clazz_offset;
3598 int java_lang_invoke_MemberName::_name_offset;
3599 int java_lang_invoke_MemberName::_type_offset;
3600 int java_lang_invoke_MemberName::_flags_offset;
3601 int java_lang_invoke_MemberName::_method_offset;
3602 int java_lang_invoke_MemberName::_vmindex_offset;
3603
3604 int java_lang_invoke_ResolvedMethodName::_vmtarget_offset;
3605 int java_lang_invoke_ResolvedMethodName::_vmholder_offset;
3606
3607 int java_lang_invoke_LambdaForm::_vmentry_offset;
3608
3609 #define METHODHANDLE_FIELDS_DO(macro) \
3610 macro(_type_offset, k, vmSymbols::type_name(), java_lang_invoke_MethodType_signature, false); \
3611 macro(_form_offset, k, "form", java_lang_invoke_LambdaForm_signature, false)
3612
3613 void java_lang_invoke_MethodHandle::compute_offsets() {
3614 InstanceKlass* k = SystemDictionary::MethodHandle_klass();
3615 METHODHANDLE_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3616 }
3617
3618 #if INCLUDE_CDS
3619 void java_lang_invoke_MethodHandle::serialize_offsets(SerializeClosure* f) {
3620 METHODHANDLE_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3621 }
3622 #endif
3623
3624 #define MEMBERNAME_FIELDS_DO(macro) \
3625 macro(_clazz_offset, k, vmSymbols::clazz_name(), class_signature, false); \
3626 macro(_name_offset, k, vmSymbols::name_name(), string_signature, false); \
3627 macro(_type_offset, k, vmSymbols::type_name(), object_signature, false); \
3628 macro(_flags_offset, k, vmSymbols::flags_name(), int_signature, false); \
3629 macro(_method_offset, k, vmSymbols::method_name(), java_lang_invoke_ResolvedMethodName_signature, false)
3630
3631 void java_lang_invoke_MemberName::compute_offsets() {
3632 InstanceKlass* k = SystemDictionary::MemberName_klass();
3633 MEMBERNAME_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3634 MEMBERNAME_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
3635 }
3636
3637 #if INCLUDE_CDS
3638 void java_lang_invoke_MemberName::serialize_offsets(SerializeClosure* f) {
3639 MEMBERNAME_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3640 MEMBERNAME_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET);
3641 }
3642 #endif
3643
3644 void java_lang_invoke_ResolvedMethodName::compute_offsets() {
3645 InstanceKlass* k = SystemDictionary::ResolvedMethodName_klass();
3646 assert(k != NULL, "jdk mismatch");
3647 RESOLVEDMETHOD_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
3648 }
3649
3650 #if INCLUDE_CDS
3651 void java_lang_invoke_ResolvedMethodName::serialize_offsets(SerializeClosure* f) {
3652 RESOLVEDMETHOD_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET);
3653 }
3654 #endif
3655
3656 #define LAMBDAFORM_FIELDS_DO(macro) \
3657 macro(_vmentry_offset, k, "vmentry", java_lang_invoke_MemberName_signature, false)
3658
3659 void java_lang_invoke_LambdaForm::compute_offsets() {
3660 InstanceKlass* k = SystemDictionary::LambdaForm_klass();
3661 assert (k != NULL, "jdk mismatch");
3662 LAMBDAFORM_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3663 }
3664
3665 #if INCLUDE_CDS
3666 void java_lang_invoke_LambdaForm::serialize_offsets(SerializeClosure* f) {
3667 LAMBDAFORM_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3668 }
3669 #endif
3670
3671 bool java_lang_invoke_LambdaForm::is_instance(oop obj) {
3672 return obj != NULL && is_subclass(obj->klass());
3673 }
3674
3675
3676 oop java_lang_invoke_MethodHandle::type(oop mh) {
3677 return mh->obj_field(_type_offset);
3678 }
3679
3680 void java_lang_invoke_MethodHandle::set_type(oop mh, oop mtype) {
3681 mh->obj_field_put(_type_offset, mtype);
3682 }
3683
3684 oop java_lang_invoke_MethodHandle::form(oop mh) {
3685 assert(_form_offset != 0, "");
3686 return mh->obj_field(_form_offset);
3798 assert(is_instance(lform), "wrong type");
3799 return lform->obj_field(_vmentry_offset);
3800 }
3801
3802
3803 // Support for java_lang_invoke_MethodType
3804
3805 int java_lang_invoke_MethodType::_rtype_offset;
3806 int java_lang_invoke_MethodType::_ptypes_offset;
3807
3808 #define METHODTYPE_FIELDS_DO(macro) \
3809 macro(_rtype_offset, k, "rtype", class_signature, false); \
3810 macro(_ptypes_offset, k, "ptypes", class_array_signature, false)
3811
3812 void java_lang_invoke_MethodType::compute_offsets() {
3813 InstanceKlass* k = SystemDictionary::MethodType_klass();
3814 METHODTYPE_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3815 }
3816
3817 #if INCLUDE_CDS
3818 void java_lang_invoke_MethodType::serialize_offsets(SerializeClosure* f) {
3819 METHODTYPE_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3820 }
3821 #endif
3822
3823 void java_lang_invoke_MethodType::print_signature(oop mt, outputStream* st) {
3824 st->print("(");
3825 objArrayOop pts = ptypes(mt);
3826 for (int i = 0, limit = pts->length(); i < limit; i++) {
3827 java_lang_Class::print_signature(pts->obj_at(i), st);
3828 }
3829 st->print(")");
3830 java_lang_Class::print_signature(rtype(mt), st);
3831 }
3832
3833 Symbol* java_lang_invoke_MethodType::as_signature(oop mt, bool intern_if_not_found, TRAPS) {
3834 ResourceMark rm;
3835 stringStream buffer(128);
3836 print_signature(mt, &buffer);
3837 const char* sigstr = buffer.base();
3838 int siglen = (int) buffer.size();
3892 BasicType bt = java_lang_Class::as_BasicType(rtype(mt));
3893 return type2size[bt];
3894 }
3895
3896
3897 // Support for java_lang_invoke_CallSite
3898
3899 int java_lang_invoke_CallSite::_target_offset;
3900 int java_lang_invoke_CallSite::_context_offset;
3901
3902 #define CALLSITE_FIELDS_DO(macro) \
3903 macro(_target_offset, k, "target", java_lang_invoke_MethodHandle_signature, false); \
3904 macro(_context_offset, k, "context", java_lang_invoke_MethodHandleNatives_CallSiteContext_signature, false)
3905
3906 void java_lang_invoke_CallSite::compute_offsets() {
3907 InstanceKlass* k = SystemDictionary::CallSite_klass();
3908 CALLSITE_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3909 }
3910
3911 #if INCLUDE_CDS
3912 void java_lang_invoke_CallSite::serialize_offsets(SerializeClosure* f) {
3913 CALLSITE_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3914 }
3915 #endif
3916
3917 oop java_lang_invoke_CallSite::context(oop call_site) {
3918 assert(java_lang_invoke_CallSite::is_instance(call_site), "");
3919
3920 oop dep_oop = call_site->obj_field(_context_offset);
3921 return dep_oop;
3922 }
3923
3924 // Support for java_lang_invoke_MethodHandleNatives_CallSiteContext
3925
3926 int java_lang_invoke_MethodHandleNatives_CallSiteContext::_vmdependencies_offset;
3927
3928 void java_lang_invoke_MethodHandleNatives_CallSiteContext::compute_offsets() {
3929 InstanceKlass* k = SystemDictionary::Context_klass();
3930 CALLSITECONTEXT_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
3931 }
3932
3933 #if INCLUDE_CDS
3934 void java_lang_invoke_MethodHandleNatives_CallSiteContext::serialize_offsets(SerializeClosure* f) {
3935 CALLSITECONTEXT_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET);
3936 }
3937 #endif
3938
3939 DependencyContext java_lang_invoke_MethodHandleNatives_CallSiteContext::vmdependencies(oop call_site) {
3940 assert(java_lang_invoke_MethodHandleNatives_CallSiteContext::is_instance(call_site), "");
3941 intptr_t* vmdeps_addr = (intptr_t*)call_site->field_addr(_vmdependencies_offset);
3942 DependencyContext dep_ctx(vmdeps_addr);
3943 return dep_ctx;
3944 }
3945
3946 // Support for java_security_AccessControlContext
3947
3948 int java_security_AccessControlContext::_context_offset = 0;
3949 int java_security_AccessControlContext::_privilegedContext_offset = 0;
3950 int java_security_AccessControlContext::_isPrivileged_offset = 0;
3951 int java_security_AccessControlContext::_isAuthorized_offset = -1;
3952
3953 #define ACCESSCONTROLCONTEXT_FIELDS_DO(macro) \
3954 macro(_context_offset, k, "context", protectiondomain_signature, false); \
3955 macro(_privilegedContext_offset, k, "privilegedContext", accesscontrolcontext_signature, false); \
3956 macro(_isPrivileged_offset, k, "isPrivileged", bool_signature, false); \
3957 macro(_isAuthorized_offset, k, "isAuthorized", bool_signature, false)
3958
3959 void java_security_AccessControlContext::compute_offsets() {
3960 assert(_isPrivileged_offset == 0, "offsets should be initialized only once");
3961 InstanceKlass* k = SystemDictionary::AccessControlContext_klass();
3962 ACCESSCONTROLCONTEXT_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3963 }
3964
3965 #if INCLUDE_CDS
3966 void java_security_AccessControlContext::serialize_offsets(SerializeClosure* f) {
3967 ACCESSCONTROLCONTEXT_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3968 }
3969 #endif
3970
3971 bool java_security_AccessControlContext::is_authorized(Handle context) {
3972 assert(context.not_null() && context->klass() == SystemDictionary::AccessControlContext_klass(), "Invalid type");
3973 assert(_isAuthorized_offset != -1, "should be set");
3974 return context->bool_field(_isAuthorized_offset) != 0;
3975 }
3976
3977 oop java_security_AccessControlContext::create(objArrayHandle context, bool isPrivileged, Handle privileged_context, TRAPS) {
3978 assert(_isPrivileged_offset != 0, "offsets should have been initialized");
3979 // Ensure klass is initialized
3980 SystemDictionary::AccessControlContext_klass()->initialize(CHECK_0);
3981 // Allocate result
3982 oop result = SystemDictionary::AccessControlContext_klass()->allocate_instance(CHECK_0);
3983 // Fill in values
3984 result->obj_field_put(_context_offset, context());
3985 result->obj_field_put(_privilegedContext_offset, privileged_context());
3986 result->bool_field_put(_isPrivileged_offset, isPrivileged);
4012 }
4013
4014 #define CLASSLOADER_FIELDS_DO(macro) \
4015 macro(parallelCapable_offset, k1, "parallelLockMap", concurrenthashmap_signature, false); \
4016 macro(name_offset, k1, vmSymbols::name_name(), string_signature, false); \
4017 macro(nameAndId_offset, k1, "nameAndId", string_signature, false); \
4018 macro(unnamedModule_offset, k1, "unnamedModule", module_signature, false); \
4019 macro(parent_offset, k1, "parent", classloader_signature, false)
4020
4021 void java_lang_ClassLoader::compute_offsets() {
4022 assert(!offsets_computed, "offsets should be initialized only once");
4023 offsets_computed = true;
4024
4025 InstanceKlass* k1 = SystemDictionary::ClassLoader_klass();
4026 CLASSLOADER_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4027
4028 CLASSLOADER_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
4029 }
4030
4031 #if INCLUDE_CDS
4032 void java_lang_ClassLoader::serialize_offsets(SerializeClosure* f) {
4033 CLASSLOADER_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4034 CLASSLOADER_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET);
4035 }
4036 #endif
4037
4038 oop java_lang_ClassLoader::parent(oop loader) {
4039 assert(is_instance(loader), "loader must be oop");
4040 return loader->obj_field(parent_offset);
4041 }
4042
4043 // Returns the name field of this class loader. If the name field has not
4044 // been set, null will be returned.
4045 oop java_lang_ClassLoader::name(oop loader) {
4046 assert(is_instance(loader), "loader must be oop");
4047 return loader->obj_field(name_offset);
4048 }
4049
4050 // Returns the nameAndId field of this class loader. The format is
4051 // as follows:
4052 // If the defining loader has a name explicitly set then '<loader-name>' @<id>
4126
4127 oop java_lang_ClassLoader::unnamedModule(oop loader) {
4128 assert(is_instance(loader), "loader must be oop");
4129 return loader->obj_field(unnamedModule_offset);
4130 }
4131
4132 // Support for java_lang_System
4133 //
4134 #define SYSTEM_FIELDS_DO(macro) \
4135 macro(static_in_offset, k, "in", input_stream_signature, true); \
4136 macro(static_out_offset, k, "out", print_stream_signature, true); \
4137 macro(static_err_offset, k, "err", print_stream_signature, true); \
4138 macro(static_security_offset, k, "security", security_manager_signature, true)
4139
4140 void java_lang_System::compute_offsets() {
4141 InstanceKlass* k = SystemDictionary::System_klass();
4142 SYSTEM_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4143 }
4144
4145 #if INCLUDE_CDS
4146 void java_lang_System::serialize_offsets(SerializeClosure* f) {
4147 SYSTEM_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4148 }
4149 #endif
4150
4151 int java_lang_System::in_offset_in_bytes() { return static_in_offset; }
4152 int java_lang_System::out_offset_in_bytes() { return static_out_offset; }
4153 int java_lang_System::err_offset_in_bytes() { return static_err_offset; }
4154
4155
4156 bool java_lang_System::has_security_manager() {
4157 InstanceKlass* ik = SystemDictionary::System_klass();
4158 oop base = ik->static_field_base_raw();
4159 return base->obj_field(static_security_offset) != NULL;
4160 }
4161
4162 int java_lang_Class::_klass_offset;
4163 int java_lang_Class::_array_klass_offset;
4164 int java_lang_Class::_oop_size_offset;
4165 int java_lang_Class::_static_oop_field_count_offset;
4166 int java_lang_Class::_class_loader_offset;
4257 int java_util_ImmutableCollections_SetN::_EMPTY_SET_offset;
4258 int java_util_ImmutableCollections_MapN::_EMPTY_MAP_offset;
4259
4260 #define STACKTRACEELEMENT_FIELDS_DO(macro) \
4261 macro(declaringClassObject_offset, k, "declaringClassObject", class_signature, false); \
4262 macro(classLoaderName_offset, k, "classLoaderName", string_signature, false); \
4263 macro(moduleName_offset, k, "moduleName", string_signature, false); \
4264 macro(moduleVersion_offset, k, "moduleVersion", string_signature, false); \
4265 macro(declaringClass_offset, k, "declaringClass", string_signature, false); \
4266 macro(methodName_offset, k, "methodName", string_signature, false); \
4267 macro(fileName_offset, k, "fileName", string_signature, false); \
4268 macro(lineNumber_offset, k, "lineNumber", int_signature, false)
4269
4270 // Support for java_lang_StackTraceElement
4271 void java_lang_StackTraceElement::compute_offsets() {
4272 InstanceKlass* k = SystemDictionary::StackTraceElement_klass();
4273 STACKTRACEELEMENT_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4274 }
4275
4276 #if INCLUDE_CDS
4277 void java_lang_StackTraceElement::serialize_offsets(SerializeClosure* f) {
4278 STACKTRACEELEMENT_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4279 }
4280 #endif
4281
4282 void java_lang_StackTraceElement::set_fileName(oop element, oop value) {
4283 element->obj_field_put(fileName_offset, value);
4284 }
4285
4286 void java_lang_StackTraceElement::set_declaringClass(oop element, oop value) {
4287 element->obj_field_put(declaringClass_offset, value);
4288 }
4289
4290 void java_lang_StackTraceElement::set_methodName(oop element, oop value) {
4291 element->obj_field_put(methodName_offset, value);
4292 }
4293
4294 void java_lang_StackTraceElement::set_lineNumber(oop element, int value) {
4295 element->int_field_put(lineNumber_offset, value);
4296 }
4297
4332 }
4333
4334 void java_lang_LiveStackFrameInfo::set_mode(oop element, int value) {
4335 element->int_field_put(_mode_offset, value);
4336 }
4337
4338 // Support for java Assertions - java_lang_AssertionStatusDirectives.
4339 #define ASSERTIONSTATUSDIRECTIVES_FIELDS_DO(macro) \
4340 macro(classes_offset, k, "classes", string_array_signature, false); \
4341 macro(classEnabled_offset, k, "classEnabled", bool_array_signature, false); \
4342 macro(packages_offset, k, "packages", string_array_signature, false); \
4343 macro(packageEnabled_offset, k, "packageEnabled", bool_array_signature, false); \
4344 macro(deflt_offset, k, "deflt", bool_signature, false)
4345
4346 void java_lang_AssertionStatusDirectives::compute_offsets() {
4347 InstanceKlass* k = SystemDictionary::AssertionStatusDirectives_klass();
4348 ASSERTIONSTATUSDIRECTIVES_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4349 }
4350
4351 #if INCLUDE_CDS
4352 void java_lang_AssertionStatusDirectives::serialize_offsets(SerializeClosure* f) {
4353 ASSERTIONSTATUSDIRECTIVES_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4354 }
4355 #endif
4356
4357 void java_lang_AssertionStatusDirectives::set_classes(oop o, oop val) {
4358 o->obj_field_put(classes_offset, val);
4359 }
4360
4361 void java_lang_AssertionStatusDirectives::set_classEnabled(oop o, oop val) {
4362 o->obj_field_put(classEnabled_offset, val);
4363 }
4364
4365 void java_lang_AssertionStatusDirectives::set_packages(oop o, oop val) {
4366 o->obj_field_put(packages_offset, val);
4367 }
4368
4369 void java_lang_AssertionStatusDirectives::set_packageEnabled(oop o, oop val) {
4370 o->obj_field_put(packageEnabled_offset, val);
4371 }
4372
4373 void java_lang_AssertionStatusDirectives::set_deflt(oop o, bool val) {
4374 o->bool_field_put(deflt_offset, val);
4375 }
4376
4377
4378 // Support for intrinsification of java.nio.Buffer.checkIndex
4379 int java_nio_Buffer::limit_offset() {
4380 return _limit_offset;
4381 }
4382
4383 #define BUFFER_FIELDS_DO(macro) \
4384 macro(_limit_offset, k, "limit", int_signature, false)
4385
4386 void java_nio_Buffer::compute_offsets() {
4387 InstanceKlass* k = SystemDictionary::nio_Buffer_klass();
4388 assert(k != NULL, "must be loaded in 1.4+");
4389 BUFFER_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4390 }
4391
4392 #if INCLUDE_CDS
4393 void java_nio_Buffer::serialize_offsets(SerializeClosure* f) {
4394 BUFFER_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4395 }
4396 #endif
4397
4398 #define AOS_FIELDS_DO(macro) \
4399 macro(_owner_offset, k, "exclusiveOwnerThread", thread_signature, false)
4400
4401 void java_util_concurrent_locks_AbstractOwnableSynchronizer::compute_offsets() {
4402 InstanceKlass* k = SystemDictionary::java_util_concurrent_locks_AbstractOwnableSynchronizer_klass();
4403 AOS_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4404 }
4405
4406 oop java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(oop obj) {
4407 assert(_owner_offset != 0, "Must be initialized");
4408 return obj->obj_field(_owner_offset);
4409 }
4410
4411 #if INCLUDE_CDS
4412 void java_util_concurrent_locks_AbstractOwnableSynchronizer::serialize_offsets(SerializeClosure* f) {
4413 AOS_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4414 }
4415 #endif
4416
4417 static int member_offset(int hardcoded_offset) {
4418 return (hardcoded_offset * heapOopSize) + instanceOopDesc::base_offset_in_bytes();
4419 }
4420
4421 #define INTEGERCACHE_FIELDS_DO(macro) \
4422 macro(_archivedCache_offset, k, "archivedCache", java_lang_Integer_array_signature, true)
4423
4424 void java_lang_Integer_IntegerCache::compute_offsets() {
4425 InstanceKlass* k = SystemDictionary::Integer_IntegerCache_klass();
4426 assert(k != NULL, "must be loaded");
4427 INTEGERCACHE_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4428 }
4429
4430 #if INCLUDE_CDS
4431 void java_lang_Integer_IntegerCache::serialize_offsets(SerializeClosure* f) {
4432 INTEGERCACHE_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4433 }
4434 #endif
4435
4436 #define ARCHIVEDMODULEGRAPH_FIELDS_DO(macro) \
4437 macro(_archivedSystemModules_offset, k, "archivedSystemModules", systemModules_signature, true); \
4438 macro(_archivedModuleFinder_offset, k, "archivedModuleFinder", moduleFinder_signature, true); \
4439 macro(_archivedMainModule_offset, k, "archivedMainModule", string_signature, true); \
4440 macro(_archivedConfiguration_offset, k, "archivedConfiguration", configuration_signature, true)
4441
4442 void jdk_internal_module_ArchivedModuleGraph::compute_offsets() {
4443 InstanceKlass* k = SystemDictionary::ArchivedModuleGraph_klass();
4444 assert(k != NULL, "must be loaded");
4445 ARCHIVEDMODULEGRAPH_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4446 }
4447
4448 #if INCLUDE_CDS
4449 void jdk_internal_module_ArchivedModuleGraph::serialize_offsets(SerializeClosure* f) {
4450 ARCHIVEDMODULEGRAPH_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4451 }
4452 #endif
4453
4454 #define CONFIGURATION_FIELDS_DO(macro) \
4455 macro(_EMPTY_CONFIGURATION_offset, k, "EMPTY_CONFIGURATION", configuration_signature, true)
4456
4457 void java_lang_module_Configuration::compute_offsets() {
4458 InstanceKlass* k = SystemDictionary::Configuration_klass();
4459 assert(k != NULL, "must be loaded");
4460 CONFIGURATION_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4461 }
4462
4463 #if INCLUDE_CDS
4464 void java_lang_module_Configuration::serialize_offsets(SerializeClosure* f) {
4465 CONFIGURATION_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4466 }
4467 #endif
4468
4469 #define LISTN_FIELDS_DO(macro) \
4470 macro(_EMPTY_LIST_offset, k, "EMPTY_LIST", list_signature, true)
4471
4472 void java_util_ImmutableCollections_ListN::compute_offsets() {
4473 InstanceKlass* k = SystemDictionary::ImmutableCollections_ListN_klass();
4474 assert(k != NULL, "must be loaded");
4475 LISTN_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4476 }
4477
4478 #if INCLUDE_CDS
4479 void java_util_ImmutableCollections_ListN::serialize_offsets(SerializeClosure* f) {
4480 LISTN_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4481 }
4482 #endif
4483
4484 #define SETN_FIELDS_DO(macro) \
4485 macro(_EMPTY_SET_offset, k, "EMPTY_SET", set_signature, true)
4486
4487 void java_util_ImmutableCollections_SetN::compute_offsets() {
4488 InstanceKlass* k = SystemDictionary::ImmutableCollections_SetN_klass();
4489 assert(k != NULL, "must be loaded");
4490 SETN_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4491 }
4492
4493 #if INCLUDE_CDS
4494 void java_util_ImmutableCollections_SetN::serialize_offsets(SerializeClosure* f) {
4495 SETN_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4496 }
4497 #endif
4498
4499 #define MAPN_FIELDS_DO(macro) \
4500 macro(_EMPTY_MAP_offset, k, "EMPTY_MAP", map_signature, true)
4501
4502 void java_util_ImmutableCollections_MapN::compute_offsets() {
4503 InstanceKlass* k = SystemDictionary::ImmutableCollections_MapN_klass();
4504 assert(k != NULL, "must be loaded");
4505 MAPN_FIELDS_DO(FIELD_COMPUTE_OFFSET);
4506 }
4507
4508 #if INCLUDE_CDS
4509 void java_util_ImmutableCollections_MapN::serialize_offsets(SerializeClosure* f) {
4510 MAPN_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
4511 }
4512 #endif
4513
4514 // Compute hard-coded offsets
4515 // Invoked before SystemDictionary::initialize, so pre-loaded classes
4516 // are not available to determine the offset_of_static_fields.
4517 void JavaClasses::compute_hard_coded_offsets() {
4518
4519 // java_lang_boxing_object
4520 java_lang_boxing_object::value_offset = member_offset(java_lang_boxing_object::hc_value_offset);
4521 java_lang_boxing_object::long_value_offset = align_up(member_offset(java_lang_boxing_object::hc_value_offset), BytesPerLong);
4522
4523 // java_lang_ref_Reference
4524 java_lang_ref_Reference::referent_offset = member_offset(java_lang_ref_Reference::hc_referent_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);
4527 java_lang_ref_Reference::discovered_offset = member_offset(java_lang_ref_Reference::hc_discovered_offset);
4528 }
4529
4530 #define DO_COMPUTE_OFFSETS(k) k::compute_offsets();
4531
4532 // Compute non-hard-coded field offsets of all the classes in this file
4533 void JavaClasses::compute_offsets() {
4534 if (UseSharedSpaces) {
4535 return; // field offsets are loaded from archive
4536 }
4537
4538 // We have already called the compute_offsets() of the
4539 // BASIC_JAVA_CLASSES_DO_PART1 classes (java_lang_String and java_lang_Class);
4540 BASIC_JAVA_CLASSES_DO_PART2(DO_COMPUTE_OFFSETS);
4541
4542 // generated interpreter code wants to know about the offsets we just computed:
4543 AbstractAssembler::update_delayed_values();
4544 }
4545
4546 #if INCLUDE_CDS
4547 #define DO_SERIALIZE_OFFSETS(k) k::serialize_offsets(soc);
4548
4549 void JavaClasses::serialize_offsets(SerializeClosure* soc) {
4550 BASIC_JAVA_CLASSES_DO(DO_SERIALIZE_OFFSETS);
4551 }
4552 #endif
4553
4554
4555 #ifndef PRODUCT
4556
4557 // These functions exist to assert the validity of hard-coded field offsets to guard
4558 // against changes in the class files
4559
4560 bool JavaClasses::check_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) {
4561 EXCEPTION_MARK;
4562 fieldDescriptor fd;
4563 TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH);
4564 Klass* k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH);
4565 InstanceKlass* ik = InstanceKlass::cast(k);
4566 TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH);
4567 TempNewSymbol f_sig = SymbolTable::new_symbol(field_sig, CATCH);
4568 if (!ik->find_local_field(f_name, f_sig, &fd)) {
4569 tty->print_cr("Nonstatic field %s.%s not found", klass_name, field_name);
4570 return false;
4571 }
4572 if (fd.is_static()) {
4573 tty->print_cr("Nonstatic field %s.%s appears to be static", klass_name, field_name);
|