Rename CFP_HAS_JIT_RETURN to CFP_JIT_RETURN

Return the pointer directly instead of a bool, for consistency with
CFP_ISEQ and CFP_PC. The pointer is truthy in if conditions so all
callers work unchanged.

Author: k0kubun

cont.c

@@ -1480,7 +1480,7 @@ rb_yjit_cancel_jit_return(void *leave_exit, void *leave_exception)
 
         const rb_control_frame_t *cfp = cont->ec->cfp;
         while (!RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(cont->ec, cfp)) {
-            if (CFP_HAS_JIT_RETURN(cfp) && cfp->jit_return != leave_exception) {
+            if (CFP_JIT_RETURN(cfp) && cfp->jit_return != leave_exception) {
                 ((rb_control_frame_t *)cfp)->jit_return = leave_exit;
             }
             cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);

vm.c

@@ -2852,7 +2852,7 @@ zjit_materialize_frames(rb_control_frame_t *cfp)
     if (!rb_zjit_enabled_p) return;
 
     while (true) {
-        if (CFP_HAS_JIT_RETURN(cfp)) {
+        if (CFP_JIT_RETURN(cfp)) {
             const zjit_jit_frame_t *jit_frame = (const zjit_jit_frame_t *)cfp->jit_return;
             cfp->pc = jit_frame->pc;
             cfp->_iseq = (rb_iseq_t *)jit_frame->iseq;
@@ -3671,7 +3671,7 @@ rb_execution_context_update(rb_execution_context_t *ec)
         while (cfp != limit_cfp) {
             const VALUE *ep = cfp->ep;
             cfp->self = rb_gc_location(cfp->self);
-            if (rb_zjit_enabled_p && CFP_HAS_JIT_RETURN(cfp)) {
+            if (CFP_JIT_RETURN(cfp)) {
                 rb_zjit_jit_frame_update_references((zjit_jit_frame_t *)cfp->jit_return);
                 // block_code must always be relocated. For ISEQ frames, the JIT caller
                 // may have written it (gen_block_handler_specval) for passing blocks.

yjit.c

@@ -480,7 +480,7 @@ rb_yjit_set_exception_return(rb_control_frame_t *cfp, void *leave_exit, void *le
         // If it's a FINISH frame, just normally exit with a non-Qundef value.
         cfp->jit_return = leave_exit;
     }
-    else if (CFP_HAS_JIT_RETURN(cfp)) {
+    else if (CFP_JIT_RETURN(cfp)) {
         while (!VM_FRAME_FINISHED_P(cfp)) {
             if (cfp->jit_return == leave_exit) {
                 // Unlike jit_exec(), leave_exit is not safe on a non-FINISH frame on

zjit.h

@@ -69,23 +69,23 @@ enum zjit_poison_values {
     ZJIT_JIT_RETURN_POISON = 2,
 };
 
-// Check if cfp->jit_return holds a ZJIT lightweight frame (JITFrame pointer).
+// Return the JITFrame pointer from cfp->jit_return, or NULL if not present.
 // YJIT also uses jit_return (as a return address), so this must only return
-// true when ZJIT is enabled and has set jit_return to a JITFrame pointer.
-static inline bool
-CFP_HAS_JIT_RETURN(const rb_control_frame_t *cfp)
+// non-NULL when ZJIT is enabled and has set jit_return to a JITFrame pointer.
+static inline void *
+CFP_JIT_RETURN(const rb_control_frame_t *cfp)
 {
-    if (!rb_zjit_enabled_p) return false;
+    if (!rb_zjit_enabled_p) return NULL;
 #if USE_ZJIT
     RUBY_ASSERT_ALWAYS(cfp->jit_return != (void *)ZJIT_JIT_RETURN_POISON);
 #endif
-    return !!cfp->jit_return;
+    return cfp->jit_return;
 }
 
 static inline const VALUE*
 CFP_PC(const rb_control_frame_t *cfp)
 {
-    if (CFP_HAS_JIT_RETURN(cfp)) {
+    if (CFP_JIT_RETURN(cfp)) {
         return ((const zjit_jit_frame_t *)cfp->jit_return)->pc;
     }
     return cfp->pc;
@@ -94,7 +94,7 @@ CFP_PC(const rb_control_frame_t *cfp)
 static inline const rb_iseq_t*
 CFP_ISEQ(const rb_control_frame_t *cfp)
 {
-    if (CFP_HAS_JIT_RETURN(cfp)) {
+    if (CFP_JIT_RETURN(cfp)) {
         return ((const zjit_jit_frame_t *)cfp->jit_return)->iseq;
     }
     return cfp->_iseq;

zjit/src/backend/lir.rs

@@ -2673,7 +2673,7 @@ impl Assembler
                     // Clear jit_return to fully materialize the frame. This must happen
                     // before any C call in the exit path (e.g. no_profile_send_recompile)
                     // because that C call can trigger GC, which walks the stack and would
-                    // hit the CFP_HAS_JIT_RETURN assertion if jit_return still holds the
+                    // hit the CFP_JIT_RETURN assertion if jit_return still holds the
                     // runtime_checks poison value (JIT_RETURN_POISON).
                     asm_comment!(asm, "clear cfp->jit_return");
                     asm.store(Opnd::mem(64, CFP, RUBY_OFFSET_CFP_JIT_RETURN), 0.into());