35 #include "memory/resourceArea.hpp"
36 #include "memory/universe.inline.hpp"
37 #include "oops/fieldStreams.hpp"
38 #include "oops/instanceKlass.hpp"
39 #include "oops/instanceMirrorKlass.hpp"
40 #include "oops/klass.hpp"
41 #include "oops/method.hpp"
42 #include "oops/symbol.hpp"
43 #include "oops/typeArrayOop.hpp"
44 #include "prims/jvmtiRedefineClassesTrace.hpp"
45 #include "runtime/fieldDescriptor.hpp"
46 #include "runtime/handles.inline.hpp"
47 #include "runtime/interfaceSupport.hpp"
48 #include "runtime/java.hpp"
49 #include "runtime/javaCalls.hpp"
50 #include "runtime/safepoint.hpp"
51 #include "runtime/thread.inline.hpp"
52 #include "runtime/vframe.hpp"
53 #include "utilities/preserveException.hpp"
54
55 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
56
57 #define INJECTED_FIELD_COMPUTE_OFFSET(klass, name, signature, may_be_java) \
58 klass::_##name##_offset = JavaClasses::compute_injected_offset(JavaClasses::klass##_##name##_enum);
59
60 #define DECLARE_INJECTED_FIELD(klass, name, signature, may_be_java) \
61 { SystemDictionary::WK_KLASS_ENUM_NAME(klass), vmSymbols::VM_SYMBOL_ENUM_NAME(name##_name), vmSymbols::VM_SYMBOL_ENUM_NAME(signature), may_be_java },
62
63 InjectedField JavaClasses::_injected_fields[] = {
64 ALL_INJECTED_FIELDS(DECLARE_INJECTED_FIELD)
65 };
66
67 int JavaClasses::compute_injected_offset(InjectedFieldID id) {
68 return _injected_fields[id].compute_offset();
69 }
70
71
72 InjectedField* JavaClasses::get_injected(Symbol* class_name, int* field_count) {
73 *field_count = 0;
74
1191 void java_lang_ThreadGroup::compute_offsets() {
1192 assert(_parent_offset == 0, "offsets should be initialized only once");
1193
1194 Klass* k = SystemDictionary::ThreadGroup_klass();
1195
1196 compute_offset(_parent_offset, k, vmSymbols::parent_name(), vmSymbols::threadgroup_signature());
1197 compute_offset(_name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature());
1198 compute_offset(_threads_offset, k, vmSymbols::threads_name(), vmSymbols::thread_array_signature());
1199 compute_offset(_groups_offset, k, vmSymbols::groups_name(), vmSymbols::threadgroup_array_signature());
1200 compute_offset(_maxPriority_offset, k, vmSymbols::maxPriority_name(), vmSymbols::int_signature());
1201 compute_offset(_destroyed_offset, k, vmSymbols::destroyed_name(), vmSymbols::bool_signature());
1202 compute_offset(_daemon_offset, k, vmSymbols::daemon_name(), vmSymbols::bool_signature());
1203 compute_offset(_vmAllowSuspension_offset, k, vmSymbols::vmAllowSuspension_name(), vmSymbols::bool_signature());
1204 compute_offset(_nthreads_offset, k, vmSymbols::nthreads_name(), vmSymbols::int_signature());
1205 compute_offset(_ngroups_offset, k, vmSymbols::ngroups_name(), vmSymbols::int_signature());
1206 }
1207
1208 oop java_lang_Throwable::unassigned_stacktrace() {
1209 InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::Throwable_klass());
1210 address addr = ik->static_field_addr(static_unassigned_stacktrace_offset);
1211 if (UseCompressedOops) {
1212 return oopDesc::load_decode_heap_oop((narrowOop *)addr);
1213 } else {
1214 return oopDesc::load_decode_heap_oop((oop*)addr);
1215 }
1216 }
1217
1218 oop java_lang_Throwable::backtrace(oop throwable) {
1219 return throwable->obj_field_acquire(backtrace_offset);
1220 }
1221
1222
1223 void java_lang_Throwable::set_backtrace(oop throwable, oop value) {
1224 throwable->release_obj_field_put(backtrace_offset, value);
1225 }
1226
1227
1228 oop java_lang_Throwable::message(oop throwable) {
1229 return throwable->obj_field(detailMessage_offset);
1230 }
1231
1232
1233 oop java_lang_Throwable::message(Handle throwable) {
1234 return throwable->obj_field(detailMessage_offset);
1235 }
2631 case T_SHORT: st->print("%d", value->s); break;
2632 case T_INT: st->print("%d", value->i); break;
2633 case T_LONG: st->print(INT64_FORMAT, value->j); break;
2634 case T_FLOAT: st->print("%f", value->f); break;
2635 case T_DOUBLE: st->print("%lf", value->d); break;
2636 default: st->print("type %d?", type); break;
2637 }
2638 }
2639
2640
2641 // Support for java_lang_ref_Reference
2642 HeapWord *java_lang_ref_Reference::pending_list_lock_addr() {
2643 InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::Reference_klass());
2644 address addr = ik->static_field_addr(static_lock_offset);
2645 return (HeapWord*) addr;
2646 }
2647
2648 oop java_lang_ref_Reference::pending_list_lock() {
2649 InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::Reference_klass());
2650 address addr = ik->static_field_addr(static_lock_offset);
2651 if (UseCompressedOops) {
2652 return oopDesc::load_decode_heap_oop((narrowOop *)addr);
2653 } else {
2654 return oopDesc::load_decode_heap_oop((oop*)addr);
2655 }
2656 }
2657
2658 HeapWord *java_lang_ref_Reference::pending_list_addr() {
2659 InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::Reference_klass());
2660 address addr = ik->static_field_addr(static_pending_offset);
2661 // XXX This might not be HeapWord aligned, almost rather be char *.
2662 return (HeapWord*)addr;
2663 }
2664
2665 oop java_lang_ref_Reference::pending_list() {
2666 char *addr = (char *)pending_list_addr();
2667 if (UseCompressedOops) {
2668 return oopDesc::load_decode_heap_oop((narrowOop *)addr);
2669 } else {
2670 return oopDesc::load_decode_heap_oop((oop*)addr);
2671 }
2672 }
2673
2674
2675 // Support for java_lang_ref_SoftReference
2676
2677 jlong java_lang_ref_SoftReference::timestamp(oop ref) {
2678 return ref->long_field(timestamp_offset);
2679 }
2680
2681 jlong java_lang_ref_SoftReference::clock() {
2682 InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::SoftReference_klass());
2683 jlong* offset = (jlong*)ik->static_field_addr(static_clock_offset);
2684 return *offset;
2685 }
2686
2687 void java_lang_ref_SoftReference::set_clock(jlong value) {
2688 InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::SoftReference_klass());
2689 jlong* offset = (jlong*)ik->static_field_addr(static_clock_offset);
2690 *offset = value;
2691 }
|
35 #include "memory/resourceArea.hpp"
36 #include "memory/universe.inline.hpp"
37 #include "oops/fieldStreams.hpp"
38 #include "oops/instanceKlass.hpp"
39 #include "oops/instanceMirrorKlass.hpp"
40 #include "oops/klass.hpp"
41 #include "oops/method.hpp"
42 #include "oops/symbol.hpp"
43 #include "oops/typeArrayOop.hpp"
44 #include "prims/jvmtiRedefineClassesTrace.hpp"
45 #include "runtime/fieldDescriptor.hpp"
46 #include "runtime/handles.inline.hpp"
47 #include "runtime/interfaceSupport.hpp"
48 #include "runtime/java.hpp"
49 #include "runtime/javaCalls.hpp"
50 #include "runtime/safepoint.hpp"
51 #include "runtime/thread.inline.hpp"
52 #include "runtime/vframe.hpp"
53 #include "utilities/preserveException.hpp"
54
55 #if INCLUDE_ALL_GCS
56 #include "gc_implementation/shenandoah/shenandoahBarrierSet.hpp"
57 #endif
58
59 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
60
61 #define INJECTED_FIELD_COMPUTE_OFFSET(klass, name, signature, may_be_java) \
62 klass::_##name##_offset = JavaClasses::compute_injected_offset(JavaClasses::klass##_##name##_enum);
63
64 #define DECLARE_INJECTED_FIELD(klass, name, signature, may_be_java) \
65 { SystemDictionary::WK_KLASS_ENUM_NAME(klass), vmSymbols::VM_SYMBOL_ENUM_NAME(name##_name), vmSymbols::VM_SYMBOL_ENUM_NAME(signature), may_be_java },
66
67 InjectedField JavaClasses::_injected_fields[] = {
68 ALL_INJECTED_FIELDS(DECLARE_INJECTED_FIELD)
69 };
70
71 int JavaClasses::compute_injected_offset(InjectedFieldID id) {
72 return _injected_fields[id].compute_offset();
73 }
74
75
76 InjectedField* JavaClasses::get_injected(Symbol* class_name, int* field_count) {
77 *field_count = 0;
78
1195 void java_lang_ThreadGroup::compute_offsets() {
1196 assert(_parent_offset == 0, "offsets should be initialized only once");
1197
1198 Klass* k = SystemDictionary::ThreadGroup_klass();
1199
1200 compute_offset(_parent_offset, k, vmSymbols::parent_name(), vmSymbols::threadgroup_signature());
1201 compute_offset(_name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature());
1202 compute_offset(_threads_offset, k, vmSymbols::threads_name(), vmSymbols::thread_array_signature());
1203 compute_offset(_groups_offset, k, vmSymbols::groups_name(), vmSymbols::threadgroup_array_signature());
1204 compute_offset(_maxPriority_offset, k, vmSymbols::maxPriority_name(), vmSymbols::int_signature());
1205 compute_offset(_destroyed_offset, k, vmSymbols::destroyed_name(), vmSymbols::bool_signature());
1206 compute_offset(_daemon_offset, k, vmSymbols::daemon_name(), vmSymbols::bool_signature());
1207 compute_offset(_vmAllowSuspension_offset, k, vmSymbols::vmAllowSuspension_name(), vmSymbols::bool_signature());
1208 compute_offset(_nthreads_offset, k, vmSymbols::nthreads_name(), vmSymbols::int_signature());
1209 compute_offset(_ngroups_offset, k, vmSymbols::ngroups_name(), vmSymbols::int_signature());
1210 }
1211
1212 oop java_lang_Throwable::unassigned_stacktrace() {
1213 InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::Throwable_klass());
1214 address addr = ik->static_field_addr(static_unassigned_stacktrace_offset);
1215 oop result;
1216 if (UseCompressedOops) {
1217 result = oopDesc::load_decode_heap_oop((narrowOop *)addr);
1218 } else {
1219 result = oopDesc::load_decode_heap_oop((oop*)addr);
1220 }
1221 #if INCLUDE_ALL_GCS
1222 if (UseShenandoahGC) {
1223 result = ShenandoahBarrierSet::barrier_set()->load_reference_barrier(result);
1224 }
1225 #endif
1226 return result;
1227 }
1228
1229 oop java_lang_Throwable::backtrace(oop throwable) {
1230 return throwable->obj_field_acquire(backtrace_offset);
1231 }
1232
1233
1234 void java_lang_Throwable::set_backtrace(oop throwable, oop value) {
1235 throwable->release_obj_field_put(backtrace_offset, value);
1236 }
1237
1238
1239 oop java_lang_Throwable::message(oop throwable) {
1240 return throwable->obj_field(detailMessage_offset);
1241 }
1242
1243
1244 oop java_lang_Throwable::message(Handle throwable) {
1245 return throwable->obj_field(detailMessage_offset);
1246 }
2642 case T_SHORT: st->print("%d", value->s); break;
2643 case T_INT: st->print("%d", value->i); break;
2644 case T_LONG: st->print(INT64_FORMAT, value->j); break;
2645 case T_FLOAT: st->print("%f", value->f); break;
2646 case T_DOUBLE: st->print("%lf", value->d); break;
2647 default: st->print("type %d?", type); break;
2648 }
2649 }
2650
2651
2652 // Support for java_lang_ref_Reference
2653 HeapWord *java_lang_ref_Reference::pending_list_lock_addr() {
2654 InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::Reference_klass());
2655 address addr = ik->static_field_addr(static_lock_offset);
2656 return (HeapWord*) addr;
2657 }
2658
2659 oop java_lang_ref_Reference::pending_list_lock() {
2660 InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::Reference_klass());
2661 address addr = ik->static_field_addr(static_lock_offset);
2662 oop result;
2663 if (UseCompressedOops) {
2664 result = oopDesc::load_decode_heap_oop((narrowOop *)addr);
2665 } else {
2666 result = oopDesc::load_decode_heap_oop((oop*)addr);
2667 }
2668 #if INCLUDE_ALL_GCS
2669 if (UseShenandoahGC) {
2670 result = ShenandoahBarrierSet::barrier_set()->load_reference_barrier(result);
2671 }
2672 #endif
2673 return result;
2674 }
2675
2676 HeapWord *java_lang_ref_Reference::pending_list_addr() {
2677 InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::Reference_klass());
2678 address addr = ik->static_field_addr(static_pending_offset);
2679 // XXX This might not be HeapWord aligned, almost rather be char *.
2680 return (HeapWord*)addr;
2681 }
2682
2683 oop java_lang_ref_Reference::pending_list() {
2684 char *addr = (char *)pending_list_addr();
2685 oop result;
2686 if (UseCompressedOops) {
2687 result = oopDesc::load_decode_heap_oop((narrowOop *)addr);
2688 } else {
2689 result = oopDesc::load_decode_heap_oop((oop*)addr);
2690 }
2691 #if INCLUDE_ALL_GCS
2692 if (UseShenandoahGC) {
2693 result = ShenandoahBarrierSet::barrier_set()->load_reference_barrier(result);
2694 }
2695 #endif
2696 return result;
2697 }
2698
2699
2700 // Support for java_lang_ref_SoftReference
2701
2702 jlong java_lang_ref_SoftReference::timestamp(oop ref) {
2703 return ref->long_field(timestamp_offset);
2704 }
2705
2706 jlong java_lang_ref_SoftReference::clock() {
2707 InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::SoftReference_klass());
2708 jlong* offset = (jlong*)ik->static_field_addr(static_clock_offset);
2709 return *offset;
2710 }
2711
2712 void java_lang_ref_SoftReference::set_clock(jlong value) {
2713 InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::SoftReference_klass());
2714 jlong* offset = (jlong*)ik->static_field_addr(static_clock_offset);
2715 *offset = value;
2716 }
|