Add back SELF_OR_NULL :(

Fidget-Spinner · Fidget-Spinner · commit 54e2f64d2c72 · 2024-02-07T20:55:45.000+08:00
diff --git a/Python/abstract_interp_cases.c.h b/Python/abstract_interp_cases.c.h
diff --git a/Python/optimizer_analysis.c b/Python/optimizer_analysis.c
@@ -88,6 +88,12 @@ typedef enum {
     NULL_TYPE = 6,
     PYMETHOD_TYPE = 7,
     GUARD_DORV_VALUES_TYPE = 8,
+    // This is a non-ideal fix. Once all _LOAD_ATTR is properly annotated
+    // with proper type information (at least, that `self` is present), this
+    // can be removed. Otherwise, for now, this is used to distinguish
+    // _LOAD_ATTR (self/null unknown) and
+    // _LOAD_ATTR (unknown, but type cannot be captured in our current type system).
+    SELF_OR_NULL = 9,
 
     // Represents something from LOAD_CONST which is truly constant.
     TRUE_CONST = 30,
@@ -491,11 +497,6 @@ sym_matches_pytype(_Py_UOpsSymType *sym, PyTypeObject *typ, uint64_t refinement)
     return sym_matches_type(sym, pytype_to_type(typ), refinement);
 }
 
-static inline bool
-sym_is_unknown_type(_Py_UOpsSymType *sym)
-{
-    return sym->types == 0 || (sym->types == 1U << INVALID_TYPE);
-}
 
 static uint64_t
 sym_type_get_refinement(_Py_UOpsSymType *sym, _Py_UOpsSymExprTypeEnum typ)
diff --git a/Python/tier2_redundancy_eliminator_bytecodes.c b/Python/tier2_redundancy_eliminator_bytecodes.c
@@ -152,6 +152,19 @@ dummy_func(void) {
         top, unused[oparg-2], bottom)) {
     }
 
+    op(_LOAD_ATTR, (owner -- attr, self_or_null if (oparg & 1))) {
+        self_or_null = sym_init_unknown(ctx);
+        if (self_or_null == NULL) {
+            goto error;
+        }
+        sym_set_type(self_or_null, SELF_OR_NULL, 0);
+        (void)owner;
+        attr = sym_init_unknown(ctx);
+        if (attr == NULL) {
+            goto error;
+        }
+    }
+
     op(_CHECK_FUNCTION_EXACT_ARGS, (func_version/2, callable, self_or_null, unused[oparg] -- callable, self_or_null, unused[oparg])) {
         sym_set_pytype(callable, &PyFunction_Type, func_version);
         (void)self_or_null;
@@ -174,7 +187,7 @@ dummy_func(void) {
         assert(self_or_null != NULL);
         assert(args != NULL);
         if (!sym_matches_pytype(self_or_null, NULL, 0) &&
-            !sym_is_unknown_type(self_or_null)) {
+            !sym_matches_type(self_or_null, SELF_OR_NULL, 0)) {
             // Bound method fiddling, same as _INIT_CALL_PY_EXACT_ARGS in
             // VM
             args--;
@@ -186,7 +199,7 @@ dummy_func(void) {
         // Can determine statically, so we interleave the new locals
         // and make the current stack the new locals.
         // This also sets up for true call inlining.
-        if (!sym_is_unknown_type(self_or_null)) {
+        if (!sym_matches_type(self_or_null, SELF_OR_NULL, 0)) {
             localsplus_start = args;
             n_locals_already_filled = argcount;
         }
