1605 }
1606
1607 void java_lang_Thread::inc_VTMS_transition_disable_count(oop java_thread) {
1608 assert(JvmtiVTMSTransition_lock->owned_by_self(), "Must be locked");
1609 int val = VTMS_transition_disable_count(java_thread);
1610 java_thread->int_field_put(_jvmti_VTMS_transition_disable_count_offset, val + 1);
1611 }
1612
1613 void java_lang_Thread::dec_VTMS_transition_disable_count(oop java_thread) {
1614 assert(JvmtiVTMSTransition_lock->owned_by_self(), "Must be locked");
1615 int val = VTMS_transition_disable_count(java_thread);
1616 assert(val > 0, "VTMS_transition_disable_count should never be negative");
1617 java_thread->int_field_put(_jvmti_VTMS_transition_disable_count_offset, val - 1);
1618 }
1619
1620 bool java_lang_Thread::is_in_VTMS_transition(oop java_thread) {
1621 return java_thread->bool_field_volatile(_jvmti_is_in_VTMS_transition_offset);
1622 }
1623
1624 void java_lang_Thread::set_is_in_VTMS_transition(oop java_thread, bool val) {
1625 java_thread->bool_field_put_volatile(_jvmti_is_in_VTMS_transition_offset, val);
1626 }
1627
1628 int java_lang_Thread::is_in_VTMS_transition_offset() {
1629 return _jvmti_is_in_VTMS_transition_offset;
1630 }
1631
1632 void java_lang_Thread::clear_scopedValueBindings(oop java_thread) {
1633 assert(java_thread != nullptr, "need a java_lang_Thread pointer here");
1634 java_thread->obj_field_put(_scopedValueBindings_offset, nullptr);
1635 }
1636
1637 oop java_lang_Thread::holder(oop java_thread) {
1638 // Note: may return null if the thread is still attaching
1639 return java_thread->obj_field(_holder_offset);
1640 }
1641 oop java_lang_Thread::interrupt_lock(oop java_thread) {
1642 return java_thread->obj_field(_interruptLock_offset);
1643 }
1644
1940 void java_lang_ThreadGroup::compute_offsets() {
1941 assert(_parent_offset == 0, "offsets should be initialized only once");
1942
1943 InstanceKlass* k = vmClasses::ThreadGroup_klass();
1944 THREADGROUP_FIELDS_DO(FIELD_COMPUTE_OFFSET);
1945 }
1946
1947 #if INCLUDE_CDS
1948 void java_lang_ThreadGroup::serialize_offsets(SerializeClosure* f) {
1949 THREADGROUP_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
1950 }
1951 #endif
1952
1953
1954 // java_lang_VirtualThread
1955
1956 int java_lang_VirtualThread::static_vthread_scope_offset;
1957 int java_lang_VirtualThread::_carrierThread_offset;
1958 int java_lang_VirtualThread::_continuation_offset;
1959 int java_lang_VirtualThread::_state_offset;
1960
1961 #define VTHREAD_FIELDS_DO(macro) \
1962 macro(static_vthread_scope_offset, k, "VTHREAD_SCOPE", continuationscope_signature, true); \
1963 macro(_carrierThread_offset, k, "carrierThread", thread_signature, false); \
1964 macro(_continuation_offset, k, "cont", continuation_signature, false); \
1965 macro(_state_offset, k, "state", int_signature, false)
1966
1967
1968 void java_lang_VirtualThread::compute_offsets() {
1969 InstanceKlass* k = vmClasses::VirtualThread_klass();
1970 VTHREAD_FIELDS_DO(FIELD_COMPUTE_OFFSET);
1971 }
1972
1973 bool java_lang_VirtualThread::is_instance(oop obj) {
1974 return obj != nullptr && is_subclass(obj->klass());
1975 }
1976
1977 oop java_lang_VirtualThread::carrier_thread(oop vthread) {
1978 oop thread = vthread->obj_field(_carrierThread_offset);
1979 return thread;
1980 }
1981
1982 oop java_lang_VirtualThread::continuation(oop vthread) {
1983 oop cont = vthread->obj_field(_continuation_offset);
1984 return cont;
1985 }
1986
1987 int java_lang_VirtualThread::state(oop vthread) {
1988 return vthread->int_field_acquire(_state_offset);
1989 }
1990
1991 JavaThreadStatus java_lang_VirtualThread::map_state_to_thread_status(int state) {
1992 JavaThreadStatus status = JavaThreadStatus::NEW;
1993 switch (state & ~SUSPENDED) {
1994 case NEW:
1995 status = JavaThreadStatus::NEW;
1996 break;
1997 case STARTED:
1998 case RUNNING:
1999 case PARKING:
2000 case TIMED_PARKING:
2001 case UNPARKED:
2002 case YIELDING:
2003 case YIELDED:
2004 status = JavaThreadStatus::RUNNABLE;
2005 break;
2006 case PARKED:
2007 case PINNED:
2008 status = JavaThreadStatus::PARKED;
2009 break;
2010 case TIMED_PARKED:
2011 case TIMED_PINNED:
2012 status = JavaThreadStatus::PARKED_TIMED;
2013 break;
2014 case TERMINATED:
2015 status = JavaThreadStatus::TERMINATED;
2016 break;
2017 default:
2018 ShouldNotReachHere();
2019 }
2020 return status;
2021 }
2022
2023 #if INCLUDE_CDS
2024 void java_lang_VirtualThread::serialize_offsets(SerializeClosure* f) {
2025 VTHREAD_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
2026 }
2027 #endif
2028
2029 // java_lang_Throwable
2030
2031 int java_lang_Throwable::_backtrace_offset;
2032 int java_lang_Throwable::_detailMessage_offset;
2033 int java_lang_Throwable::_stackTrace_offset;
2034 int java_lang_Throwable::_depth_offset;
2035 int java_lang_Throwable::_cause_offset;
2036 int java_lang_Throwable::_static_unassigned_stacktrace_offset;
2037
2038 #define THROWABLE_FIELDS_DO(macro) \
2039 macro(_backtrace_offset, k, "backtrace", object_signature, false); \
2040 macro(_detailMessage_offset, k, "detailMessage", string_signature, false); \
2041 macro(_stackTrace_offset, k, "stackTrace", java_lang_StackTraceElement_array, false); \
2042 macro(_depth_offset, k, "depth", int_signature, false); \
|
1605 }
1606
1607 void java_lang_Thread::inc_VTMS_transition_disable_count(oop java_thread) {
1608 assert(JvmtiVTMSTransition_lock->owned_by_self(), "Must be locked");
1609 int val = VTMS_transition_disable_count(java_thread);
1610 java_thread->int_field_put(_jvmti_VTMS_transition_disable_count_offset, val + 1);
1611 }
1612
1613 void java_lang_Thread::dec_VTMS_transition_disable_count(oop java_thread) {
1614 assert(JvmtiVTMSTransition_lock->owned_by_self(), "Must be locked");
1615 int val = VTMS_transition_disable_count(java_thread);
1616 assert(val > 0, "VTMS_transition_disable_count should never be negative");
1617 java_thread->int_field_put(_jvmti_VTMS_transition_disable_count_offset, val - 1);
1618 }
1619
1620 bool java_lang_Thread::is_in_VTMS_transition(oop java_thread) {
1621 return java_thread->bool_field_volatile(_jvmti_is_in_VTMS_transition_offset);
1622 }
1623
1624 void java_lang_Thread::set_is_in_VTMS_transition(oop java_thread, bool val) {
1625 assert(is_in_VTMS_transition(java_thread) != val, "already %s transition", val ? "inside" : "outside");
1626 java_thread->bool_field_put_volatile(_jvmti_is_in_VTMS_transition_offset, val);
1627 }
1628
1629 int java_lang_Thread::is_in_VTMS_transition_offset() {
1630 return _jvmti_is_in_VTMS_transition_offset;
1631 }
1632
1633 void java_lang_Thread::clear_scopedValueBindings(oop java_thread) {
1634 assert(java_thread != nullptr, "need a java_lang_Thread pointer here");
1635 java_thread->obj_field_put(_scopedValueBindings_offset, nullptr);
1636 }
1637
1638 oop java_lang_Thread::holder(oop java_thread) {
1639 // Note: may return null if the thread is still attaching
1640 return java_thread->obj_field(_holder_offset);
1641 }
1642 oop java_lang_Thread::interrupt_lock(oop java_thread) {
1643 return java_thread->obj_field(_interruptLock_offset);
1644 }
1645
1941 void java_lang_ThreadGroup::compute_offsets() {
1942 assert(_parent_offset == 0, "offsets should be initialized only once");
1943
1944 InstanceKlass* k = vmClasses::ThreadGroup_klass();
1945 THREADGROUP_FIELDS_DO(FIELD_COMPUTE_OFFSET);
1946 }
1947
1948 #if INCLUDE_CDS
1949 void java_lang_ThreadGroup::serialize_offsets(SerializeClosure* f) {
1950 THREADGROUP_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
1951 }
1952 #endif
1953
1954
1955 // java_lang_VirtualThread
1956
1957 int java_lang_VirtualThread::static_vthread_scope_offset;
1958 int java_lang_VirtualThread::_carrierThread_offset;
1959 int java_lang_VirtualThread::_continuation_offset;
1960 int java_lang_VirtualThread::_state_offset;
1961 int java_lang_VirtualThread::_next_offset;
1962 int java_lang_VirtualThread::_onWaitingList_offset;
1963 int java_lang_VirtualThread::_recheckInterval_offset;
1964
1965 #define VTHREAD_FIELDS_DO(macro) \
1966 macro(static_vthread_scope_offset, k, "VTHREAD_SCOPE", continuationscope_signature, true); \
1967 macro(_carrierThread_offset, k, "carrierThread", thread_signature, false); \
1968 macro(_continuation_offset, k, "cont", continuation_signature, false); \
1969 macro(_state_offset, k, "state", int_signature, false); \
1970 macro(_next_offset, k, "next", vthread_signature, false); \
1971 macro(_onWaitingList_offset, k, "onWaitingList", byte_signature, false); \
1972 macro(_recheckInterval_offset, k, "recheckInterval", byte_signature, false);
1973
1974
1975 void java_lang_VirtualThread::compute_offsets() {
1976 InstanceKlass* k = vmClasses::VirtualThread_klass();
1977 VTHREAD_FIELDS_DO(FIELD_COMPUTE_OFFSET);
1978 }
1979
1980 bool java_lang_VirtualThread::is_instance(oop obj) {
1981 return obj != nullptr && is_subclass(obj->klass());
1982 }
1983
1984 oop java_lang_VirtualThread::carrier_thread(oop vthread) {
1985 oop thread = vthread->obj_field(_carrierThread_offset);
1986 return thread;
1987 }
1988
1989 oop java_lang_VirtualThread::continuation(oop vthread) {
1990 oop cont = vthread->obj_field(_continuation_offset);
1991 return cont;
1992 }
1993
1994 int java_lang_VirtualThread::state(oop vthread) {
1995 return vthread->int_field_acquire(_state_offset);
1996 }
1997
1998 void java_lang_VirtualThread::set_state(oop vthread, int state) {
1999 vthread->release_int_field_put(_state_offset, state);
2000 }
2001
2002 oop java_lang_VirtualThread::next(oop vthread) {
2003 return vthread->obj_field(_next_offset);
2004 }
2005
2006 void java_lang_VirtualThread::set_next(oop vthread, oop next_vthread) {
2007 vthread->obj_field_put(_next_offset, next_vthread);
2008 }
2009
2010 bool java_lang_VirtualThread::set_onWaitingList(oop vthread, OopHandle& list_head) {
2011 uint8_t* addr = vthread->field_addr<uint8_t>(_onWaitingList_offset);
2012 uint8_t value = Atomic::load(addr);
2013 assert(value == 0x00 || value == 0x01, "invariant");
2014 if (value == 0x00) {
2015 value = Atomic::cmpxchg(addr, (uint8_t)0x00, (uint8_t)0x01);
2016 if (value == 0x00) {
2017 for (;;) {
2018 oop head = list_head.resolve();
2019 java_lang_VirtualThread::set_next(vthread, head);
2020 if (list_head.cmpxchg(head, vthread) == head) return true;
2021 }
2022 }
2023 }
2024 return false; // already on waiting list
2025 }
2026
2027 jbyte java_lang_VirtualThread::recheckInterval(oop vthread) {
2028 return vthread->byte_field(_recheckInterval_offset);
2029 }
2030
2031 void java_lang_VirtualThread::set_recheckInterval(oop vthread, jbyte value) {
2032 vthread->release_byte_field_put(_recheckInterval_offset, value);
2033 }
2034
2035 JavaThreadStatus java_lang_VirtualThread::map_state_to_thread_status(int state) {
2036 JavaThreadStatus status = JavaThreadStatus::NEW;
2037 switch (state & ~SUSPENDED) {
2038 case NEW:
2039 status = JavaThreadStatus::NEW;
2040 break;
2041 case STARTED:
2042 case RUNNING:
2043 case PARKING:
2044 case TIMED_PARKING:
2045 case UNPARKED:
2046 case YIELDING:
2047 case YIELDED:
2048 case BLOCKING:
2049 case UNBLOCKED:
2050 status = JavaThreadStatus::RUNNABLE;
2051 break;
2052 case PARKED:
2053 case PINNED:
2054 status = JavaThreadStatus::PARKED;
2055 break;
2056 case TIMED_PARKED:
2057 case TIMED_PINNED:
2058 status = JavaThreadStatus::PARKED_TIMED;
2059 break;
2060 case BLOCKED:
2061 status = JavaThreadStatus::BLOCKED_ON_MONITOR_ENTER;
2062 break;
2063 case TERMINATED:
2064 status = JavaThreadStatus::TERMINATED;
2065 break;
2066 default:
2067 ShouldNotReachHere();
2068 }
2069 return status;
2070 }
2071
2072 bool java_lang_VirtualThread::is_preempted(oop vthread) {
2073 oop continuation = java_lang_VirtualThread::continuation(vthread);
2074 return jdk_internal_vm_Continuation::is_preempted(continuation);
2075 }
2076
2077 #if INCLUDE_CDS
2078 void java_lang_VirtualThread::serialize_offsets(SerializeClosure* f) {
2079 VTHREAD_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
2080 }
2081 #endif
2082
2083 // java_lang_Throwable
2084
2085 int java_lang_Throwable::_backtrace_offset;
2086 int java_lang_Throwable::_detailMessage_offset;
2087 int java_lang_Throwable::_stackTrace_offset;
2088 int java_lang_Throwable::_depth_offset;
2089 int java_lang_Throwable::_cause_offset;
2090 int java_lang_Throwable::_static_unassigned_stacktrace_offset;
2091
2092 #define THROWABLE_FIELDS_DO(macro) \
2093 macro(_backtrace_offset, k, "backtrace", object_signature, false); \
2094 macro(_detailMessage_offset, k, "detailMessage", string_signature, false); \
2095 macro(_stackTrace_offset, k, "stackTrace", java_lang_StackTraceElement_array, false); \
2096 macro(_depth_offset, k, "depth", int_signature, false); \
|