Rename to LOAD_FAST_CHECK

python · sweeneyde · May 31, 2022 · May 10, 2022 · May 10, 2022 · May 10, 2022
commit 9c74fe5b0aecd01ee3ed1b21fa6c74a4043d6d13
diff --git a/Include/internal/pycore_opcode.h b/Include/internal/pycore_opcode.h
diff --git a/Include/opcode.h b/Include/opcode.h
diff --git a/Lib/opcode.py b/Lib/opcode.py
@@ -139,13 +139,13 @@ def jabs_op(name, op):
 def_op('COPY', 120)
 def_op('BINARY_OP', 122)
 jrel_op('SEND', 123) # Number of bytes to skip
-def_op('LOAD_FAST', 124)        # Local variable number
+def_op('LOAD_FAST_CHECK', 124)        # Local variable number
 haslocal.append(124)
 def_op('STORE_FAST', 125)       # Local variable number
 haslocal.append(125)
 def_op('DELETE_FAST', 126)      # Local variable number
 haslocal.append(126)
-def_op('LOAD_FAST_KNOWN', 127)  # Local variable number
+def_op('LOAD_FAST', 127)  # Local variable number, no null check
 haslocal.append(127)
 jrel_op('POP_JUMP_FORWARD_IF_NOT_NONE', 128)
 jrel_op('POP_JUMP_FORWARD_IF_NONE', 129)

@@ -456,19 +456,19 @@ _PyFrame_GetState(PyFrameObject *frame)
 }
 
 void
