Separate compact int and int64 optimizer facts

Author: KRRT7

Include/internal/pycore_optimizer.h

@@ -462,6 +462,7 @@ extern JitOptRef _Py_uop_sym_tuple_getitem(JitOptContext *ctx, JitOptRef sym, Py
 extern Py_ssize_t _Py_uop_sym_tuple_length(JitOptRef sym);
 extern JitOptRef _Py_uop_sym_new_truthiness(JitOptContext *ctx, JitOptRef value, bool truthy);
 extern bool _Py_uop_sym_is_compact_int(JitOptRef sym);
+extern bool _Py_uop_sym_fits_int64(JitOptRef sym);
 extern JitOptRef _Py_uop_sym_new_compact_int(JitOptContext *ctx);
 extern void _Py_uop_sym_set_compact_int(JitOptContext *ctx,  JitOptRef sym);
 extern JitOptRef _Py_uop_sym_new_predicate(JitOptContext *ctx, JitOptRef lhs_ref, JitOptRef rhs_ref, JitOptPredicateKind kind);

Python/optimizer_analysis.c

@@ -299,6 +299,7 @@ add_op(JitOptContext *ctx, _PyUOpInstruction *this_instr,
 #define sym_tuple_length _Py_uop_sym_tuple_length
 #define sym_is_immortal _Py_uop_symbol_is_immortal
 #define sym_is_compact_int _Py_uop_sym_is_compact_int
+#define sym_fits_int64 _Py_uop_sym_fits_int64
 #define sym_new_compact_int _Py_uop_sym_new_compact_int
 #define sym_new_truthiness _Py_uop_sym_new_truthiness
 #define sym_new_predicate _Py_uop_sym_new_predicate

Python/optimizer_bytecodes.c

@@ -43,6 +43,7 @@ typedef struct _Py_UOpsAbstractFrame _Py_UOpsAbstractFrame;
 #define sym_is_immortal _Py_uop_symbol_is_immortal
 #define sym_new_compact_int _Py_uop_sym_new_compact_int
 #define sym_is_compact_int _Py_uop_sym_is_compact_int
+#define sym_fits_int64 _Py_uop_sym_fits_int64
 #define sym_new_truthiness _Py_uop_sym_new_truthiness
 #define sym_new_predicate _Py_uop_sym_new_predicate
 #define sym_apply_predicate_narrowing _Py_uop_sym_apply_predicate_narrowing
@@ -236,7 +237,7 @@ dummy_func(void) {
      * type is already known to be PyLong_Type the cheaper _OVERFLOWED guard
      * (which skips the type check) can be used instead. */
     op(_GUARD_TOS_INT_WIDE, (value -- value)) {
-        if (sym_is_compact_int(value)) {
+        if (sym_fits_int64(value)) {
             ADD_OP(_NOP, 0, 0);
         }
         else {
@@ -248,7 +249,7 @@ dummy_func(void) {
     }
 
     op(_GUARD_NOS_INT_WIDE, (left, unused -- left, unused)) {
-        if (sym_is_compact_int(left)) {
+        if (sym_fits_int64(left)) {
             ADD_OP(_NOP, 0, 0);
         }
         else {

Python/optimizer_cases.c.h

@@ -967,6 +967,16 @@ _Py_uop_symbol_is_immortal(JitOptSymbol *sym)
 
 bool
 _Py_uop_sym_is_compact_int(JitOptRef ref)
+{
+    JitOptSymbol *sym = PyJitRef_Unwrap(ref);
+    if (sym->tag == JIT_SYM_KNOWN_VALUE_TAG) {
+        return (bool)_PyLong_CheckExactAndCompact(sym->value.value);
+    }
+    return sym->tag == JIT_SYM_COMPACT_INT;
+}
+
+bool
+_Py_uop_sym_fits_int64(JitOptRef ref)
 {
     JitOptSymbol *sym = PyJitRef_Unwrap(ref);
     if (sym->tag == JIT_SYM_KNOWN_VALUE_TAG) {
@@ -1008,7 +1018,7 @@ _Py_uop_sym_set_compact_int(JitOptContext *ctx, JitOptRef ref)
             }
             return;
         case JIT_SYM_KNOWN_VALUE_TAG:
-            if (!_PyLong_CheckExactAndFitsInt64(sym->value.value)) {
+            if (!_PyLong_CheckExactAndCompact(sym->value.value)) {
                 Py_CLEAR(sym->value.value);
                 sym_set_bottom(ctx, sym);
             }
@@ -1567,6 +1577,7 @@ _Py_uop_symbols_test(PyObject *Py_UNUSED(self), PyObject *Py_UNUSED(ignored))
     _Py_uop_abstractcontext_init(ctx, NULL);
     PyObject *val_42 = NULL;
     PyObject *val_43 = NULL;
+    PyObject *val_noncompact_int64 = NULL;
     PyObject *val_big = NULL;
     PyObject *tuple = NULL;
     PyFunctionObject *func = NULL;
@@ -1619,6 +1630,11 @@ _Py_uop_symbols_test(PyObject *Py_UNUSED(self), PyObject *Py_UNUSED(ignored))
     assert(val_43 != NULL);
     assert(_Py_IsImmortal(val_43));
 
+    val_noncompact_int64 = PyNumber_Lshift(_PyLong_GetOne(), PyLong_FromLong(40));
+    if (val_noncompact_int64 == NULL) {
+        goto fail;
+    }
+
     ref = _Py_uop_sym_new_type(ctx, &PyLong_Type);
     if (PyJitRef_IsNull(ref)) {
         goto fail;
@@ -1960,10 +1976,19 @@ _Py_uop_symbols_test(PyObject *Py_UNUSED(self), PyObject *Py_UNUSED(ignored))
     }
 
     JitOptRef ref_42 = _Py_uop_sym_new_const(ctx, val_42);
+    JitOptRef ref_noncompact_int64 = _Py_uop_sym_new_const(ctx, val_noncompact_int64);
     JitOptRef ref_big = _Py_uop_sym_new_const(ctx, val_big);
     JitOptRef ref_int = _Py_uop_sym_new_compact_int(ctx);
     TEST_PREDICATE(_Py_uop_sym_is_compact_int(ref_42), "42 is not a compact int");
+    TEST_PREDICATE(_Py_uop_sym_fits_int64(ref_42), "42 does not fit int64");
+    TEST_PREDICATE(
+        !_Py_uop_sym_is_compact_int(ref_noncompact_int64),
+        "(1 << 40) is a compact int");
+    TEST_PREDICATE(
+        _Py_uop_sym_fits_int64(ref_noncompact_int64),
+        "(1 << 40) does not fit int64");
     TEST_PREDICATE(!_Py_uop_sym_is_compact_int(ref_big), "(1 << 200) is a compact int");
+    TEST_PREDICATE(!_Py_uop_sym_fits_int64(ref_big), "(1 << 200) fits int64");
     TEST_PREDICATE(_Py_uop_sym_is_compact_int(ref_int), "compact int is not a compact int");
     TEST_PREDICATE(_Py_uop_sym_matches_type(ref_int, &PyLong_Type), "compact int is not an int");
 
@@ -2092,6 +2117,7 @@ _Py_uop_symbols_test(PyObject *Py_UNUSED(self), PyObject *Py_UNUSED(ignored))
     _Py_uop_abstractcontext_fini(ctx);
     Py_DECREF(val_42);
     Py_DECREF(val_43);
+    Py_DECREF(val_noncompact_int64);
     Py_DECREF(val_big);
     Py_DECREF(tuple);
     Py_DECREF(func);
@@ -2101,6 +2127,7 @@ _Py_uop_symbols_test(PyObject *Py_UNUSED(self), PyObject *Py_UNUSED(ignored))
     _Py_uop_abstractcontext_fini(ctx);
     Py_XDECREF(val_42);
     Py_XDECREF(val_43);
+    Py_XDECREF(val_noncompact_int64);
     Py_XDECREF(val_big);
     Py_XDECREF(tuple);
     Py_XDECREF(func);