1 #ifdef USE_PRAGMA_IDENT_SRC
2 #pragma ident "@(#)javaClasses.cpp 1.250 08/01/17 09:41:13 JVM"
3 #endif
4 /*
5 * Copyright 1997-2007 Sun Microsystems, Inc. All Rights Reserved.
6 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
7 *
8 * This code is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License version 2 only, as
10 * published by the Free Software Foundation.
11 *
12 * This code is distributed in the hope that it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 * version 2 for more details (a copy is included in the LICENSE file that
16 * accompanied this code).
17 *
18 * You should have received a copy of the GNU General Public License version
19 * 2 along with this work; if not, write to the Free Software Foundation,
20 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
21 *
22 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
23 * CA 95054 USA or visit www.sun.com if you need additional information or
24 * have any questions.
25 *
26 */
27
28 # include "incls/_precompiled.incl"
29 # include "incls/_javaClasses.cpp.incl"
30
31 // Helpful macro for computing field offsets at run time rather than hardcoding them
32 #define COMPUTE_OFFSET(klass_name_as_C_str, dest_offset, klass_oop, name_symbol, signature_symbol) \
33 { \
34 fieldDescriptor fd; \
35 instanceKlass* ik = instanceKlass::cast(klass_oop); \
36 if (!ik->find_local_field(name_symbol, signature_symbol, &fd)) { \
37 fatal("Invalid layout of " klass_name_as_C_str); \
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 #define COMPUTE_OPTIONAL_OFFSET(klass_name_as_C_str, dest_offset, klass_oop, name_symbol, signature_symbol) \
44 { \
45 fieldDescriptor fd; \
46 instanceKlass* ik = instanceKlass::cast(klass_oop); \
47 if (ik->find_local_field(name_symbol, signature_symbol, &fd)) { \
48 dest_offset = fd.offset(); \
49 } \
50 }
51
52 Handle java_lang_String::basic_create(int length, bool tenured, TRAPS) {
53 // Create the String object first, so there's a chance that the String
54 // and the char array it points to end up in the same cache line.
55 oop obj;
56 if (tenured) {
57 obj = instanceKlass::cast(SystemDictionary::string_klass())->allocate_permanent_instance(CHECK_NH);
58 } else {
59 obj = instanceKlass::cast(SystemDictionary::string_klass())->allocate_instance(CHECK_NH);
60 }
61
62 // Create the char array. The String object must be handlized here
63 // because GC can happen as a result of the allocation attempt.
64 Handle h_obj(THREAD, obj);
65 typeArrayOop buffer;
66 if (tenured) {
67 buffer = oopFactory::new_permanent_charArray(length, CHECK_NH);
68 } else {
69 buffer = oopFactory::new_charArray(length, CHECK_NH);
431 }
432
433
434 oop java_lang_Class::primitive_mirror(BasicType t) {
435 oop mirror = Universe::java_mirror(t);
436 assert(mirror != NULL && mirror->is_a(SystemDictionary::class_klass()), "must be a Class");
437 assert(java_lang_Class::is_primitive(mirror), "must be primitive");
438 return mirror;
439 }
440
441 bool java_lang_Class::offsets_computed = false;
442 int java_lang_Class::classRedefinedCount_offset = -1;
443
444 void java_lang_Class::compute_offsets() {
445 assert(!offsets_computed, "offsets should be initialized only once");
446 offsets_computed = true;
447
448 klassOop k = SystemDictionary::class_klass();
449 // The classRedefinedCount field is only present starting in 1.5,
450 // so don't go fatal.
451 COMPUTE_OPTIONAL_OFFSET("java.lang.Class", classRedefinedCount_offset,
452 k, vmSymbols::classRedefinedCount_name(), vmSymbols::int_signature());
453 }
454
455 int java_lang_Class::classRedefinedCount(oop the_class_mirror) {
456 if (!JDK_Version::is_gte_jdk15x_version()
457 || classRedefinedCount_offset == -1) {
458 // The classRedefinedCount field is only present starting in 1.5.
459 // If we don't have an offset for it then just return -1 as a marker.
460 return -1;
461 }
462
463 return the_class_mirror->int_field(classRedefinedCount_offset);
464 }
465
466 void java_lang_Class::set_classRedefinedCount(oop the_class_mirror, int value) {
467 if (!JDK_Version::is_gte_jdk15x_version()
468 || classRedefinedCount_offset == -1) {
469 // The classRedefinedCount field is only present starting in 1.5.
470 // If we don't have an offset for it then nothing to set.
471 return;
485
486 int java_lang_Thread::_name_offset = 0;
487 int java_lang_Thread::_group_offset = 0;
488 int java_lang_Thread::_contextClassLoader_offset = 0;
489 int java_lang_Thread::_inheritedAccessControlContext_offset = 0;
490 int java_lang_Thread::_priority_offset = 0;
491 int java_lang_Thread::_eetop_offset = 0;
492 int java_lang_Thread::_daemon_offset = 0;
493 int java_lang_Thread::_stillborn_offset = 0;
494 int java_lang_Thread::_stackSize_offset = 0;
495 int java_lang_Thread::_tid_offset = 0;
496 int java_lang_Thread::_thread_status_offset = 0;
497 int java_lang_Thread::_park_blocker_offset = 0;
498 int java_lang_Thread::_park_event_offset = 0 ;
499
500
501 void java_lang_Thread::compute_offsets() {
502 assert(_group_offset == 0, "offsets should be initialized only once");
503
504 klassOop k = SystemDictionary::thread_klass();
505 COMPUTE_OFFSET("java.lang.Thread", _name_offset, k, vmSymbols::name_name(), vmSymbols::char_array_signature());
506 COMPUTE_OFFSET("java.lang.Thread", _group_offset, k, vmSymbols::group_name(), vmSymbols::threadgroup_signature());
507 COMPUTE_OFFSET("java.lang.Thread", _contextClassLoader_offset, k, vmSymbols::contextClassLoader_name(), vmSymbols::classloader_signature());
508 COMPUTE_OFFSET("java.lang.Thread", _inheritedAccessControlContext_offset, k, vmSymbols::inheritedAccessControlContext_name(), vmSymbols::accesscontrolcontext_signature());
509 COMPUTE_OFFSET("java.lang.Thread", _priority_offset, k, vmSymbols::priority_name(), vmSymbols::int_signature());
510 COMPUTE_OFFSET("java.lang.Thread", _daemon_offset, k, vmSymbols::daemon_name(), vmSymbols::bool_signature());
511 COMPUTE_OFFSET("java.lang.Thread", _eetop_offset, k, vmSymbols::eetop_name(), vmSymbols::long_signature());
512 COMPUTE_OFFSET("java.lang.Thread", _stillborn_offset, k, vmSymbols::stillborn_name(), vmSymbols::bool_signature());
513 // The stackSize field is only present starting in 1.4, so don't go fatal.
514 COMPUTE_OPTIONAL_OFFSET("java.lang.Thread", _stackSize_offset, k, vmSymbols::stackSize_name(), vmSymbols::long_signature());
515 // The tid and thread_status fields are only present starting in 1.5, so don't go fatal.
516 COMPUTE_OPTIONAL_OFFSET("java.lang.Thread", _tid_offset, k, vmSymbols::thread_id_name(), vmSymbols::long_signature());
517 COMPUTE_OPTIONAL_OFFSET("java.lang.Thread", _thread_status_offset, k, vmSymbols::thread_status_name(), vmSymbols::int_signature());
518 // The parkBlocker field is only present starting in 1.6, so don't go fatal.
519 COMPUTE_OPTIONAL_OFFSET("java.lang.Thread", _park_blocker_offset, k, vmSymbols::park_blocker_name(), vmSymbols::object_signature());
520 COMPUTE_OPTIONAL_OFFSET("java.lang.Thread", _park_event_offset, k, vmSymbols::park_event_name(),
521 vmSymbols::long_signature());
522 }
523
524
525 JavaThread* java_lang_Thread::thread(oop java_thread) {
526 return (JavaThread*) java_thread->obj_field(_eetop_offset);
527 }
528
529
530 void java_lang_Thread::set_thread(oop java_thread, JavaThread* thread) {
531 // We are storing a JavaThread* (malloc'ed data) into a long field in the thread
532 // object. The store has to be 64-bit wide so we use a pointer store, but we
533 // cannot call oopDesc::obj_field_put since it includes a write barrier!
534 oop* addr = java_thread->obj_field_addr(_eetop_offset);
535 *addr = (oop) thread;
536 }
537
538
539 typeArrayOop java_lang_Thread::name(oop java_thread) {
540 oop name = java_thread->obj_field(_name_offset);
541 assert(name == NULL || (name->is_typeArray() && typeArrayKlass::cast(name->klass())->element_type() == T_CHAR), "just checking");
542 return typeArrayOop(name);
543 }
544
545
546 void java_lang_Thread::set_name(oop java_thread, typeArrayOop name) {
547 assert(java_thread->obj_field(_name_offset) == NULL, "name should be NULL");
548 java_thread->obj_field_put(_name_offset, name);
549 }
550
551
552 ThreadPriority java_lang_Thread::priority(oop java_thread) {
553 return (ThreadPriority)java_thread->int_field(_priority_offset);
554 }
555
635 JavaThread* thr = java_lang_Thread::thread(java_thread);
636 if (thr == NULL) {
637 // the thread hasn't run yet or is in the process of exiting
638 return NEW;
639 }
640 return (java_lang_Thread::ThreadStatus)JVMTI_THREAD_STATE_ALIVE;
641 }
642 }
643
644
645 jlong java_lang_Thread::thread_id(oop java_thread) {
646 // The thread ID field is only present starting in 1.5
647 if (_tid_offset > 0) {
648 return java_thread->long_field(_tid_offset);
649 } else {
650 return 0;
651 }
652 }
653
654 oop java_lang_Thread::park_blocker(oop java_thread) {
655 assert(JDK_Version::supports_thread_park_blocker() && _park_blocker_offset != 0,
656 "Must support parkBlocker field");
657
658 if (_park_blocker_offset > 0) {
659 return java_thread->obj_field(_park_blocker_offset);
660 }
661
662 return NULL;
663 }
664
665 jlong java_lang_Thread::park_event(oop java_thread) {
666 if (_park_event_offset > 0) {
667 return java_thread->long_field(_park_event_offset);
668 }
669 return 0;
670 }
671
672 bool java_lang_Thread::set_park_event(oop java_thread, jlong ptr) {
673 if (_park_event_offset > 0) {
674 java_thread->long_field_put(_park_event_offset, ptr);
675 return true;
676 }
749 bool java_lang_ThreadGroup::is_destroyed(oop java_thread_group) {
750 assert(java_thread_group->is_oop(), "thread group must be oop");
751 return java_thread_group->bool_field(_destroyed_offset) != 0;
752 }
753
754 bool java_lang_ThreadGroup::is_daemon(oop java_thread_group) {
755 assert(java_thread_group->is_oop(), "thread group must be oop");
756 return java_thread_group->bool_field(_daemon_offset) != 0;
757 }
758
759 bool java_lang_ThreadGroup::is_vmAllowSuspension(oop java_thread_group) {
760 assert(java_thread_group->is_oop(), "thread group must be oop");
761 return java_thread_group->bool_field(_vmAllowSuspension_offset) != 0;
762 }
763
764 void java_lang_ThreadGroup::compute_offsets() {
765 assert(_parent_offset == 0, "offsets should be initialized only once");
766
767 klassOop k = SystemDictionary::threadGroup_klass();
768
769 COMPUTE_OFFSET("java.lang.ThreadGroup", _parent_offset, k, vmSymbols::parent_name(), vmSymbols::threadgroup_signature());
770 COMPUTE_OFFSET("java.lang.ThreadGroup", _name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature());
771 COMPUTE_OFFSET("java.lang.ThreadGroup", _threads_offset, k, vmSymbols::threads_name(), vmSymbols::thread_array_signature());
772 COMPUTE_OFFSET("java.lang.ThreadGroup", _groups_offset, k, vmSymbols::groups_name(), vmSymbols::threadgroup_array_signature());
773 COMPUTE_OFFSET("java.lang.ThreadGroup", _maxPriority_offset, k, vmSymbols::maxPriority_name(), vmSymbols::int_signature());
774 COMPUTE_OFFSET("java.lang.ThreadGroup", _destroyed_offset, k, vmSymbols::destroyed_name(), vmSymbols::bool_signature());
775 COMPUTE_OFFSET("java.lang.ThreadGroup", _daemon_offset, k, vmSymbols::daemon_name(), vmSymbols::bool_signature());
776 COMPUTE_OFFSET("java.lang.ThreadGroup", _vmAllowSuspension_offset, k, vmSymbols::vmAllowSuspension_name(), vmSymbols::bool_signature());
777 COMPUTE_OFFSET("java.lang.ThreadGroup", _nthreads_offset, k, vmSymbols::nthreads_name(), vmSymbols::int_signature());
778 COMPUTE_OFFSET("java.lang.ThreadGroup", _ngroups_offset, k, vmSymbols::ngroups_name(), vmSymbols::int_signature());
779 }
780
781 oop java_lang_Throwable::backtrace(oop throwable) {
782 return throwable->obj_field_acquire(backtrace_offset);
783 }
784
785
786 void java_lang_Throwable::set_backtrace(oop throwable, oop value) {
787 throwable->release_obj_field_put(backtrace_offset, value);
788 }
789
790
791 oop java_lang_Throwable::message(oop throwable) {
792 return throwable->obj_field(detailMessage_offset);
793 }
794
795
796 oop java_lang_Throwable::message(Handle throwable) {
797 return throwable->obj_field(detailMessage_offset);
798 }
1001 methodOop method = methodOop(methods()->obj_at(index));
1002 if (method == NULL) return;
1003 int bci = bcis->ushort_at(index);
1004 print_stack_element(stream, method, bci);
1005 }
1006 result = objArrayHandle(thread, objArrayOop(result->obj_at(trace_next_offset)));
1007 }
1008 }
1009
1010 // This class provides a simple wrapper over the internal structure of
1011 // exception backtrace to insulate users of the backtrace from needing
1012 // to know what it looks like.
1013 class BacktraceBuilder: public StackObj {
1014 private:
1015 Handle _backtrace;
1016 objArrayOop _head;
1017 objArrayOop _methods;
1018 typeArrayOop _bcis;
1019 int _index;
1020 bool _dirty;
1021 bool _done;
1022 No_Safepoint_Verifier _nsv;
1023
1024 public:
1025
1026 enum {
1027 trace_methods_offset = java_lang_Throwable::trace_methods_offset,
1028 trace_bcis_offset = java_lang_Throwable::trace_bcis_offset,
1029 trace_next_offset = java_lang_Throwable::trace_next_offset,
1030 trace_size = java_lang_Throwable::trace_size,
1031 trace_chunk_size = java_lang_Throwable::trace_chunk_size
1032 };
1033
1034 // constructor for new backtrace
1035 BacktraceBuilder(TRAPS): _methods(NULL), _bcis(NULL), _head(NULL) {
1036 expand(CHECK);
1037 _backtrace = _head;
1038 _index = 0;
1039 _dirty = false;
1040 _done = false;
1041 }
1042
1043 void flush() {
1044 if (_dirty && _methods != NULL) {
1045 BarrierSet* bs = Universe::heap()->barrier_set();
1046 assert(bs->has_write_ref_array_opt(), "Barrier set must have ref array opt");
1047 bs->write_ref_array(MemRegion((HeapWord*)_methods->obj_at_addr(0),
1048 _methods->length() * HeapWordsPerOop));
1049 _dirty = false;
1050 }
1051 }
1052
1053 void expand(TRAPS) {
1054 flush();
1055
1056 objArrayHandle old_head(THREAD, _head);
1057 Pause_No_Safepoint_Verifier pnsv(&_nsv);
1058
1059 objArrayOop head = oopFactory::new_objectArray(trace_size, CHECK);
1060 objArrayHandle new_head(THREAD, head);
1061
1062 objArrayOop methods = oopFactory::new_objectArray(trace_chunk_size, CHECK);
1063 objArrayHandle new_methods(THREAD, methods);
1064
1065 typeArrayOop bcis = oopFactory::new_shortArray(trace_chunk_size, CHECK);
1066 typeArrayHandle new_bcis(THREAD, bcis);
1067
1068 if (!old_head.is_null()) {
1072 new_head->obj_at_put(trace_bcis_offset, new_bcis());
1073
1074 _head = new_head();
1075 _methods = new_methods();
1076 _bcis = new_bcis();
1077 _index = 0;
1078 }
1079
1080 oop backtrace() {
1081 flush();
1082 return _backtrace();
1083 }
1084
1085 inline void push(methodOop method, short bci, TRAPS) {
1086 if (_index >= trace_chunk_size) {
1087 methodHandle mhandle(THREAD, method);
1088 expand(CHECK);
1089 method = mhandle();
1090 }
1091
1092 // _methods->obj_at_put(_index, method);
1093 *_methods->obj_at_addr(_index) = method;
1094 _bcis->ushort_at_put(_index, bci);
1095 _index++;
1096 _dirty = true;
1097 }
1098
1099 methodOop current_method() {
1100 assert(_index >= 0 && _index < trace_chunk_size, "out of range");
1101 return methodOop(_methods->obj_at(_index));
1102 }
1103
1104 jushort current_bci() {
1105 assert(_index >= 0 && _index < trace_chunk_size, "out of range");
1106 return _bcis->ushort_at(_index);
1107 }
1108 };
1109
1110
1111 void java_lang_Throwable::fill_in_stack_trace(Handle throwable, TRAPS) {
1112 if (!StackTraceInThrowable) return;
1113 ResourceMark rm(THREAD);
1353 objArrayOop methods = objArrayOop(chunk->obj_at(trace_methods_offset));
1354 typeArrayOop bcis = typeArrayOop(chunk->obj_at(trace_bcis_offset));
1355 assert(methods != NULL && bcis != NULL, "sanity check");
1356 methodHandle method(THREAD, methodOop(methods->obj_at(chunk_index)));
1357 int bci = bcis->ushort_at(chunk_index);
1358 // Chunk can be partial full
1359 if (method.is_null()) {
1360 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
1361 }
1362
1363 oop element = java_lang_StackTraceElement::create(method, bci, CHECK_0);
1364 return element;
1365 }
1366
1367 oop java_lang_StackTraceElement::create(methodHandle method, int bci, TRAPS) {
1368 // SystemDictionary::stackTraceElement_klass() will be null for pre-1.4 JDKs
1369 assert(JDK_Version::is_gte_jdk14x_version(), "should only be called in >= 1.4");
1370
1371 // Allocate java.lang.StackTraceElement instance
1372 klassOop k = SystemDictionary::stackTraceElement_klass();
1373 instanceKlassHandle ik (THREAD, k);
1374 if (ik->should_be_initialized()) {
1375 ik->initialize(CHECK_0);
1376 }
1377
1378 Handle element = ik->allocate_instance_handle(CHECK_0);
1379 // Fill in class name
1380 ResourceMark rm(THREAD);
1381 const char* str = instanceKlass::cast(method->method_holder())->external_name();
1382 oop classname = StringTable::intern((char*) str, CHECK_0);
1383 java_lang_StackTraceElement::set_declaringClass(element(), classname);
1384 // Fill in method name
1385 oop methodname = StringTable::intern(method->name(), CHECK_0);
1386 java_lang_StackTraceElement::set_methodName(element(), methodname);
1387 // Fill in source file name
1388 symbolOop source = instanceKlass::cast(method->method_holder())->source_file_name();
1389 oop filename = StringTable::intern(source, CHECK_0);
1390 java_lang_StackTraceElement::set_fileName(element(), filename);
1391 // File in source line number
1392 int line_number;
1393 if (method->is_native()) {
1394 // Negative value different from -1 below, enabling Java code in
1395 // class java.lang.StackTraceElement to distinguish "native" from
1396 // "no LineNumberTable".
1397 line_number = -2;
1398 } else {
1399 // Returns -1 if no LineNumberTable, and otherwise actual line number
1400 line_number = method->line_number_from_bci(bci);
1401 }
1402 java_lang_StackTraceElement::set_lineNumber(element(), line_number);
1403
1404 return element();
1405 }
1406
1407
1408 void java_lang_reflect_AccessibleObject::compute_offsets() {
1409 klassOop k = SystemDictionary::reflect_accessible_object_klass();
1410 COMPUTE_OFFSET("java.lang.reflect.AccessibleObject", override_offset, k, vmSymbols::override_name(), vmSymbols::bool_signature());
1411 }
1412
1413 jboolean java_lang_reflect_AccessibleObject::override(oop reflect) {
1414 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1415 return (jboolean) reflect->bool_field(override_offset);
1416 }
1417
1418 void java_lang_reflect_AccessibleObject::set_override(oop reflect, jboolean value) {
1419 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1420 reflect->bool_field_put(override_offset, (int) value);
1421 }
1422
1423 void java_lang_reflect_Method::compute_offsets() {
1424 klassOop k = SystemDictionary::reflect_method_klass();
1425 COMPUTE_OFFSET("java.lang.reflect.Method", clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature());
1426 COMPUTE_OFFSET("java.lang.reflect.Method", name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature());
1427 COMPUTE_OFFSET("java.lang.reflect.Method", returnType_offset, k, vmSymbols::returnType_name(), vmSymbols::class_signature());
1428 COMPUTE_OFFSET("java.lang.reflect.Method", parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature());
1429 COMPUTE_OFFSET("java.lang.reflect.Method", exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature());
1430 COMPUTE_OFFSET("java.lang.reflect.Method", slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature());
1431 COMPUTE_OFFSET("java.lang.reflect.Method", modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature());
1432 // The generic signature and annotations fields are only present in 1.5
1433 signature_offset = -1;
1434 annotations_offset = -1;
1435 parameter_annotations_offset = -1;
1436 annotation_default_offset = -1;
1437 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Method", signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature());
1438 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Method", annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature());
1439 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Method", parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), vmSymbols::byte_array_signature());
1440 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Method", annotation_default_offset, k, vmSymbols::annotation_default_name(), vmSymbols::byte_array_signature());
1441 }
1442
1443 Handle java_lang_reflect_Method::create(TRAPS) {
1444 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1445 klassOop klass = SystemDictionary::reflect_method_klass();
1446 // This class is eagerly initialized during VM initialization, since we keep a refence
1447 // to one of the methods
1448 assert(instanceKlass::cast(klass)->is_initialized(), "must be initialized");
1449 return instanceKlass::cast(klass)->allocate_instance_handle(CHECK_NH);
1450 }
1451
1452 oop java_lang_reflect_Method::clazz(oop reflect) {
1453 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1454 return reflect->obj_field(clazz_offset);
1455 }
1456
1457 void java_lang_reflect_Method::set_clazz(oop reflect, oop value) {
1458 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1459 reflect->obj_field_put(clazz_offset, value);
1460 }
1568 }
1569
1570 bool java_lang_reflect_Method::has_annotation_default_field() {
1571 return (annotation_default_offset >= 0);
1572 }
1573
1574 oop java_lang_reflect_Method::annotation_default(oop method) {
1575 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1576 assert(has_annotation_default_field(), "annotation default field must be present");
1577 return method->obj_field(annotation_default_offset);
1578 }
1579
1580 void java_lang_reflect_Method::set_annotation_default(oop method, oop value) {
1581 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1582 assert(has_annotation_default_field(), "annotation default field must be present");
1583 method->obj_field_put(annotation_default_offset, value);
1584 }
1585
1586 void java_lang_reflect_Constructor::compute_offsets() {
1587 klassOop k = SystemDictionary::reflect_constructor_klass();
1588 COMPUTE_OFFSET("java.lang.reflect.Constructor", clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature());
1589 COMPUTE_OFFSET("java.lang.reflect.Constructor", parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature());
1590 COMPUTE_OFFSET("java.lang.reflect.Constructor", exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature());
1591 COMPUTE_OFFSET("java.lang.reflect.Constructor", slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature());
1592 COMPUTE_OFFSET("java.lang.reflect.Constructor", modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature());
1593 // The generic signature and annotations fields are only present in 1.5
1594 signature_offset = -1;
1595 annotations_offset = -1;
1596 parameter_annotations_offset = -1;
1597 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Constructor", signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature());
1598 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Constructor", annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature());
1599 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Constructor", parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), vmSymbols::byte_array_signature());
1600 }
1601
1602 Handle java_lang_reflect_Constructor::create(TRAPS) {
1603 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1604 symbolHandle name = vmSymbolHandles::java_lang_reflect_Constructor();
1605 klassOop k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH);
1606 instanceKlassHandle klass (THREAD, k);
1607 // Ensure it is initialized
1608 klass->initialize(CHECK_NH);
1609 return klass->allocate_instance_handle(CHECK_NH);
1610 }
1611
1612 oop java_lang_reflect_Constructor::clazz(oop reflect) {
1613 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1614 return reflect->obj_field(clazz_offset);
1615 }
1616
1617 void java_lang_reflect_Constructor::set_clazz(oop reflect, oop value) {
1618 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1619 reflect->obj_field_put(clazz_offset, value);
1692 }
1693
1694 bool java_lang_reflect_Constructor::has_parameter_annotations_field() {
1695 return (parameter_annotations_offset >= 0);
1696 }
1697
1698 oop java_lang_reflect_Constructor::parameter_annotations(oop method) {
1699 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1700 assert(has_parameter_annotations_field(), "parameter annotations field must be present");
1701 return method->obj_field(parameter_annotations_offset);
1702 }
1703
1704 void java_lang_reflect_Constructor::set_parameter_annotations(oop method, oop value) {
1705 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1706 assert(has_parameter_annotations_field(), "parameter annotations field must be present");
1707 method->obj_field_put(parameter_annotations_offset, value);
1708 }
1709
1710 void java_lang_reflect_Field::compute_offsets() {
1711 klassOop k = SystemDictionary::reflect_field_klass();
1712 COMPUTE_OFFSET("java.lang.reflect.Field", clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature());
1713 COMPUTE_OFFSET("java.lang.reflect.Field", name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature());
1714 COMPUTE_OFFSET("java.lang.reflect.Field", type_offset, k, vmSymbols::type_name(), vmSymbols::class_signature());
1715 COMPUTE_OFFSET("java.lang.reflect.Field", slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature());
1716 COMPUTE_OFFSET("java.lang.reflect.Field", modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature());
1717 // The generic signature and annotations fields are only present in 1.5
1718 signature_offset = -1;
1719 annotations_offset = -1;
1720 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Field", signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature());
1721 COMPUTE_OPTIONAL_OFFSET("java.lang.reflect.Field", annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature());
1722 }
1723
1724 Handle java_lang_reflect_Field::create(TRAPS) {
1725 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1726 symbolHandle name = vmSymbolHandles::java_lang_reflect_Field();
1727 klassOop k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH);
1728 instanceKlassHandle klass (THREAD, k);
1729 // Ensure it is initialized
1730 klass->initialize(CHECK_NH);
1731 return klass->allocate_instance_handle(CHECK_NH);
1732 }
1733
1734 oop java_lang_reflect_Field::clazz(oop reflect) {
1735 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1736 return reflect->obj_field(clazz_offset);
1737 }
1738
1739 void java_lang_reflect_Field::set_clazz(oop reflect, oop value) {
1740 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1741 reflect->obj_field_put(clazz_offset, value);
1801 return (annotations_offset >= 0);
1802 }
1803
1804 oop java_lang_reflect_Field::annotations(oop field) {
1805 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1806 assert(has_annotations_field(), "annotations field must be present");
1807 return field->obj_field(annotations_offset);
1808 }
1809
1810 void java_lang_reflect_Field::set_annotations(oop field, oop value) {
1811 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1812 assert(has_annotations_field(), "annotations field must be present");
1813 field->obj_field_put(annotations_offset, value);
1814 }
1815
1816
1817 void sun_reflect_ConstantPool::compute_offsets() {
1818 klassOop k = SystemDictionary::reflect_constant_pool_klass();
1819 // This null test can be removed post beta
1820 if (k != NULL) {
1821 COMPUTE_OFFSET("sun.reflect.ConstantPool", _cp_oop_offset, k, vmSymbols::constantPoolOop_name(), vmSymbols::object_signature());
1822 }
1823 }
1824
1825
1826 Handle sun_reflect_ConstantPool::create(TRAPS) {
1827 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1828 klassOop k = SystemDictionary::reflect_constant_pool_klass();
1829 instanceKlassHandle klass (THREAD, k);
1830 // Ensure it is initialized
1831 klass->initialize(CHECK_NH);
1832 return klass->allocate_instance_handle(CHECK_NH);
1833 }
1834
1835
1836 oop sun_reflect_ConstantPool::cp_oop(oop reflect) {
1837 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1838 return reflect->obj_field(_cp_oop_offset);
1839 }
1840
1841
1842 void sun_reflect_ConstantPool::set_cp_oop(oop reflect, oop value) {
1843 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1844 reflect->obj_field_put(_cp_oop_offset, value);
1845 }
1846
1847 void sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets() {
1848 klassOop k = SystemDictionary::reflect_unsafe_static_field_accessor_impl_klass();
1849 // This null test can be removed post beta
1850 if (k != NULL) {
1851 COMPUTE_OFFSET("sun.reflect.UnsafeStaticFieldAccessorImpl", _base_offset, k,
1852 vmSymbols::base_name(), vmSymbols::object_signature());
1853 }
1854 }
1855
1856 oop java_lang_boxing_object::initialize_and_allocate(klassOop k, TRAPS) {
1857 instanceKlassHandle h (THREAD, k);
1858 if (!h->is_initialized()) h->initialize(CHECK_0);
1859 return h->allocate_instance(THREAD);
1860 }
1861
1862
1863 oop java_lang_boxing_object::create(BasicType type, jvalue* value, TRAPS) {
1864 oop box;
1865 switch (type) {
1866 case T_BOOLEAN:
1867 box = initialize_and_allocate(SystemDictionary::boolean_klass(), CHECK_0);
1868 box->bool_field_put(value_offset, value->z);
1869 break;
1870 case T_CHAR:
1871 box = initialize_and_allocate(SystemDictionary::char_klass(), CHECK_0);
1872 box->char_field_put(value_offset, value->c);
1873 break;
1874 case T_FLOAT:
1875 box = initialize_and_allocate(SystemDictionary::float_klass(), CHECK_0);
1876 box->float_field_put(value_offset, value->f);
1877 break;
1878 case T_DOUBLE:
1879 box = initialize_and_allocate(SystemDictionary::double_klass(), CHECK_0);
1880 box->double_field_put(value_offset, value->d);
1881 break;
1882 case T_BYTE:
1883 box = initialize_and_allocate(SystemDictionary::byte_klass(), CHECK_0);
1884 box->byte_field_put(value_offset, value->b);
1885 break;
1886 case T_SHORT:
1887 box = initialize_and_allocate(SystemDictionary::short_klass(), CHECK_0);
1888 box->short_field_put(value_offset, value->s);
1889 break;
1890 case T_INT:
1891 box = initialize_and_allocate(SystemDictionary::int_klass(), CHECK_0);
1892 box->int_field_put(value_offset, value->i);
1893 break;
1894 case T_LONG:
1895 box = initialize_and_allocate(SystemDictionary::long_klass(), CHECK_0);
1896 box->long_field_put(value_offset, value->j);
1897 break;
1898 default:
1899 return NULL;
1900 }
1901 return box;
1902 }
1903
1904
1905 BasicType java_lang_boxing_object::get_value(oop box, jvalue* value) {
1906 klassOop k = box->klass();
1907 if (k == SystemDictionary::boolean_klass()) {
1908 value->z = box->bool_field(value_offset);
1909 return T_BOOLEAN;
1910 }
1911 if (k == SystemDictionary::char_klass()) {
1912 value->c = box->char_field(value_offset);
1913 return T_CHAR;
1914 }
1915 if (k == SystemDictionary::float_klass()) {
1916 value->f = box->float_field(value_offset);
1917 return T_FLOAT;
1918 }
1919 if (k == SystemDictionary::double_klass()) {
1920 value->d = box->double_field(value_offset);
1921 return T_DOUBLE;
1922 }
1923 if (k == SystemDictionary::byte_klass()) {
1924 value->b = box->byte_field(value_offset);
1925 return T_BYTE;
1926 }
1927 if (k == SystemDictionary::short_klass()) {
1928 value->s = box->short_field(value_offset);
1929 return T_SHORT;
1930 }
1931 if (k == SystemDictionary::int_klass()) {
1932 value->i = box->int_field(value_offset);
1933 return T_INT;
1934 }
1935 if (k == SystemDictionary::long_klass()) {
1936 value->j = box->long_field(value_offset);
1937 return T_LONG;
1938 }
1939 return T_ILLEGAL;
1940 }
1941
1942
1943 BasicType java_lang_boxing_object::set_value(oop box, jvalue* value) {
1944 klassOop k = box->klass();
1945 if (k == SystemDictionary::boolean_klass()) {
1946 box->bool_field_put(value_offset, value->z);
1947 return T_BOOLEAN;
1948 }
1949 if (k == SystemDictionary::char_klass()) {
1950 box->char_field_put(value_offset, value->c);
1951 return T_CHAR;
1952 }
1953 if (k == SystemDictionary::float_klass()) {
1954 box->float_field_put(value_offset, value->f);
1955 return T_FLOAT;
1956 }
1957 if (k == SystemDictionary::double_klass()) {
1958 box->double_field_put(value_offset, value->d);
1959 return T_DOUBLE;
1960 }
1961 if (k == SystemDictionary::byte_klass()) {
1962 box->byte_field_put(value_offset, value->b);
1963 return T_BYTE;
1964 }
1965 if (k == SystemDictionary::short_klass()) {
1966 box->short_field_put(value_offset, value->s);
1967 return T_SHORT;
1968 }
1969 if (k == SystemDictionary::int_klass()) {
1970 box->int_field_put(value_offset, value->i);
1971 return T_INT;
1972 }
1973 if (k == SystemDictionary::long_klass()) {
1974 box->long_field_put(value_offset, value->j);
1975 return T_LONG;
1976 }
1977 return T_ILLEGAL;
1978 }
1979
1980
1981 // Support for java_lang_ref_Reference
1982
1983 void java_lang_ref_Reference::set_referent(oop ref, oop value) {
1984 ref->obj_field_put(referent_offset, value);
1985 }
1986
1987 oop* java_lang_ref_Reference::referent_addr(oop ref) {
1988 return ref->obj_field_addr(referent_offset);
1989 }
1990
1991 void java_lang_ref_Reference::set_next(oop ref, oop value) {
1992 ref->obj_field_put(next_offset, value);
1993 }
1994
1995 oop* java_lang_ref_Reference::next_addr(oop ref) {
1996 return ref->obj_field_addr(next_offset);
1997 }
1998
1999 void java_lang_ref_Reference::set_discovered(oop ref, oop value) {
2000 ref->obj_field_put(discovered_offset, value);
2001 }
2002
2003 oop* java_lang_ref_Reference::discovered_addr(oop ref) {
2004 return ref->obj_field_addr(discovered_offset);
2005 }
2006
2007 oop* java_lang_ref_Reference::pending_list_lock_addr() {
2008 instanceKlass* ik = instanceKlass::cast(SystemDictionary::reference_klass());
2009 return (oop*)(((char *)ik->start_of_static_fields()) + static_lock_offset);
2010 }
2011
2012 oop* java_lang_ref_Reference::pending_list_addr() {
2013 instanceKlass* ik = instanceKlass::cast(SystemDictionary::reference_klass());
2014 return (oop *)(((char *)ik->start_of_static_fields()) + static_pending_offset);
2015 }
2016
2017
2018 // Support for java_lang_ref_SoftReference
2019
2020 jlong java_lang_ref_SoftReference::timestamp(oop ref) {
2021 return ref->long_field(timestamp_offset);
2022 }
2023
2024 jlong java_lang_ref_SoftReference::clock() {
2025 instanceKlass* ik = instanceKlass::cast(SystemDictionary::soft_reference_klass());
2026 int offset = ik->offset_of_static_fields() + static_clock_offset;
2027
2028 return SystemDictionary::soft_reference_klass()->long_field(offset);
2029 }
2030
2031 void java_lang_ref_SoftReference::set_clock(jlong value) {
2032 instanceKlass* ik = instanceKlass::cast(SystemDictionary::soft_reference_klass());
2033 int offset = ik->offset_of_static_fields() + static_clock_offset;
2034
2163 int java_lang_reflect_Method::signature_offset;
2164 int java_lang_reflect_Method::annotations_offset;
2165 int java_lang_reflect_Method::parameter_annotations_offset;
2166 int java_lang_reflect_Method::annotation_default_offset;
2167 int java_lang_reflect_Constructor::clazz_offset;
2168 int java_lang_reflect_Constructor::parameterTypes_offset;
2169 int java_lang_reflect_Constructor::exceptionTypes_offset;
2170 int java_lang_reflect_Constructor::slot_offset;
2171 int java_lang_reflect_Constructor::modifiers_offset;
2172 int java_lang_reflect_Constructor::signature_offset;
2173 int java_lang_reflect_Constructor::annotations_offset;
2174 int java_lang_reflect_Constructor::parameter_annotations_offset;
2175 int java_lang_reflect_Field::clazz_offset;
2176 int java_lang_reflect_Field::name_offset;
2177 int java_lang_reflect_Field::type_offset;
2178 int java_lang_reflect_Field::slot_offset;
2179 int java_lang_reflect_Field::modifiers_offset;
2180 int java_lang_reflect_Field::signature_offset;
2181 int java_lang_reflect_Field::annotations_offset;
2182 int java_lang_boxing_object::value_offset;
2183 int java_lang_ref_Reference::referent_offset;
2184 int java_lang_ref_Reference::queue_offset;
2185 int java_lang_ref_Reference::next_offset;
2186 int java_lang_ref_Reference::discovered_offset;
2187 int java_lang_ref_Reference::static_lock_offset;
2188 int java_lang_ref_Reference::static_pending_offset;
2189 int java_lang_ref_Reference::number_of_fake_oop_fields;
2190 int java_lang_ref_SoftReference::timestamp_offset;
2191 int java_lang_ref_SoftReference::static_clock_offset;
2192 int java_lang_ClassLoader::parent_offset;
2193 int java_lang_System::offset_of_static_fields;
2194 int java_lang_System::static_in_offset;
2195 int java_lang_System::static_out_offset;
2196 int java_lang_System::static_err_offset;
2197 int java_lang_StackTraceElement::declaringClass_offset;
2198 int java_lang_StackTraceElement::methodName_offset;
2199 int java_lang_StackTraceElement::fileName_offset;
2200 int java_lang_StackTraceElement::lineNumber_offset;
2201 int java_lang_AssertionStatusDirectives::classes_offset;
2202 int java_lang_AssertionStatusDirectives::classEnabled_offset;
2243 o->obj_field_put(packages_offset, val);
2244 }
2245
2246 void java_lang_AssertionStatusDirectives::set_packageEnabled(oop o, oop val) {
2247 o->obj_field_put(packageEnabled_offset, val);
2248 }
2249
2250 void java_lang_AssertionStatusDirectives::set_deflt(oop o, bool val) {
2251 o->bool_field_put(deflt_offset, val);
2252 }
2253
2254
2255 // Support for intrinsification of java.nio.Buffer.checkIndex
2256 int java_nio_Buffer::limit_offset() {
2257 return _limit_offset;
2258 }
2259
2260
2261 void java_nio_Buffer::compute_offsets() {
2262 klassOop k = SystemDictionary::java_nio_Buffer_klass();
2263 COMPUTE_OFFSET("java.nio.Buffer", _limit_offset, k, vmSymbols::limit_name(), vmSymbols::int_signature());
2264 }
2265
2266 // Support for intrinsification of sun.misc.AtomicLongCSImpl.attemptUpdate
2267 int sun_misc_AtomicLongCSImpl::value_offset() {
2268 assert(SystemDictionary::sun_misc_AtomicLongCSImpl_klass() != NULL, "can't call this");
2269 return _value_offset;
2270 }
2271
2272
2273 void sun_misc_AtomicLongCSImpl::compute_offsets() {
2274 klassOop k = SystemDictionary::sun_misc_AtomicLongCSImpl_klass();
2275 // If this class is not present, its value field offset won't be referenced.
2276 if (k != NULL) {
2277 COMPUTE_OFFSET("sun.misc.AtomicLongCSImpl", _value_offset, k, vmSymbols::value_name(), vmSymbols::long_signature());
2278 }
2279 }
2280
2281 void java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(TRAPS) {
2282 if (_owner_offset != 0) return;
2283
2284 assert(JDK_Version::is_gte_jdk16x_version(), "Must be JDK 1.6 or later");
2285 SystemDictionary::load_abstract_ownable_synchronizer_klass(CHECK);
2286 klassOop k = SystemDictionary::abstract_ownable_synchronizer_klass();
2287 COMPUTE_OFFSET("java.util.concurrent.locks.AbstractOwnableSynchronizer", _owner_offset, k,
2288 vmSymbols::exclusive_owner_thread_name(), vmSymbols::thread_signature());
2289 }
2290
2291 oop java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(oop obj) {
2292 assert(_owner_offset != 0, "Must be initialized");
2293 return obj->obj_field(_owner_offset);
2294 }
2295
2296 // Compute hard-coded offsets
2297 // Invoked before SystemDictionary::initialize, so pre-loaded classes
2298 // are not available to determine the offset_of_static_fields.
2299 void JavaClasses::compute_hard_coded_offsets() {
2300 const int x = wordSize;
2301 const int header = instanceOopDesc::header_size_in_bytes();
2302
2303 // Do the String Class
2304 java_lang_String::value_offset = java_lang_String::hc_value_offset * x + header;
2305 java_lang_String::offset_offset = java_lang_String::hc_offset_offset * x + header;
2306 java_lang_String::count_offset = java_lang_String::offset_offset + sizeof (jint);
2307 java_lang_String::hash_offset = java_lang_String::count_offset + sizeof (jint);
2308
2309 // Do the Class Class
2310 java_lang_Class::klass_offset = java_lang_Class::hc_klass_offset * x + header;
2311 java_lang_Class::array_klass_offset = java_lang_Class::hc_array_klass_offset * x + header;
2312 java_lang_Class::resolved_constructor_offset = java_lang_Class::hc_resolved_constructor_offset * x + header;
2313
2314 // This is NOT an offset
2315 java_lang_Class::number_of_fake_oop_fields = java_lang_Class::hc_number_of_fake_oop_fields;
2316
2317 // Throwable Class
2318 java_lang_Throwable::backtrace_offset = java_lang_Throwable::hc_backtrace_offset * x + header;
2319 java_lang_Throwable::detailMessage_offset = java_lang_Throwable::hc_detailMessage_offset * x + header;
2320 java_lang_Throwable::cause_offset = java_lang_Throwable::hc_cause_offset * x + header;
2321 java_lang_Throwable::stackTrace_offset = java_lang_Throwable::hc_stackTrace_offset * x + header;
2322
2323 // java_lang_boxing_object
2324 java_lang_boxing_object::value_offset = java_lang_boxing_object::hc_value_offset * x + header;
2325
2326 // java_lang_ref_Reference:
2327 java_lang_ref_Reference::referent_offset = java_lang_ref_Reference::hc_referent_offset * x + header;
2328 java_lang_ref_Reference::queue_offset = java_lang_ref_Reference::hc_queue_offset * x + header;
2329 java_lang_ref_Reference::next_offset = java_lang_ref_Reference::hc_next_offset * x + header;
2330 java_lang_ref_Reference::discovered_offset = java_lang_ref_Reference::hc_discovered_offset * x + header;
2331 java_lang_ref_Reference::static_lock_offset = java_lang_ref_Reference::hc_static_lock_offset * x;
2332 java_lang_ref_Reference::static_pending_offset = java_lang_ref_Reference::hc_static_pending_offset * x;
2333 // Artificial fields for java_lang_ref_Reference
2334 // The first field is for the discovered field added in 1.4
2335 java_lang_ref_Reference::number_of_fake_oop_fields = 1;
2336
2337 // java_lang_ref_SoftReference Class
2338 java_lang_ref_SoftReference::timestamp_offset = java_lang_ref_SoftReference::hc_timestamp_offset * x + header;
2339 // Don't multiply static fields because they are always in wordSize units
2340 java_lang_ref_SoftReference::static_clock_offset = java_lang_ref_SoftReference::hc_static_clock_offset * x;
2341
2342 // java_lang_ClassLoader
2343 java_lang_ClassLoader::parent_offset = java_lang_ClassLoader::hc_parent_offset * x + header;
2344
2345 // java_lang_System
2346 java_lang_System::static_in_offset = java_lang_System::hc_static_in_offset * x;
2347 java_lang_System::static_out_offset = java_lang_System::hc_static_out_offset * x;
2348 java_lang_System::static_err_offset = java_lang_System::hc_static_err_offset * x;
2349
2350 // java_lang_StackTraceElement
2351 java_lang_StackTraceElement::declaringClass_offset = java_lang_StackTraceElement::hc_declaringClass_offset * x + header;
2352 java_lang_StackTraceElement::methodName_offset = java_lang_StackTraceElement::hc_methodName_offset * x + header;
2353 java_lang_StackTraceElement::fileName_offset = java_lang_StackTraceElement::hc_fileName_offset * x + header;
2354 java_lang_StackTraceElement::lineNumber_offset = java_lang_StackTraceElement::hc_lineNumber_offset * x + header;
2355 java_lang_AssertionStatusDirectives::classes_offset = java_lang_AssertionStatusDirectives::hc_classes_offset * x + header;
2356 java_lang_AssertionStatusDirectives::classEnabled_offset = java_lang_AssertionStatusDirectives::hc_classEnabled_offset * x + header;
2357 java_lang_AssertionStatusDirectives::packages_offset = java_lang_AssertionStatusDirectives::hc_packages_offset * x + header;
2358 java_lang_AssertionStatusDirectives::packageEnabled_offset = java_lang_AssertionStatusDirectives::hc_packageEnabled_offset * x + header;
2427 instanceKlassHandle h_klass (THREAD, k);
2428 symbolHandle f_name = oopFactory::new_symbol_handle(field_name, CATCH);
2429 symbolHandle f_sig = oopFactory::new_symbol_handle(field_sig, CATCH);
2430 if (!h_klass->find_local_field(f_name(), f_sig(), &fd)) {
2431 tty->print_cr("Static field %s.%s not found", klass_name, field_name);
2432 return false;
2433 }
2434 if (!fd.is_static()) {
2435 tty->print_cr("Static field %s.%s appears to be nonstatic", klass_name, field_name);
2436 return false;
2437 }
2438 if (fd.offset() == hardcoded_offset + h_klass->offset_of_static_fields()) {
2439 return true;
2440 } else {
2441 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());
2442 return false;
2443 }
2444 }
2445
2446
2447 // Check the hard-coded field offsets of all the classes in this file
2448
2449 void JavaClasses::check_offsets() {
2450 bool valid = true;
2451
2452 #define CHECK_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \
2453 valid &= check_offset(klass_name, cpp_klass_name :: field_name ## _offset, #field_name, field_sig)
2454
2455 #define CHECK_STATIC_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \
2456 valid &= check_static_offset(klass_name, cpp_klass_name :: static_ ## field_name ## _offset, #field_name, field_sig)
2457
2458 // java.lang.String
2459
2460 CHECK_OFFSET("java/lang/String", java_lang_String, value, "[C");
2461 CHECK_OFFSET("java/lang/String", java_lang_String, offset, "I");
2462 CHECK_OFFSET("java/lang/String", java_lang_String, count, "I");
2463 CHECK_OFFSET("java/lang/String", java_lang_String, hash, "I");
2464
2465 // java.lang.Class
2466
2467 // Fake fields
2468 // CHECK_OFFSET("java/lang/Class", java_lang_Class, klass); // %%% this needs to be checked
2469 // CHECK_OFFSET("java/lang/Class", java_lang_Class, array_klass); // %%% this needs to be checked
2470 // CHECK_OFFSET("java/lang/Class", java_lang_Class, resolved_constructor); // %%% this needs to be checked
2471
2472 // java.lang.Throwable
2473
2474 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, backtrace, "Ljava/lang/Object;");
2475 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, detailMessage, "Ljava/lang/String;");
2476 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, cause, "Ljava/lang/Throwable;");
2477 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, stackTrace, "[Ljava/lang/StackTraceElement;");
2478
2479 // Boxed primitive objects (java_lang_boxing_object)
2480
2481 CHECK_OFFSET("java/lang/Boolean", java_lang_boxing_object, value, "Z");
2482 CHECK_OFFSET("java/lang/Character", java_lang_boxing_object, value, "C");
2483 CHECK_OFFSET("java/lang/Float", java_lang_boxing_object, value, "F");
2484 CHECK_OFFSET("java/lang/Double", java_lang_boxing_object, value, "D");
2485 CHECK_OFFSET("java/lang/Byte", java_lang_boxing_object, value, "B");
2486 CHECK_OFFSET("java/lang/Short", java_lang_boxing_object, value, "S");
2487 CHECK_OFFSET("java/lang/Integer", java_lang_boxing_object, value, "I");
2488 CHECK_OFFSET("java/lang/Long", java_lang_boxing_object, value, "J");
2489
2490 // java.lang.ClassLoader
2491
2492 CHECK_OFFSET("java/lang/ClassLoader", java_lang_ClassLoader, parent, "Ljava/lang/ClassLoader;");
2493
2494 // java.lang.System
2495
2496 CHECK_STATIC_OFFSET("java/lang/System", java_lang_System, in, "Ljava/io/InputStream;");
2497 CHECK_STATIC_OFFSET("java/lang/System", java_lang_System, out, "Ljava/io/PrintStream;");
2498 CHECK_STATIC_OFFSET("java/lang/System", java_lang_System, err, "Ljava/io/PrintStream;");
2499
2500 // java.lang.StackTraceElement
2501
2502 CHECK_OFFSET("java/lang/StackTraceElement", java_lang_StackTraceElement, declaringClass, "Ljava/lang/String;");
2503 CHECK_OFFSET("java/lang/StackTraceElement", java_lang_StackTraceElement, methodName, "Ljava/lang/String;");
2504 CHECK_OFFSET("java/lang/StackTraceElement", java_lang_StackTraceElement, fileName, "Ljava/lang/String;");
2505 CHECK_OFFSET("java/lang/StackTraceElement", java_lang_StackTraceElement, lineNumber, "I");
2506
2507 // java.lang.ref.Reference
2508
|
1 #ifdef USE_PRAGMA_IDENT_SRC
2 #pragma ident "@(#)javaClasses.cpp 1.250 08/01/17 09:41:13 JVM"
3 #endif
4 /*
5 * Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
6 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
7 *
8 * This code is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License version 2 only, as
10 * published by the Free Software Foundation.
11 *
12 * This code is distributed in the hope that it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 * version 2 for more details (a copy is included in the LICENSE file that
16 * accompanied this code).
17 *
18 * You should have received a copy of the GNU General Public License version
19 * 2 along with this work; if not, write to the Free Software Foundation,
20 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
21 *
22 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
23 * CA 95054 USA or visit www.sun.com if you need additional information or
24 * have any questions.
25 *
26 */
27
28 # include "incls/_precompiled.incl"
29 # include "incls/_javaClasses.cpp.incl"
30
31 // Helpful routine for computing field offsets at run time rather than hardcoding them
32 static void
33 compute_offset(int &dest_offset,
34 klassOop klass_oop, symbolOop name_symbol, symbolOop signature_symbol) {
35 fieldDescriptor fd;
36 instanceKlass* ik = instanceKlass::cast(klass_oop);
37 if (!ik->find_local_field(name_symbol, signature_symbol, &fd)) {
38 ResourceMark rm;
39 tty->print_cr("Invalid layout of %s at %s", ik->external_name(), name_symbol->as_C_string());
40 fatal("Invalid layout of preloaded class");
41 }
42 dest_offset = fd.offset();
43 }
44
45 // Same as above but for "optional" offsets that might not be present in certain JDK versions
46 static void
47 compute_optional_offset(int& dest_offset,
48 klassOop klass_oop, symbolOop name_symbol, symbolOop signature_symbol) {
49 fieldDescriptor fd;
50 instanceKlass* ik = instanceKlass::cast(klass_oop);
51 if (ik->find_local_field(name_symbol, signature_symbol, &fd)) {
52 dest_offset = fd.offset();
53 }
54 }
55
56 Handle java_lang_String::basic_create(int length, bool tenured, TRAPS) {
57 // Create the String object first, so there's a chance that the String
58 // and the char array it points to end up in the same cache line.
59 oop obj;
60 if (tenured) {
61 obj = instanceKlass::cast(SystemDictionary::string_klass())->allocate_permanent_instance(CHECK_NH);
62 } else {
63 obj = instanceKlass::cast(SystemDictionary::string_klass())->allocate_instance(CHECK_NH);
64 }
65
66 // Create the char array. The String object must be handlized here
67 // because GC can happen as a result of the allocation attempt.
68 Handle h_obj(THREAD, obj);
69 typeArrayOop buffer;
70 if (tenured) {
71 buffer = oopFactory::new_permanent_charArray(length, CHECK_NH);
72 } else {
73 buffer = oopFactory::new_charArray(length, CHECK_NH);
435 }
436
437
438 oop java_lang_Class::primitive_mirror(BasicType t) {
439 oop mirror = Universe::java_mirror(t);
440 assert(mirror != NULL && mirror->is_a(SystemDictionary::class_klass()), "must be a Class");
441 assert(java_lang_Class::is_primitive(mirror), "must be primitive");
442 return mirror;
443 }
444
445 bool java_lang_Class::offsets_computed = false;
446 int java_lang_Class::classRedefinedCount_offset = -1;
447
448 void java_lang_Class::compute_offsets() {
449 assert(!offsets_computed, "offsets should be initialized only once");
450 offsets_computed = true;
451
452 klassOop k = SystemDictionary::class_klass();
453 // The classRedefinedCount field is only present starting in 1.5,
454 // so don't go fatal.
455 compute_optional_offset(classRedefinedCount_offset,
456 k, vmSymbols::classRedefinedCount_name(), vmSymbols::int_signature());
457 }
458
459 int java_lang_Class::classRedefinedCount(oop the_class_mirror) {
460 if (!JDK_Version::is_gte_jdk15x_version()
461 || classRedefinedCount_offset == -1) {
462 // The classRedefinedCount field is only present starting in 1.5.
463 // If we don't have an offset for it then just return -1 as a marker.
464 return -1;
465 }
466
467 return the_class_mirror->int_field(classRedefinedCount_offset);
468 }
469
470 void java_lang_Class::set_classRedefinedCount(oop the_class_mirror, int value) {
471 if (!JDK_Version::is_gte_jdk15x_version()
472 || classRedefinedCount_offset == -1) {
473 // The classRedefinedCount field is only present starting in 1.5.
474 // If we don't have an offset for it then nothing to set.
475 return;
489
490 int java_lang_Thread::_name_offset = 0;
491 int java_lang_Thread::_group_offset = 0;
492 int java_lang_Thread::_contextClassLoader_offset = 0;
493 int java_lang_Thread::_inheritedAccessControlContext_offset = 0;
494 int java_lang_Thread::_priority_offset = 0;
495 int java_lang_Thread::_eetop_offset = 0;
496 int java_lang_Thread::_daemon_offset = 0;
497 int java_lang_Thread::_stillborn_offset = 0;
498 int java_lang_Thread::_stackSize_offset = 0;
499 int java_lang_Thread::_tid_offset = 0;
500 int java_lang_Thread::_thread_status_offset = 0;
501 int java_lang_Thread::_park_blocker_offset = 0;
502 int java_lang_Thread::_park_event_offset = 0 ;
503
504
505 void java_lang_Thread::compute_offsets() {
506 assert(_group_offset == 0, "offsets should be initialized only once");
507
508 klassOop k = SystemDictionary::thread_klass();
509 compute_offset(_name_offset, k, vmSymbols::name_name(), vmSymbols::char_array_signature());
510 compute_offset(_group_offset, k, vmSymbols::group_name(), vmSymbols::threadgroup_signature());
511 compute_offset(_contextClassLoader_offset, k, vmSymbols::contextClassLoader_name(), vmSymbols::classloader_signature());
512 compute_offset(_inheritedAccessControlContext_offset, k, vmSymbols::inheritedAccessControlContext_name(), vmSymbols::accesscontrolcontext_signature());
513 compute_offset(_priority_offset, k, vmSymbols::priority_name(), vmSymbols::int_signature());
514 compute_offset(_daemon_offset, k, vmSymbols::daemon_name(), vmSymbols::bool_signature());
515 compute_offset(_eetop_offset, k, vmSymbols::eetop_name(), vmSymbols::long_signature());
516 compute_offset(_stillborn_offset, k, vmSymbols::stillborn_name(), vmSymbols::bool_signature());
517 // The stackSize field is only present starting in 1.4, so don't go fatal.
518 compute_optional_offset(_stackSize_offset, k, vmSymbols::stackSize_name(), vmSymbols::long_signature());
519 // The tid and thread_status fields are only present starting in 1.5, so don't go fatal.
520 compute_optional_offset(_tid_offset, k, vmSymbols::thread_id_name(), vmSymbols::long_signature());
521 compute_optional_offset(_thread_status_offset, k, vmSymbols::thread_status_name(), vmSymbols::int_signature());
522 // The parkBlocker field is only present starting in 1.6, so don't go fatal.
523 compute_optional_offset(_park_blocker_offset, k, vmSymbols::park_blocker_name(), vmSymbols::object_signature());
524 compute_optional_offset(_park_event_offset, k, vmSymbols::park_event_name(),
525 vmSymbols::long_signature());
526 }
527
528
529 JavaThread* java_lang_Thread::thread(oop java_thread) {
530 return (JavaThread*)java_thread->address_field(_eetop_offset);
531 }
532
533
534 void java_lang_Thread::set_thread(oop java_thread, JavaThread* thread) {
535 java_thread->address_field_put(_eetop_offset, (address)thread);
536 }
537
538
539 typeArrayOop java_lang_Thread::name(oop java_thread) {
540 oop name = java_thread->obj_field(_name_offset);
541 assert(name == NULL || (name->is_typeArray() && typeArrayKlass::cast(name->klass())->element_type() == T_CHAR), "just checking");
542 return typeArrayOop(name);
543 }
544
545
546 void java_lang_Thread::set_name(oop java_thread, typeArrayOop name) {
547 assert(java_thread->obj_field(_name_offset) == NULL, "name should be NULL");
548 java_thread->obj_field_put(_name_offset, name);
549 }
550
551
552 ThreadPriority java_lang_Thread::priority(oop java_thread) {
553 return (ThreadPriority)java_thread->int_field(_priority_offset);
554 }
555
635 JavaThread* thr = java_lang_Thread::thread(java_thread);
636 if (thr == NULL) {
637 // the thread hasn't run yet or is in the process of exiting
638 return NEW;
639 }
640 return (java_lang_Thread::ThreadStatus)JVMTI_THREAD_STATE_ALIVE;
641 }
642 }
643
644
645 jlong java_lang_Thread::thread_id(oop java_thread) {
646 // The thread ID field is only present starting in 1.5
647 if (_tid_offset > 0) {
648 return java_thread->long_field(_tid_offset);
649 } else {
650 return 0;
651 }
652 }
653
654 oop java_lang_Thread::park_blocker(oop java_thread) {
655 assert(JDK_Version::current().supports_thread_park_blocker() &&
656 _park_blocker_offset != 0, "Must support parkBlocker field");
657
658 if (_park_blocker_offset > 0) {
659 return java_thread->obj_field(_park_blocker_offset);
660 }
661
662 return NULL;
663 }
664
665 jlong java_lang_Thread::park_event(oop java_thread) {
666 if (_park_event_offset > 0) {
667 return java_thread->long_field(_park_event_offset);
668 }
669 return 0;
670 }
671
672 bool java_lang_Thread::set_park_event(oop java_thread, jlong ptr) {
673 if (_park_event_offset > 0) {
674 java_thread->long_field_put(_park_event_offset, ptr);
675 return true;
676 }
749 bool java_lang_ThreadGroup::is_destroyed(oop java_thread_group) {
750 assert(java_thread_group->is_oop(), "thread group must be oop");
751 return java_thread_group->bool_field(_destroyed_offset) != 0;
752 }
753
754 bool java_lang_ThreadGroup::is_daemon(oop java_thread_group) {
755 assert(java_thread_group->is_oop(), "thread group must be oop");
756 return java_thread_group->bool_field(_daemon_offset) != 0;
757 }
758
759 bool java_lang_ThreadGroup::is_vmAllowSuspension(oop java_thread_group) {
760 assert(java_thread_group->is_oop(), "thread group must be oop");
761 return java_thread_group->bool_field(_vmAllowSuspension_offset) != 0;
762 }
763
764 void java_lang_ThreadGroup::compute_offsets() {
765 assert(_parent_offset == 0, "offsets should be initialized only once");
766
767 klassOop k = SystemDictionary::threadGroup_klass();
768
769 compute_offset(_parent_offset, k, vmSymbols::parent_name(), vmSymbols::threadgroup_signature());
770 compute_offset(_name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature());
771 compute_offset(_threads_offset, k, vmSymbols::threads_name(), vmSymbols::thread_array_signature());
772 compute_offset(_groups_offset, k, vmSymbols::groups_name(), vmSymbols::threadgroup_array_signature());
773 compute_offset(_maxPriority_offset, k, vmSymbols::maxPriority_name(), vmSymbols::int_signature());
774 compute_offset(_destroyed_offset, k, vmSymbols::destroyed_name(), vmSymbols::bool_signature());
775 compute_offset(_daemon_offset, k, vmSymbols::daemon_name(), vmSymbols::bool_signature());
776 compute_offset(_vmAllowSuspension_offset, k, vmSymbols::vmAllowSuspension_name(), vmSymbols::bool_signature());
777 compute_offset(_nthreads_offset, k, vmSymbols::nthreads_name(), vmSymbols::int_signature());
778 compute_offset(_ngroups_offset, k, vmSymbols::ngroups_name(), vmSymbols::int_signature());
779 }
780
781 oop java_lang_Throwable::backtrace(oop throwable) {
782 return throwable->obj_field_acquire(backtrace_offset);
783 }
784
785
786 void java_lang_Throwable::set_backtrace(oop throwable, oop value) {
787 throwable->release_obj_field_put(backtrace_offset, value);
788 }
789
790
791 oop java_lang_Throwable::message(oop throwable) {
792 return throwable->obj_field(detailMessage_offset);
793 }
794
795
796 oop java_lang_Throwable::message(Handle throwable) {
797 return throwable->obj_field(detailMessage_offset);
798 }
1001 methodOop method = methodOop(methods()->obj_at(index));
1002 if (method == NULL) return;
1003 int bci = bcis->ushort_at(index);
1004 print_stack_element(stream, method, bci);
1005 }
1006 result = objArrayHandle(thread, objArrayOop(result->obj_at(trace_next_offset)));
1007 }
1008 }
1009
1010 // This class provides a simple wrapper over the internal structure of
1011 // exception backtrace to insulate users of the backtrace from needing
1012 // to know what it looks like.
1013 class BacktraceBuilder: public StackObj {
1014 private:
1015 Handle _backtrace;
1016 objArrayOop _head;
1017 objArrayOop _methods;
1018 typeArrayOop _bcis;
1019 int _index;
1020 bool _dirty;
1021 No_Safepoint_Verifier _nsv;
1022
1023 public:
1024
1025 enum {
1026 trace_methods_offset = java_lang_Throwable::trace_methods_offset,
1027 trace_bcis_offset = java_lang_Throwable::trace_bcis_offset,
1028 trace_next_offset = java_lang_Throwable::trace_next_offset,
1029 trace_size = java_lang_Throwable::trace_size,
1030 trace_chunk_size = java_lang_Throwable::trace_chunk_size
1031 };
1032
1033 // constructor for new backtrace
1034 BacktraceBuilder(TRAPS): _methods(NULL), _bcis(NULL), _head(NULL), _dirty(false) {
1035 expand(CHECK);
1036 _backtrace = _head;
1037 _index = 0;
1038 }
1039
1040 void flush() {
1041 if (_dirty && _methods != NULL) {
1042 BarrierSet* bs = Universe::heap()->barrier_set();
1043 assert(bs->has_write_ref_array_opt(), "Barrier set must have ref array opt");
1044 bs->write_ref_array(MemRegion((HeapWord*)_methods->base(),
1045 _methods->array_size()));
1046 _dirty = false;
1047 }
1048 }
1049
1050 void expand(TRAPS) {
1051 flush();
1052
1053 objArrayHandle old_head(THREAD, _head);
1054 Pause_No_Safepoint_Verifier pnsv(&_nsv);
1055
1056 objArrayOop head = oopFactory::new_objectArray(trace_size, CHECK);
1057 objArrayHandle new_head(THREAD, head);
1058
1059 objArrayOop methods = oopFactory::new_objectArray(trace_chunk_size, CHECK);
1060 objArrayHandle new_methods(THREAD, methods);
1061
1062 typeArrayOop bcis = oopFactory::new_shortArray(trace_chunk_size, CHECK);
1063 typeArrayHandle new_bcis(THREAD, bcis);
1064
1065 if (!old_head.is_null()) {
1069 new_head->obj_at_put(trace_bcis_offset, new_bcis());
1070
1071 _head = new_head();
1072 _methods = new_methods();
1073 _bcis = new_bcis();
1074 _index = 0;
1075 }
1076
1077 oop backtrace() {
1078 flush();
1079 return _backtrace();
1080 }
1081
1082 inline void push(methodOop method, short bci, TRAPS) {
1083 if (_index >= trace_chunk_size) {
1084 methodHandle mhandle(THREAD, method);
1085 expand(CHECK);
1086 method = mhandle();
1087 }
1088
1089 _methods->obj_at_put(_index, method);
1090 // bad for UseCompressedOops
1091 // *_methods->obj_at_addr(_index) = method;
1092 _bcis->ushort_at_put(_index, bci);
1093 _index++;
1094 _dirty = true;
1095 }
1096
1097 methodOop current_method() {
1098 assert(_index >= 0 && _index < trace_chunk_size, "out of range");
1099 return methodOop(_methods->obj_at(_index));
1100 }
1101
1102 jushort current_bci() {
1103 assert(_index >= 0 && _index < trace_chunk_size, "out of range");
1104 return _bcis->ushort_at(_index);
1105 }
1106 };
1107
1108
1109 void java_lang_Throwable::fill_in_stack_trace(Handle throwable, TRAPS) {
1110 if (!StackTraceInThrowable) return;
1111 ResourceMark rm(THREAD);
1351 objArrayOop methods = objArrayOop(chunk->obj_at(trace_methods_offset));
1352 typeArrayOop bcis = typeArrayOop(chunk->obj_at(trace_bcis_offset));
1353 assert(methods != NULL && bcis != NULL, "sanity check");
1354 methodHandle method(THREAD, methodOop(methods->obj_at(chunk_index)));
1355 int bci = bcis->ushort_at(chunk_index);
1356 // Chunk can be partial full
1357 if (method.is_null()) {
1358 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
1359 }
1360
1361 oop element = java_lang_StackTraceElement::create(method, bci, CHECK_0);
1362 return element;
1363 }
1364
1365 oop java_lang_StackTraceElement::create(methodHandle method, int bci, TRAPS) {
1366 // SystemDictionary::stackTraceElement_klass() will be null for pre-1.4 JDKs
1367 assert(JDK_Version::is_gte_jdk14x_version(), "should only be called in >= 1.4");
1368
1369 // Allocate java.lang.StackTraceElement instance
1370 klassOop k = SystemDictionary::stackTraceElement_klass();
1371 assert(k != NULL, "must be loaded in 1.4+");
1372 instanceKlassHandle ik (THREAD, k);
1373 if (ik->should_be_initialized()) {
1374 ik->initialize(CHECK_0);
1375 }
1376
1377 Handle element = ik->allocate_instance_handle(CHECK_0);
1378 // Fill in class name
1379 ResourceMark rm(THREAD);
1380 const char* str = instanceKlass::cast(method->method_holder())->external_name();
1381 oop classname = StringTable::intern((char*) str, CHECK_0);
1382 java_lang_StackTraceElement::set_declaringClass(element(), classname);
1383 // Fill in method name
1384 oop methodname = StringTable::intern(method->name(), CHECK_0);
1385 java_lang_StackTraceElement::set_methodName(element(), methodname);
1386 // Fill in source file name
1387 symbolOop source = instanceKlass::cast(method->method_holder())->source_file_name();
1388 oop filename = StringTable::intern(source, CHECK_0);
1389 java_lang_StackTraceElement::set_fileName(element(), filename);
1390 // File in source line number
1391 int line_number;
1392 if (method->is_native()) {
1393 // Negative value different from -1 below, enabling Java code in
1394 // class java.lang.StackTraceElement to distinguish "native" from
1395 // "no LineNumberTable".
1396 line_number = -2;
1397 } else {
1398 // Returns -1 if no LineNumberTable, and otherwise actual line number
1399 line_number = method->line_number_from_bci(bci);
1400 }
1401 java_lang_StackTraceElement::set_lineNumber(element(), line_number);
1402
1403 return element();
1404 }
1405
1406
1407 void java_lang_reflect_AccessibleObject::compute_offsets() {
1408 klassOop k = SystemDictionary::reflect_accessible_object_klass();
1409 compute_offset(override_offset, k, vmSymbols::override_name(), vmSymbols::bool_signature());
1410 }
1411
1412 jboolean java_lang_reflect_AccessibleObject::override(oop reflect) {
1413 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1414 return (jboolean) reflect->bool_field(override_offset);
1415 }
1416
1417 void java_lang_reflect_AccessibleObject::set_override(oop reflect, jboolean value) {
1418 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1419 reflect->bool_field_put(override_offset, (int) value);
1420 }
1421
1422 void java_lang_reflect_Method::compute_offsets() {
1423 klassOop k = SystemDictionary::reflect_method_klass();
1424 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature());
1425 compute_offset(name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature());
1426 compute_offset(returnType_offset, k, vmSymbols::returnType_name(), vmSymbols::class_signature());
1427 compute_offset(parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature());
1428 compute_offset(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature());
1429 compute_offset(slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature());
1430 compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature());
1431 // The generic signature and annotations fields are only present in 1.5
1432 signature_offset = -1;
1433 annotations_offset = -1;
1434 parameter_annotations_offset = -1;
1435 annotation_default_offset = -1;
1436 compute_optional_offset(signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature());
1437 compute_optional_offset(annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature());
1438 compute_optional_offset(parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), vmSymbols::byte_array_signature());
1439 compute_optional_offset(annotation_default_offset, k, vmSymbols::annotation_default_name(), vmSymbols::byte_array_signature());
1440 }
1441
1442 Handle java_lang_reflect_Method::create(TRAPS) {
1443 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1444 klassOop klass = SystemDictionary::reflect_method_klass();
1445 // This class is eagerly initialized during VM initialization, since we keep a refence
1446 // to one of the methods
1447 assert(instanceKlass::cast(klass)->is_initialized(), "must be initialized");
1448 return instanceKlass::cast(klass)->allocate_instance_handle(CHECK_NH);
1449 }
1450
1451 oop java_lang_reflect_Method::clazz(oop reflect) {
1452 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1453 return reflect->obj_field(clazz_offset);
1454 }
1455
1456 void java_lang_reflect_Method::set_clazz(oop reflect, oop value) {
1457 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1458 reflect->obj_field_put(clazz_offset, value);
1459 }
1567 }
1568
1569 bool java_lang_reflect_Method::has_annotation_default_field() {
1570 return (annotation_default_offset >= 0);
1571 }
1572
1573 oop java_lang_reflect_Method::annotation_default(oop method) {
1574 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1575 assert(has_annotation_default_field(), "annotation default field must be present");
1576 return method->obj_field(annotation_default_offset);
1577 }
1578
1579 void java_lang_reflect_Method::set_annotation_default(oop method, oop value) {
1580 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1581 assert(has_annotation_default_field(), "annotation default field must be present");
1582 method->obj_field_put(annotation_default_offset, value);
1583 }
1584
1585 void java_lang_reflect_Constructor::compute_offsets() {
1586 klassOop k = SystemDictionary::reflect_constructor_klass();
1587 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature());
1588 compute_offset(parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature());
1589 compute_offset(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature());
1590 compute_offset(slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature());
1591 compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature());
1592 // The generic signature and annotations fields are only present in 1.5
1593 signature_offset = -1;
1594 annotations_offset = -1;
1595 parameter_annotations_offset = -1;
1596 compute_optional_offset(signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature());
1597 compute_optional_offset(annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature());
1598 compute_optional_offset(parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), vmSymbols::byte_array_signature());
1599 }
1600
1601 Handle java_lang_reflect_Constructor::create(TRAPS) {
1602 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1603 symbolHandle name = vmSymbolHandles::java_lang_reflect_Constructor();
1604 klassOop k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH);
1605 instanceKlassHandle klass (THREAD, k);
1606 // Ensure it is initialized
1607 klass->initialize(CHECK_NH);
1608 return klass->allocate_instance_handle(CHECK_NH);
1609 }
1610
1611 oop java_lang_reflect_Constructor::clazz(oop reflect) {
1612 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1613 return reflect->obj_field(clazz_offset);
1614 }
1615
1616 void java_lang_reflect_Constructor::set_clazz(oop reflect, oop value) {
1617 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1618 reflect->obj_field_put(clazz_offset, value);
1691 }
1692
1693 bool java_lang_reflect_Constructor::has_parameter_annotations_field() {
1694 return (parameter_annotations_offset >= 0);
1695 }
1696
1697 oop java_lang_reflect_Constructor::parameter_annotations(oop method) {
1698 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1699 assert(has_parameter_annotations_field(), "parameter annotations field must be present");
1700 return method->obj_field(parameter_annotations_offset);
1701 }
1702
1703 void java_lang_reflect_Constructor::set_parameter_annotations(oop method, oop value) {
1704 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1705 assert(has_parameter_annotations_field(), "parameter annotations field must be present");
1706 method->obj_field_put(parameter_annotations_offset, value);
1707 }
1708
1709 void java_lang_reflect_Field::compute_offsets() {
1710 klassOop k = SystemDictionary::reflect_field_klass();
1711 compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature());
1712 compute_offset(name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature());
1713 compute_offset(type_offset, k, vmSymbols::type_name(), vmSymbols::class_signature());
1714 compute_offset(slot_offset, k, vmSymbols::slot_name(), vmSymbols::int_signature());
1715 compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature());
1716 // The generic signature and annotations fields are only present in 1.5
1717 signature_offset = -1;
1718 annotations_offset = -1;
1719 compute_optional_offset(signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature());
1720 compute_optional_offset(annotations_offset, k, vmSymbols::annotations_name(), vmSymbols::byte_array_signature());
1721 }
1722
1723 Handle java_lang_reflect_Field::create(TRAPS) {
1724 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1725 symbolHandle name = vmSymbolHandles::java_lang_reflect_Field();
1726 klassOop k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH);
1727 instanceKlassHandle klass (THREAD, k);
1728 // Ensure it is initialized
1729 klass->initialize(CHECK_NH);
1730 return klass->allocate_instance_handle(CHECK_NH);
1731 }
1732
1733 oop java_lang_reflect_Field::clazz(oop reflect) {
1734 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1735 return reflect->obj_field(clazz_offset);
1736 }
1737
1738 void java_lang_reflect_Field::set_clazz(oop reflect, oop value) {
1739 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1740 reflect->obj_field_put(clazz_offset, value);
1800 return (annotations_offset >= 0);
1801 }
1802
1803 oop java_lang_reflect_Field::annotations(oop field) {
1804 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1805 assert(has_annotations_field(), "annotations field must be present");
1806 return field->obj_field(annotations_offset);
1807 }
1808
1809 void java_lang_reflect_Field::set_annotations(oop field, oop value) {
1810 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1811 assert(has_annotations_field(), "annotations field must be present");
1812 field->obj_field_put(annotations_offset, value);
1813 }
1814
1815
1816 void sun_reflect_ConstantPool::compute_offsets() {
1817 klassOop k = SystemDictionary::reflect_constant_pool_klass();
1818 // This null test can be removed post beta
1819 if (k != NULL) {
1820 compute_offset(_cp_oop_offset, k, vmSymbols::constantPoolOop_name(), vmSymbols::object_signature());
1821 }
1822 }
1823
1824
1825 Handle sun_reflect_ConstantPool::create(TRAPS) {
1826 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1827 klassOop k = SystemDictionary::reflect_constant_pool_klass();
1828 instanceKlassHandle klass (THREAD, k);
1829 // Ensure it is initialized
1830 klass->initialize(CHECK_NH);
1831 return klass->allocate_instance_handle(CHECK_NH);
1832 }
1833
1834
1835 oop sun_reflect_ConstantPool::cp_oop(oop reflect) {
1836 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1837 return reflect->obj_field(_cp_oop_offset);
1838 }
1839
1840
1841 void sun_reflect_ConstantPool::set_cp_oop(oop reflect, oop value) {
1842 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1843 reflect->obj_field_put(_cp_oop_offset, value);
1844 }
1845
1846 void sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets() {
1847 klassOop k = SystemDictionary::reflect_unsafe_static_field_accessor_impl_klass();
1848 // This null test can be removed post beta
1849 if (k != NULL) {
1850 compute_offset(_base_offset, k,
1851 vmSymbols::base_name(), vmSymbols::object_signature());
1852 }
1853 }
1854
1855 oop java_lang_boxing_object::initialize_and_allocate(BasicType type, TRAPS) {
1856 klassOop k = SystemDictionary::box_klass(type);
1857 if (k == NULL) return NULL;
1858 instanceKlassHandle h (THREAD, k);
1859 if (!h->is_initialized()) h->initialize(CHECK_0);
1860 return h->allocate_instance(THREAD);
1861 }
1862
1863
1864 oop java_lang_boxing_object::create(BasicType type, jvalue* value, TRAPS) {
1865 oop box = initialize_and_allocate(type, CHECK_0);
1866 if (box == NULL) return NULL;
1867 switch (type) {
1868 case T_BOOLEAN:
1869 box->bool_field_put(value_offset, value->z);
1870 break;
1871 case T_CHAR:
1872 box->char_field_put(value_offset, value->c);
1873 break;
1874 case T_FLOAT:
1875 box->float_field_put(value_offset, value->f);
1876 break;
1877 case T_DOUBLE:
1878 box->double_field_put(long_value_offset, value->d);
1879 break;
1880 case T_BYTE:
1881 box->byte_field_put(value_offset, value->b);
1882 break;
1883 case T_SHORT:
1884 box->short_field_put(value_offset, value->s);
1885 break;
1886 case T_INT:
1887 box->int_field_put(value_offset, value->i);
1888 break;
1889 case T_LONG:
1890 box->long_field_put(long_value_offset, value->j);
1891 break;
1892 default:
1893 return NULL;
1894 }
1895 return box;
1896 }
1897
1898
1899 BasicType java_lang_boxing_object::basic_type(oop box) {
1900 if (box == NULL) return T_ILLEGAL;
1901 BasicType type = SystemDictionary::box_klass_type(box->klass());
1902 if (type == T_OBJECT) // 'unknown' value returned by SD::bkt
1903 return T_ILLEGAL;
1904 return type;
1905 }
1906
1907
1908 BasicType java_lang_boxing_object::get_value(oop box, jvalue* value) {
1909 BasicType type = SystemDictionary::box_klass_type(box->klass());
1910 switch (type) {
1911 case T_BOOLEAN:
1912 value->z = box->bool_field(value_offset);
1913 break;
1914 case T_CHAR:
1915 value->c = box->char_field(value_offset);
1916 break;
1917 case T_FLOAT:
1918 value->f = box->float_field(value_offset);
1919 break;
1920 case T_DOUBLE:
1921 value->d = box->double_field(long_value_offset);
1922 break;
1923 case T_BYTE:
1924 value->b = box->byte_field(value_offset);
1925 break;
1926 case T_SHORT:
1927 value->s = box->short_field(value_offset);
1928 break;
1929 case T_INT:
1930 value->i = box->int_field(value_offset);
1931 break;
1932 case T_LONG:
1933 value->j = box->long_field(long_value_offset);
1934 break;
1935 default:
1936 return T_ILLEGAL;
1937 } // end switch
1938 return type;
1939 }
1940
1941
1942 BasicType java_lang_boxing_object::set_value(oop box, jvalue* value) {
1943 BasicType type = SystemDictionary::box_klass_type(box->klass());
1944 switch (type) {
1945 case T_BOOLEAN:
1946 box->bool_field_put(value_offset, value->z);
1947 break;
1948 case T_CHAR:
1949 box->char_field_put(value_offset, value->c);
1950 break;
1951 case T_FLOAT:
1952 box->float_field_put(value_offset, value->f);
1953 break;
1954 case T_DOUBLE:
1955 box->double_field_put(long_value_offset, value->d);
1956 break;
1957 case T_BYTE:
1958 box->byte_field_put(value_offset, value->b);
1959 break;
1960 case T_SHORT:
1961 box->short_field_put(value_offset, value->s);
1962 break;
1963 case T_INT:
1964 box->int_field_put(value_offset, value->i);
1965 break;
1966 case T_LONG:
1967 box->long_field_put(long_value_offset, value->j);
1968 break;
1969 default:
1970 return T_ILLEGAL;
1971 } // end switch
1972 return type;
1973 }
1974
1975
1976 // Support for java_lang_ref_Reference
1977 oop java_lang_ref_Reference::pending_list_lock() {
1978 instanceKlass* ik = instanceKlass::cast(SystemDictionary::reference_klass());
1979 char *addr = (((char *)ik->start_of_static_fields()) + static_lock_offset);
1980 if (UseCompressedOops) {
1981 return oopDesc::load_decode_heap_oop((narrowOop *)addr);
1982 } else {
1983 return oopDesc::load_decode_heap_oop((oop*)addr);
1984 }
1985 }
1986
1987 HeapWord *java_lang_ref_Reference::pending_list_addr() {
1988 instanceKlass* ik = instanceKlass::cast(SystemDictionary::reference_klass());
1989 char *addr = (((char *)ik->start_of_static_fields()) + static_pending_offset);
1990 // XXX This might not be HeapWord aligned, almost rather be char *.
1991 return (HeapWord*)addr;
1992 }
1993
1994 oop java_lang_ref_Reference::pending_list() {
1995 char *addr = (char *)pending_list_addr();
1996 if (UseCompressedOops) {
1997 return oopDesc::load_decode_heap_oop((narrowOop *)addr);
1998 } else {
1999 return oopDesc::load_decode_heap_oop((oop*)addr);
2000 }
2001 }
2002
2003
2004 // Support for java_lang_ref_SoftReference
2005
2006 jlong java_lang_ref_SoftReference::timestamp(oop ref) {
2007 return ref->long_field(timestamp_offset);
2008 }
2009
2010 jlong java_lang_ref_SoftReference::clock() {
2011 instanceKlass* ik = instanceKlass::cast(SystemDictionary::soft_reference_klass());
2012 int offset = ik->offset_of_static_fields() + static_clock_offset;
2013
2014 return SystemDictionary::soft_reference_klass()->long_field(offset);
2015 }
2016
2017 void java_lang_ref_SoftReference::set_clock(jlong value) {
2018 instanceKlass* ik = instanceKlass::cast(SystemDictionary::soft_reference_klass());
2019 int offset = ik->offset_of_static_fields() + static_clock_offset;
2020
2149 int java_lang_reflect_Method::signature_offset;
2150 int java_lang_reflect_Method::annotations_offset;
2151 int java_lang_reflect_Method::parameter_annotations_offset;
2152 int java_lang_reflect_Method::annotation_default_offset;
2153 int java_lang_reflect_Constructor::clazz_offset;
2154 int java_lang_reflect_Constructor::parameterTypes_offset;
2155 int java_lang_reflect_Constructor::exceptionTypes_offset;
2156 int java_lang_reflect_Constructor::slot_offset;
2157 int java_lang_reflect_Constructor::modifiers_offset;
2158 int java_lang_reflect_Constructor::signature_offset;
2159 int java_lang_reflect_Constructor::annotations_offset;
2160 int java_lang_reflect_Constructor::parameter_annotations_offset;
2161 int java_lang_reflect_Field::clazz_offset;
2162 int java_lang_reflect_Field::name_offset;
2163 int java_lang_reflect_Field::type_offset;
2164 int java_lang_reflect_Field::slot_offset;
2165 int java_lang_reflect_Field::modifiers_offset;
2166 int java_lang_reflect_Field::signature_offset;
2167 int java_lang_reflect_Field::annotations_offset;
2168 int java_lang_boxing_object::value_offset;
2169 int java_lang_boxing_object::long_value_offset;
2170 int java_lang_ref_Reference::referent_offset;
2171 int java_lang_ref_Reference::queue_offset;
2172 int java_lang_ref_Reference::next_offset;
2173 int java_lang_ref_Reference::discovered_offset;
2174 int java_lang_ref_Reference::static_lock_offset;
2175 int java_lang_ref_Reference::static_pending_offset;
2176 int java_lang_ref_Reference::number_of_fake_oop_fields;
2177 int java_lang_ref_SoftReference::timestamp_offset;
2178 int java_lang_ref_SoftReference::static_clock_offset;
2179 int java_lang_ClassLoader::parent_offset;
2180 int java_lang_System::offset_of_static_fields;
2181 int java_lang_System::static_in_offset;
2182 int java_lang_System::static_out_offset;
2183 int java_lang_System::static_err_offset;
2184 int java_lang_StackTraceElement::declaringClass_offset;
2185 int java_lang_StackTraceElement::methodName_offset;
2186 int java_lang_StackTraceElement::fileName_offset;
2187 int java_lang_StackTraceElement::lineNumber_offset;
2188 int java_lang_AssertionStatusDirectives::classes_offset;
2189 int java_lang_AssertionStatusDirectives::classEnabled_offset;
2230 o->obj_field_put(packages_offset, val);
2231 }
2232
2233 void java_lang_AssertionStatusDirectives::set_packageEnabled(oop o, oop val) {
2234 o->obj_field_put(packageEnabled_offset, val);
2235 }
2236
2237 void java_lang_AssertionStatusDirectives::set_deflt(oop o, bool val) {
2238 o->bool_field_put(deflt_offset, val);
2239 }
2240
2241
2242 // Support for intrinsification of java.nio.Buffer.checkIndex
2243 int java_nio_Buffer::limit_offset() {
2244 return _limit_offset;
2245 }
2246
2247
2248 void java_nio_Buffer::compute_offsets() {
2249 klassOop k = SystemDictionary::java_nio_Buffer_klass();
2250 assert(k != NULL, "must be loaded in 1.4+");
2251 compute_offset(_limit_offset, k, vmSymbols::limit_name(), vmSymbols::int_signature());
2252 }
2253
2254 // Support for intrinsification of sun.misc.AtomicLongCSImpl.attemptUpdate
2255 int sun_misc_AtomicLongCSImpl::value_offset() {
2256 assert(SystemDictionary::sun_misc_AtomicLongCSImpl_klass() != NULL, "can't call this");
2257 return _value_offset;
2258 }
2259
2260
2261 void sun_misc_AtomicLongCSImpl::compute_offsets() {
2262 klassOop k = SystemDictionary::sun_misc_AtomicLongCSImpl_klass();
2263 // If this class is not present, its value field offset won't be referenced.
2264 if (k != NULL) {
2265 compute_offset(_value_offset, k, vmSymbols::value_name(), vmSymbols::long_signature());
2266 }
2267 }
2268
2269 void java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(TRAPS) {
2270 if (_owner_offset != 0) return;
2271
2272 assert(JDK_Version::is_gte_jdk16x_version(), "Must be JDK 1.6 or later");
2273 SystemDictionary::load_abstract_ownable_synchronizer_klass(CHECK);
2274 klassOop k = SystemDictionary::abstract_ownable_synchronizer_klass();
2275 compute_offset(_owner_offset, k,
2276 vmSymbols::exclusive_owner_thread_name(), vmSymbols::thread_signature());
2277 }
2278
2279 oop java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(oop obj) {
2280 assert(_owner_offset != 0, "Must be initialized");
2281 return obj->obj_field(_owner_offset);
2282 }
2283
2284 // Compute hard-coded offsets
2285 // Invoked before SystemDictionary::initialize, so pre-loaded classes
2286 // are not available to determine the offset_of_static_fields.
2287 void JavaClasses::compute_hard_coded_offsets() {
2288 const int x = heapOopSize;
2289 const int header = instanceOopDesc::base_offset_in_bytes();
2290
2291 // Do the String Class
2292 java_lang_String::value_offset = java_lang_String::hc_value_offset * x + header;
2293 java_lang_String::offset_offset = java_lang_String::hc_offset_offset * x + header;
2294 java_lang_String::count_offset = java_lang_String::offset_offset + sizeof (jint);
2295 java_lang_String::hash_offset = java_lang_String::count_offset + sizeof (jint);
2296
2297 // Do the Class Class
2298 java_lang_Class::klass_offset = java_lang_Class::hc_klass_offset * x + header;
2299 java_lang_Class::array_klass_offset = java_lang_Class::hc_array_klass_offset * x + header;
2300 java_lang_Class::resolved_constructor_offset = java_lang_Class::hc_resolved_constructor_offset * x + header;
2301
2302 // This is NOT an offset
2303 java_lang_Class::number_of_fake_oop_fields = java_lang_Class::hc_number_of_fake_oop_fields;
2304
2305 // Throwable Class
2306 java_lang_Throwable::backtrace_offset = java_lang_Throwable::hc_backtrace_offset * x + header;
2307 java_lang_Throwable::detailMessage_offset = java_lang_Throwable::hc_detailMessage_offset * x + header;
2308 java_lang_Throwable::cause_offset = java_lang_Throwable::hc_cause_offset * x + header;
2309 java_lang_Throwable::stackTrace_offset = java_lang_Throwable::hc_stackTrace_offset * x + header;
2310
2311 // java_lang_boxing_object
2312 java_lang_boxing_object::value_offset = java_lang_boxing_object::hc_value_offset + header;
2313 java_lang_boxing_object::long_value_offset = align_size_up((java_lang_boxing_object::hc_value_offset + header), BytesPerLong);
2314
2315 // java_lang_ref_Reference:
2316 java_lang_ref_Reference::referent_offset = java_lang_ref_Reference::hc_referent_offset * x + header;
2317 java_lang_ref_Reference::queue_offset = java_lang_ref_Reference::hc_queue_offset * x + header;
2318 java_lang_ref_Reference::next_offset = java_lang_ref_Reference::hc_next_offset * x + header;
2319 java_lang_ref_Reference::discovered_offset = java_lang_ref_Reference::hc_discovered_offset * x + header;
2320 java_lang_ref_Reference::static_lock_offset = java_lang_ref_Reference::hc_static_lock_offset * x;
2321 java_lang_ref_Reference::static_pending_offset = java_lang_ref_Reference::hc_static_pending_offset * x;
2322 // Artificial fields for java_lang_ref_Reference
2323 // The first field is for the discovered field added in 1.4
2324 java_lang_ref_Reference::number_of_fake_oop_fields = 1;
2325
2326 // java_lang_ref_SoftReference Class
2327 java_lang_ref_SoftReference::timestamp_offset = align_size_up((java_lang_ref_SoftReference::hc_timestamp_offset * x + header), BytesPerLong);
2328 // Don't multiply static fields because they are always in wordSize units
2329 java_lang_ref_SoftReference::static_clock_offset = java_lang_ref_SoftReference::hc_static_clock_offset * x;
2330
2331 // java_lang_ClassLoader
2332 java_lang_ClassLoader::parent_offset = java_lang_ClassLoader::hc_parent_offset * x + header;
2333
2334 // java_lang_System
2335 java_lang_System::static_in_offset = java_lang_System::hc_static_in_offset * x;
2336 java_lang_System::static_out_offset = java_lang_System::hc_static_out_offset * x;
2337 java_lang_System::static_err_offset = java_lang_System::hc_static_err_offset * x;
2338
2339 // java_lang_StackTraceElement
2340 java_lang_StackTraceElement::declaringClass_offset = java_lang_StackTraceElement::hc_declaringClass_offset * x + header;
2341 java_lang_StackTraceElement::methodName_offset = java_lang_StackTraceElement::hc_methodName_offset * x + header;
2342 java_lang_StackTraceElement::fileName_offset = java_lang_StackTraceElement::hc_fileName_offset * x + header;
2343 java_lang_StackTraceElement::lineNumber_offset = java_lang_StackTraceElement::hc_lineNumber_offset * x + header;
2344 java_lang_AssertionStatusDirectives::classes_offset = java_lang_AssertionStatusDirectives::hc_classes_offset * x + header;
2345 java_lang_AssertionStatusDirectives::classEnabled_offset = java_lang_AssertionStatusDirectives::hc_classEnabled_offset * x + header;
2346 java_lang_AssertionStatusDirectives::packages_offset = java_lang_AssertionStatusDirectives::hc_packages_offset * x + header;
2347 java_lang_AssertionStatusDirectives::packageEnabled_offset = java_lang_AssertionStatusDirectives::hc_packageEnabled_offset * x + header;
2416 instanceKlassHandle h_klass (THREAD, k);
2417 symbolHandle f_name = oopFactory::new_symbol_handle(field_name, CATCH);
2418 symbolHandle f_sig = oopFactory::new_symbol_handle(field_sig, CATCH);
2419 if (!h_klass->find_local_field(f_name(), f_sig(), &fd)) {
2420 tty->print_cr("Static field %s.%s not found", klass_name, field_name);
2421 return false;
2422 }
2423 if (!fd.is_static()) {
2424 tty->print_cr("Static field %s.%s appears to be nonstatic", klass_name, field_name);
2425 return false;
2426 }
2427 if (fd.offset() == hardcoded_offset + h_klass->offset_of_static_fields()) {
2428 return true;
2429 } else {
2430 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());
2431 return false;
2432 }
2433 }
2434
2435
2436 bool JavaClasses::check_constant(const char *klass_name, int hardcoded_constant, const char *field_name, const char* field_sig) {
2437 EXCEPTION_MARK;
2438 fieldDescriptor fd;
2439 symbolHandle klass_sym = oopFactory::new_symbol_handle(klass_name, CATCH);
2440 klassOop k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH);
2441 instanceKlassHandle h_klass (THREAD, k);
2442 symbolHandle f_name = oopFactory::new_symbol_handle(field_name, CATCH);
2443 symbolHandle f_sig = oopFactory::new_symbol_handle(field_sig, CATCH);
2444 if (!h_klass->find_local_field(f_name(), f_sig(), &fd)) {
2445 tty->print_cr("Static field %s.%s not found", klass_name, field_name);
2446 return false;
2447 }
2448 if (!fd.is_static() || !fd.has_initial_value()) {
2449 tty->print_cr("Static field %s.%s appears to be non-constant", klass_name, field_name);
2450 return false;
2451 }
2452 if (!fd.initial_value_tag().is_int()) {
2453 tty->print_cr("Static field %s.%s is not an int", klass_name, field_name);
2454 return false;
2455 }
2456 jint field_value = fd.int_initial_value();
2457 if (field_value == hardcoded_constant) {
2458 return true;
2459 } else {
2460 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);
2461 return false;
2462 }
2463 }
2464
2465
2466 // Check the hard-coded field offsets of all the classes in this file
2467
2468 void JavaClasses::check_offsets() {
2469 bool valid = true;
2470
2471 #define CHECK_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \
2472 valid &= check_offset(klass_name, cpp_klass_name :: field_name ## _offset, #field_name, field_sig)
2473
2474 #define CHECK_LONG_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \
2475 valid &= check_offset(klass_name, cpp_klass_name :: long_ ## field_name ## _offset, #field_name, field_sig)
2476
2477 #define CHECK_STATIC_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \
2478 valid &= check_static_offset(klass_name, cpp_klass_name :: static_ ## field_name ## _offset, #field_name, field_sig)
2479
2480 #define CHECK_CONSTANT(klass_name, cpp_klass_name, field_name, field_sig) \
2481 valid &= check_constant(klass_name, cpp_klass_name :: field_name, #field_name, field_sig)
2482
2483 // java.lang.String
2484
2485 CHECK_OFFSET("java/lang/String", java_lang_String, value, "[C");
2486 CHECK_OFFSET("java/lang/String", java_lang_String, offset, "I");
2487 CHECK_OFFSET("java/lang/String", java_lang_String, count, "I");
2488 CHECK_OFFSET("java/lang/String", java_lang_String, hash, "I");
2489
2490 // java.lang.Class
2491
2492 // Fake fields
2493 // CHECK_OFFSET("java/lang/Class", java_lang_Class, klass); // %%% this needs to be checked
2494 // CHECK_OFFSET("java/lang/Class", java_lang_Class, array_klass); // %%% this needs to be checked
2495 // CHECK_OFFSET("java/lang/Class", java_lang_Class, resolved_constructor); // %%% this needs to be checked
2496
2497 // java.lang.Throwable
2498
2499 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, backtrace, "Ljava/lang/Object;");
2500 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, detailMessage, "Ljava/lang/String;");
2501 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, cause, "Ljava/lang/Throwable;");
2502 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, stackTrace, "[Ljava/lang/StackTraceElement;");
2503
2504 // Boxed primitive objects (java_lang_boxing_object)
2505
2506 CHECK_OFFSET("java/lang/Boolean", java_lang_boxing_object, value, "Z");
2507 CHECK_OFFSET("java/lang/Character", java_lang_boxing_object, value, "C");
2508 CHECK_OFFSET("java/lang/Float", java_lang_boxing_object, value, "F");
2509 CHECK_LONG_OFFSET("java/lang/Double", java_lang_boxing_object, value, "D");
2510 CHECK_OFFSET("java/lang/Byte", java_lang_boxing_object, value, "B");
2511 CHECK_OFFSET("java/lang/Short", java_lang_boxing_object, value, "S");
2512 CHECK_OFFSET("java/lang/Integer", java_lang_boxing_object, value, "I");
2513 CHECK_LONG_OFFSET("java/lang/Long", java_lang_boxing_object, value, "J");
2514
2515 // java.lang.ClassLoader
2516
2517 CHECK_OFFSET("java/lang/ClassLoader", java_lang_ClassLoader, parent, "Ljava/lang/ClassLoader;");
2518
2519 // java.lang.System
2520
2521 CHECK_STATIC_OFFSET("java/lang/System", java_lang_System, in, "Ljava/io/InputStream;");
2522 CHECK_STATIC_OFFSET("java/lang/System", java_lang_System, out, "Ljava/io/PrintStream;");
2523 CHECK_STATIC_OFFSET("java/lang/System", java_lang_System, err, "Ljava/io/PrintStream;");
2524
2525 // java.lang.StackTraceElement
2526
2527 CHECK_OFFSET("java/lang/StackTraceElement", java_lang_StackTraceElement, declaringClass, "Ljava/lang/String;");
2528 CHECK_OFFSET("java/lang/StackTraceElement", java_lang_StackTraceElement, methodName, "Ljava/lang/String;");
2529 CHECK_OFFSET("java/lang/StackTraceElement", java_lang_StackTraceElement, fileName, "Ljava/lang/String;");
2530 CHECK_OFFSET("java/lang/StackTraceElement", java_lang_StackTraceElement, lineNumber, "I");
2531
2532 // java.lang.ref.Reference
2533
|