Rename int64 guard helper and drop simple benchmark

Author: KRRT7

Include/internal/pycore_long.h

@@ -360,7 +360,7 @@ _PyLong_CheckExactAndCompact(PyObject *op)
 #define _PY_LONG_MAX_DIGITS_FOR_INT64 ((64 + PyLong_SHIFT - 1) / PyLong_SHIFT)
 
 static inline int
-_PyLong_MightFitInt64(const PyLongObject *v)
+_PyLong_FitsInt64(const PyLongObject *v)
 {
     uintptr_t tag = v->long_value.lv_tag;
     if (tag < (2 << NON_SIZE_BITS)) {
@@ -396,10 +396,10 @@ _PyLong_MightFitInt64(const PyLongObject *v)
 }
 
 static inline int
-_PyLong_CheckExactAndMightFitInt64(PyObject *op)
+_PyLong_CheckExactAndFitsInt64(PyObject *op)
 {
     return PyLong_CheckExact(op) &&
-           _PyLong_MightFitInt64((const PyLongObject *)op);
+           _PyLong_FitsInt64((const PyLongObject *)op);
 }
 
 /* Extract an exact int to int64_t without raising.

Modules/_testinternalcapi/test_cases.c.h

@@ -648,25 +648,25 @@ dummy_func(
         /* Wide guards: accept exact ints in the full int64 range. */
         op(_GUARD_NOS_INT_WIDE, (left, unused -- left, unused)) {
             PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
-            EXIT_IF(!_PyLong_CheckExactAndMightFitInt64(left_o));
+            EXIT_IF(!_PyLong_CheckExactAndFitsInt64(left_o));
         }
 
         op(_GUARD_TOS_INT_WIDE, (value -- value)) {
             PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);
-            EXIT_IF(!_PyLong_CheckExactAndMightFitInt64(value_o));
+            EXIT_IF(!_PyLong_CheckExactAndFitsInt64(value_o));
         }
 
         op(_GUARD_NOS_OVERFLOWED, (left, unused -- left, unused)) {
             PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
             assert(Py_TYPE(left_o) == &PyLong_Type);
-            int ok = _PyLong_MightFitInt64((PyLongObject *)left_o);
+            int ok = _PyLong_FitsInt64((PyLongObject *)left_o);
             EXIT_IF(!ok);
         }
 
         op(_GUARD_TOS_OVERFLOWED, (value -- value)) {
             PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);
             assert(Py_TYPE(value_o) == &PyLong_Type);
-            int ok = _PyLong_MightFitInt64((PyLongObject *)value_o);
+            int ok = _PyLong_FitsInt64((PyLongObject *)value_o);
             EXIT_IF(!ok);
         }
 

Python/bytecodes.c

@@ -272,7 +272,7 @@ _Py_uop_sym_is_safe_const(JitOptContext *ctx, JitOptRef sym)
     if (const_val == NULL) {
         return false;
     }
-    if (_PyLong_CheckExactAndMightFitInt64(const_val)) {
+    if (_PyLong_CheckExactAndFitsInt64(const_val)) {
         return true;
     }
     PyTypeObject *typ = Py_TYPE(const_val);
@@ -566,7 +566,7 @@ _Py_uop_sym_set_const(JitOptContext *ctx, JitOptRef ref, PyObject *const_val)
             make_const(sym, const_val);
             return;
         case JIT_SYM_COMPACT_INT:
-            if (_PyLong_CheckExactAndMightFitInt64(const_val)) {
+            if (_PyLong_CheckExactAndFitsInt64(const_val)) {
                 make_const(sym, const_val);
             }
             else {
@@ -970,7 +970,7 @@ _Py_uop_sym_is_compact_int(JitOptRef ref)
 {
     JitOptSymbol *sym = PyJitRef_Unwrap(ref);
     if (sym->tag == JIT_SYM_KNOWN_VALUE_TAG) {
-        return (bool)_PyLong_CheckExactAndMightFitInt64(sym->value.value);
+        return (bool)_PyLong_CheckExactAndFitsInt64(sym->value.value);
     }
     return sym->tag == JIT_SYM_COMPACT_INT;
 }
@@ -1008,7 +1008,7 @@ _Py_uop_sym_set_compact_int(JitOptContext *ctx, JitOptRef ref)
             }
             return;
         case JIT_SYM_KNOWN_VALUE_TAG:
-            if (!_PyLong_CheckExactAndMightFitInt64(sym->value.value)) {
+            if (!_PyLong_CheckExactAndFitsInt64(sym->value.value)) {
                 Py_CLEAR(sym->value.value);
                 sym_set_bottom(ctx, sym);
             }

Python/executor_cases.c.h

@@ -2354,8 +2354,8 @@ _Py_Specialize_BinaryOp(_PyStackRef lhs_st, _PyStackRef rhs_st, _Py_CODEUNIT *in
                 specialize(instr, BINARY_OP_ADD_INT);
                 return;
             }
-            if (_PyLong_CheckExactAndMightFitInt64(lhs) &&
-                _PyLong_CheckExactAndMightFitInt64(rhs))
+            if (_PyLong_CheckExactAndFitsInt64(lhs) &&
+                _PyLong_CheckExactAndFitsInt64(rhs))
             {
                 specialize(instr, BINARY_OP_ADD_INT_WIDE);
                 return;
@@ -2374,8 +2374,8 @@ _Py_Specialize_BinaryOp(_PyStackRef lhs_st, _PyStackRef rhs_st, _Py_CODEUNIT *in
                 specialize(instr, BINARY_OP_MULTIPLY_INT);
                 return;
             }
-            if (_PyLong_CheckExactAndMightFitInt64(lhs) &&
-                _PyLong_CheckExactAndMightFitInt64(rhs))
+            if (_PyLong_CheckExactAndFitsInt64(lhs) &&
+                _PyLong_CheckExactAndFitsInt64(rhs))
             {
                 specialize(instr, BINARY_OP_MULTIPLY_INT_WIDE);
                 return;
@@ -2394,8 +2394,8 @@ _Py_Specialize_BinaryOp(_PyStackRef lhs_st, _PyStackRef rhs_st, _Py_CODEUNIT *in
                 specialize(instr, BINARY_OP_SUBTRACT_INT);
                 return;
             }
-            if (_PyLong_CheckExactAndMightFitInt64(lhs) &&
-                _PyLong_CheckExactAndMightFitInt64(rhs))
+            if (_PyLong_CheckExactAndFitsInt64(lhs) &&
+                _PyLong_CheckExactAndFitsInt64(rhs))
             {
                 specialize(instr, BINARY_OP_SUBTRACT_INT_WIDE);
                 return;

Python/generated_cases.c.h

@@ -721,8 +721,8 @@ def has_error_without_pop(op: parser.CodeDef) -> bool:
     "PyStackRef_Wrap",
     "PyStackRef_Unwrap",
     "_PyLong_CheckExactAndCompact",
-    "_PyLong_CheckExactAndMightFitInt64",
-    "_PyLong_MightFitInt64",
+    "_PyLong_CheckExactAndFitsInt64",
+    "_PyLong_FitsInt64",
     "_PyExecutor_FromExit",
     "_PyJit_TryInitializeTracing",
     "_Py_unset_eval_breaker_bit",