Mercurial > hg > truffle

comparison src/share/vm/classfile/javaClasses.cpp @ 132:60b728ec77c1

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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");