8356251: Need minor cleanup for interp_only_mode

Reviewed-by: lmesnik, cjplummer

Author: Serguei Spitsyn

src/hotspot/share/prims/jvmtiThreadState.cpp

@@ -123,7 +123,7 @@ JvmtiThreadState::JvmtiThreadState(JavaThread* thread, oop thread_oop)
       // Set this only if thread_oop is current thread->jvmti_vthread().
       thread->set_jvmti_thread_state(this);
     }
-    thread->set_interp_only_mode(0);
+    thread->set_interp_only_mode(false);
   }
 }
 
@@ -790,18 +790,19 @@ void JvmtiThreadState::add_env(JvmtiEnvBase *env) {
 
 void JvmtiThreadState::enter_interp_only_mode() {
   assert(_thread != nullptr, "sanity check");
+  assert(!is_interp_only_mode(), "entering interp only when in interp only mode");
   _seen_interp_only_mode = true;
-  _thread->increment_interp_only_mode();
+  _thread->set_interp_only_mode(true);
   invalidate_cur_stack_depth();
 }
 
 void JvmtiThreadState::leave_interp_only_mode() {
   assert(is_interp_only_mode(), "leaving interp only when not in interp only mode");
   if (_thread == nullptr) {
     // Unmounted virtual thread updates the saved value.
-    --_saved_interp_only_mode;
+    _saved_interp_only_mode = 0;
   } else {
-    _thread->decrement_interp_only_mode();
+    _thread->set_interp_only_mode(false);
   }
 }
 

src/hotspot/share/prims/jvmtiThreadState.hpp

@@ -193,6 +193,7 @@ class JvmtiThreadState : public CHeapObj<mtInternal> {
   bool              _pending_step_for_popframe;
   bool              _pending_step_for_earlyret;
   bool              _top_frame_is_exiting;
+  bool              _saved_interp_only_mode;
   int               _hide_level;
 
  public:
@@ -213,7 +214,6 @@ class JvmtiThreadState : public CHeapObj<mtInternal> {
 
   // This is only valid when is_interp_only_mode() returns true
   int               _cur_stack_depth;
-  int               _saved_interp_only_mode;
 
   JvmtiThreadEventEnable _thread_event_enable;
 
@@ -275,7 +275,7 @@ class JvmtiThreadState : public CHeapObj<mtInternal> {
 
   // Used by the interpreter for fullspeed debugging support
   bool is_interp_only_mode()                {
-    return _thread == nullptr ?  _saved_interp_only_mode != 0 : _thread->is_interp_only_mode();
+    return _thread == nullptr ? _saved_interp_only_mode : _thread->is_interp_only_mode();
   }
   void enter_interp_only_mode();
   void leave_interp_only_mode();

src/hotspot/share/prims/jvmtiThreadState.inline.hpp

@@ -144,13 +144,13 @@ inline void JvmtiThreadState::unbind_from(JvmtiThreadState* state, JavaThread* t
     return;
   }
   // Save thread's interp_only_mode.
-  state->_saved_interp_only_mode = thread->get_interp_only_mode();
+  state->_saved_interp_only_mode = thread->is_interp_only_mode();
   state->set_thread(nullptr);  // Make sure stale _thread value is never used.
 }
 
 inline void JvmtiThreadState::bind_to(JvmtiThreadState* state, JavaThread* thread) {
   // Restore thread's interp_only_mode.
-  thread->set_interp_only_mode(state == nullptr ? 0 : state->_saved_interp_only_mode);
+  thread->set_interp_only_mode(state != nullptr && state->_saved_interp_only_mode);
 
   // Make continuation notice the interp_only_mode change.
   Continuation::set_cont_fastpath_thread_state(thread);
@@ -168,11 +168,7 @@ inline void JvmtiThreadState::process_pending_interp_only(JavaThread* current) {
   JvmtiThreadState* state = current->jvmti_thread_state();
 
   if (state != nullptr && state->is_pending_interp_only_mode()) {
-    MutexLocker mu(JvmtiThreadState_lock);
-    state = current->jvmti_thread_state();
-    if (state != nullptr && state->is_pending_interp_only_mode()) {
-      JvmtiEventController::enter_interp_only_mode(state);
-    }
+    JvmtiEventController::enter_interp_only_mode(state);
   }
 }
 #endif // SHARE_PRIMS_JVMTITHREADSTATE_INLINE_HPP

src/hotspot/share/runtime/javaThread.hpp

@@ -1167,16 +1167,14 @@ class JavaThread: public Thread {
   // It can be set to zero asynchronously to this threads execution (i.e., without
   // safepoint/handshake or a lock) so we have to be very careful.
   // Accesses by other threads are synchronized using JvmtiThreadState_lock though.
+  // This field is checked by the interpreter which expects it to be an integer.
   int               _interp_only_mode;
 
  public:
   // used by the interpreter for fullspeed debugging support (see above)
   static ByteSize interp_only_mode_offset() { return byte_offset_of(JavaThread, _interp_only_mode); }
   bool is_interp_only_mode()                { return (_interp_only_mode != 0); }
-  int get_interp_only_mode()                { return _interp_only_mode; }
-  int set_interp_only_mode(int val)         { return _interp_only_mode = val; }
-  void increment_interp_only_mode()         { ++_interp_only_mode; }
-  void decrement_interp_only_mode()         { --_interp_only_mode; }
+  void set_interp_only_mode(bool val)       { _interp_only_mode = val ? 1 : 0; }
 
   // support for cached flag that indicates whether exceptions need to be posted for this thread
   // if this is false, we can avoid deoptimizing when events are thrown