rename jitref functions

Fidget-Spinner · Fidget-Spinner · commit 2d779c4ded74 · 2025-06-04T23:11:37.000+08:00
diff --git a/Include/internal/pycore_optimizer.h b/Include/internal/pycore_optimizer.h
@@ -230,24 +230,19 @@ typedef union {
 #define JIT_BITS_TO_PTR_MASKED(REF) ((JitOptSymbol *)(((REF).bits) & (~Py_TAG_REFCNT)))
 
 static inline JitOptSymbol *
-PyJitRef_AsSymbolBorrow(JitOptRef ref)
+PyJitRef_Unwrap(JitOptRef ref)
 {
     return JIT_BITS_TO_PTR_MASKED(ref);
 }
 
 bool _Py_uop_symbol_is_immortal(JitOptSymbol *sym);
 
-static inline JitOptRef
-PyJitRef_FromSymbolBorrow(JitOptSymbol *sym)
-{
-    return (JitOptRef){.bits=(uintptr_t)sym | Py_TAG_REFCNT};
-}
 
 static inline JitOptRef
-PyJitRef_FromSymbolSteal(JitOptSymbol *sym)
+PyJitRef_Wrap(JitOptSymbol *sym)
 {
     if (sym == NULL || _Py_uop_symbol_is_immortal(sym)) {
-        return PyJitRef_FromSymbolBorrow(sym);
+        return (JitOptRef){.bits=(uintptr_t)sym | Py_TAG_REFCNT};
     }
     return (JitOptRef){.bits=(uintptr_t)sym};
 }
diff --git a/Python/optimizer_symbols.c b/Python/optimizer_symbols.c
@@ -91,7 +91,7 @@ out_of_space(JitOptContext *ctx)
 JitOptRef
 out_of_space_ref(JitOptContext *ctx)
 {
-    return PyJitRef_FromSymbolSteal(out_of_space(ctx));
+    return PyJitRef_Wrap(out_of_space(ctx));
 }
 
 static JitOptSymbol *
@@ -125,26 +125,26 @@ sym_set_bottom(JitOptContext *ctx, JitOptSymbol *sym)
 bool
 _Py_uop_sym_is_bottom(JitOptRef ref)
 {
-    JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);
+    JitOptSymbol *sym = PyJitRef_Unwrap(ref);
     return sym->tag == JIT_SYM_BOTTOM_TAG;
 }
 
 bool
 _Py_uop_sym_is_not_null(JitOptRef ref) {
-    JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);
+    JitOptSymbol *sym = PyJitRef_Unwrap(ref);
     return sym->tag == JIT_SYM_NON_NULL_TAG || sym->tag > JIT_SYM_BOTTOM_TAG;
 }
 
 bool
 _Py_uop_sym_is_const(JitOptContext *ctx, JitOptRef ref)
 {
-    JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);
+    JitOptSymbol *sym = PyJitRef_Unwrap(ref);
     if (sym->tag == JIT_SYM_KNOWN_VALUE_TAG) {
         return true;
     }
     if (sym->tag == JIT_SYM_TRUTHINESS_TAG) {
         JitOptSymbol *value = allocation_base(ctx) + sym->truthiness.value;
-        int truthiness = _Py_uop_sym_truthiness(ctx, PyJitRef_FromSymbolSteal(value));
+        int truthiness = _Py_uop_sym_truthiness(ctx, PyJitRef_Wrap(value));
         if (truthiness < 0) {
             return false;
         }
@@ -157,20 +157,20 @@ _Py_uop_sym_is_const(JitOptContext *ctx, JitOptRef ref)
 bool
 _Py_uop_sym_is_null(JitOptRef ref)
 {
-    return PyJitRef_AsSymbolBorrow(ref)->tag == JIT_SYM_NULL_TAG;
+    return PyJitRef_Unwrap(ref)->tag == JIT_SYM_NULL_TAG;
 }
 
 
 PyObject *
 _Py_uop_sym_get_const(JitOptContext *ctx, JitOptRef ref)
 {
-    JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);
+    JitOptSymbol *sym = PyJitRef_Unwrap(ref);
     if (sym->tag == JIT_SYM_KNOWN_VALUE_TAG) {
         return sym->value.value;
     }
     if (sym->tag == JIT_SYM_TRUTHINESS_TAG) {
         JitOptSymbol *value = allocation_base(ctx) + sym->truthiness.value;
-        int truthiness = _Py_uop_sym_truthiness(ctx, PyJitRef_FromSymbolSteal(value));
+        int truthiness = _Py_uop_sym_truthiness(ctx, PyJitRef_Wrap(value));
         if (truthiness < 0) {
             return NULL;
         }
@@ -184,7 +184,7 @@ _Py_uop_sym_get_const(JitOptContext *ctx, JitOptRef ref)
 void
 _Py_uop_sym_set_type(JitOptContext *ctx, JitOptRef ref, PyTypeObject *typ)
 {
-    JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);
+    JitOptSymbol *sym = PyJitRef_Unwrap(ref);
     JitSymType tag = sym->tag;
     switch(tag) {
         case JIT_SYM_NULL_TAG:
@@ -235,7 +235,7 @@ _Py_uop_sym_set_type(JitOptContext *ctx, JitOptRef ref, PyTypeObject *typ)
 bool
 _Py_uop_sym_set_type_version(JitOptContext *ctx, JitOptRef ref, unsigned int version)
 {
-    JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);
+    JitOptSymbol *sym = PyJitRef_Unwrap(ref);
     PyTypeObject *type = _PyType_LookupByVersion(version);
     if (type) {
         _Py_uop_sym_set_type(ctx, ref, type);
@@ -293,7 +293,7 @@ _Py_uop_sym_set_type_version(JitOptContext *ctx, JitOptRef ref, unsigned int ver
 void
 _Py_uop_sym_set_const(JitOptContext *ctx, JitOptRef ref, PyObject *const_val)
 {
-    JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);
+    JitOptSymbol *sym = PyJitRef_Unwrap(ref);
     JitSymType tag = sym->tag;
     switch(tag) {
         case JIT_SYM_NULL_TAG:
@@ -348,7 +348,8 @@ _Py_uop_sym_set_const(JitOptContext *ctx, JitOptRef ref, PyObject *const_val)
                 sym_set_bottom(ctx, sym);
                 return;
             }
-            JitOptRef value = PyJitRef_FromSymbolSteal(allocation_base(ctx) + sym->truthiness.value);
+            JitOptRef value = PyJitRef_Wrap(
+                allocation_base(ctx) + sym->truthiness.value);
             PyTypeObject *type = _Py_uop_sym_get_type(value);
             if (const_val == (sym->truthiness.invert ? Py_False : Py_True)) {
                 // value is truthy. This is only useful for bool:
@@ -375,7 +376,7 @@ _Py_uop_sym_set_const(JitOptContext *ctx, JitOptRef ref, PyObject *const_val)
 void
 _Py_uop_sym_set_null(JitOptContext *ctx, JitOptRef ref)
 {
-    JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);
+    JitOptSymbol *sym = PyJitRef_Unwrap(ref);
     if (sym->tag == JIT_SYM_UNKNOWN_TAG) {
         sym->tag = JIT_SYM_NULL_TAG;
     }
@@ -387,7 +388,7 @@ _Py_uop_sym_set_null(JitOptContext *ctx, JitOptRef ref)
 void
 _Py_uop_sym_set_non_null(JitOptContext *ctx, JitOptRef ref)
 {
-    JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);
+    JitOptSymbol *sym = PyJitRef_Unwrap(ref);
     if (sym->tag == JIT_SYM_UNKNOWN_TAG) {
         sym->tag = JIT_SYM_NON_NULL_TAG;
     }
@@ -403,7 +404,7 @@ _Py_uop_sym_new_unknown(JitOptContext *ctx)
     if (res == NULL) {
         return out_of_space_ref(ctx);
     }
-    return PyJitRef_FromSymbolSteal(res);
+    return PyJitRef_Wrap(res);
 }
 
 JitOptRef
@@ -414,7 +415,7 @@ _Py_uop_sym_new_not_null(JitOptContext *ctx)
         return out_of_space_ref(ctx);
     }
     res->tag = JIT_SYM_NON_NULL_TAG;
-    return PyJitRef_FromSymbolSteal(res);
+    return PyJitRef_Wrap(res);
 }
 
 JitOptRef
@@ -424,7 +425,7 @@ _Py_uop_sym_new_type(JitOptContext *ctx, PyTypeObject *typ)
     if (res == NULL) {
         return out_of_space_ref(ctx);
     }
-    JitOptRef ref = PyJitRef_FromSymbolSteal(res);
+    JitOptRef ref = PyJitRef_Wrap(res);
     _Py_uop_sym_set_type(ctx, ref, typ);
     return ref;
 }
@@ -438,7 +439,7 @@ _Py_uop_sym_new_const(JitOptContext *ctx, PyObject *const_val)
     if (res == NULL) {
         return out_of_space_ref(ctx);
     }
-    JitOptRef ref = PyJitRef_FromSymbolSteal(res);
+    JitOptRef ref = PyJitRef_Wrap(res);
     _Py_uop_sym_set_const(ctx, ref, const_val);
     return ref;
 }
@@ -450,15 +451,15 @@ _Py_uop_sym_new_null(JitOptContext *ctx)
     if (null_sym == NULL) {
         return out_of_space_ref(ctx);
     }
-    JitOptRef ref = PyJitRef_FromSymbolSteal(null_sym);
+    JitOptRef ref = PyJitRef_Wrap(null_sym);
     _Py_uop_sym_set_null(ctx, ref);
     return ref;
 }
 
 PyTypeObject *
 _Py_uop_sym_get_type(JitOptRef ref)
 {
-    JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);
+    JitOptSymbol *sym = PyJitRef_Unwrap(ref);
     JitSymType tag = sym->tag;
     switch(tag) {
         case JIT_SYM_NULL_TAG:
@@ -483,7 +484,7 @@ _Py_uop_sym_get_type(JitOptRef ref)
 unsigned int
 _Py_uop_sym_get_type_version(JitOptRef ref)
 {
-    JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);
+    JitOptSymbol *sym = PyJitRef_Unwrap(ref);
     JitSymType tag = sym->tag;
     switch(tag) {
         case JIT_SYM_NULL_TAG:
@@ -527,7 +528,7 @@ _Py_uop_sym_matches_type_version(JitOptRef sym, unsigned int version)
 int
 _Py_uop_sym_truthiness(JitOptContext *ctx, JitOptRef ref)
 {
-    JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);
+    JitOptSymbol *sym = PyJitRef_Unwrap(ref);
     switch(sym->tag) {
         case JIT_SYM_NULL_TAG:
         case JIT_SYM_TYPE_VERSION_TAG:
@@ -548,7 +549,7 @@ _Py_uop_sym_truthiness(JitOptContext *ctx, JitOptRef ref)
             ;
             JitOptSymbol *value = allocation_base(ctx) + sym->truthiness.value;
             int truthiness = _Py_uop_sym_truthiness(ctx,
-                                                    PyJitRef_FromSymbolBorrow(value));
+                                                    PyJitRef_Wrap(value));
             if (truthiness < 0) {
                 return truthiness;
             }
@@ -589,16 +590,16 @@ _Py_uop_sym_new_tuple(JitOptContext *ctx, int size, JitOptRef *args)
         res->tag = JIT_SYM_TUPLE_TAG;
         res->tuple.length = size;
         for (int i = 0; i < size; i++) {
-            res->tuple.items[i] = (uint16_t)(PyJitRef_AsSymbolBorrow(args[i]) - allocation_base(ctx));
+            res->tuple.items[i] = (uint16_t)(PyJitRef_Unwrap(args[i]) - allocation_base(ctx));
         }
     }
-    return PyJitRef_FromSymbolSteal(res);
+    return PyJitRef_Wrap(res);
 }
 
 JitOptRef
 _Py_uop_sym_tuple_getitem(JitOptContext *ctx, JitOptRef ref, int item)
 {
-    JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);
+    JitOptSymbol *sym = PyJitRef_Unwrap(ref);
     assert(item >= 0);
     if (sym->tag == JIT_SYM_KNOWN_VALUE_TAG) {
         PyObject *tuple = sym->value.value;
@@ -607,15 +608,15 @@ _Py_uop_sym_tuple_getitem(JitOptContext *ctx, JitOptRef ref, int item)
         }
     }
     else if (sym->tag == JIT_SYM_TUPLE_TAG && item < sym->tuple.length) {
-        return PyJitRef_FromSymbolSteal(allocation_base(ctx) + sym->tuple.items[item]);
+        return PyJitRef_Wrap(allocation_base(ctx) + sym->tuple.items[item]);
     }
     return _Py_uop_sym_new_not_null(ctx);
 }
 
 int
 _Py_uop_sym_tuple_length(JitOptRef ref)
 {
-    JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);
+    JitOptSymbol *sym = PyJitRef_Unwrap(ref);
     if (sym->tag == JIT_SYM_KNOWN_VALUE_TAG) {
         PyObject *tuple = sym->value.value;
         if (PyTuple_CheckExact(tuple)) {
@@ -647,14 +648,14 @@ _Py_uop_symbol_is_immortal(JitOptSymbol *sym)
 bool
 _Py_uop_sym_is_immortal(JitOptRef ref)
 {
-    JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);
+    JitOptSymbol *sym = PyJitRef_Unwrap(ref);
     return _Py_uop_symbol_is_immortal(sym);
 }
 
 JitOptRef
 _Py_uop_sym_new_truthiness(JitOptContext *ctx, JitOptRef ref, bool truthy)
 {
-    JitOptSymbol *value = PyJitRef_AsSymbolBorrow(ref);
+    JitOptSymbol *value = PyJitRef_Unwrap(ref);
     // It's clearer to invert this in the signature:
     bool invert = !truthy;
     if (value->tag == JIT_SYM_TRUTHINESS_TAG && value->truthiness.invert == invert) {
@@ -673,7 +674,7 @@ _Py_uop_sym_new_truthiness(JitOptContext *ctx, JitOptRef ref, bool truthy)
     else {
         make_const(res, (truthiness ^ invert) ? Py_True : Py_False);
     }
-    return PyJitRef_FromSymbolSteal(res);
+    return PyJitRef_Wrap(res);
 }
 
 // 0 on success, -1 on error.
@@ -809,7 +810,7 @@ _Py_uop_symbols_test(PyObject *Py_UNUSED(self), PyObject *Py_UNUSED(ignored))
     TEST_PREDICATE(_Py_uop_sym_get_const(ctx, ref) == NULL, "top as constant is not NULL");
     TEST_PREDICATE(!_Py_uop_sym_is_bottom(ref), "top is bottom");
 
-    ref = PyJitRef_FromSymbolSteal(make_bottom(ctx));
+    ref = PyJitRef_Wrap(make_bottom(ctx));
     if (PyJitRef_IsNull(ref)) {
         goto fail;
     }

Original file line number	Diff line number	Diff line change
`@@ -230,24 +230,19 @@ typedef union {`
`230`	`230`	`#define JIT_BITS_TO_PTR_MASKED(REF) ((JitOptSymbol *)(((REF).bits) & (~Py_TAG_REFCNT)))`
`231`	`231`
`232`	`232`	`static inline JitOptSymbol *`
`233`		`-PyJitRef_AsSymbolBorrow(JitOptRef ref)`
	`233`	`+PyJitRef_Unwrap(JitOptRef ref)`
`234`	`234`	`{`
`235`	`235`	`return JIT_BITS_TO_PTR_MASKED(ref);`
`236`	`236`	`}`
`237`	`237`
`238`	`238`	`bool _Py_uop_symbol_is_immortal(JitOptSymbol *sym);`
`239`	`239`
`240`		`-static inline JitOptRef`
`241`		`-PyJitRef_FromSymbolBorrow(JitOptSymbol *sym)`
`242`		`-{`
`243`		`- return (JitOptRef){.bits=(uintptr_t)sym \| Py_TAG_REFCNT};`
`244`		`-}`
`245`	`240`
`246`	`241`	`static inline JitOptRef`
`247`		`-PyJitRef_FromSymbolSteal(JitOptSymbol *sym)`
	`242`	`+PyJitRef_Wrap(JitOptSymbol *sym)`
`248`	`243`	`{`
`249`	`244`	`if (sym == NULL \|\| _Py_uop_symbol_is_immortal(sym)) {`
`250`		`- return PyJitRef_FromSymbolBorrow(sym);`
	`245`	`+ return (JitOptRef){.bits=(uintptr_t)sym \| Py_TAG_REFCNT};`
`251`	`246`	`}`
`252`	`247`	`return (JitOptRef){.bits=(uintptr_t)sym};`
`253`	`248`	`}`
Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ out_of_space(JitOptContext *ctx)`
`91`	`91`	`JitOptRef`
`92`	`92`	`out_of_space_ref(JitOptContext *ctx)`
`93`	`93`	`{`
`94`		`- return PyJitRef_FromSymbolSteal(out_of_space(ctx));`
	`94`	`+ return PyJitRef_Wrap(out_of_space(ctx));`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`static JitOptSymbol *`
`@@ -125,26 +125,26 @@ sym_set_bottom(JitOptContext ctx, JitOptSymbol sym)`
`125`	`125`	`bool`
`126`	`126`	`_Py_uop_sym_is_bottom(JitOptRef ref)`
`127`	`127`	`{`
`128`		`- JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);`
	`128`	`+ JitOptSymbol *sym = PyJitRef_Unwrap(ref);`
`129`	`129`	`return sym->tag == JIT_SYM_BOTTOM_TAG;`
`130`	`130`	`}`
`131`	`131`
`132`	`132`	`bool`
`133`	`133`	`_Py_uop_sym_is_not_null(JitOptRef ref) {`
`134`		`- JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);`
	`134`	`+ JitOptSymbol *sym = PyJitRef_Unwrap(ref);`
`135`	`135`	`return sym->tag == JIT_SYM_NON_NULL_TAG \|\| sym->tag > JIT_SYM_BOTTOM_TAG;`
`136`	`136`	`}`
`137`	`137`
`138`	`138`	`bool`
`139`	`139`	`_Py_uop_sym_is_const(JitOptContext *ctx, JitOptRef ref)`
`140`	`140`	`{`
`141`		`- JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);`
	`141`	`+ JitOptSymbol *sym = PyJitRef_Unwrap(ref);`
`142`	`142`	`if (sym->tag == JIT_SYM_KNOWN_VALUE_TAG) {`
`143`	`143`	`return true;`
`144`	`144`	`}`
`145`	`145`	`if (sym->tag == JIT_SYM_TRUTHINESS_TAG) {`
`146`	`146`	`JitOptSymbol *value = allocation_base(ctx) + sym->truthiness.value;`
`147`		`- int truthiness = _Py_uop_sym_truthiness(ctx, PyJitRef_FromSymbolSteal(value));`
	`147`	`+ int truthiness = _Py_uop_sym_truthiness(ctx, PyJitRef_Wrap(value));`
`148`	`148`	`if (truthiness < 0) {`
`149`	`149`	`return false;`
`150`	`150`	`}`
`@@ -157,20 +157,20 @@ _Py_uop_sym_is_const(JitOptContext *ctx, JitOptRef ref)`
`157`	`157`	`bool`
`158`	`158`	`_Py_uop_sym_is_null(JitOptRef ref)`
`159`	`159`	`{`
`160`		`- return PyJitRef_AsSymbolBorrow(ref)->tag == JIT_SYM_NULL_TAG;`
	`160`	`+ return PyJitRef_Unwrap(ref)->tag == JIT_SYM_NULL_TAG;`
`161`	`161`	`}`
`162`	`162`
`163`	`163`
`164`	`164`	`PyObject *`
`165`	`165`	`_Py_uop_sym_get_const(JitOptContext *ctx, JitOptRef ref)`
`166`	`166`	`{`
`167`		`- JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);`
	`167`	`+ JitOptSymbol *sym = PyJitRef_Unwrap(ref);`
`168`	`168`	`if (sym->tag == JIT_SYM_KNOWN_VALUE_TAG) {`
`169`	`169`	`return sym->value.value;`
`170`	`170`	`}`
`171`	`171`	`if (sym->tag == JIT_SYM_TRUTHINESS_TAG) {`
`172`	`172`	`JitOptSymbol *value = allocation_base(ctx) + sym->truthiness.value;`
`173`		`- int truthiness = _Py_uop_sym_truthiness(ctx, PyJitRef_FromSymbolSteal(value));`
	`173`	`+ int truthiness = _Py_uop_sym_truthiness(ctx, PyJitRef_Wrap(value));`
`174`	`174`	`if (truthiness < 0) {`
`175`	`175`	`return NULL;`
`176`	`176`	`}`
`@@ -184,7 +184,7 @@ _Py_uop_sym_get_const(JitOptContext *ctx, JitOptRef ref)`
`184`	`184`	`void`
`185`	`185`	`_Py_uop_sym_set_type(JitOptContext ctx, JitOptRef ref, PyTypeObject typ)`
`186`	`186`	`{`
`187`		`- JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);`
	`187`	`+ JitOptSymbol *sym = PyJitRef_Unwrap(ref);`
`188`	`188`	`JitSymType tag = sym->tag;`
`189`	`189`	`switch(tag) {`
`190`	`190`	`case JIT_SYM_NULL_TAG:`
`@@ -235,7 +235,7 @@ _Py_uop_sym_set_type(JitOptContext ctx, JitOptRef ref, PyTypeObject typ)`
`235`	`235`	`bool`
`236`	`236`	`_Py_uop_sym_set_type_version(JitOptContext *ctx, JitOptRef ref, unsigned int version)`
`237`	`237`	`{`
`238`		`- JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);`
	`238`	`+ JitOptSymbol *sym = PyJitRef_Unwrap(ref);`
`239`	`239`	`PyTypeObject *type = _PyType_LookupByVersion(version);`
`240`	`240`	`if (type) {`
`241`	`241`	`_Py_uop_sym_set_type(ctx, ref, type);`
`@@ -293,7 +293,7 @@ _Py_uop_sym_set_type_version(JitOptContext *ctx, JitOptRef ref, unsigned int ver`
`293`	`293`	`void`
`294`	`294`	`_Py_uop_sym_set_const(JitOptContext ctx, JitOptRef ref, PyObject const_val)`
`295`	`295`	`{`
`296`		`- JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);`
	`296`	`+ JitOptSymbol *sym = PyJitRef_Unwrap(ref);`
`297`	`297`	`JitSymType tag = sym->tag;`
`298`	`298`	`switch(tag) {`
`299`	`299`	`case JIT_SYM_NULL_TAG:`
`@@ -348,7 +348,8 @@ _Py_uop_sym_set_const(JitOptContext ctx, JitOptRef ref, PyObject const_val)`
`348`	`348`	`sym_set_bottom(ctx, sym);`
`349`	`349`	`return;`
`350`	`350`	`}`
`351`		`- JitOptRef value = PyJitRef_FromSymbolSteal(allocation_base(ctx) + sym->truthiness.value);`
	`351`	`+ JitOptRef value = PyJitRef_Wrap(`
	`352`	`+ allocation_base(ctx) + sym->truthiness.value);`
`352`	`353`	`PyTypeObject *type = _Py_uop_sym_get_type(value);`
`353`	`354`	`if (const_val == (sym->truthiness.invert ? Py_False : Py_True)) {`
`354`	`355`	`// value is truthy. This is only useful for bool:`
`@@ -375,7 +376,7 @@ _Py_uop_sym_set_const(JitOptContext ctx, JitOptRef ref, PyObject const_val)`
`375`	`376`	`void`
`376`	`377`	`_Py_uop_sym_set_null(JitOptContext *ctx, JitOptRef ref)`
`377`	`378`	`{`
`378`		`- JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);`
	`379`	`+ JitOptSymbol *sym = PyJitRef_Unwrap(ref);`
`379`	`380`	`if (sym->tag == JIT_SYM_UNKNOWN_TAG) {`
`380`	`381`	`sym->tag = JIT_SYM_NULL_TAG;`
`381`	`382`	`}`
`@@ -387,7 +388,7 @@ _Py_uop_sym_set_null(JitOptContext *ctx, JitOptRef ref)`
`387`	`388`	`void`
`388`	`389`	`_Py_uop_sym_set_non_null(JitOptContext *ctx, JitOptRef ref)`
`389`	`390`	`{`
`390`		`- JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);`
	`391`	`+ JitOptSymbol *sym = PyJitRef_Unwrap(ref);`
`391`	`392`	`if (sym->tag == JIT_SYM_UNKNOWN_TAG) {`
`392`	`393`	`sym->tag = JIT_SYM_NON_NULL_TAG;`
`393`	`394`	`}`
`@@ -403,7 +404,7 @@ _Py_uop_sym_new_unknown(JitOptContext *ctx)`
`403`	`404`	`if (res == NULL) {`
`404`	`405`	`return out_of_space_ref(ctx);`
`405`	`406`	`}`
`406`		`- return PyJitRef_FromSymbolSteal(res);`
	`407`	`+ return PyJitRef_Wrap(res);`
`407`	`408`	`}`
`408`	`409`
`409`	`410`	`JitOptRef`
`@@ -414,7 +415,7 @@ _Py_uop_sym_new_not_null(JitOptContext *ctx)`
`414`	`415`	`return out_of_space_ref(ctx);`
`415`	`416`	`}`
`416`	`417`	`res->tag = JIT_SYM_NON_NULL_TAG;`
`417`		`- return PyJitRef_FromSymbolSteal(res);`
	`418`	`+ return PyJitRef_Wrap(res);`
`418`	`419`	`}`
`419`	`420`
`420`	`421`	`JitOptRef`
`@@ -424,7 +425,7 @@ _Py_uop_sym_new_type(JitOptContext ctx, PyTypeObject typ)`
`424`	`425`	`if (res == NULL) {`
`425`	`426`	`return out_of_space_ref(ctx);`
`426`	`427`	`}`
`427`		`- JitOptRef ref = PyJitRef_FromSymbolSteal(res);`
	`428`	`+ JitOptRef ref = PyJitRef_Wrap(res);`
`428`	`429`	`_Py_uop_sym_set_type(ctx, ref, typ);`
`429`	`430`	`return ref;`
`430`	`431`	`}`
`@@ -438,7 +439,7 @@ _Py_uop_sym_new_const(JitOptContext ctx, PyObject const_val)`
`438`	`439`	`if (res == NULL) {`
`439`	`440`	`return out_of_space_ref(ctx);`
`440`	`441`	`}`
`441`		`- JitOptRef ref = PyJitRef_FromSymbolSteal(res);`
	`442`	`+ JitOptRef ref = PyJitRef_Wrap(res);`
`442`	`443`	`_Py_uop_sym_set_const(ctx, ref, const_val);`
`443`	`444`	`return ref;`
`444`	`445`	`}`
`@@ -450,15 +451,15 @@ _Py_uop_sym_new_null(JitOptContext *ctx)`
`450`	`451`	`if (null_sym == NULL) {`
`451`	`452`	`return out_of_space_ref(ctx);`
`452`	`453`	`}`
`453`		`- JitOptRef ref = PyJitRef_FromSymbolSteal(null_sym);`
	`454`	`+ JitOptRef ref = PyJitRef_Wrap(null_sym);`
`454`	`455`	`_Py_uop_sym_set_null(ctx, ref);`
`455`	`456`	`return ref;`
`456`	`457`	`}`
`457`	`458`
`458`	`459`	`PyTypeObject *`
`459`	`460`	`_Py_uop_sym_get_type(JitOptRef ref)`
`460`	`461`	`{`
`461`		`- JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);`
	`462`	`+ JitOptSymbol *sym = PyJitRef_Unwrap(ref);`
`462`	`463`	`JitSymType tag = sym->tag;`
`463`	`464`	`switch(tag) {`
`464`	`465`	`case JIT_SYM_NULL_TAG:`
`@@ -483,7 +484,7 @@ _Py_uop_sym_get_type(JitOptRef ref)`
`483`	`484`	`unsigned int`
`484`	`485`	`_Py_uop_sym_get_type_version(JitOptRef ref)`
`485`	`486`	`{`
`486`		`- JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);`
	`487`	`+ JitOptSymbol *sym = PyJitRef_Unwrap(ref);`
`487`	`488`	`JitSymType tag = sym->tag;`
`488`	`489`	`switch(tag) {`
`489`	`490`	`case JIT_SYM_NULL_TAG:`
`@@ -527,7 +528,7 @@ _Py_uop_sym_matches_type_version(JitOptRef sym, unsigned int version)`
`527`	`528`	`int`
`528`	`529`	`_Py_uop_sym_truthiness(JitOptContext *ctx, JitOptRef ref)`
`529`	`530`	`{`
`530`		`- JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);`
	`531`	`+ JitOptSymbol *sym = PyJitRef_Unwrap(ref);`
`531`	`532`	`switch(sym->tag) {`
`532`	`533`	`case JIT_SYM_NULL_TAG:`
`533`	`534`	`case JIT_SYM_TYPE_VERSION_TAG:`
`@@ -548,7 +549,7 @@ _Py_uop_sym_truthiness(JitOptContext *ctx, JitOptRef ref)`
`548`	`549`	`;`
`549`	`550`	`JitOptSymbol *value = allocation_base(ctx) + sym->truthiness.value;`
`550`	`551`	`int truthiness = _Py_uop_sym_truthiness(ctx,`
`551`		`- PyJitRef_FromSymbolBorrow(value));`
	`552`	`+ PyJitRef_Wrap(value));`
`552`	`553`	`if (truthiness < 0) {`
`553`	`554`	`return truthiness;`
`554`	`555`	`}`
`@@ -589,16 +590,16 @@ _Py_uop_sym_new_tuple(JitOptContext ctx, int size, JitOptRef args)`
`589`	`590`	`res->tag = JIT_SYM_TUPLE_TAG;`
`590`	`591`	`res->tuple.length = size;`
`591`	`592`	`for (int i = 0; i < size; i++) {`
`592`		`- res->tuple.items[i] = (uint16_t)(PyJitRef_AsSymbolBorrow(args[i]) - allocation_base(ctx));`
	`593`	`+ res->tuple.items[i] = (uint16_t)(PyJitRef_Unwrap(args[i]) - allocation_base(ctx));`
`593`	`594`	`}`
`594`	`595`	`}`
`595`		`- return PyJitRef_FromSymbolSteal(res);`
	`596`	`+ return PyJitRef_Wrap(res);`
`596`	`597`	`}`
`597`	`598`
`598`	`599`	`JitOptRef`
`599`	`600`	`_Py_uop_sym_tuple_getitem(JitOptContext *ctx, JitOptRef ref, int item)`
`600`	`601`	`{`
`601`		`- JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);`
	`602`	`+ JitOptSymbol *sym = PyJitRef_Unwrap(ref);`
`602`	`603`	`assert(item >= 0);`
`603`	`604`	`if (sym->tag == JIT_SYM_KNOWN_VALUE_TAG) {`
`604`	`605`	`PyObject *tuple = sym->value.value;`
`@@ -607,15 +608,15 @@ _Py_uop_sym_tuple_getitem(JitOptContext *ctx, JitOptRef ref, int item)`
`607`	`608`	`}`
`608`	`609`	`}`
`609`	`610`	`else if (sym->tag == JIT_SYM_TUPLE_TAG && item < sym->tuple.length) {`
`610`		`- return PyJitRef_FromSymbolSteal(allocation_base(ctx) + sym->tuple.items[item]);`
	`611`	`+ return PyJitRef_Wrap(allocation_base(ctx) + sym->tuple.items[item]);`
`611`	`612`	`}`
`612`	`613`	`return _Py_uop_sym_new_not_null(ctx);`
`613`	`614`	`}`
`614`	`615`
`615`	`616`	`int`
`616`	`617`	`_Py_uop_sym_tuple_length(JitOptRef ref)`
`617`	`618`	`{`
`618`		`- JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);`
	`619`	`+ JitOptSymbol *sym = PyJitRef_Unwrap(ref);`
`619`	`620`	`if (sym->tag == JIT_SYM_KNOWN_VALUE_TAG) {`
`620`	`621`	`PyObject *tuple = sym->value.value;`
`621`	`622`	`if (PyTuple_CheckExact(tuple)) {`
`@@ -647,14 +648,14 @@ _Py_uop_symbol_is_immortal(JitOptSymbol *sym)`
`647`	`648`	`bool`
`648`	`649`	`_Py_uop_sym_is_immortal(JitOptRef ref)`
`649`	`650`	`{`
`650`		`- JitOptSymbol *sym = PyJitRef_AsSymbolBorrow(ref);`
	`651`	`+ JitOptSymbol *sym = PyJitRef_Unwrap(ref);`
`651`	`652`	`return _Py_uop_symbol_is_immortal(sym);`
`652`	`653`	`}`
`653`	`654`
`654`	`655`	`JitOptRef`
`655`	`656`	`_Py_uop_sym_new_truthiness(JitOptContext *ctx, JitOptRef ref, bool truthy)`
`656`	`657`	`{`
`657`		`- JitOptSymbol *value = PyJitRef_AsSymbolBorrow(ref);`
	`658`	`+ JitOptSymbol *value = PyJitRef_Unwrap(ref);`
`658`	`659`	`// It's clearer to invert this in the signature:`
`659`	`660`	`bool invert = !truthy;`
`660`	`661`	`if (value->tag == JIT_SYM_TRUTHINESS_TAG && value->truthiness.invert == invert) {`
`@@ -673,7 +674,7 @@ _Py_uop_sym_new_truthiness(JitOptContext *ctx, JitOptRef ref, bool truthy)`
`673`	`674`	`else {`
`674`	`675`	`make_const(res, (truthiness ^ invert) ? Py_True : Py_False);`
`675`	`676`	`}`
`676`		`- return PyJitRef_FromSymbolSteal(res);`
	`677`	`+ return PyJitRef_Wrap(res);`
`677`	`678`	`}`
`678`	`679`
`679`	`680`	`// 0 on success, -1 on error.`
`@@ -809,7 +810,7 @@ _Py_uop_symbols_test(PyObject Py_UNUSED(self), PyObject Py_UNUSED(ignored))`
`809`	`810`	`TEST_PREDICATE(_Py_uop_sym_get_const(ctx, ref) == NULL, "top as constant is not NULL");`
`810`	`811`	`TEST_PREDICATE(!_Py_uop_sym_is_bottom(ref), "top is bottom");`
`811`	`812`
`812`		`- ref = PyJitRef_FromSymbolSteal(make_bottom(ctx));`
	`813`	`+ ref = PyJitRef_Wrap(make_bottom(ctx));`
`813`	`814`	`if (PyJitRef_IsNull(ref)) {`
`814`	`815`	`goto fail;`
`815`	`816`	`}`