Don't promote borrowed references in STORE_FAST

This reduces the number of changes to the interpreter loop and leaves
the various STORE_FAST instructions unmodified. It means that we cannot
optimize LOAD_FAST instructions that are consumed by STORE_FAST instructions,
but I think this is a net positive. It speeds up STORE_FAST and doesn't appreciably
reduce the number of optimized instructions in the benchmark suite.

Author: mpage

Python/bytecodes.c

@@ -339,7 +339,7 @@ dummy_func(
 
         replicate(8) inst(STORE_FAST, (value --)) {
             _PyStackRef tmp = GETLOCAL(oparg);
-            GETLOCAL(oparg) = _PyStackRef_StealIfUnborrowed(value);
+            GETLOCAL(oparg) = value;
             DEAD(value);
             PyStackRef_XCLOSE(tmp);
         }
@@ -352,7 +352,7 @@ dummy_func(
             uint32_t oparg1 = oparg >> 4;
             uint32_t oparg2 = oparg & 15;
             _PyStackRef tmp = GETLOCAL(oparg1);
-            GETLOCAL(oparg1) = _PyStackRef_StealIfUnborrowed(value1);
+            GETLOCAL(oparg1) = value1;
             DEAD(value1);
             value2 = PyStackRef_DUP(GETLOCAL(oparg2));
             PyStackRef_XCLOSE(tmp);
@@ -362,11 +362,11 @@ dummy_func(
             uint32_t oparg1 = oparg >> 4;
             uint32_t oparg2 = oparg & 15;
             _PyStackRef tmp = GETLOCAL(oparg1);
-            GETLOCAL(oparg1) = _PyStackRef_StealIfUnborrowed(value1);
+            GETLOCAL(oparg1) = value1;
             DEAD(value1);
             PyStackRef_XCLOSE(tmp);
             tmp = GETLOCAL(oparg2);
-            GETLOCAL(oparg2) = _PyStackRef_StealIfUnborrowed(value2);
+            GETLOCAL(oparg2) = value2;
             DEAD(value2);
             PyStackRef_XCLOSE(tmp);
         }

Python/executor_cases.c.h

@@ -2614,22 +2614,34 @@ optimize_load_fast(cfg_builder *g)
 
                 case STORE_FAST: {
                     kill_local(has_killed_refs, &refs, oparg);
-                    ref_stack_pop(&refs);
+                    ref r = ref_stack_pop(&refs);
+                    if (r.instr != -1) {
+                        has_killed_refs[r.instr] = true;
+                    }
                     break;
                 }
 
                 case STORE_FAST_LOAD_FAST: {
                     kill_local(has_killed_refs, &refs, oparg >> 4);
-                    ref_stack_pop(&refs);
+                    ref r = ref_stack_pop(&refs);
+                    if (r.instr != -1) {
+                        has_killed_refs[r.instr] = true;
+                    }
                     ref_stack_push(&refs, (ref){i, oparg & 15});
                     break;
                 }
 
                 case STORE_FAST_STORE_FAST: {
                     kill_local(has_killed_refs, &refs, oparg >> 4);
                     kill_local(has_killed_refs, &refs, oparg & 15);
-                    ref_stack_pop(&refs);
-                    ref_stack_pop(&refs);
+                    ref r = ref_stack_pop(&refs);
+                    if (r.instr != -1) {
+                        has_killed_refs[r.instr] = true;
+                    }
+                    r = ref_stack_pop(&refs);
+                    if (r.instr != -1) {
+                        has_killed_refs[r.instr] = true;
+                    }
                     break;
                 }