Use freeze_result consistently

Author: pchilano

src/hotspot/share/runtime/continuation.cpp

@@ -61,12 +61,12 @@ JVM_END
 class JvmtiUnmountBeginMark : public StackObj {
   Handle _vthread;
   JavaThread* _target;
-  int _preempt_result;
+  freeze_result _result;
   bool _failed;
 
  public:
   JvmtiUnmountBeginMark(JavaThread* t) :
-    _vthread(t, t->vthread()), _target(t), _preempt_result(freeze_pinned_native), _failed(false) {
+    _vthread(t, t->vthread()), _target(t), _result(freeze_pinned_native), _failed(false) {
     assert(!_target->is_in_VTMS_transition(), "must be");
 
     if (JvmtiVTMSTransitionDisabler::VTMS_notify_jvmti_events()) {
@@ -101,7 +101,7 @@ class JvmtiUnmountBeginMark : public StackObj {
     // been set while blocked in the allocation path during freeze.
     bool jvmti_present = JvmtiVTMSTransitionDisabler::VTMS_notify_jvmti_events();
 
-    if (_preempt_result != freeze_ok) {
+    if (_result != freeze_ok) {
       // Undo transition
       if (jvmti_present) {
         JvmtiVTMSTransitionDisabler::finish_VTMS_transition((jthread)_vthread.raw_value(), false);
@@ -120,7 +120,7 @@ class JvmtiUnmountBeginMark : public StackObj {
       }
     }
   }
-  void set_preempt_result(int res) { _preempt_result = res; }
+  void set_result(freeze_result res) { _result = res; }
   bool failed() { return _failed; }
 };
 
@@ -141,7 +141,7 @@ static bool is_vthread_safe_to_preempt(JavaThread* target, oop vthread) {
   return JVMTI_ONLY(is_vthread_safe_to_preempt_for_jvmti(target, vthread)) NOT_JVMTI(true);
 }
 
-typedef int (*FreezeContFnT)(JavaThread*, intptr_t*);
+typedef freeze_result (*FreezeContFnT)(JavaThread*, intptr_t*);
 
 static void verify_preempt_preconditions(JavaThread* target, oop continuation) {
   assert(target == JavaThread::current(), "no support for external preemption");
@@ -153,7 +153,7 @@ static void verify_preempt_preconditions(JavaThread* target, oop continuation) {
   assert(!target->has_pending_exception(), "");
 }
 
-int Continuation::try_preempt(JavaThread* target, oop continuation) {
+freeze_result Continuation::try_preempt(JavaThread* target, oop continuation) {
   verify_preempt_preconditions(target, continuation);
 
   if (LockingMode == LM_LEGACY) {
@@ -166,9 +166,9 @@ int Continuation::try_preempt(JavaThread* target, oop continuation) {
 
   JVMTI_ONLY(JvmtiUnmountBeginMark jubm(target);)
   JVMTI_ONLY(if (jubm.failed()) return freeze_pinned_native;)
-  int res = CAST_TO_FN_PTR(FreezeContFnT, freeze_preempt_entry())(target, target->last_Java_sp());
+  freeze_result res = CAST_TO_FN_PTR(FreezeContFnT, freeze_preempt_entry())(target, target->last_Java_sp());
   log_trace(continuations, preempt)("try_preempt: %d", res);
-  JVMTI_ONLY(jubm.set_preempt_result(res);)
+  JVMTI_ONLY(jubm.set_result(res);)
   return res;
 }
 

src/hotspot/share/runtime/continuation.hpp

@@ -90,7 +90,7 @@ class Continuation : AllStatic {
   static int prepare_thaw(JavaThread* thread, bool return_barrier);
   static address thaw_entry();
 
-  static int try_preempt(JavaThread* target, oop continuation);
+  static freeze_result try_preempt(JavaThread* target, oop continuation);
 
   static ContinuationEntry* get_continuation_entry_for_continuation(JavaThread* thread, oop continuation);
   static ContinuationEntry* get_continuation_entry_for_sp(JavaThread* thread, intptr_t* const sp);

src/hotspot/share/runtime/continuationFreezeThaw.cpp

@@ -202,7 +202,7 @@ static void verify_continuation(oop continuation) { }
 #endif
 
 static freeze_result is_pinned0(JavaThread* thread, oop cont_scope, bool safepoint);
-template<typename ConfigT, bool preempt> static inline int freeze_internal(JavaThread* current, intptr_t* const sp);
+template<typename ConfigT, bool preempt> static inline freeze_result freeze_internal(JavaThread* current, intptr_t* const sp);
 
 static inline int prepare_thaw_internal(JavaThread* thread, bool return_barrier);
 template<typename ConfigT> static inline intptr_t* thaw_internal(JavaThread* thread, const Continuation::thaw_kind kind);
@@ -218,7 +218,7 @@ static JRT_BLOCK_ENTRY(int, freeze(JavaThread* current, intptr_t* sp))
     current->set_cont_fastpath(nullptr);
   }
 
-  return ConfigT::freeze(current, sp);
+  return checked_cast<int>(ConfigT::freeze(current, sp));
 JRT_END
 
 JRT_LEAF(int, Continuation::prepare_thaw(JavaThread* thread, bool return_barrier))
@@ -255,11 +255,11 @@ class Config {
   typedef Config<oops, BarrierSetT> SelfT;
   using OopT = std::conditional_t<oops == oop_kind::NARROW, narrowOop, oop>;
 
-  static int freeze(JavaThread* thread, intptr_t* const sp) {
+  static freeze_result freeze(JavaThread* thread, intptr_t* const sp) {
     return freeze_internal<SelfT, false>(thread, sp);
   }
 
-  static int freeze_preempt(JavaThread* thread, intptr_t* const sp) {
+  static freeze_result freeze_preempt(JavaThread* thread, intptr_t* const sp) {
     return freeze_internal<SelfT, true>(thread, sp);
   }
 
@@ -1666,15 +1666,15 @@ bool FreezeBase::check_valid_fast_path() {
 }
 #endif // ASSERT
 
-static inline int freeze_epilog(ContinuationWrapper& cont) {
+static inline freeze_result freeze_epilog(ContinuationWrapper& cont) {
   verify_continuation(cont.continuation());
   assert(!cont.is_empty(), "");
 
   log_develop_debug(continuations)("=== End of freeze cont ### #" INTPTR_FORMAT, cont.hash());
-  return 0;
+  return freeze_ok;
 }
 
-static int freeze_epilog(JavaThread* thread, ContinuationWrapper& cont, freeze_result res) {
+static freeze_result freeze_epilog(JavaThread* thread, ContinuationWrapper& cont, freeze_result res) {
   if (UNLIKELY(res != freeze_ok)) {
     verify_continuation(cont.continuation());
     log_develop_trace(continuations)("=== end of freeze (fail %d)", res);
@@ -1685,7 +1685,7 @@ static int freeze_epilog(JavaThread* thread, ContinuationWrapper& cont, freeze_r
   return freeze_epilog(cont);
 }
 
-static int preempt_epilog(ContinuationWrapper& cont, freeze_result res, frame& old_last_frame) {
+static freeze_result preempt_epilog(ContinuationWrapper& cont, freeze_result res, frame& old_last_frame) {
   if (UNLIKELY(res != freeze_ok)) {
     verify_continuation(cont.continuation());
     log_develop_trace(continuations)("=== end of freeze (fail %d)", res);
@@ -1699,7 +1699,7 @@ static int preempt_epilog(ContinuationWrapper& cont, freeze_result res, frame& o
 }
 
 template<typename ConfigT, bool preempt>
-static inline int freeze_internal(JavaThread* current, intptr_t* const sp) {
+static inline freeze_result freeze_internal(JavaThread* current, intptr_t* const sp) {
   assert(!current->has_pending_exception(), "");
 
 #ifdef ASSERT

src/hotspot/share/runtime/objectMonitor.cpp

@@ -517,7 +517,7 @@ void ObjectMonitor::enter_with_contention_mark(JavaThread *current, ObjectMonito
 
     ContinuationEntry* ce = current->last_continuation();
     if (ce != nullptr && ce->is_virtual_thread()) {
-      int result = Continuation::try_preempt(current, ce->cont_oop(current));
+      freeze_result result = Continuation::try_preempt(current, ce->cont_oop(current));
       if (result == freeze_ok) {
         bool acquired = VThreadMonitorEnter(current);
         if (acquired) {
@@ -1691,7 +1691,7 @@ void ObjectMonitor::wait(jlong millis, bool interruptible, TRAPS) {
 
   ContinuationEntry* ce = current->last_continuation();
   if (ce != nullptr && ce->is_virtual_thread()) {
-    int result = Continuation::try_preempt(current, ce->cont_oop(current));
+    freeze_result result = Continuation::try_preempt(current, ce->cont_oop(current));
     if (result == freeze_ok) {
       VThreadWait(current, millis);
       current->set_current_waiting_monitor(nullptr);