Mercurial > hg > graal-jvmci-8
comparison src/share/vm/classfile/javaClasses.cpp @ 132:60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
Summary: combine many scalar variables into a single enum-indexed array in SystemDictionary.
Reviewed-by: kvn
author | jrose |
---|---|
date | Tue, 29 Apr 2008 19:45:22 -0700 |
parents | ba764ed4b6f2 |
children | 437d03ea40b1 |
comparison
equal
deleted
inserted
replaced
131:6e825ad773c6 | 132:60b728ec77c1 |
---|---|
23 */ | 23 */ |
24 | 24 |
25 # include "incls/_precompiled.incl" | 25 # include "incls/_precompiled.incl" |
26 # include "incls/_javaClasses.cpp.incl" | 26 # include "incls/_javaClasses.cpp.incl" |
27 | 27 |
28 // Helpful macro for computing field offsets at run time rather than hardcoding them | 28 // Helpful routine for computing field offsets at run time rather than hardcoding them |
29 #define COMPUTE_OFFSET(klass_name_as_C_str, dest_offset, klass_oop, name_symbol, signature_symbol) \ | 29 static void |
30 { \ | 30 compute_offset(int &dest_offset, |
31 fieldDescriptor fd; \ | 31 klassOop klass_oop, symbolOop name_symbol, symbolOop signature_symbol) { |
32 instanceKlass* ik = instanceKlass::cast(klass_oop); \ | 32 fieldDescriptor fd; |
33 if (!ik->find_local_field(name_symbol, signature_symbol, &fd)) { \ | 33 instanceKlass* ik = instanceKlass::cast(klass_oop); |
34 fatal("Invalid layout of " klass_name_as_C_str); \ | 34 if (!ik->find_local_field(name_symbol, signature_symbol, &fd)) { |
35 } \ | 35 ResourceMark rm; |
36 dest_offset = fd.offset(); \ | 36 tty->print_cr("Invalid layout of %s at %s", ik->external_name(), name_symbol->as_C_string()); |
37 fatal("Invalid layout of preloaded class"); | |
38 } | |
39 dest_offset = fd.offset(); | |
37 } | 40 } |
38 | 41 |
39 // Same as above but for "optional" offsets that might not be present in certain JDK versions | 42 // Same as above but for "optional" offsets that might not be present in certain JDK versions |
40 #define COMPUTE_OPTIONAL_OFFSET(klass_name_as_C_str, dest_offset, klass_oop, name_symbol, signature_symbol) \ | 43 static void |
41 { \ | 44 compute_optional_offset(int& dest_offset, |
42 fieldDescriptor fd; \ | 45 klassOop klass_oop, symbolOop name_symbol, symbolOop signature_symbol) { |
43 instanceKlass* ik = instanceKlass::cast(klass_oop); \ | 46 fieldDescriptor fd; |
44 if (ik->find_local_field(name_symbol, signature_symbol, &fd)) { \ | 47 instanceKlass* ik = instanceKlass::cast(klass_oop); |
45 dest_offset = fd.offset(); \ | 48 if (ik->find_local_field(name_symbol, signature_symbol, &fd)) { |
46 } \ | 49 dest_offset = fd.offset(); |
50 } | |
47 } | 51 } |
48 | 52 |
49 Handle java_lang_String::basic_create(int length, bool tenured, TRAPS) { | 53 Handle java_lang_String::basic_create(int length, bool tenured, TRAPS) { |
50 // Create the String object first, so there's a chance that the String | 54 // Create the String object first, so there's a chance that the String |
51 // and the char array it points to end up in the same cache line. | 55 // and the char array it points to end up in the same cache line. |
443 offsets_computed = true; | 447 offsets_computed = true; |
444 | 448 |
445 klassOop k = SystemDictionary::class_klass(); | 449 klassOop k = SystemDictionary::class_klass(); |
446 // The classRedefinedCount field is only present starting in 1.5, | 450 // The classRedefinedCount field is only present starting in 1.5, |
447 // so don't go fatal. | 451 // so don't go fatal. |
448 COMPUTE_OPTIONAL_OFFSET("java.lang.Class", classRedefinedCount_offset, | 452 compute_optional_offset(classRedefinedCount_offset, |
449 k, vmSymbols::classRedefinedCount_name(), vmSymbols::int_signature()); | 453 k, vmSymbols::classRedefinedCount_name(), vmSymbols::int_signature()); |
450 } | 454 } |
451 | 455 |
452 int java_lang_Class::classRedefinedCount(oop the_class_mirror) { | 456 int java_lang_Class::classRedefinedCount(oop the_class_mirror) { |
453 if (!JDK_Version::is_gte_jdk15x_version() | 457 if (!JDK_Version::is_gte_jdk15x_version() |
497 | 501 |
498 void java_lang_Thread::compute_offsets() { | 502 void java_lang_Thread::compute_offsets() { |
499 assert(_group_offset == 0, "offsets should be initialized only once"); | 503 assert(_group_offset == 0, "offsets should be initialized only once"); |
500 | 504 |
501 klassOop k = SystemDictionary::thread_klass(); | 505 klassOop k = SystemDictionary::thread_klass(); |
502 COMPUTE_OFFSET("java.lang.Thread", _name_offset, k, vmSymbols::name_name(), vmSymbols::char_array_signature()); | 506 compute_offset(_name_offset, k, vmSymbols::name_name(), vmSymbols::char_array_signature()); |
503 COMPUTE_OFFSET("java.lang.Thread", _group_offset, k, vmSymbols::group_name(), vmSymbols::threadgroup_signature()); | 507 compute_offset(_group_offset, k, vmSymbols::group_name(), vmSymbols::threadgroup_signature()); |
504 COMPUTE_OFFSET("java.lang.Thread", _contextClassLoader_offset, k, vmSymbols::contextClassLoader_name(), vmSymbols::classloader_signature()); | 508 compute_offset(_contextClassLoader_offset, k, vmSymbols::contextClassLoader_name(), vmSymbols::classloader_signature()); |
505 COMPUTE_OFFSET("java.lang.Thread", _inheritedAccessControlContext_offset, k, vmSymbols::inheritedAccessControlContext_name(), vmSymbols::accesscontrolcontext_signature()); | 509 compute_offset(_inheritedAccessControlContext_offset, k, vmSymbols::inheritedAccessControlContext_name(), vmSymbols::accesscontrolcontext_signature()); |
506 COMPUTE_OFFSET("java.lang.Thread", _priority_offset, k, vmSymbols::priority_name(), vmSymbols::int_signature()); | 510 compute_offset(_priority_offset, k, vmSymbols::priority_name(), vmSymbols::int_signature()); |
507 COMPUTE_OFFSET("java.lang.Thread", _daemon_offset, k, vmSymbols::daemon_name(), vmSymbols::bool_signature()); | 511 compute_offset(_daemon_offset, k, vmSymbols::daemon_name(), vmSymbols::bool_signature()); |
508 COMPUTE_OFFSET("java.lang.Thread", _eetop_offset, k, vmSymbols::eetop_name(), vmSymbols::long_signature()); | 512 compute_offset(_eetop_offset, k, vmSymbols::eetop_name(), vmSymbols::long_signature()); |
509 COMPUTE_OFFSET("java.lang.Thread", _stillborn_offset, k, vmSymbols::stillborn_name(), vmSymbols::bool_signature()); | 513 compute_offset(_stillborn_offset, k, vmSymbols::stillborn_name(), vmSymbols::bool_signature()); |
510 // The stackSize field is only present starting in 1.4, so don't go fatal. | 514 // The stackSize field is only present starting in 1.4, so don't go fatal. |
511 COMPUTE_OPTIONAL_OFFSET("java.lang.Thread", _stackSize_offset, k, vmSymbols::stackSize_name(), vmSymbols::long_signature()); | 515 compute_optional_offset(_stackSize_offset, k, vmSymbols::stackSize_name(), vmSymbols::long_signature()); |
512 // The tid and thread_status fields are only present starting in 1.5, so don't go fatal. | 516 // The tid and thread_status fields are only present starting in 1.5, so don't go fatal. |
513 COMPUTE_OPTIONAL_OFFSET("java.lang.Thread", _tid_offset, k, vmSymbols::thread_id_name(), vmSymbols::long_signature()); | 517 compute_optional_offset(_tid_offset, k, vmSymbols::thread_id_name(), vmSymbols::long_signature()); |
514 COMPUTE_OPTIONAL_OFFSET("java.lang.Thread", _thread_status_offset, k, vmSymbols::thread_status_name(), vmSymbols::int_signature()); | 518 compute_optional_offset(_thread_status_offset, k, vmSymbols::thread_status_name(), vmSymbols::int_signature()); |
515 // The parkBlocker field is only present starting in 1.6, so don't go fatal. | 519 // The parkBlocker field is only present starting in 1.6, so don't go fatal. |
516 COMPUTE_OPTIONAL_OFFSET("java.lang.Thread", _park_blocker_offset, k, vmSymbols::park_blocker_name(), vmSymbols::object_signature()); | 520 compute_optional_offset(_park_blocker_offset, k, vmSymbols::park_blocker_name(), vmSymbols::object_signature()); |
517 COMPUTE_OPTIONAL_OFFSET("java.lang.Thread", _park_event_offset, k, vmSymbols::park_event_name(), | 521 compute_optional_offset(_park_event_offset, k, vmSymbols::park_event_name(), |
518 vmSymbols::long_signature()); | 522 vmSymbols::long_signature()); |
519 } | 523 } |
520 | 524 |
521 | 525 |
522 JavaThread* java_lang_Thread::thread(oop java_thread) { | 526 JavaThread* java_lang_Thread::thread(oop java_thread) { |
757 void java_lang_ThreadGroup::compute_offsets() { | 761 void java_lang_ThreadGroup::compute_offsets() { |
758 assert(_parent_offset == 0, "offsets should be initialized only once"); | 762 assert(_parent_offset == 0, "offsets should be initialized only once"); |
759 | 763 |
760 klassOop k = SystemDictionary::threadGroup_klass(); | 764 klassOop k = SystemDictionary::threadGroup_klass(); |
761 | 765 |
762 COMPUTE_OFFSET("java.lang.ThreadGroup", _parent_offset, k, vmSymbols::parent_name(), vmSymbols::threadgroup_signature()); | 766 compute_offset(_parent_offset, k, vmSymbols::parent_name(), vmSymbols::threadgroup_signature()); |
763 COMPUTE_OFFSET("java.lang.ThreadGroup", _name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); | 767 compute_offset(_name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); |
764 COMPUTE_OFFSET("java.lang.ThreadGroup", _threads_offset, k, vmSymbols::threads_name(), vmSymbols::thread_array_signature()); | 768 compute_offset(_threads_offset, k, vmSymbols::threads_name(), vmSymbols::thread_array_signature()); |
765 COMPUTE_OFFSET("java.lang.ThreadGroup", _groups_offset, k, vmSymbols::groups_name(), vmSymbols::threadgroup_array_signature()); | 769 compute_offset(_groups_offset, k, vmSymbols::groups_name(), vmSymbols::threadgroup_array_signature()); |
766 COMPUTE_OFFSET("java.lang.ThreadGroup", _maxPriority_offset, k, vmSymbols::maxPriority_name(), vmSymbols::int_signature()); | 770 compute_offset(_maxPriority_offset, k, vmSymbols::maxPriority_name(), vmSymbols::int_signature()); |
767 COMPUTE_OFFSET("java.lang.ThreadGroup", _destroyed_offset, k, vmSymbols::destroyed_name(), vmSymbols::bool_signature()); | 771 compute_offset(_destroyed_offset, k, vmSymbols::destroyed_name(), vmSymbols::bool_signature()); |
768 COMPUTE_OFFSET("java.lang.ThreadGroup", _daemon_offset, k, vmSymbols::daemon_name(), vmSymbols::bool_signature()); | 772 compute_offset(_daemon_offset, k, vmSymbols::daemon_name(), vmSymbols::bool_signature()); |
769 COMPUTE_OFFSET("java.lang.ThreadGroup", _vmAllowSuspension_offset, k, vmSymbols::vmAllowSuspension_name(), vmSymbols::bool_signature()); | 773 compute_offset(_vmAllowSuspension_offset, k, vmSymbols::vmAllowSuspension_name(), vmSymbols::bool_signature()); |
770 COMPUTE_OFFSET("java.lang.ThreadGroup", _nthreads_offset, k, vmSymbols::nthreads_name(), vmSymbols::int_signature()); | 774 compute_offset(_nthreads_offset, k, vmSymbols::nthreads_name(), vmSymbols::int_signature()); |
771 COMPUTE_OFFSET("java.lang.ThreadGroup", _ngroups_offset, k, vmSymbols::ngroups_name(), vmSymbols::int_signature()); | 775 compute_offset(_ngroups_offset, k, vmSymbols::ngroups_name(), vmSymbols::int_signature()); |
772 } | 776 } |
773 | 777 |
774 oop java_lang_Throwable::backtrace(oop throwable) { | 778 oop java_lang_Throwable::backtrace(oop throwable) { |
775 return throwable->obj_field_acquire(backtrace_offset); | 779 return throwable->obj_field_acquire(backtrace_offset); |
776 } | 780 } |
1359 // SystemDictionary::stackTraceElement_klass() will be null for pre-1.4 JDKs | 1363 // SystemDictionary::stackTraceElement_klass() will be null for pre-1.4 JDKs |
1360 assert(JDK_Version::is_gte_jdk14x_version(), "should only be called in >= 1.4"); | 1364 assert(JDK_Version::is_gte_jdk14x_version(), "should only be called in >= 1.4"); |
1361 | 1365 |
1362 // Allocate java.lang.StackTraceElement instance | 1366 // Allocate java.lang.StackTraceElement instance |
1363 klassOop k = SystemDictionary::stackTraceElement_klass(); | 1367 klassOop k = SystemDictionary::stackTraceElement_klass(); |
1368 assert(k != NULL, "must be loaded in 1.4+"); | |
1364 instanceKlassHandle ik (THREAD, k); | 1369 instanceKlassHandle ik (THREAD, k); |
1365 if (ik->should_be_initialized()) { | 1370 if (ik->should_be_initialized()) { |
1366 ik->initialize(CHECK_0); | 1371 ik->initialize(CHECK_0); |
1367 } | 1372 } |
1368 | 1373 |
1396 } | 1401 } |
1397 | 1402 |
1398 | 1403 |
1399 void java_lang_reflect_AccessibleObject::compute_offsets() { | 1404 void java_lang_reflect_AccessibleObject::compute_offsets() { |
1400 klassOop k = SystemDictionary::reflect_accessible_object_klass(); | 1405 klassOop k = SystemDictionary::reflect_accessible_object_klass(); |
1401 COMPUTE_OFFSET("java.lang.reflect.AccessibleObject", override_offset, k, vmSymbols::override_name(), vmSymbols::bool_signature()); | 1406 compute_offset(override_offset, k, vmSymbols::override_name(), vmSymbols::bool_signature()); |
1402 } | 1407 } |
1403 | 1408 |
1404 jboolean java_lang_reflect_AccessibleObject::override(oop reflect) { | 1409 jboolean java_lang_reflect_AccessibleObject::override(oop reflect) { |
1405 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | 1410 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); |
1406 return (jboolean) reflect->bool_field(override_offset); | 1411 return (jboolean) reflect->bool_field(override_offset); |
1411 reflect->bool_field_put(override_offset, (int) value); | 1416 reflect->bool_field_put(override_offset, (int) value); |
1412 } | 1417 } |
1413 | 1418 |
1414 void java_lang_reflect_Method::compute_offsets() { | 1419 void java_lang_reflect_Method::compute_offsets() { |
1415 klassOop k = SystemDictionary::reflect_method_klass(); | 1420 klassOop k = SystemDictionary::reflect_method_klass(); |
1416 COMPUTE_OFFSET("java.lang.reflect.Method", clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); | 1421 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); |
1417 COMPUTE_OFFSET("java.lang.reflect.Method", name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); | 1422 compute_offset(name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); |
1418 COMPUTE_OFFSET("java.lang.reflect.Method", returnType_offset, k, vmSymbols::returnType_name(), vmSymbols::class_signature()); | 1423 compute_offset(returnType_offset, k, vmSymbols::returnType_name(), vmSymbols::class_signature()); |
1419 COMPUTE_OFFSET("java.lang.reflect.Method", parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature()); | 1424 compute_offset(parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature()); |
1420 COMPUTE_OFFSET("java.lang.reflect.Method", exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature()); | 1425 compute_offset(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature()); |
1421 COMPUTE_OFFSET("java.lang.reflect.Method", slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature()); | 1426 compute_offset(slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature()); |
1422 COMPUTE_OFFSET("java.lang.reflect.Method", modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature()); | 1427 compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature()); |
1423 // The generic signature and annotations fields are only present in 1.5 | 1428 // The generic signature and annotations fields are only present in 1.5 |
1424 signature_offset = -1; | 1429 signature_offset = -1; |
1425 annotations_offset = -1; | 1430 annotations_offset = -1; |
1426 parameter_annotations_offset = -1; | 1431 parameter_annotations_offset = -1; |
1427 annotation_default_offset = -1; | 1432 annotation_default_offset = -1; |
1428 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Method", signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature()); | 1433 compute_optional_offset(signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature()); |
1429 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Method", annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature()); | 1434 compute_optional_offset(annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature()); |
1430 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Method", parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), vmSymbols::byte_array_signature()); | 1435 compute_optional_offset(parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), vmSymbols::byte_array_signature()); |
1431 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Method", annotation_default_offset, k, vmSymbols::annotation_default_name(), vmSymbols::byte_array_signature()); | 1436 compute_optional_offset(annotation_default_offset, k, vmSymbols::annotation_default_name(), vmSymbols::byte_array_signature()); |
1432 } | 1437 } |
1433 | 1438 |
1434 Handle java_lang_reflect_Method::create(TRAPS) { | 1439 Handle java_lang_reflect_Method::create(TRAPS) { |
1435 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | 1440 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); |
1436 klassOop klass = SystemDictionary::reflect_method_klass(); | 1441 klassOop klass = SystemDictionary::reflect_method_klass(); |
1574 method->obj_field_put(annotation_default_offset, value); | 1579 method->obj_field_put(annotation_default_offset, value); |
1575 } | 1580 } |
1576 | 1581 |
1577 void java_lang_reflect_Constructor::compute_offsets() { | 1582 void java_lang_reflect_Constructor::compute_offsets() { |
1578 klassOop k = SystemDictionary::reflect_constructor_klass(); | 1583 klassOop k = SystemDictionary::reflect_constructor_klass(); |
1579 COMPUTE_OFFSET("java.lang.reflect.Constructor", clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); | 1584 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); |
1580 COMPUTE_OFFSET("java.lang.reflect.Constructor", parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature()); | 1585 compute_offset(parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature()); |
1581 COMPUTE_OFFSET("java.lang.reflect.Constructor", exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature()); | 1586 compute_offset(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature()); |
1582 COMPUTE_OFFSET("java.lang.reflect.Constructor", slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature()); | 1587 compute_offset(slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature()); |
1583 COMPUTE_OFFSET("java.lang.reflect.Constructor", modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature()); | 1588 compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature()); |
1584 // The generic signature and annotations fields are only present in 1.5 | 1589 // The generic signature and annotations fields are only present in 1.5 |
1585 signature_offset = -1; | 1590 signature_offset = -1; |
1586 annotations_offset = -1; | 1591 annotations_offset = -1; |
1587 parameter_annotations_offset = -1; | 1592 parameter_annotations_offset = -1; |
1588 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Constructor", signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature()); | 1593 compute_optional_offset(signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature()); |
1589 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Constructor", annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature()); | 1594 compute_optional_offset(annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature()); |
1590 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Constructor", parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), vmSymbols::byte_array_signature()); | 1595 compute_optional_offset(parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), vmSymbols::byte_array_signature()); |
1591 } | 1596 } |
1592 | 1597 |
1593 Handle java_lang_reflect_Constructor::create(TRAPS) { | 1598 Handle java_lang_reflect_Constructor::create(TRAPS) { |
1594 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | 1599 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); |
1595 symbolHandle name = vmSymbolHandles::java_lang_reflect_Constructor(); | 1600 symbolHandle name = vmSymbolHandles::java_lang_reflect_Constructor(); |
1698 method->obj_field_put(parameter_annotations_offset, value); | 1703 method->obj_field_put(parameter_annotations_offset, value); |
1699 } | 1704 } |
1700 | 1705 |
1701 void java_lang_reflect_Field::compute_offsets() { | 1706 void java_lang_reflect_Field::compute_offsets() { |
1702 klassOop k = SystemDictionary::reflect_field_klass(); | 1707 klassOop k = SystemDictionary::reflect_field_klass(); |
1703 COMPUTE_OFFSET("java.lang.reflect.Field", clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); | 1708 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); |
1704 COMPUTE_OFFSET("java.lang.reflect.Field", name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); | 1709 compute_offset(name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); |
1705 COMPUTE_OFFSET("java.lang.reflect.Field", type_offset, k, vmSymbols::type_name(), vmSymbols::class_signature()); | 1710 compute_offset(type_offset, k, vmSymbols::type_name(), vmSymbols::class_signature()); |
1706 COMPUTE_OFFSET("java.lang.reflect.Field", slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature()); | 1711 compute_offset(slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature()); |
1707 COMPUTE_OFFSET("java.lang.reflect.Field", modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature()); | 1712 compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature()); |
1708 // The generic signature and annotations fields are only present in 1.5 | 1713 // The generic signature and annotations fields are only present in 1.5 |
1709 signature_offset = -1; | 1714 signature_offset = -1; |
1710 annotations_offset = -1; | 1715 annotations_offset = -1; |
1711 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Field", signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature()); | 1716 compute_optional_offset(signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature()); |
1712 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Field", annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature()); | 1717 compute_optional_offset(annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature()); |
1713 } | 1718 } |
1714 | 1719 |
1715 Handle java_lang_reflect_Field::create(TRAPS) { | 1720 Handle java_lang_reflect_Field::create(TRAPS) { |
1716 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); | 1721 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); |
1717 symbolHandle name = vmSymbolHandles::java_lang_reflect_Field(); | 1722 symbolHandle name = vmSymbolHandles::java_lang_reflect_Field(); |
1807 | 1812 |
1808 void sun_reflect_ConstantPool::compute_offsets() { | 1813 void sun_reflect_ConstantPool::compute_offsets() { |
1809 klassOop k = SystemDictionary::reflect_constant_pool_klass(); | 1814 klassOop k = SystemDictionary::reflect_constant_pool_klass(); |
1810 // This null test can be removed post beta | 1815 // This null test can be removed post beta |
1811 if (k != NULL) { | 1816 if (k != NULL) { |
1812 COMPUTE_OFFSET("sun.reflect.ConstantPool", _cp_oop_offset, k, vmSymbols::constantPoolOop_name(), vmSymbols::object_signature()); | 1817 compute_offset(_cp_oop_offset, k, vmSymbols::constantPoolOop_name(), vmSymbols::object_signature()); |
1813 } | 1818 } |
1814 } | 1819 } |
1815 | 1820 |
1816 | 1821 |
1817 Handle sun_reflect_ConstantPool::create(TRAPS) { | 1822 Handle sun_reflect_ConstantPool::create(TRAPS) { |
1837 | 1842 |
1838 void sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets() { | 1843 void sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets() { |
1839 klassOop k = SystemDictionary::reflect_unsafe_static_field_accessor_impl_klass(); | 1844 klassOop k = SystemDictionary::reflect_unsafe_static_field_accessor_impl_klass(); |
1840 // This null test can be removed post beta | 1845 // This null test can be removed post beta |
1841 if (k != NULL) { | 1846 if (k != NULL) { |
1842 COMPUTE_OFFSET("sun.reflect.UnsafeStaticFieldAccessorImpl", _base_offset, k, | 1847 compute_offset(_base_offset, k, |
1843 vmSymbols::base_name(), vmSymbols::object_signature()); | 1848 vmSymbols::base_name(), vmSymbols::object_signature()); |
1844 } | 1849 } |
1845 } | 1850 } |
1846 | 1851 |
1847 oop java_lang_boxing_object::initialize_and_allocate(klassOop k, TRAPS) { | 1852 oop java_lang_boxing_object::initialize_and_allocate(BasicType type, TRAPS) { |
1848 instanceKlassHandle h (THREAD, k); | 1853 klassOop k = SystemDictionary::box_klass(type); |
1849 if (!h->is_initialized()) h->initialize(CHECK_0); | 1854 if (k == NULL) return NULL; |
1850 return h->allocate_instance(THREAD); | 1855 instanceKlassHandle h (THREAD, k); |
1856 if (!h->is_initialized()) h->initialize(CHECK_0); | |
1857 return h->allocate_instance(THREAD); | |
1851 } | 1858 } |
1852 | 1859 |
1853 | 1860 |
1854 oop java_lang_boxing_object::create(BasicType type, jvalue* value, TRAPS) { | 1861 oop java_lang_boxing_object::create(BasicType type, jvalue* value, TRAPS) { |
1855 oop box; | 1862 oop box = initialize_and_allocate(type, CHECK_0); |
1863 if (box == NULL) return NULL; | |
1856 switch (type) { | 1864 switch (type) { |
1857 case T_BOOLEAN: | 1865 case T_BOOLEAN: |
1858 box = initialize_and_allocate(SystemDictionary::boolean_klass(), CHECK_0); | |
1859 box->bool_field_put(value_offset, value->z); | 1866 box->bool_field_put(value_offset, value->z); |
1860 break; | 1867 break; |
1861 case T_CHAR: | 1868 case T_CHAR: |
1862 box = initialize_and_allocate(SystemDictionary::char_klass(), CHECK_0); | |
1863 box->char_field_put(value_offset, value->c); | 1869 box->char_field_put(value_offset, value->c); |
1864 break; | 1870 break; |
1865 case T_FLOAT: | 1871 case T_FLOAT: |
1866 box = initialize_and_allocate(SystemDictionary::float_klass(), CHECK_0); | |
1867 box->float_field_put(value_offset, value->f); | 1872 box->float_field_put(value_offset, value->f); |
1868 break; | 1873 break; |
1869 case T_DOUBLE: | 1874 case T_DOUBLE: |
1870 box = initialize_and_allocate(SystemDictionary::double_klass(), CHECK_0); | |
1871 box->double_field_put(value_offset, value->d); | 1875 box->double_field_put(value_offset, value->d); |
1872 break; | 1876 break; |
1873 case T_BYTE: | 1877 case T_BYTE: |
1874 box = initialize_and_allocate(SystemDictionary::byte_klass(), CHECK_0); | |
1875 box->byte_field_put(value_offset, value->b); | 1878 box->byte_field_put(value_offset, value->b); |
1876 break; | 1879 break; |
1877 case T_SHORT: | 1880 case T_SHORT: |
1878 box = initialize_and_allocate(SystemDictionary::short_klass(), CHECK_0); | |
1879 box->short_field_put(value_offset, value->s); | 1881 box->short_field_put(value_offset, value->s); |
1880 break; | 1882 break; |
1881 case T_INT: | 1883 case T_INT: |
1882 box = initialize_and_allocate(SystemDictionary::int_klass(), CHECK_0); | |
1883 box->int_field_put(value_offset, value->i); | 1884 box->int_field_put(value_offset, value->i); |
1884 break; | 1885 break; |
1885 case T_LONG: | 1886 case T_LONG: |
1886 box = initialize_and_allocate(SystemDictionary::long_klass(), CHECK_0); | |
1887 box->long_field_put(value_offset, value->j); | 1887 box->long_field_put(value_offset, value->j); |
1888 break; | 1888 break; |
1889 default: | 1889 default: |
1890 return NULL; | 1890 return NULL; |
1891 } | 1891 } |
1892 return box; | 1892 return box; |
1893 } | 1893 } |
1894 | 1894 |
1895 | 1895 |
1896 BasicType java_lang_boxing_object::basic_type(oop box) { | |
1897 if (box == NULL) return T_ILLEGAL; | |
1898 BasicType type = SystemDictionary::box_klass_type(box->klass()); | |
1899 if (type == T_OBJECT) // 'unknown' value returned by SD::bkt | |
1900 return T_ILLEGAL; | |
1901 return type; | |
1902 } | |
1903 | |
1904 | |
1896 BasicType java_lang_boxing_object::get_value(oop box, jvalue* value) { | 1905 BasicType java_lang_boxing_object::get_value(oop box, jvalue* value) { |
1897 klassOop k = box->klass(); | 1906 BasicType type = SystemDictionary::box_klass_type(box->klass()); |
1898 if (k == SystemDictionary::boolean_klass()) { | 1907 switch (type) { |
1908 case T_BOOLEAN: | |
1899 value->z = box->bool_field(value_offset); | 1909 value->z = box->bool_field(value_offset); |
1900 return T_BOOLEAN; | 1910 break; |
1901 } | 1911 case T_CHAR: |
1902 if (k == SystemDictionary::char_klass()) { | |
1903 value->c = box->char_field(value_offset); | 1912 value->c = box->char_field(value_offset); |
1904 return T_CHAR; | 1913 break; |
1905 } | 1914 case T_FLOAT: |
1906 if (k == SystemDictionary::float_klass()) { | |
1907 value->f = box->float_field(value_offset); | 1915 value->f = box->float_field(value_offset); |
1908 return T_FLOAT; | 1916 break; |
1909 } | 1917 case T_DOUBLE: |
1910 if (k == SystemDictionary::double_klass()) { | |
1911 value->d = box->double_field(value_offset); | 1918 value->d = box->double_field(value_offset); |
1912 return T_DOUBLE; | 1919 break; |
1913 } | 1920 case T_BYTE: |
1914 if (k == SystemDictionary::byte_klass()) { | |
1915 value->b = box->byte_field(value_offset); | 1921 value->b = box->byte_field(value_offset); |
1916 return T_BYTE; | 1922 break; |
1917 } | 1923 case T_SHORT: |
1918 if (k == SystemDictionary::short_klass()) { | |
1919 value->s = box->short_field(value_offset); | 1924 value->s = box->short_field(value_offset); |
1920 return T_SHORT; | 1925 break; |
1921 } | 1926 case T_INT: |
1922 if (k == SystemDictionary::int_klass()) { | |
1923 value->i = box->int_field(value_offset); | 1927 value->i = box->int_field(value_offset); |
1924 return T_INT; | 1928 break; |
1925 } | 1929 case T_LONG: |
1926 if (k == SystemDictionary::long_klass()) { | |
1927 value->j = box->long_field(value_offset); | 1930 value->j = box->long_field(value_offset); |
1928 return T_LONG; | 1931 break; |
1929 } | 1932 default: |
1930 return T_ILLEGAL; | 1933 return T_ILLEGAL; |
1934 } // end switch | |
1935 return type; | |
1931 } | 1936 } |
1932 | 1937 |
1933 | 1938 |
1934 BasicType java_lang_boxing_object::set_value(oop box, jvalue* value) { | 1939 BasicType java_lang_boxing_object::set_value(oop box, jvalue* value) { |
1935 klassOop k = box->klass(); | 1940 BasicType type = SystemDictionary::box_klass_type(box->klass()); |
1936 if (k == SystemDictionary::boolean_klass()) { | 1941 switch (type) { |
1942 case T_BOOLEAN: | |
1937 box->bool_field_put(value_offset, value->z); | 1943 box->bool_field_put(value_offset, value->z); |
1938 return T_BOOLEAN; | 1944 break; |
1939 } | 1945 case T_CHAR: |
1940 if (k == SystemDictionary::char_klass()) { | |
1941 box->char_field_put(value_offset, value->c); | 1946 box->char_field_put(value_offset, value->c); |
1942 return T_CHAR; | 1947 break; |
1943 } | 1948 case T_FLOAT: |
1944 if (k == SystemDictionary::float_klass()) { | |
1945 box->float_field_put(value_offset, value->f); | 1949 box->float_field_put(value_offset, value->f); |
1946 return T_FLOAT; | 1950 break; |
1947 } | 1951 case T_DOUBLE: |
1948 if (k == SystemDictionary::double_klass()) { | |
1949 box->double_field_put(value_offset, value->d); | 1952 box->double_field_put(value_offset, value->d); |
1950 return T_DOUBLE; | 1953 break; |
1951 } | 1954 case T_BYTE: |
1952 if (k == SystemDictionary::byte_klass()) { | |
1953 box->byte_field_put(value_offset, value->b); | 1955 box->byte_field_put(value_offset, value->b); |
1954 return T_BYTE; | 1956 break; |
1955 } | 1957 case T_SHORT: |
1956 if (k == SystemDictionary::short_klass()) { | |
1957 box->short_field_put(value_offset, value->s); | 1958 box->short_field_put(value_offset, value->s); |
1958 return T_SHORT; | 1959 break; |
1959 } | 1960 case T_INT: |
1960 if (k == SystemDictionary::int_klass()) { | |
1961 box->int_field_put(value_offset, value->i); | 1961 box->int_field_put(value_offset, value->i); |
1962 return T_INT; | 1962 break; |
1963 } | 1963 case T_LONG: |
1964 if (k == SystemDictionary::long_klass()) { | |
1965 box->long_field_put(value_offset, value->j); | 1964 box->long_field_put(value_offset, value->j); |
1966 return T_LONG; | 1965 break; |
1967 } | 1966 default: |
1968 return T_ILLEGAL; | 1967 return T_ILLEGAL; |
1968 } // end switch | |
1969 return type; | |
1969 } | 1970 } |
1970 | 1971 |
1971 | 1972 |
1972 // Support for java_lang_ref_Reference | 1973 // Support for java_lang_ref_Reference |
1973 oop java_lang_ref_Reference::pending_list_lock() { | 1974 oop java_lang_ref_Reference::pending_list_lock() { |
2240 } | 2241 } |
2241 | 2242 |
2242 | 2243 |
2243 void java_nio_Buffer::compute_offsets() { | 2244 void java_nio_Buffer::compute_offsets() { |
2244 klassOop k = SystemDictionary::java_nio_Buffer_klass(); | 2245 klassOop k = SystemDictionary::java_nio_Buffer_klass(); |
2245 COMPUTE_OFFSET("java.nio.Buffer", _limit_offset, k, vmSymbols::limit_name(), vmSymbols::int_signature()); | 2246 assert(k != NULL, "must be loaded in 1.4+"); |
2247 compute_offset(_limit_offset, k, vmSymbols::limit_name(), vmSymbols::int_signature()); | |
2246 } | 2248 } |
2247 | 2249 |
2248 // Support for intrinsification of sun.misc.AtomicLongCSImpl.attemptUpdate | 2250 // Support for intrinsification of sun.misc.AtomicLongCSImpl.attemptUpdate |
2249 int sun_misc_AtomicLongCSImpl::value_offset() { | 2251 int sun_misc_AtomicLongCSImpl::value_offset() { |
2250 assert(SystemDictionary::sun_misc_AtomicLongCSImpl_klass() != NULL, "can't call this"); | 2252 assert(SystemDictionary::sun_misc_AtomicLongCSImpl_klass() != NULL, "can't call this"); |
2254 | 2256 |
2255 void sun_misc_AtomicLongCSImpl::compute_offsets() { | 2257 void sun_misc_AtomicLongCSImpl::compute_offsets() { |
2256 klassOop k = SystemDictionary::sun_misc_AtomicLongCSImpl_klass(); | 2258 klassOop k = SystemDictionary::sun_misc_AtomicLongCSImpl_klass(); |
2257 // If this class is not present, its value field offset won't be referenced. | 2259 // If this class is not present, its value field offset won't be referenced. |
2258 if (k != NULL) { | 2260 if (k != NULL) { |
2259 COMPUTE_OFFSET("sun.misc.AtomicLongCSImpl", _value_offset, k, vmSymbols::value_name(), vmSymbols::long_signature()); | 2261 compute_offset(_value_offset, k, vmSymbols::value_name(), vmSymbols::long_signature()); |
2260 } | 2262 } |
2261 } | 2263 } |
2262 | 2264 |
2263 void java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(TRAPS) { | 2265 void java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(TRAPS) { |
2264 if (_owner_offset != 0) return; | 2266 if (_owner_offset != 0) return; |
2265 | 2267 |
2266 assert(JDK_Version::is_gte_jdk16x_version(), "Must be JDK 1.6 or later"); | 2268 assert(JDK_Version::is_gte_jdk16x_version(), "Must be JDK 1.6 or later"); |
2267 SystemDictionary::load_abstract_ownable_synchronizer_klass(CHECK); | 2269 SystemDictionary::load_abstract_ownable_synchronizer_klass(CHECK); |
2268 klassOop k = SystemDictionary::abstract_ownable_synchronizer_klass(); | 2270 klassOop k = SystemDictionary::abstract_ownable_synchronizer_klass(); |
2269 COMPUTE_OFFSET("java.util.concurrent.locks.AbstractOwnableSynchronizer", _owner_offset, k, | 2271 compute_offset(_owner_offset, k, |
2270 vmSymbols::exclusive_owner_thread_name(), vmSymbols::thread_signature()); | 2272 vmSymbols::exclusive_owner_thread_name(), vmSymbols::thread_signature()); |
2271 } | 2273 } |
2272 | 2274 |
2273 oop java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(oop obj) { | 2275 oop java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(oop obj) { |
2274 assert(_owner_offset != 0, "Must be initialized"); | 2276 assert(_owner_offset != 0, "Must be initialized"); |
2427 return false; | 2429 return false; |
2428 } | 2430 } |
2429 } | 2431 } |
2430 | 2432 |
2431 | 2433 |
2434 bool JavaClasses::check_constant(const char *klass_name, int hardcoded_constant, const char *field_name, const char* field_sig) { | |
2435 EXCEPTION_MARK; | |
2436 fieldDescriptor fd; | |
2437 symbolHandle klass_sym = oopFactory::new_symbol_handle(klass_name, CATCH); | |
2438 klassOop k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH); | |
2439 instanceKlassHandle h_klass (THREAD, k); | |
2440 symbolHandle f_name = oopFactory::new_symbol_handle(field_name, CATCH); | |
2441 symbolHandle f_sig = oopFactory::new_symbol_handle(field_sig, CATCH); | |
2442 if (!h_klass->find_local_field(f_name(), f_sig(), &fd)) { | |
2443 tty->print_cr("Static field %s.%s not found", klass_name, field_name); | |
2444 return false; | |
2445 } | |
2446 if (!fd.is_static() || !fd.has_initial_value()) { | |
2447 tty->print_cr("Static field %s.%s appears to be non-constant", klass_name, field_name); | |
2448 return false; | |
2449 } | |
2450 if (!fd.initial_value_tag().is_int()) { | |
2451 tty->print_cr("Static field %s.%s is not an int", klass_name, field_name); | |
2452 return false; | |
2453 } | |
2454 jint field_value = fd.int_initial_value(); | |
2455 if (field_value == hardcoded_constant) { | |
2456 return true; | |
2457 } else { | |
2458 tty->print_cr("Constant value of static field %s.%s is hardcoded as %d but should really be %d.", klass_name, field_name, hardcoded_constant, field_value); | |
2459 return false; | |
2460 } | |
2461 } | |
2462 | |
2463 | |
2432 // Check the hard-coded field offsets of all the classes in this file | 2464 // Check the hard-coded field offsets of all the classes in this file |
2433 | 2465 |
2434 void JavaClasses::check_offsets() { | 2466 void JavaClasses::check_offsets() { |
2435 bool valid = true; | 2467 bool valid = true; |
2436 | 2468 |
2437 #define CHECK_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \ | 2469 #define CHECK_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \ |
2438 valid &= check_offset(klass_name, cpp_klass_name :: field_name ## _offset, #field_name, field_sig) | 2470 valid &= check_offset(klass_name, cpp_klass_name :: field_name ## _offset, #field_name, field_sig) |
2439 | 2471 |
2440 #define CHECK_STATIC_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \ | 2472 #define CHECK_STATIC_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \ |
2441 valid &= check_static_offset(klass_name, cpp_klass_name :: static_ ## field_name ## _offset, #field_name, field_sig) | 2473 valid &= check_static_offset(klass_name, cpp_klass_name :: static_ ## field_name ## _offset, #field_name, field_sig) |
2474 | |
2475 #define CHECK_CONSTANT(klass_name, cpp_klass_name, field_name, field_sig) \ | |
2476 valid &= check_constant(klass_name, cpp_klass_name :: field_name, #field_name, field_sig) | |
2442 | 2477 |
2443 // java.lang.String | 2478 // java.lang.String |
2444 | 2479 |
2445 CHECK_OFFSET("java/lang/String", java_lang_String, value, "[C"); | 2480 CHECK_OFFSET("java/lang/String", java_lang_String, value, "[C"); |
2446 CHECK_OFFSET("java/lang/String", java_lang_String, offset, "I"); | 2481 CHECK_OFFSET("java/lang/String", java_lang_String, offset, "I"); |