-replace_LOAD_FAST_KNOWNs(PyCodeObject *co)
+add_load_fast_null_checks(PyCodeObject *co)
 {
     _Py_CODEUNIT *instructions = _PyCode_CODE(co);
     for (Py_ssize_t i = 0; i < Py_SIZE(co); i++) {
         switch (_Py_OPCODE(instructions[i])) {
-            case LOAD_FAST_KNOWN:
-                _Py_SET_OPCODE(instructions[i], LOAD_FAST);
+            case LOAD_FAST:
+                _Py_SET_OPCODE(instructions[i], LOAD_FAST_CHECK);
                 break;
             case LOAD_FAST__LOAD_FAST:
-                _Py_SET_OPCODE(instructions[i], LOAD_FAST);
+                _Py_SET_OPCODE(instructions[i], LOAD_FAST_CHECK);
                 break;
             case LOAD_FAST__LOAD_CONST:
-                _Py_SET_OPCODE(instructions[i], LOAD_FAST);
+                _Py_SET_OPCODE(instructions[i], LOAD_FAST_CHECK);
                 break;
             case LOAD_CONST__LOAD_FAST:
                 _Py_SET_OPCODE(instructions[i], LOAD_CONST);
@@ -569,7 +569,7 @@ frame_setlineno(PyFrameObject *f, PyObject* p_new_lineno, void *Py_UNUSED(ignore
         return -1;
     }
 
-    replace_LOAD_FAST_KNOWNs(f->f_frame->f_code);
+    add_load_fast_null_checks(f->f_frame->f_code);
 
     /* PyCode_NewWithPosOnlyArgs limits co_code to be under INT_MAX so this
      * should never overflow. */
@@ -1073,7 +1073,7 @@ _PyFrame_LocalsToFast(_PyInterpreterFrame *frame, int clear)
     }
     fast = _PyFrame_GetLocalsArray(frame);
     co = frame->f_code;
-    bool replaced_code = false;
+    bool added_null_checks = false;
 
     PyErr_Fetch(&error_type, &error_value, &error_traceback);
     for (int i = 0; i < co->co_nlocalsplus; i++) {
@@ -1092,9 +1092,9 @@ _PyFrame_LocalsToFast(_PyInterpreterFrame *frame, int clear)
                 continue;
             }
         }
-        if (!replaced_code) {
-            replace_LOAD_FAST_KNOWNs(co);
-            replaced_code = true;
+        if (!added_null_checks) {
+            add_load_fast_null_checks(co);
+            added_null_checks = true;
         }
         PyObject *oldvalue = fast[i];
         PyObject *cell = NULL;

@@ -1861,7 +1861,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int
             DISPATCH();
         }
 
-        TARGET(LOAD_FAST) {
+        TARGET(LOAD_FAST_CHECK) {
             PyObject *value = GETLOCAL(oparg);
             if (value == NULL) {
                 goto unbound_local_error;
@@ -1871,7 +1871,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int
             DISPATCH();
         }
 
-        TARGET(LOAD_FAST_KNOWN) {
+        TARGET(LOAD_FAST) {
             PyObject *value = GETLOCAL(oparg);
             assert(value != NULL);
             Py_INCREF(value);

@@ -1148,7 +1148,7 @@ stack_effect(int opcode, int oparg, int jump)
             return 1;
 
         case LOAD_FAST:
-        case LOAD_FAST_KNOWN:
+        case LOAD_FAST_CHECK:
             return 1;
         case STORE_FAST:
             return -1;
@@ -7822,13 +7822,13 @@ scan_block_for_local(int target, basicblock *b, bool unsafe_to_start,
             MAYBE_PUSH(instr->i_except);
         }
         switch (instr->i_opcode) {
-            case LOAD_FAST:
+            case LOAD_FAST_CHECK:
                 // if this doesn't raise, then var is defined
                 unsafe = false;
                 break;
-            case LOAD_FAST_KNOWN:
+            case LOAD_FAST:
                 if (unsafe) {
-                    b->b_instr[i].i_opcode = LOAD_FAST;
+                    b->b_instr[i].i_opcode = LOAD_FAST_CHECK;
                 }
                 unsafe = false;
                 break;
@@ -7856,21 +7856,10 @@ scan_block_for_local(int target, basicblock *b, bool unsafe_to_start,
 #undef MAYBE_PUSH
 
 int
-mark_known_variables(struct assembler *a, struct compiler *c)
+mark_unknown_variables(struct assembler *a, struct compiler *c)
 {
-    Py_ssize_t num_blocks = 0;
-    int nlocals = (int)PyDict_GET_SIZE(c->u->u_varnames);
-    for (basicblock *b = a->a_entry; b != NULL; b = b->b_next) {
-        num_blocks++;
-        for (Py_ssize_t i = 0; i < b->b_iused; i++) {
-            struct instr *instr = &b->b_instr[i];
-            if (instr->i_opcode == LOAD_FAST) {
-                instr->i_opcode = LOAD_FAST_KNOWN;
-            }
-        }
-    }
-    // fprintf(stderr, "num blocks: %d\nnum_locals: %d\n", (int)num_blocks, num_locals);
-    basicblock **stack = PyMem_New(basicblock *, num_blocks);
+
+    basicblock **stack = make_cfg_traversal_stack(a->a_entry);
     if (stack == NULL) {
         return -1;
     }
@@ -7889,6 +7878,7 @@ mark_known_variables(struct assembler *a, struct compiler *c)
         }
     }
 
+    int nlocals = (int)PyDict_GET_SIZE(c->u->u_varnames);
     for (int target = 0; target < nlocals; target++) {
         for (basicblock *b = a->a_entry; b != NULL; b = b->b_next) {
             b->b_visited = 0;
@@ -8528,7 +8518,7 @@ assemble(struct compiler *c, int addNone)
     /* Order of basic blocks must have been determined by now */
     normalize_jumps(&a);
 
-    if (mark_known_variables(&a, c) < 0) {
+    if (mark_unknown_variables(&a, c) < 0) {
         goto error;
     }
     // fprintf(stderr, "Success???\n");

diff --git a/Python/opcode_targets.h b/Python/opcode_targets.h
diff --git a/Python/specialize.c b/Python/specialize.c
@@ -283,9 +283,9 @@ _PyCode_Quicken(PyCodeObject *code)
                 case RESUME:
                     _Py_SET_OPCODE(instructions[i], RESUME_QUICK);
                     break;
-                case LOAD_FAST_KNOWN:
+                case LOAD_FAST:
                     switch(previous_opcode) {
-                        case LOAD_FAST_KNOWN:
+                        case LOAD_FAST:
                             _Py_SET_OPCODE(instructions[i - 1],
                                            LOAD_FAST__LOAD_FAST);
                             break;
@@ -306,7 +306,7 @@ _PyCode_Quicken(PyCodeObject *code)
                     }
                     break;
                 case LOAD_CONST:
-                    if (previous_opcode == LOAD_FAST_KNOWN) {
+                    if (previous_opcode == LOAD_FAST) {
                         _Py_SET_OPCODE(instructions[i - 1],
                                        LOAD_FAST__LOAD_CONST);
                     }