8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
20 * CA 95054 USA or visit www.sun.com if you need additional information or
21 * have any questions.
22 *
23 */
24
25 # include "incls/_precompiled.incl"
26 # include "incls/_javaClasses.cpp.incl"
27
28 // Helpful macro 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) \
30 { \
31 fieldDescriptor fd; \
32 instanceKlass* ik = instanceKlass::cast(klass_oop); \
33 if (!ik->find_local_field(name_symbol, signature_symbol, &fd)) { \
34 fatal("Invalid layout of " klass_name_as_C_str); \
35 } \
36 dest_offset = fd.offset(); \
37 }
38
39 // 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) \
41 { \
42 fieldDescriptor fd; \
43 instanceKlass* ik = instanceKlass::cast(klass_oop); \
44 if (ik->find_local_field(name_symbol, signature_symbol, &fd)) { \
45 dest_offset = fd.offset(); \
46 } \
47 }
48
49 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
51 // and the char array it points to end up in the same cache line.
52 oop obj;
53 if (tenured) {
54 obj = instanceKlass::cast(SystemDictionary::string_klass())->allocate_permanent_instance(CHECK_NH);
55 } else {
56 obj = instanceKlass::cast(SystemDictionary::string_klass())->allocate_instance(CHECK_NH);
57 }
58
59 // Create the char array. The String object must be handlized here
60 // because GC can happen as a result of the allocation attempt.
61 Handle h_obj(THREAD, obj);
62 typeArrayOop buffer;
63 if (tenured) {
64 buffer = oopFactory::new_permanent_charArray(length, CHECK_NH);
65 } else {
66 buffer = oopFactory::new_charArray(length, CHECK_NH);
398 }
399
400
401 oop java_lang_Class::primitive_mirror(BasicType t) {
402 oop mirror = Universe::java_mirror(t);
403 assert(mirror != NULL && mirror->is_a(SystemDictionary::class_klass()), "must be a Class");
404 assert(java_lang_Class::is_primitive(mirror), "must be primitive");
405 return mirror;
406 }
407
408 bool java_lang_Class::offsets_computed = false;
409 int java_lang_Class::classRedefinedCount_offset = -1;
410
411 void java_lang_Class::compute_offsets() {
412 assert(!offsets_computed, "offsets should be initialized only once");
413 offsets_computed = true;
414
415 klassOop k = SystemDictionary::class_klass();
416 // The classRedefinedCount field is only present starting in 1.5,
417 // so don't go fatal.
418 COMPUTE_OPTIONAL_OFFSET("java.lang.Class", classRedefinedCount_offset,
419 k, vmSymbols::classRedefinedCount_name(), vmSymbols::int_signature());
420 }
421
422 int java_lang_Class::classRedefinedCount(oop the_class_mirror) {
423 if (!JDK_Version::is_gte_jdk15x_version()
424 || classRedefinedCount_offset == -1) {
425 // The classRedefinedCount field is only present starting in 1.5.
426 // If we don't have an offset for it then just return -1 as a marker.
427 return -1;
428 }
429
430 return the_class_mirror->int_field(classRedefinedCount_offset);
431 }
432
433 void java_lang_Class::set_classRedefinedCount(oop the_class_mirror, int value) {
434 if (!JDK_Version::is_gte_jdk15x_version()
435 || classRedefinedCount_offset == -1) {
436 // The classRedefinedCount field is only present starting in 1.5.
437 // If we don't have an offset for it then nothing to set.
438 return;
452
453 int java_lang_Thread::_name_offset = 0;
454 int java_lang_Thread::_group_offset = 0;
455 int java_lang_Thread::_contextClassLoader_offset = 0;
456 int java_lang_Thread::_inheritedAccessControlContext_offset = 0;
457 int java_lang_Thread::_priority_offset = 0;
458 int java_lang_Thread::_eetop_offset = 0;
459 int java_lang_Thread::_daemon_offset = 0;
460 int java_lang_Thread::_stillborn_offset = 0;
461 int java_lang_Thread::_stackSize_offset = 0;
462 int java_lang_Thread::_tid_offset = 0;
463 int java_lang_Thread::_thread_status_offset = 0;
464 int java_lang_Thread::_park_blocker_offset = 0;
465 int java_lang_Thread::_park_event_offset = 0 ;
466
467
468 void java_lang_Thread::compute_offsets() {
469 assert(_group_offset == 0, "offsets should be initialized only once");
470
471 klassOop k = SystemDictionary::thread_klass();
472 COMPUTE_OFFSET("java.lang.Thread", _name_offset, k, vmSymbols::name_name(), vmSymbols::char_array_signature());
473 COMPUTE_OFFSET("java.lang.Thread", _group_offset, k, vmSymbols::group_name(), vmSymbols::threadgroup_signature());
474 COMPUTE_OFFSET("java.lang.Thread", _contextClassLoader_offset, k, vmSymbols::contextClassLoader_name(), vmSymbols::classloader_signature());
475 COMPUTE_OFFSET("java.lang.Thread", _inheritedAccessControlContext_offset, k, vmSymbols::inheritedAccessControlContext_name(), vmSymbols::accesscontrolcontext_signature());
476 COMPUTE_OFFSET("java.lang.Thread", _priority_offset, k, vmSymbols::priority_name(), vmSymbols::int_signature());
477 COMPUTE_OFFSET("java.lang.Thread", _daemon_offset, k, vmSymbols::daemon_name(), vmSymbols::bool_signature());
478 COMPUTE_OFFSET("java.lang.Thread", _eetop_offset, k, vmSymbols::eetop_name(), vmSymbols::long_signature());
479 COMPUTE_OFFSET("java.lang.Thread", _stillborn_offset, k, vmSymbols::stillborn_name(), vmSymbols::bool_signature());
480 // The stackSize field is only present starting in 1.4, so don't go fatal.
481 COMPUTE_OPTIONAL_OFFSET("java.lang.Thread", _stackSize_offset, k, vmSymbols::stackSize_name(), vmSymbols::long_signature());
482 // The tid and thread_status fields are only present starting in 1.5, so don't go fatal.
483 COMPUTE_OPTIONAL_OFFSET("java.lang.Thread", _tid_offset, k, vmSymbols::thread_id_name(), vmSymbols::long_signature());
484 COMPUTE_OPTIONAL_OFFSET("java.lang.Thread", _thread_status_offset, k, vmSymbols::thread_status_name(), vmSymbols::int_signature());
485 // The parkBlocker field is only present starting in 1.6, so don't go fatal.
486 COMPUTE_OPTIONAL_OFFSET("java.lang.Thread", _park_blocker_offset, k, vmSymbols::park_blocker_name(), vmSymbols::object_signature());
487 COMPUTE_OPTIONAL_OFFSET("java.lang.Thread", _park_event_offset, k, vmSymbols::park_event_name(),
488 vmSymbols::long_signature());
489 }
490
491
492 JavaThread* java_lang_Thread::thread(oop java_thread) {
493 return (JavaThread*) java_thread->obj_field(_eetop_offset);
494 }
495
496
497 void java_lang_Thread::set_thread(oop java_thread, JavaThread* thread) {
498 // We are storing a JavaThread* (malloc'ed data) into a long field in the thread
499 // object. The store has to be 64-bit wide so we use a pointer store, but we
500 // cannot call oopDesc::obj_field_put since it includes a write barrier!
501 oop* addr = java_thread->obj_field_addr(_eetop_offset);
502 *addr = (oop) thread;
503 }
504
505
506 typeArrayOop java_lang_Thread::name(oop java_thread) {
507 oop name = java_thread->obj_field(_name_offset);
716 bool java_lang_ThreadGroup::is_destroyed(oop java_thread_group) {
717 assert(java_thread_group->is_oop(), "thread group must be oop");
718 return java_thread_group->bool_field(_destroyed_offset) != 0;
719 }
720
721 bool java_lang_ThreadGroup::is_daemon(oop java_thread_group) {
722 assert(java_thread_group->is_oop(), "thread group must be oop");
723 return java_thread_group->bool_field(_daemon_offset) != 0;
724 }
725
726 bool java_lang_ThreadGroup::is_vmAllowSuspension(oop java_thread_group) {
727 assert(java_thread_group->is_oop(), "thread group must be oop");
728 return java_thread_group->bool_field(_vmAllowSuspension_offset) != 0;
729 }
730
731 void java_lang_ThreadGroup::compute_offsets() {
732 assert(_parent_offset == 0, "offsets should be initialized only once");
733
734 klassOop k = SystemDictionary::threadGroup_klass();
735
736 COMPUTE_OFFSET("java.lang.ThreadGroup", _parent_offset, k, vmSymbols::parent_name(), vmSymbols::threadgroup_signature());
737 COMPUTE_OFFSET("java.lang.ThreadGroup", _name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature());
738 COMPUTE_OFFSET("java.lang.ThreadGroup", _threads_offset, k, vmSymbols::threads_name(), vmSymbols::thread_array_signature());
739 COMPUTE_OFFSET("java.lang.ThreadGroup", _groups_offset, k, vmSymbols::groups_name(), vmSymbols::threadgroup_array_signature());
740 COMPUTE_OFFSET("java.lang.ThreadGroup", _maxPriority_offset, k, vmSymbols::maxPriority_name(), vmSymbols::int_signature());
741 COMPUTE_OFFSET("java.lang.ThreadGroup", _destroyed_offset, k, vmSymbols::destroyed_name(), vmSymbols::bool_signature());
742 COMPUTE_OFFSET("java.lang.ThreadGroup", _daemon_offset, k, vmSymbols::daemon_name(), vmSymbols::bool_signature());
743 COMPUTE_OFFSET("java.lang.ThreadGroup", _vmAllowSuspension_offset, k, vmSymbols::vmAllowSuspension_name(), vmSymbols::bool_signature());
744 COMPUTE_OFFSET("java.lang.ThreadGroup", _nthreads_offset, k, vmSymbols::nthreads_name(), vmSymbols::int_signature());
745 COMPUTE_OFFSET("java.lang.ThreadGroup", _ngroups_offset, k, vmSymbols::ngroups_name(), vmSymbols::int_signature());
746 }
747
748 oop java_lang_Throwable::backtrace(oop throwable) {
749 return throwable->obj_field_acquire(backtrace_offset);
750 }
751
752
753 void java_lang_Throwable::set_backtrace(oop throwable, oop value) {
754 throwable->release_obj_field_put(backtrace_offset, value);
755 }
756
757
758 oop java_lang_Throwable::message(oop throwable) {
759 return throwable->obj_field(detailMessage_offset);
760 }
761
762
763 oop java_lang_Throwable::message(Handle throwable) {
764 return throwable->obj_field(detailMessage_offset);
765 }
1320 objArrayOop methods = objArrayOop(chunk->obj_at(trace_methods_offset));
1321 typeArrayOop bcis = typeArrayOop(chunk->obj_at(trace_bcis_offset));
1322 assert(methods != NULL && bcis != NULL, "sanity check");
1323 methodHandle method(THREAD, methodOop(methods->obj_at(chunk_index)));
1324 int bci = bcis->ushort_at(chunk_index);
1325 // Chunk can be partial full
1326 if (method.is_null()) {
1327 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
1328 }
1329
1330 oop element = java_lang_StackTraceElement::create(method, bci, CHECK_0);
1331 return element;
1332 }
1333
1334 oop java_lang_StackTraceElement::create(methodHandle method, int bci, TRAPS) {
1335 // SystemDictionary::stackTraceElement_klass() will be null for pre-1.4 JDKs
1336 assert(JDK_Version::is_gte_jdk14x_version(), "should only be called in >= 1.4");
1337
1338 // Allocate java.lang.StackTraceElement instance
1339 klassOop k = SystemDictionary::stackTraceElement_klass();
1340 instanceKlassHandle ik (THREAD, k);
1341 if (ik->should_be_initialized()) {
1342 ik->initialize(CHECK_0);
1343 }
1344
1345 Handle element = ik->allocate_instance_handle(CHECK_0);
1346 // Fill in class name
1347 ResourceMark rm(THREAD);
1348 const char* str = instanceKlass::cast(method->method_holder())->external_name();
1349 oop classname = StringTable::intern((char*) str, CHECK_0);
1350 java_lang_StackTraceElement::set_declaringClass(element(), classname);
1351 // Fill in method name
1352 oop methodname = StringTable::intern(method->name(), CHECK_0);
1353 java_lang_StackTraceElement::set_methodName(element(), methodname);
1354 // Fill in source file name
1355 symbolOop source = instanceKlass::cast(method->method_holder())->source_file_name();
1356 oop filename = StringTable::intern(source, CHECK_0);
1357 java_lang_StackTraceElement::set_fileName(element(), filename);
1358 // File in source line number
1359 int line_number;
1360 if (method->is_native()) {
1361 // Negative value different from -1 below, enabling Java code in
1362 // class java.lang.StackTraceElement to distinguish "native" from
1363 // "no LineNumberTable".
1364 line_number = -2;
1365 } else {
1366 // Returns -1 if no LineNumberTable, and otherwise actual line number
1367 line_number = method->line_number_from_bci(bci);
1368 }
1369 java_lang_StackTraceElement::set_lineNumber(element(), line_number);
1370
1371 return element();
1372 }
1373
1374
1375 void java_lang_reflect_AccessibleObject::compute_offsets() {
1376 klassOop k = SystemDictionary::reflect_accessible_object_klass();
1377 COMPUTE_OFFSET("java.lang.reflect.AccessibleObject", override_offset, k, vmSymbols::override_name(), vmSymbols::bool_signature());
1378 }
1379
1380 jboolean java_lang_reflect_AccessibleObject::override(oop reflect) {
1381 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1382 return (jboolean) reflect->bool_field(override_offset);
1383 }
1384
1385 void java_lang_reflect_AccessibleObject::set_override(oop reflect, jboolean value) {
1386 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1387 reflect->bool_field_put(override_offset, (int) value);
1388 }
1389
1390 void java_lang_reflect_Method::compute_offsets() {
1391 klassOop k = SystemDictionary::reflect_method_klass();
1392 COMPUTE_OFFSET("java.lang.reflect.Method", clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature());
1393 COMPUTE_OFFSET("java.lang.reflect.Method", name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature());
1394 COMPUTE_OFFSET("java.lang.reflect.Method", returnType_offset, k, vmSymbols::returnType_name(), vmSymbols::class_signature());
1395 COMPUTE_OFFSET("java.lang.reflect.Method", parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature());
1396 COMPUTE_OFFSET("java.lang.reflect.Method", exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature());
1397 COMPUTE_OFFSET("java.lang.reflect.Method", slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature());
1398 COMPUTE_OFFSET("java.lang.reflect.Method", modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature());
1399 // The generic signature and annotations fields are only present in 1.5
1400 signature_offset = -1;
1401 annotations_offset = -1;
1402 parameter_annotations_offset = -1;
1403 annotation_default_offset = -1;
1404 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Method", signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature());
1405 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Method", annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature());
1406 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Method", parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), vmSymbols::byte_array_signature());
1407 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Method", annotation_default_offset, k, vmSymbols::annotation_default_name(), vmSymbols::byte_array_signature());
1408 }
1409
1410 Handle java_lang_reflect_Method::create(TRAPS) {
1411 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1412 klassOop klass = SystemDictionary::reflect_method_klass();
1413 // This class is eagerly initialized during VM initialization, since we keep a refence
1414 // to one of the methods
1415 assert(instanceKlass::cast(klass)->is_initialized(), "must be initialized");
1416 return instanceKlass::cast(klass)->allocate_instance_handle(CHECK_NH);
1417 }
1418
1419 oop java_lang_reflect_Method::clazz(oop reflect) {
1420 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1421 return reflect->obj_field(clazz_offset);
1422 }
1423
1424 void java_lang_reflect_Method::set_clazz(oop reflect, oop value) {
1425 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1426 reflect->obj_field_put(clazz_offset, value);
1427 }
1535 }
1536
1537 bool java_lang_reflect_Method::has_annotation_default_field() {
1538 return (annotation_default_offset >= 0);
1539 }
1540
1541 oop java_lang_reflect_Method::annotation_default(oop method) {
1542 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1543 assert(has_annotation_default_field(), "annotation default field must be present");
1544 return method->obj_field(annotation_default_offset);
1545 }
1546
1547 void java_lang_reflect_Method::set_annotation_default(oop method, oop value) {
1548 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1549 assert(has_annotation_default_field(), "annotation default field must be present");
1550 method->obj_field_put(annotation_default_offset, value);
1551 }
1552
1553 void java_lang_reflect_Constructor::compute_offsets() {
1554 klassOop k = SystemDictionary::reflect_constructor_klass();
1555 COMPUTE_OFFSET("java.lang.reflect.Constructor", clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature());
1556 COMPUTE_OFFSET("java.lang.reflect.Constructor", parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature());
1557 COMPUTE_OFFSET("java.lang.reflect.Constructor", exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature());
1558 COMPUTE_OFFSET("java.lang.reflect.Constructor", slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature());
1559 COMPUTE_OFFSET("java.lang.reflect.Constructor", modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature());
1560 // The generic signature and annotations fields are only present in 1.5
1561 signature_offset = -1;
1562 annotations_offset = -1;
1563 parameter_annotations_offset = -1;
1564 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Constructor", signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature());
1565 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Constructor", annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature());
1566 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Constructor", parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), vmSymbols::byte_array_signature());
1567 }
1568
1569 Handle java_lang_reflect_Constructor::create(TRAPS) {
1570 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1571 symbolHandle name = vmSymbolHandles::java_lang_reflect_Constructor();
1572 klassOop k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH);
1573 instanceKlassHandle klass (THREAD, k);
1574 // Ensure it is initialized
1575 klass->initialize(CHECK_NH);
1576 return klass->allocate_instance_handle(CHECK_NH);
1577 }
1578
1579 oop java_lang_reflect_Constructor::clazz(oop reflect) {
1580 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1581 return reflect->obj_field(clazz_offset);
1582 }
1583
1584 void java_lang_reflect_Constructor::set_clazz(oop reflect, oop value) {
1585 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1586 reflect->obj_field_put(clazz_offset, value);
1659 }
1660
1661 bool java_lang_reflect_Constructor::has_parameter_annotations_field() {
1662 return (parameter_annotations_offset >= 0);
1663 }
1664
1665 oop java_lang_reflect_Constructor::parameter_annotations(oop method) {
1666 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1667 assert(has_parameter_annotations_field(), "parameter annotations field must be present");
1668 return method->obj_field(parameter_annotations_offset);
1669 }
1670
1671 void java_lang_reflect_Constructor::set_parameter_annotations(oop method, oop value) {
1672 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1673 assert(has_parameter_annotations_field(), "parameter annotations field must be present");
1674 method->obj_field_put(parameter_annotations_offset, value);
1675 }
1676
1677 void java_lang_reflect_Field::compute_offsets() {
1678 klassOop k = SystemDictionary::reflect_field_klass();
1679 COMPUTE_OFFSET("java.lang.reflect.Field", clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature());
1680 COMPUTE_OFFSET("java.lang.reflect.Field", name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature());
1681 COMPUTE_OFFSET("java.lang.reflect.Field", type_offset, k, vmSymbols::type_name(), vmSymbols::class_signature());
1682 COMPUTE_OFFSET("java.lang.reflect.Field", slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature());
1683 COMPUTE_OFFSET("java.lang.reflect.Field", modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature());
1684 // The generic signature and annotations fields are only present in 1.5
1685 signature_offset = -1;
1686 annotations_offset = -1;
1687 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Field", signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature());
1688 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Field", annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature());
1689 }
1690
1691 Handle java_lang_reflect_Field::create(TRAPS) {
1692 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1693 symbolHandle name = vmSymbolHandles::java_lang_reflect_Field();
1694 klassOop k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH);
1695 instanceKlassHandle klass (THREAD, k);
1696 // Ensure it is initialized
1697 klass->initialize(CHECK_NH);
1698 return klass->allocate_instance_handle(CHECK_NH);
1699 }
1700
1701 oop java_lang_reflect_Field::clazz(oop reflect) {
1702 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1703 return reflect->obj_field(clazz_offset);
1704 }
1705
1706 void java_lang_reflect_Field::set_clazz(oop reflect, oop value) {
1707 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1708 reflect->obj_field_put(clazz_offset, value);
1768 return (annotations_offset >= 0);
1769 }
1770
1771 oop java_lang_reflect_Field::annotations(oop field) {
1772 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1773 assert(has_annotations_field(), "annotations field must be present");
1774 return field->obj_field(annotations_offset);
1775 }
1776
1777 void java_lang_reflect_Field::set_annotations(oop field, oop value) {
1778 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1779 assert(has_annotations_field(), "annotations field must be present");
1780 field->obj_field_put(annotations_offset, value);
1781 }
1782
1783
1784 void sun_reflect_ConstantPool::compute_offsets() {
1785 klassOop k = SystemDictionary::reflect_constant_pool_klass();
1786 // This null test can be removed post beta
1787 if (k != NULL) {
1788 COMPUTE_OFFSET("sun.reflect.ConstantPool", _cp_oop_offset, k, vmSymbols::constantPoolOop_name(), vmSymbols::object_signature());
1789 }
1790 }
1791
1792
1793 Handle sun_reflect_ConstantPool::create(TRAPS) {
1794 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1795 klassOop k = SystemDictionary::reflect_constant_pool_klass();
1796 instanceKlassHandle klass (THREAD, k);
1797 // Ensure it is initialized
1798 klass->initialize(CHECK_NH);
1799 return klass->allocate_instance_handle(CHECK_NH);
1800 }
1801
1802
1803 oop sun_reflect_ConstantPool::cp_oop(oop reflect) {
1804 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1805 return reflect->obj_field(_cp_oop_offset);
1806 }
1807
1808
1809 void sun_reflect_ConstantPool::set_cp_oop(oop reflect, oop value) {
1810 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1811 reflect->obj_field_put(_cp_oop_offset, value);
1812 }
1813
1814 void sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets() {
1815 klassOop k = SystemDictionary::reflect_unsafe_static_field_accessor_impl_klass();
1816 // This null test can be removed post beta
1817 if (k != NULL) {
1818 COMPUTE_OFFSET("sun.reflect.UnsafeStaticFieldAccessorImpl", _base_offset, k,
1819 vmSymbols::base_name(), vmSymbols::object_signature());
1820 }
1821 }
1822
1823 oop java_lang_boxing_object::initialize_and_allocate(klassOop k, TRAPS) {
1824 instanceKlassHandle h (THREAD, k);
1825 if (!h->is_initialized()) h->initialize(CHECK_0);
1826 return h->allocate_instance(THREAD);
1827 }
1828
1829
1830 oop java_lang_boxing_object::create(BasicType type, jvalue* value, TRAPS) {
1831 oop box;
1832 switch (type) {
1833 case T_BOOLEAN:
1834 box = initialize_and_allocate(SystemDictionary::boolean_klass(), CHECK_0);
1835 box->bool_field_put(value_offset, value->z);
1836 break;
1837 case T_CHAR:
1838 box = initialize_and_allocate(SystemDictionary::char_klass(), CHECK_0);
1839 box->char_field_put(value_offset, value->c);
1840 break;
1841 case T_FLOAT:
1842 box = initialize_and_allocate(SystemDictionary::float_klass(), CHECK_0);
1843 box->float_field_put(value_offset, value->f);
1844 break;
1845 case T_DOUBLE:
1846 box = initialize_and_allocate(SystemDictionary::double_klass(), CHECK_0);
1847 box->double_field_put(value_offset, value->d);
1848 break;
1849 case T_BYTE:
1850 box = initialize_and_allocate(SystemDictionary::byte_klass(), CHECK_0);
1851 box->byte_field_put(value_offset, value->b);
1852 break;
1853 case T_SHORT:
1854 box = initialize_and_allocate(SystemDictionary::short_klass(), CHECK_0);
1855 box->short_field_put(value_offset, value->s);
1856 break;
1857 case T_INT:
1858 box = initialize_and_allocate(SystemDictionary::int_klass(), CHECK_0);
1859 box->int_field_put(value_offset, value->i);
1860 break;
1861 case T_LONG:
1862 box = initialize_and_allocate(SystemDictionary::long_klass(), CHECK_0);
1863 box->long_field_put(value_offset, value->j);
1864 break;
1865 default:
1866 return NULL;
1867 }
1868 return box;
1869 }
1870
1871
1872 BasicType java_lang_boxing_object::get_value(oop box, jvalue* value) {
1873 klassOop k = box->klass();
1874 if (k == SystemDictionary::boolean_klass()) {
1875 value->z = box->bool_field(value_offset);
1876 return T_BOOLEAN;
1877 }
1878 if (k == SystemDictionary::char_klass()) {
1879 value->c = box->char_field(value_offset);
1880 return T_CHAR;
1881 }
1882 if (k == SystemDictionary::float_klass()) {
1883 value->f = box->float_field(value_offset);
1884 return T_FLOAT;
1885 }
1886 if (k == SystemDictionary::double_klass()) {
1887 value->d = box->double_field(value_offset);
1888 return T_DOUBLE;
1889 }
1890 if (k == SystemDictionary::byte_klass()) {
1891 value->b = box->byte_field(value_offset);
1892 return T_BYTE;
1893 }
1894 if (k == SystemDictionary::short_klass()) {
1895 value->s = box->short_field(value_offset);
1896 return T_SHORT;
1897 }
1898 if (k == SystemDictionary::int_klass()) {
1899 value->i = box->int_field(value_offset);
1900 return T_INT;
1901 }
1902 if (k == SystemDictionary::long_klass()) {
1903 value->j = box->long_field(value_offset);
1904 return T_LONG;
1905 }
1906 return T_ILLEGAL;
1907 }
1908
1909
1910 BasicType java_lang_boxing_object::set_value(oop box, jvalue* value) {
1911 klassOop k = box->klass();
1912 if (k == SystemDictionary::boolean_klass()) {
1913 box->bool_field_put(value_offset, value->z);
1914 return T_BOOLEAN;
1915 }
1916 if (k == SystemDictionary::char_klass()) {
1917 box->char_field_put(value_offset, value->c);
1918 return T_CHAR;
1919 }
1920 if (k == SystemDictionary::float_klass()) {
1921 box->float_field_put(value_offset, value->f);
1922 return T_FLOAT;
1923 }
1924 if (k == SystemDictionary::double_klass()) {
1925 box->double_field_put(value_offset, value->d);
1926 return T_DOUBLE;
1927 }
1928 if (k == SystemDictionary::byte_klass()) {
1929 box->byte_field_put(value_offset, value->b);
1930 return T_BYTE;
1931 }
1932 if (k == SystemDictionary::short_klass()) {
1933 box->short_field_put(value_offset, value->s);
1934 return T_SHORT;
1935 }
1936 if (k == SystemDictionary::int_klass()) {
1937 box->int_field_put(value_offset, value->i);
1938 return T_INT;
1939 }
1940 if (k == SystemDictionary::long_klass()) {
1941 box->long_field_put(value_offset, value->j);
1942 return T_LONG;
1943 }
1944 return T_ILLEGAL;
1945 }
1946
1947
1948 // Support for java_lang_ref_Reference
1949
1950 void java_lang_ref_Reference::set_referent(oop ref, oop value) {
1951 ref->obj_field_put(referent_offset, value);
1952 }
1953
1954 oop* java_lang_ref_Reference::referent_addr(oop ref) {
1955 return ref->obj_field_addr(referent_offset);
1956 }
1957
1958 void java_lang_ref_Reference::set_next(oop ref, oop value) {
1959 ref->obj_field_put(next_offset, value);
1960 }
1961
1962 oop* java_lang_ref_Reference::next_addr(oop ref) {
1963 return ref->obj_field_addr(next_offset);
1964 }
2210 o->obj_field_put(packages_offset, val);
2211 }
2212
2213 void java_lang_AssertionStatusDirectives::set_packageEnabled(oop o, oop val) {
2214 o->obj_field_put(packageEnabled_offset, val);
2215 }
2216
2217 void java_lang_AssertionStatusDirectives::set_deflt(oop o, bool val) {
2218 o->bool_field_put(deflt_offset, val);
2219 }
2220
2221
2222 // Support for intrinsification of java.nio.Buffer.checkIndex
2223 int java_nio_Buffer::limit_offset() {
2224 return _limit_offset;
2225 }
2226
2227
2228 void java_nio_Buffer::compute_offsets() {
2229 klassOop k = SystemDictionary::java_nio_Buffer_klass();
2230 COMPUTE_OFFSET("java.nio.Buffer", _limit_offset, k, vmSymbols::limit_name(), vmSymbols::int_signature());
2231 }
2232
2233 // Support for intrinsification of sun.misc.AtomicLongCSImpl.attemptUpdate
2234 int sun_misc_AtomicLongCSImpl::value_offset() {
2235 assert(SystemDictionary::sun_misc_AtomicLongCSImpl_klass() != NULL, "can't call this");
2236 return _value_offset;
2237 }
2238
2239
2240 void sun_misc_AtomicLongCSImpl::compute_offsets() {
2241 klassOop k = SystemDictionary::sun_misc_AtomicLongCSImpl_klass();
2242 // If this class is not present, its value field offset won't be referenced.
2243 if (k != NULL) {
2244 COMPUTE_OFFSET("sun.misc.AtomicLongCSImpl", _value_offset, k, vmSymbols::value_name(), vmSymbols::long_signature());
2245 }
2246 }
2247
2248 void java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(TRAPS) {
2249 if (_owner_offset != 0) return;
2250
2251 assert(JDK_Version::is_gte_jdk16x_version(), "Must be JDK 1.6 or later");
2252 SystemDictionary::load_abstract_ownable_synchronizer_klass(CHECK);
2253 klassOop k = SystemDictionary::abstract_ownable_synchronizer_klass();
2254 COMPUTE_OFFSET("java.util.concurrent.locks.AbstractOwnableSynchronizer", _owner_offset, k,
2255 vmSymbols::exclusive_owner_thread_name(), vmSymbols::thread_signature());
2256 }
2257
2258 oop java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(oop obj) {
2259 assert(_owner_offset != 0, "Must be initialized");
2260 return obj->obj_field(_owner_offset);
2261 }
2262
2263 // Compute hard-coded offsets
2264 // Invoked before SystemDictionary::initialize, so pre-loaded classes
2265 // are not available to determine the offset_of_static_fields.
2266 void JavaClasses::compute_hard_coded_offsets() {
2267 const int x = wordSize;
2268 const int header = instanceOopDesc::header_size_in_bytes();
2269
2270 // Do the String Class
2271 java_lang_String::value_offset = java_lang_String::hc_value_offset * x + header;
2272 java_lang_String::offset_offset = java_lang_String::hc_offset_offset * x + header;
2273 java_lang_String::count_offset = java_lang_String::offset_offset + sizeof (jint);
2274 java_lang_String::hash_offset = java_lang_String::count_offset + sizeof (jint);
2394 instanceKlassHandle h_klass (THREAD, k);
2395 symbolHandle f_name = oopFactory::new_symbol_handle(field_name, CATCH);
2396 symbolHandle f_sig = oopFactory::new_symbol_handle(field_sig, CATCH);
2397 if (!h_klass->find_local_field(f_name(), f_sig(), &fd)) {
2398 tty->print_cr("Static field %s.%s not found", klass_name, field_name);
2399 return false;
2400 }
2401 if (!fd.is_static()) {
2402 tty->print_cr("Static field %s.%s appears to be nonstatic", klass_name, field_name);
2403 return false;
2404 }
2405 if (fd.offset() == hardcoded_offset + h_klass->offset_of_static_fields()) {
2406 return true;
2407 } else {
2408 tty->print_cr("Offset of static field %s.%s is hardcoded as %d but should really be %d.", klass_name, field_name, hardcoded_offset, fd.offset() - h_klass->offset_of_static_fields());
2409 return false;
2410 }
2411 }
2412
2413
2414 // Check the hard-coded field offsets of all the classes in this file
2415
2416 void JavaClasses::check_offsets() {
2417 bool valid = true;
2418
2419 #define CHECK_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \
2420 valid &= check_offset(klass_name, cpp_klass_name :: field_name ## _offset, #field_name, field_sig)
2421
2422 #define CHECK_STATIC_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \
2423 valid &= check_static_offset(klass_name, cpp_klass_name :: static_ ## field_name ## _offset, #field_name, field_sig)
2424
2425 // java.lang.String
2426
2427 CHECK_OFFSET("java/lang/String", java_lang_String, value, "[C");
2428 CHECK_OFFSET("java/lang/String", java_lang_String, offset, "I");
2429 CHECK_OFFSET("java/lang/String", java_lang_String, count, "I");
2430 CHECK_OFFSET("java/lang/String", java_lang_String, hash, "I");
2431
2432 // java.lang.Class
2433
2434 // Fake fields
2435 // CHECK_OFFSET("java/lang/Class", java_lang_Class, klass); // %%% this needs to be checked
2436 // CHECK_OFFSET("java/lang/Class", java_lang_Class, array_klass); // %%% this needs to be checked
2437 // CHECK_OFFSET("java/lang/Class", java_lang_Class, resolved_constructor); // %%% this needs to be checked
2438
2439 // java.lang.Throwable
2440
2441 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, backtrace, "Ljava/lang/Object;");
2442 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, detailMessage, "Ljava/lang/String;");
2443 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, cause, "Ljava/lang/Throwable;");
2444 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, stackTrace, "[Ljava/lang/StackTraceElement;");
|
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
20 * CA 95054 USA or visit www.sun.com if you need additional information or
21 * have any questions.
22 *
23 */
24
25 # include "incls/_precompiled.incl"
26 # include "incls/_javaClasses.cpp.incl"
27
28 // Helpful routine for computing field offsets at run time rather than hardcoding them
29 static void
30 compute_offset(int &dest_offset,
31 klassOop klass_oop, symbolOop name_symbol, symbolOop signature_symbol) {
32 fieldDescriptor fd;
33 instanceKlass* ik = instanceKlass::cast(klass_oop);
34 if (!ik->find_local_field(name_symbol, signature_symbol, &fd)) {
35 ResourceMark rm;
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();
40 }
41
42 // Same as above but for "optional" offsets that might not be present in certain JDK versions
43 static void
44 compute_optional_offset(int& dest_offset,
45 klassOop klass_oop, symbolOop name_symbol, symbolOop signature_symbol) {
46 fieldDescriptor fd;
47 instanceKlass* ik = instanceKlass::cast(klass_oop);
48 if (ik->find_local_field(name_symbol, signature_symbol, &fd)) {
49 dest_offset = fd.offset();
50 }
51 }
52
53 Handle java_lang_String::basic_create(int length, bool tenured, TRAPS) {
54 // Create the String object first, so there's a chance that the String
55 // and the char array it points to end up in the same cache line.
56 oop obj;
57 if (tenured) {
58 obj = instanceKlass::cast(SystemDictionary::string_klass())->allocate_permanent_instance(CHECK_NH);
59 } else {
60 obj = instanceKlass::cast(SystemDictionary::string_klass())->allocate_instance(CHECK_NH);
61 }
62
63 // Create the char array. The String object must be handlized here
64 // because GC can happen as a result of the allocation attempt.
65 Handle h_obj(THREAD, obj);
66 typeArrayOop buffer;
67 if (tenured) {
68 buffer = oopFactory::new_permanent_charArray(length, CHECK_NH);
69 } else {
70 buffer = oopFactory::new_charArray(length, CHECK_NH);
402 }
403
404
405 oop java_lang_Class::primitive_mirror(BasicType t) {
406 oop mirror = Universe::java_mirror(t);
407 assert(mirror != NULL && mirror->is_a(SystemDictionary::class_klass()), "must be a Class");
408 assert(java_lang_Class::is_primitive(mirror), "must be primitive");
409 return mirror;
410 }
411
412 bool java_lang_Class::offsets_computed = false;
413 int java_lang_Class::classRedefinedCount_offset = -1;
414
415 void java_lang_Class::compute_offsets() {
416 assert(!offsets_computed, "offsets should be initialized only once");
417 offsets_computed = true;
418
419 klassOop k = SystemDictionary::class_klass();
420 // The classRedefinedCount field is only present starting in 1.5,
421 // so don't go fatal.
422 compute_optional_offset(classRedefinedCount_offset,
423 k, vmSymbols::classRedefinedCount_name(), vmSymbols::int_signature());
424 }
425
426 int java_lang_Class::classRedefinedCount(oop the_class_mirror) {
427 if (!JDK_Version::is_gte_jdk15x_version()
428 || classRedefinedCount_offset == -1) {
429 // The classRedefinedCount field is only present starting in 1.5.
430 // If we don't have an offset for it then just return -1 as a marker.
431 return -1;
432 }
433
434 return the_class_mirror->int_field(classRedefinedCount_offset);
435 }
436
437 void java_lang_Class::set_classRedefinedCount(oop the_class_mirror, int value) {
438 if (!JDK_Version::is_gte_jdk15x_version()
439 || classRedefinedCount_offset == -1) {
440 // The classRedefinedCount field is only present starting in 1.5.
441 // If we don't have an offset for it then nothing to set.
442 return;
456
457 int java_lang_Thread::_name_offset = 0;
458 int java_lang_Thread::_group_offset = 0;
459 int java_lang_Thread::_contextClassLoader_offset = 0;
460 int java_lang_Thread::_inheritedAccessControlContext_offset = 0;
461 int java_lang_Thread::_priority_offset = 0;
462 int java_lang_Thread::_eetop_offset = 0;
463 int java_lang_Thread::_daemon_offset = 0;
464 int java_lang_Thread::_stillborn_offset = 0;
465 int java_lang_Thread::_stackSize_offset = 0;
466 int java_lang_Thread::_tid_offset = 0;
467 int java_lang_Thread::_thread_status_offset = 0;
468 int java_lang_Thread::_park_blocker_offset = 0;
469 int java_lang_Thread::_park_event_offset = 0 ;
470
471
472 void java_lang_Thread::compute_offsets() {
473 assert(_group_offset == 0, "offsets should be initialized only once");
474
475 klassOop k = SystemDictionary::thread_klass();
476 compute_offset(_name_offset, k, vmSymbols::name_name(), vmSymbols::char_array_signature());
477 compute_offset(_group_offset, k, vmSymbols::group_name(), vmSymbols::threadgroup_signature());
478 compute_offset(_contextClassLoader_offset, k, vmSymbols::contextClassLoader_name(), vmSymbols::classloader_signature());
479 compute_offset(_inheritedAccessControlContext_offset, k, vmSymbols::inheritedAccessControlContext_name(), vmSymbols::accesscontrolcontext_signature());
480 compute_offset(_priority_offset, k, vmSymbols::priority_name(), vmSymbols::int_signature());
481 compute_offset(_daemon_offset, k, vmSymbols::daemon_name(), vmSymbols::bool_signature());
482 compute_offset(_eetop_offset, k, vmSymbols::eetop_name(), vmSymbols::long_signature());
483 compute_offset(_stillborn_offset, k, vmSymbols::stillborn_name(), vmSymbols::bool_signature());
484 // The stackSize field is only present starting in 1.4, so don't go fatal.
485 compute_optional_offset(_stackSize_offset, k, vmSymbols::stackSize_name(), vmSymbols::long_signature());
486 // The tid and thread_status fields are only present starting in 1.5, so don't go fatal.
487 compute_optional_offset(_tid_offset, k, vmSymbols::thread_id_name(), vmSymbols::long_signature());
488 compute_optional_offset(_thread_status_offset, k, vmSymbols::thread_status_name(), vmSymbols::int_signature());
489 // The parkBlocker field is only present starting in 1.6, so don't go fatal.
490 compute_optional_offset(_park_blocker_offset, k, vmSymbols::park_blocker_name(), vmSymbols::object_signature());
491 compute_optional_offset(_park_event_offset, k, vmSymbols::park_event_name(),
492 vmSymbols::long_signature());
493 }
494
495
496 JavaThread* java_lang_Thread::thread(oop java_thread) {
497 return (JavaThread*) java_thread->obj_field(_eetop_offset);
498 }
499
500
501 void java_lang_Thread::set_thread(oop java_thread, JavaThread* thread) {
502 // We are storing a JavaThread* (malloc'ed data) into a long field in the thread
503 // object. The store has to be 64-bit wide so we use a pointer store, but we
504 // cannot call oopDesc::obj_field_put since it includes a write barrier!
505 oop* addr = java_thread->obj_field_addr(_eetop_offset);
506 *addr = (oop) thread;
507 }
508
509
510 typeArrayOop java_lang_Thread::name(oop java_thread) {
511 oop name = java_thread->obj_field(_name_offset);
720 bool java_lang_ThreadGroup::is_destroyed(oop java_thread_group) {
721 assert(java_thread_group->is_oop(), "thread group must be oop");
722 return java_thread_group->bool_field(_destroyed_offset) != 0;
723 }
724
725 bool java_lang_ThreadGroup::is_daemon(oop java_thread_group) {
726 assert(java_thread_group->is_oop(), "thread group must be oop");
727 return java_thread_group->bool_field(_daemon_offset) != 0;
728 }
729
730 bool java_lang_ThreadGroup::is_vmAllowSuspension(oop java_thread_group) {
731 assert(java_thread_group->is_oop(), "thread group must be oop");
732 return java_thread_group->bool_field(_vmAllowSuspension_offset) != 0;
733 }
734
735 void java_lang_ThreadGroup::compute_offsets() {
736 assert(_parent_offset == 0, "offsets should be initialized only once");
737
738 klassOop k = SystemDictionary::threadGroup_klass();
739
740 compute_offset(_parent_offset, k, vmSymbols::parent_name(), vmSymbols::threadgroup_signature());
741 compute_offset(_name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature());
742 compute_offset(_threads_offset, k, vmSymbols::threads_name(), vmSymbols::thread_array_signature());
743 compute_offset(_groups_offset, k, vmSymbols::groups_name(), vmSymbols::threadgroup_array_signature());
744 compute_offset(_maxPriority_offset, k, vmSymbols::maxPriority_name(), vmSymbols::int_signature());
745 compute_offset(_destroyed_offset, k, vmSymbols::destroyed_name(), vmSymbols::bool_signature());
746 compute_offset(_daemon_offset, k, vmSymbols::daemon_name(), vmSymbols::bool_signature());
747 compute_offset(_vmAllowSuspension_offset, k, vmSymbols::vmAllowSuspension_name(), vmSymbols::bool_signature());
748 compute_offset(_nthreads_offset, k, vmSymbols::nthreads_name(), vmSymbols::int_signature());
749 compute_offset(_ngroups_offset, k, vmSymbols::ngroups_name(), vmSymbols::int_signature());
750 }
751
752 oop java_lang_Throwable::backtrace(oop throwable) {
753 return throwable->obj_field_acquire(backtrace_offset);
754 }
755
756
757 void java_lang_Throwable::set_backtrace(oop throwable, oop value) {
758 throwable->release_obj_field_put(backtrace_offset, value);
759 }
760
761
762 oop java_lang_Throwable::message(oop throwable) {
763 return throwable->obj_field(detailMessage_offset);
764 }
765
766
767 oop java_lang_Throwable::message(Handle throwable) {
768 return throwable->obj_field(detailMessage_offset);
769 }
1324 objArrayOop methods = objArrayOop(chunk->obj_at(trace_methods_offset));
1325 typeArrayOop bcis = typeArrayOop(chunk->obj_at(trace_bcis_offset));
1326 assert(methods != NULL && bcis != NULL, "sanity check");
1327 methodHandle method(THREAD, methodOop(methods->obj_at(chunk_index)));
1328 int bci = bcis->ushort_at(chunk_index);
1329 // Chunk can be partial full
1330 if (method.is_null()) {
1331 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
1332 }
1333
1334 oop element = java_lang_StackTraceElement::create(method, bci, CHECK_0);
1335 return element;
1336 }
1337
1338 oop java_lang_StackTraceElement::create(methodHandle method, int bci, TRAPS) {
1339 // SystemDictionary::stackTraceElement_klass() will be null for pre-1.4 JDKs
1340 assert(JDK_Version::is_gte_jdk14x_version(), "should only be called in >= 1.4");
1341
1342 // Allocate java.lang.StackTraceElement instance
1343 klassOop k = SystemDictionary::stackTraceElement_klass();
1344 assert(k != NULL, "must be loaded in 1.4+");
1345 instanceKlassHandle ik (THREAD, k);
1346 if (ik->should_be_initialized()) {
1347 ik->initialize(CHECK_0);
1348 }
1349
1350 Handle element = ik->allocate_instance_handle(CHECK_0);
1351 // Fill in class name
1352 ResourceMark rm(THREAD);
1353 const char* str = instanceKlass::cast(method->method_holder())->external_name();
1354 oop classname = StringTable::intern((char*) str, CHECK_0);
1355 java_lang_StackTraceElement::set_declaringClass(element(), classname);
1356 // Fill in method name
1357 oop methodname = StringTable::intern(method->name(), CHECK_0);
1358 java_lang_StackTraceElement::set_methodName(element(), methodname);
1359 // Fill in source file name
1360 symbolOop source = instanceKlass::cast(method->method_holder())->source_file_name();
1361 oop filename = StringTable::intern(source, CHECK_0);
1362 java_lang_StackTraceElement::set_fileName(element(), filename);
1363 // File in source line number
1364 int line_number;
1365 if (method->is_native()) {
1366 // Negative value different from -1 below, enabling Java code in
1367 // class java.lang.StackTraceElement to distinguish "native" from
1368 // "no LineNumberTable".
1369 line_number = -2;
1370 } else {
1371 // Returns -1 if no LineNumberTable, and otherwise actual line number
1372 line_number = method->line_number_from_bci(bci);
1373 }
1374 java_lang_StackTraceElement::set_lineNumber(element(), line_number);
1375
1376 return element();
1377 }
1378
1379
1380 void java_lang_reflect_AccessibleObject::compute_offsets() {
1381 klassOop k = SystemDictionary::reflect_accessible_object_klass();
1382 compute_offset(override_offset, k, vmSymbols::override_name(), vmSymbols::bool_signature());
1383 }
1384
1385 jboolean java_lang_reflect_AccessibleObject::override(oop reflect) {
1386 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1387 return (jboolean) reflect->bool_field(override_offset);
1388 }
1389
1390 void java_lang_reflect_AccessibleObject::set_override(oop reflect, jboolean value) {
1391 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1392 reflect->bool_field_put(override_offset, (int) value);
1393 }
1394
1395 void java_lang_reflect_Method::compute_offsets() {
1396 klassOop k = SystemDictionary::reflect_method_klass();
1397 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature());
1398 compute_offset(name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature());
1399 compute_offset(returnType_offset, k, vmSymbols::returnType_name(), vmSymbols::class_signature());
1400 compute_offset(parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature());
1401 compute_offset(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature());
1402 compute_offset(slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature());
1403 compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature());
1404 // The generic signature and annotations fields are only present in 1.5
1405 signature_offset = -1;
1406 annotations_offset = -1;
1407 parameter_annotations_offset = -1;
1408 annotation_default_offset = -1;
1409 compute_optional_offset(signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature());
1410 compute_optional_offset(annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature());
1411 compute_optional_offset(parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), vmSymbols::byte_array_signature());
1412 compute_optional_offset(annotation_default_offset, k, vmSymbols::annotation_default_name(), vmSymbols::byte_array_signature());
1413 }
1414
1415 Handle java_lang_reflect_Method::create(TRAPS) {
1416 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1417 klassOop klass = SystemDictionary::reflect_method_klass();
1418 // This class is eagerly initialized during VM initialization, since we keep a refence
1419 // to one of the methods
1420 assert(instanceKlass::cast(klass)->is_initialized(), "must be initialized");
1421 return instanceKlass::cast(klass)->allocate_instance_handle(CHECK_NH);
1422 }
1423
1424 oop java_lang_reflect_Method::clazz(oop reflect) {
1425 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1426 return reflect->obj_field(clazz_offset);
1427 }
1428
1429 void java_lang_reflect_Method::set_clazz(oop reflect, oop value) {
1430 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1431 reflect->obj_field_put(clazz_offset, value);
1432 }
1540 }
1541
1542 bool java_lang_reflect_Method::has_annotation_default_field() {
1543 return (annotation_default_offset >= 0);
1544 }
1545
1546 oop java_lang_reflect_Method::annotation_default(oop method) {
1547 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1548 assert(has_annotation_default_field(), "annotation default field must be present");
1549 return method->obj_field(annotation_default_offset);
1550 }
1551
1552 void java_lang_reflect_Method::set_annotation_default(oop method, oop value) {
1553 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1554 assert(has_annotation_default_field(), "annotation default field must be present");
1555 method->obj_field_put(annotation_default_offset, value);
1556 }
1557
1558 void java_lang_reflect_Constructor::compute_offsets() {
1559 klassOop k = SystemDictionary::reflect_constructor_klass();
1560 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature());
1561 compute_offset(parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature());
1562 compute_offset(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature());
1563 compute_offset(slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature());
1564 compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature());
1565 // The generic signature and annotations fields are only present in 1.5
1566 signature_offset = -1;
1567 annotations_offset = -1;
1568 parameter_annotations_offset = -1;
1569 compute_optional_offset(signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature());
1570 compute_optional_offset(annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature());
1571 compute_optional_offset(parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), vmSymbols::byte_array_signature());
1572 }
1573
1574 Handle java_lang_reflect_Constructor::create(TRAPS) {
1575 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1576 symbolHandle name = vmSymbolHandles::java_lang_reflect_Constructor();
1577 klassOop k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH);
1578 instanceKlassHandle klass (THREAD, k);
1579 // Ensure it is initialized
1580 klass->initialize(CHECK_NH);
1581 return klass->allocate_instance_handle(CHECK_NH);
1582 }
1583
1584 oop java_lang_reflect_Constructor::clazz(oop reflect) {
1585 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1586 return reflect->obj_field(clazz_offset);
1587 }
1588
1589 void java_lang_reflect_Constructor::set_clazz(oop reflect, oop value) {
1590 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1591 reflect->obj_field_put(clazz_offset, value);
1664 }
1665
1666 bool java_lang_reflect_Constructor::has_parameter_annotations_field() {
1667 return (parameter_annotations_offset >= 0);
1668 }
1669
1670 oop java_lang_reflect_Constructor::parameter_annotations(oop method) {
1671 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1672 assert(has_parameter_annotations_field(), "parameter annotations field must be present");
1673 return method->obj_field(parameter_annotations_offset);
1674 }
1675
1676 void java_lang_reflect_Constructor::set_parameter_annotations(oop method, oop value) {
1677 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1678 assert(has_parameter_annotations_field(), "parameter annotations field must be present");
1679 method->obj_field_put(parameter_annotations_offset, value);
1680 }
1681
1682 void java_lang_reflect_Field::compute_offsets() {
1683 klassOop k = SystemDictionary::reflect_field_klass();
1684 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature());
1685 compute_offset(name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature());
1686 compute_offset(type_offset, k, vmSymbols::type_name(), vmSymbols::class_signature());
1687 compute_offset(slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature());
1688 compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature());
1689 // The generic signature and annotations fields are only present in 1.5
1690 signature_offset = -1;
1691 annotations_offset = -1;
1692 compute_optional_offset(signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature());
1693 compute_optional_offset(annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature());
1694 }
1695
1696 Handle java_lang_reflect_Field::create(TRAPS) {
1697 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1698 symbolHandle name = vmSymbolHandles::java_lang_reflect_Field();
1699 klassOop k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH);
1700 instanceKlassHandle klass (THREAD, k);
1701 // Ensure it is initialized
1702 klass->initialize(CHECK_NH);
1703 return klass->allocate_instance_handle(CHECK_NH);
1704 }
1705
1706 oop java_lang_reflect_Field::clazz(oop reflect) {
1707 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1708 return reflect->obj_field(clazz_offset);
1709 }
1710
1711 void java_lang_reflect_Field::set_clazz(oop reflect, oop value) {
1712 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1713 reflect->obj_field_put(clazz_offset, value);
1773 return (annotations_offset >= 0);
1774 }
1775
1776 oop java_lang_reflect_Field::annotations(oop field) {
1777 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1778 assert(has_annotations_field(), "annotations field must be present");
1779 return field->obj_field(annotations_offset);
1780 }
1781
1782 void java_lang_reflect_Field::set_annotations(oop field, oop value) {
1783 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1784 assert(has_annotations_field(), "annotations field must be present");
1785 field->obj_field_put(annotations_offset, value);
1786 }
1787
1788
1789 void sun_reflect_ConstantPool::compute_offsets() {
1790 klassOop k = SystemDictionary::reflect_constant_pool_klass();
1791 // This null test can be removed post beta
1792 if (k != NULL) {
1793 compute_offset(_cp_oop_offset, k, vmSymbols::constantPoolOop_name(), vmSymbols::object_signature());
1794 }
1795 }
1796
1797
1798 Handle sun_reflect_ConstantPool::create(TRAPS) {
1799 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1800 klassOop k = SystemDictionary::reflect_constant_pool_klass();
1801 instanceKlassHandle klass (THREAD, k);
1802 // Ensure it is initialized
1803 klass->initialize(CHECK_NH);
1804 return klass->allocate_instance_handle(CHECK_NH);
1805 }
1806
1807
1808 oop sun_reflect_ConstantPool::cp_oop(oop reflect) {
1809 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1810 return reflect->obj_field(_cp_oop_offset);
1811 }
1812
1813
1814 void sun_reflect_ConstantPool::set_cp_oop(oop reflect, oop value) {
1815 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1816 reflect->obj_field_put(_cp_oop_offset, value);
1817 }
1818
1819 void sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets() {
1820 klassOop k = SystemDictionary::reflect_unsafe_static_field_accessor_impl_klass();
1821 // This null test can be removed post beta
1822 if (k != NULL) {
1823 compute_offset(_base_offset, k,
1824 vmSymbols::base_name(), vmSymbols::object_signature());
1825 }
1826 }
1827
1828 oop java_lang_boxing_object::initialize_and_allocate(BasicType type, TRAPS) {
1829 klassOop k = SystemDictionary::box_klass(type);
1830 if (k == NULL) return NULL;
1831 instanceKlassHandle h (THREAD, k);
1832 if (!h->is_initialized()) h->initialize(CHECK_0);
1833 return h->allocate_instance(THREAD);
1834 }
1835
1836
1837 oop java_lang_boxing_object::create(BasicType type, jvalue* value, TRAPS) {
1838 oop box = initialize_and_allocate(type, CHECK_0);
1839 if (box == NULL) return NULL;
1840 switch (type) {
1841 case T_BOOLEAN:
1842 box->bool_field_put(value_offset, value->z);
1843 break;
1844 case T_CHAR:
1845 box->char_field_put(value_offset, value->c);
1846 break;
1847 case T_FLOAT:
1848 box->float_field_put(value_offset, value->f);
1849 break;
1850 case T_DOUBLE:
1851 box->double_field_put(value_offset, value->d);
1852 break;
1853 case T_BYTE:
1854 box->byte_field_put(value_offset, value->b);
1855 break;
1856 case T_SHORT:
1857 box->short_field_put(value_offset, value->s);
1858 break;
1859 case T_INT:
1860 box->int_field_put(value_offset, value->i);
1861 break;
1862 case T_LONG:
1863 box->long_field_put(value_offset, value->j);
1864 break;
1865 default:
1866 return NULL;
1867 }
1868 return box;
1869 }
1870
1871
1872 BasicType java_lang_boxing_object::basic_type(oop box) {
1873 if (box == NULL) return T_ILLEGAL;
1874 BasicType type = SystemDictionary::box_klass_type(box->klass());
1875 if (type == T_OBJECT) // 'unknown' value returned by SD::bkt
1876 return T_ILLEGAL;
1877 return type;
1878 }
1879
1880
1881 BasicType java_lang_boxing_object::get_value(oop box, jvalue* value) {
1882 BasicType type = SystemDictionary::box_klass_type(box->klass());
1883 switch (type) {
1884 case T_BOOLEAN:
1885 value->z = box->bool_field(value_offset);
1886 break;
1887 case T_CHAR:
1888 value->c = box->char_field(value_offset);
1889 break;
1890 case T_FLOAT:
1891 value->f = box->float_field(value_offset);
1892 break;
1893 case T_DOUBLE:
1894 value->d = box->double_field(value_offset);
1895 break;
1896 case T_BYTE:
1897 value->b = box->byte_field(value_offset);
1898 break;
1899 case T_SHORT:
1900 value->s = box->short_field(value_offset);
1901 break;
1902 case T_INT:
1903 value->i = box->int_field(value_offset);
1904 break;
1905 case T_LONG:
1906 value->j = box->long_field(value_offset);
1907 break;
1908 default:
1909 return T_ILLEGAL;
1910 } // end switch
1911 return type;
1912 }
1913
1914
1915 BasicType java_lang_boxing_object::set_value(oop box, jvalue* value) {
1916 BasicType type = SystemDictionary::box_klass_type(box->klass());
1917 switch (type) {
1918 case T_BOOLEAN:
1919 box->bool_field_put(value_offset, value->z);
1920 break;
1921 case T_CHAR:
1922 box->char_field_put(value_offset, value->c);
1923 break;
1924 case T_FLOAT:
1925 box->float_field_put(value_offset, value->f);
1926 break;
1927 case T_DOUBLE:
1928 box->double_field_put(value_offset, value->d);
1929 break;
1930 case T_BYTE:
1931 box->byte_field_put(value_offset, value->b);
1932 break;
1933 case T_SHORT:
1934 box->short_field_put(value_offset, value->s);
1935 break;
1936 case T_INT:
1937 box->int_field_put(value_offset, value->i);
1938 break;
1939 case T_LONG:
1940 box->long_field_put(value_offset, value->j);
1941 break;
1942 default:
1943 return T_ILLEGAL;
1944 } // end switch
1945 return type;
1946 }
1947
1948
1949 // Support for java_lang_ref_Reference
1950
1951 void java_lang_ref_Reference::set_referent(oop ref, oop value) {
1952 ref->obj_field_put(referent_offset, value);
1953 }
1954
1955 oop* java_lang_ref_Reference::referent_addr(oop ref) {
1956 return ref->obj_field_addr(referent_offset);
1957 }
1958
1959 void java_lang_ref_Reference::set_next(oop ref, oop value) {
1960 ref->obj_field_put(next_offset, value);
1961 }
1962
1963 oop* java_lang_ref_Reference::next_addr(oop ref) {
1964 return ref->obj_field_addr(next_offset);
1965 }
2211 o->obj_field_put(packages_offset, val);
2212 }
2213
2214 void java_lang_AssertionStatusDirectives::set_packageEnabled(oop o, oop val) {
2215 o->obj_field_put(packageEnabled_offset, val);
2216 }
2217
2218 void java_lang_AssertionStatusDirectives::set_deflt(oop o, bool val) {
2219 o->bool_field_put(deflt_offset, val);
2220 }
2221
2222
2223 // Support for intrinsification of java.nio.Buffer.checkIndex
2224 int java_nio_Buffer::limit_offset() {
2225 return _limit_offset;
2226 }
2227
2228
2229 void java_nio_Buffer::compute_offsets() {
2230 klassOop k = SystemDictionary::java_nio_Buffer_klass();
2231 assert(k != NULL, "must be loaded in 1.4+");
2232 compute_offset(_limit_offset, k, vmSymbols::limit_name(), vmSymbols::int_signature());
2233 }
2234
2235 // Support for intrinsification of sun.misc.AtomicLongCSImpl.attemptUpdate
2236 int sun_misc_AtomicLongCSImpl::value_offset() {
2237 assert(SystemDictionary::sun_misc_AtomicLongCSImpl_klass() != NULL, "can't call this");
2238 return _value_offset;
2239 }
2240
2241
2242 void sun_misc_AtomicLongCSImpl::compute_offsets() {
2243 klassOop k = SystemDictionary::sun_misc_AtomicLongCSImpl_klass();
2244 // If this class is not present, its value field offset won't be referenced.
2245 if (k != NULL) {
2246 compute_offset(_value_offset, k, vmSymbols::value_name(), vmSymbols::long_signature());
2247 }
2248 }
2249
2250 void java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(TRAPS) {
2251 if (_owner_offset != 0) return;
2252
2253 assert(JDK_Version::is_gte_jdk16x_version(), "Must be JDK 1.6 or later");
2254 SystemDictionary::load_abstract_ownable_synchronizer_klass(CHECK);
2255 klassOop k = SystemDictionary::abstract_ownable_synchronizer_klass();
2256 compute_offset(_owner_offset, k,
2257 vmSymbols::exclusive_owner_thread_name(), vmSymbols::thread_signature());
2258 }
2259
2260 oop java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(oop obj) {
2261 assert(_owner_offset != 0, "Must be initialized");
2262 return obj->obj_field(_owner_offset);
2263 }
2264
2265 // Compute hard-coded offsets
2266 // Invoked before SystemDictionary::initialize, so pre-loaded classes
2267 // are not available to determine the offset_of_static_fields.
2268 void JavaClasses::compute_hard_coded_offsets() {
2269 const int x = wordSize;
2270 const int header = instanceOopDesc::header_size_in_bytes();
2271
2272 // Do the String Class
2273 java_lang_String::value_offset = java_lang_String::hc_value_offset * x + header;
2274 java_lang_String::offset_offset = java_lang_String::hc_offset_offset * x + header;
2275 java_lang_String::count_offset = java_lang_String::offset_offset + sizeof (jint);
2276 java_lang_String::hash_offset = java_lang_String::count_offset + sizeof (jint);
2396 instanceKlassHandle h_klass (THREAD, k);
2397 symbolHandle f_name = oopFactory::new_symbol_handle(field_name, CATCH);
2398 symbolHandle f_sig = oopFactory::new_symbol_handle(field_sig, CATCH);
2399 if (!h_klass->find_local_field(f_name(), f_sig(), &fd)) {
2400 tty->print_cr("Static field %s.%s not found", klass_name, field_name);
2401 return false;
2402 }
2403 if (!fd.is_static()) {
2404 tty->print_cr("Static field %s.%s appears to be nonstatic", klass_name, field_name);
2405 return false;
2406 }
2407 if (fd.offset() == hardcoded_offset + h_klass->offset_of_static_fields()) {
2408 return true;
2409 } else {
2410 tty->print_cr("Offset of static field %s.%s is hardcoded as %d but should really be %d.", klass_name, field_name, hardcoded_offset, fd.offset() - h_klass->offset_of_static_fields());
2411 return false;
2412 }
2413 }
2414
2415
2416 bool JavaClasses::check_constant(const char *klass_name, int hardcoded_constant, const char *field_name, const char* field_sig) {
2417 EXCEPTION_MARK;
2418 fieldDescriptor fd;
2419 symbolHandle klass_sym = oopFactory::new_symbol_handle(klass_name, CATCH);
2420 klassOop k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH);
2421 instanceKlassHandle h_klass (THREAD, k);
2422 symbolHandle f_name = oopFactory::new_symbol_handle(field_name, CATCH);
2423 symbolHandle f_sig = oopFactory::new_symbol_handle(field_sig, CATCH);
2424 if (!h_klass->find_local_field(f_name(), f_sig(), &fd)) {
2425 tty->print_cr("Static field %s.%s not found", klass_name, field_name);
2426 return false;
2427 }
2428 if (!fd.is_static() || !fd.has_initial_value()) {
2429 tty->print_cr("Static field %s.%s appears to be non-constant", klass_name, field_name);
2430 return false;
2431 }
2432 if (!fd.initial_value_tag().is_int()) {
2433 tty->print_cr("Static field %s.%s is not an int", klass_name, field_name);
2434 return false;
2435 }
2436 jint field_value = fd.int_initial_value();
2437 if (field_value == hardcoded_constant) {
2438 return true;
2439 } else {
2440 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);
2441 return false;
2442 }
2443 }
2444
2445
2446 // Check the hard-coded field offsets of all the classes in this file
2447
2448 void JavaClasses::check_offsets() {
2449 bool valid = true;
2450
2451 #define CHECK_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \
2452 valid &= check_offset(klass_name, cpp_klass_name :: field_name ## _offset, #field_name, field_sig)
2453
2454 #define CHECK_STATIC_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \
2455 valid &= check_static_offset(klass_name, cpp_klass_name :: static_ ## field_name ## _offset, #field_name, field_sig)
2456
2457 #define CHECK_CONSTANT(klass_name, cpp_klass_name, field_name, field_sig) \
2458 valid &= check_constant(klass_name, cpp_klass_name :: field_name, #field_name, field_sig)
2459
2460 // java.lang.String
2461
2462 CHECK_OFFSET("java/lang/String", java_lang_String, value, "[C");
2463 CHECK_OFFSET("java/lang/String", java_lang_String, offset, "I");
2464 CHECK_OFFSET("java/lang/String", java_lang_String, count, "I");
2465 CHECK_OFFSET("java/lang/String", java_lang_String, hash, "I");
2466
2467 // java.lang.Class
2468
2469 // Fake fields
2470 // CHECK_OFFSET("java/lang/Class", java_lang_Class, klass); // %%% this needs to be checked
2471 // CHECK_OFFSET("java/lang/Class", java_lang_Class, array_klass); // %%% this needs to be checked
2472 // CHECK_OFFSET("java/lang/Class", java_lang_Class, resolved_constructor); // %%% this needs to be checked
2473
2474 // java.lang.Throwable
2475
2476 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, backtrace, "Ljava/lang/Object;");
2477 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, detailMessage, "Ljava/lang/String;");
2478 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, cause, "Ljava/lang/Throwable;");
2479 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, stackTrace, "[Ljava/lang/StackTraceElement;");
|