gh-130415: Narrowing to constants in branches involving is comparisons with a constant

Include/internal/pycore_optimizer.h

@@ -191,6 +191,9 @@ extern JitOptRef _Py_uop_sym_new_truthiness(JitOptContext *ctx, JitOptRef value,
 extern bool _Py_uop_sym_is_compact_int(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 subject_ref, JitOptRef constant_ref, JitOptPredicateKind kind, bool invert);
+extern bool _Py_uop_sym_is_known_singleton(JitOptContext *ctx, JitOptRef sym);
+extern void _Py_uop_sym_apply_predicate_narrowing(JitOptContext *ctx, JitOptRef sym, bool branch_is_true);
 
 extern void _Py_uop_abstractcontext_init(JitOptContext *ctx);
 extern void _Py_uop_abstractcontext_fini(JitOptContext *ctx);

Include/internal/pycore_optimizer_types.h

@@ -39,6 +39,7 @@ typedef enum _JitSymType {
     JIT_SYM_TUPLE_TAG = 8,
     JIT_SYM_TRUTHINESS_TAG = 9,
     JIT_SYM_COMPACT_INT = 10,
+    JIT_SYM_PREDICATE_TAG = 11,
 } JitSymType;
 
 typedef struct _jit_opt_known_class {
@@ -71,6 +72,19 @@ typedef struct {
     uint16_t value;
 } JitOptTruthiness;
 
+typedef enum {
+    JIT_PRED_IS,
+    // JIT_PRED_EQ,
+} JitOptPredicateKind;
+
+typedef struct {
+    uint8_t tag;
+    uint8_t kind;
+    bool invert;
+    uint16_t subject;
+    uint16_t constant;
+} JitOptPredicate;
+
 typedef struct {
     uint8_t tag;
 } JitOptCompactInt;
@@ -83,6 +97,7 @@ typedef union _jit_opt_symbol {
     JitOptTuple tuple;
     JitOptTruthiness truthiness;
     JitOptCompactInt compact;
+    JitOptPredicate predicate;
 } JitOptSymbol;
 
 // This mimics the _PyStackRef API

Lib/test/test_capi/test_opt.py

@@ -3534,6 +3534,46 @@ def test_is_none(n):
         self.assertIn("_POP_TOP_NOP", uops)
         self.assertLessEqual(count_ops(ex, "_POP_TOP"), 2)
 
+    def test_is_true_narrows_to_constant(self):
+        def f(n):
+            def return_true():
+                return True
+
+            hits = 0
+            v = return_true()
+            for i in range(n):
+                if v is True:
+                    hits += v + 1
+            return hits
+
+        res, ex = self._run_with_optimizer(f, TIER2_THRESHOLD)
+        self.assertEqual(res, TIER2_THRESHOLD * 2)
+        self.assertIsNotNone(ex)
+        uops = get_opnames(ex)
+
+        # v + 1 should be constant folded
+        self.assertNotIn("_BINARY_OP", uops)
+
+    def test_is_false_narrows_to_constant(self):
+        def f(n):
+            def return_false():
+                return False
+
+            hits = 0
+            v = return_false()
+            for i in range(n):
+                if v is False:
+                    hits += v + 1
+            return hits
+
+        res, ex = self._run_with_optimizer(f, TIER2_THRESHOLD)
+        self.assertEqual(res, TIER2_THRESHOLD)
+        self.assertIsNotNone(ex)
+        uops = get_opnames(ex)
+
+        # v + 1 should be constant folded
+        self.assertNotIn("_BINARY_OP", uops)
+
     def test_for_iter_gen_frame(self):
         def f(n):
             for i in range(n):

Python/optimizer_analysis.c

@@ -186,6 +186,9 @@ incorrect_keys(PyObject *obj, uint32_t version)
 #define sym_is_compact_int _Py_uop_sym_is_compact_int
 #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
+#define sym_is_known_singleton _Py_uop_sym_is_known_singleton
+#define sym_apply_predicate_narrowing _Py_uop_sym_apply_predicate_narrowing
 
 #define JUMP_TO_LABEL(label) goto label;
 

Python/optimizer_bytecodes.c

@@ -38,6 +38,9 @@ typedef struct _Py_UOpsAbstractFrame _Py_UOpsAbstractFrame;
 #define sym_new_compact_int _Py_uop_sym_new_compact_int
 #define sym_is_compact_int _Py_uop_sym_is_compact_int
 #define sym_new_truthiness _Py_uop_sym_new_truthiness
+#define sym_new_predicate _Py_uop_sym_new_predicate
+#define sym_is_known_singleton _Py_uop_sym_is_known_singleton
+#define sym_apply_predicate_narrowing _Py_uop_sym_apply_predicate_narrowing
 
 extern int
 optimize_to_bool(
@@ -533,7 +536,16 @@ dummy_func(void) {
     }
 
     op(_IS_OP, (left, right -- b, l, r)) {
-        b = sym_new_type(ctx, &PyBool_Type);
+        bool invert = (oparg != 0);
+        if (sym_is_known_singleton(ctx, left)) {
+            b = sym_new_predicate(ctx, right, left, JIT_PRED_IS ,invert);
+        }
+        else if (sym_is_known_singleton(ctx, right)) {
+            b = sym_new_predicate(ctx, left, right, JIT_PRED_IS, invert);
+        }
+        else {
+            b = sym_new_type(ctx, &PyBool_Type);
+        }
         l = left;
         r = right;
     }
@@ -1142,6 +1154,7 @@ dummy_func(void) {
             assert(value != NULL);
             eliminate_pop_guard(this_instr, value != Py_True);
         }
+        sym_apply_predicate_narrowing(ctx, flag, true);
         sym_set_const(flag, Py_True);
     }
 
@@ -1187,6 +1200,7 @@ dummy_func(void) {
             assert(value != NULL);
             eliminate_pop_guard(this_instr, value != Py_False);
         }
+        sym_apply_predicate_narrowing(ctx, flag, false);
         sym_set_const(flag, Py_False);
     }
 

Python/optimizer_symbols.c

@@ -258,6 +258,7 @@ _Py_uop_sym_set_type(JitOptContext *ctx, JitOptRef ref, PyTypeObject *typ)
             sym->cls.version = 0;
             sym->cls.type = typ;
             return;
+        case JIT_SYM_PREDICATE_TAG:
         case JIT_SYM_TRUTHINESS_TAG:
             if (typ != &PyBool_Type) {
                 sym_set_bottom(ctx, sym);
@@ -319,6 +320,7 @@ _Py_uop_sym_set_type_version(JitOptContext *ctx, JitOptRef ref, unsigned int ver
             sym->tag = JIT_SYM_TYPE_VERSION_TAG;
             sym->version.version = version;
             return true;
+        case JIT_SYM_PREDICATE_TAG:
         case JIT_SYM_TRUTHINESS_TAG:
             if (version != PyBool_Type.tp_version_tag) {
                 sym_set_bottom(ctx, sym);
@@ -385,6 +387,16 @@ _Py_uop_sym_set_const(JitOptContext *ctx, JitOptRef ref, PyObject *const_val)
         case JIT_SYM_UNKNOWN_TAG:
             make_const(sym, const_val);
             return;
+        case JIT_SYM_PREDICATE_TAG:
+            if (!PyBool_Check(const_val) ||
+                (_Py_uop_sym_is_const(ctx, ref) &&
+                _Py_uop_sym_get_const(ctx, ref) != const_val))
+            {
+                sym_set_bottom(ctx, sym);
+                return;
+            }
+            make_const(sym, const_val);
+            return;
         case JIT_SYM_TRUTHINESS_TAG:
             if (!PyBool_Check(const_val) ||
                 (_Py_uop_sym_is_const(ctx, ref) &&
@@ -538,6 +550,7 @@ _Py_uop_sym_get_type(JitOptRef ref)
             return _PyType_LookupByVersion(sym->version.version);
         case JIT_SYM_TUPLE_TAG:
             return &PyTuple_Type;
+        case JIT_SYM_PREDICATE_TAG:
         case JIT_SYM_TRUTHINESS_TAG:
             return &PyBool_Type;
         case JIT_SYM_COMPACT_INT:
@@ -566,6 +579,7 @@ _Py_uop_sym_get_type_version(JitOptRef ref)
             return Py_TYPE(sym->value.value)->tp_version_tag;
         case JIT_SYM_TUPLE_TAG:
             return PyTuple_Type.tp_version_tag;
+        case JIT_SYM_PREDICATE_TAG:
         case JIT_SYM_TRUTHINESS_TAG:
             return PyBool_Type.tp_version_tag;
         case JIT_SYM_COMPACT_INT:
@@ -759,6 +773,7 @@ _Py_uop_sym_set_compact_int(JitOptContext *ctx, JitOptRef ref)
             }
             return;
         case JIT_SYM_TUPLE_TAG:
+        case JIT_SYM_PREDICATE_TAG:
         case JIT_SYM_TRUTHINESS_TAG:
             sym_set_bottom(ctx, sym);
             return;
@@ -772,6 +787,64 @@ _Py_uop_sym_set_compact_int(JitOptContext *ctx, JitOptRef ref)
     }
 }
 
+JitOptRef
+_Py_uop_sym_new_predicate(JitOptContext *ctx, JitOptRef subject_ref, JitOptRef constant_ref, JitOptPredicateKind kind, bool invert)
+{
+    assert(_Py_uop_sym_is_const(ctx, constant_ref));
+
+    JitOptSymbol *subject = PyJitRef_Unwrap(subject_ref);
+    JitOptSymbol *constant = PyJitRef_Unwrap(constant_ref);
+
+    JitOptSymbol *res = sym_new(ctx);
+    if (res == NULL) {
+        return out_of_space_ref(ctx);
+    }
+
+    res->tag = JIT_SYM_PREDICATE_TAG;
+    res->predicate.invert = invert;
+    res->predicate.kind = kind;
+    res->predicate.subject = (uint16_t)(subject - allocation_base(ctx));
+    res->predicate.constant = (uint16_t)(constant - allocation_base(ctx));
+
+    return PyJitRef_Wrap(res);
+}
+
+bool
+_Py_uop_sym_is_known_singleton(JitOptContext *ctx, JitOptRef ref)
+{
+    if (_Py_uop_sym_is_safe_const(ctx, ref)) {
+        PyObject *value = _Py_uop_sym_get_const(ctx, ref);
+        return value == Py_None || value == Py_True || value == Py_False;
+    }
+    return false;
+}
+
+void
+_Py_uop_sym_apply_predicate_narrowing(JitOptContext *ctx, JitOptRef ref, bool branch_is_true)
+{
+    JitOptSymbol *sym = PyJitRef_Unwrap(ref);
+    if (sym->tag != JIT_SYM_PREDICATE_TAG) {
+        return;
+    }
+
+    JitOptPredicate pred = sym->predicate;
+    bool narrow = (branch_is_true && !pred.invert) || (!branch_is_true && pred.invert);
+    if (!narrow) {
+        return;
+    }
+
+    if (pred.kind == JIT_PRED_IS) {
+        JitOptRef subject_ref = PyJitRef_Wrap(allocation_base(ctx) + pred.subject);
+        JitOptRef constant_ref = PyJitRef_Wrap(allocation_base(ctx) + pred.constant);
+        PyObject *const_val = _Py_uop_sym_get_const(ctx, constant_ref);
+        if (const_val == NULL) {
+            return;
+        }
+        _Py_uop_sym_set_const(ctx, subject_ref, const_val);
+        assert(_Py_uop_sym_is_safe_const(ctx, subject_ref));
+    }
+}
+
 JitOptRef
 _Py_uop_sym_new_truthiness(JitOptContext *ctx, JitOptRef ref, bool truthy)
 {