fold in codegen instead of cfg

Author: WolframAlph

Lib/test/test_peepholer.py

@@ -1349,71 +1349,6 @@ def test_fold_tuple_of_constants(self):
         ]
         self.cfg_optimization_test(same, same, consts=[])
 
-    def test_fold_constant_intrinsic_list_to_tuple(self):
-        INTRINSIC_LIST_TO_TUPLE = 6
-
-        # long tuple
-        consts = 1000
-        before = (
-            [('BUILD_LIST', 0, 0)] +
-            [('LOAD_CONST', 0, 0), ('LIST_APPEND', 1, 0)] * consts +
-            [('CALL_INTRINSIC_1', INTRINSIC_LIST_TO_TUPLE, 0), ('RETURN_VALUE', None, 0)]
-        )
-        after = [
-            ('LOAD_CONST', 1, 0),
-            ('RETURN_VALUE', None, 0)
-        ]
-        result_const = tuple(["test"] * consts)
-        self.cfg_optimization_test(before, after, consts=["test"], expected_consts=["test", result_const])
-
-        # empty list
-        before = [
-            ('BUILD_LIST', 0, 0),
-            ('CALL_INTRINSIC_1', INTRINSIC_LIST_TO_TUPLE, 0),
-            ('RETURN_VALUE', None, 0)
-        ]
-        after = [
-            ('LOAD_CONST', 0, 0),
-            ('RETURN_VALUE', None, 0)
-        ]
-        self.cfg_optimization_test(before, after, consts=[], expected_consts=[()])
-
-        # multiple BUILD_LIST 0: ([], 1, [], 2)
-        same = [
-            ('BUILD_LIST', 0, 0),
-            ('BUILD_LIST', 0, 0),
-            ('LIST_APPEND', 1, 0),
-            ('LOAD_SMALL_INT', 1, 0),
-            ('LIST_APPEND', 1, 0),
-            ('BUILD_LIST', 0, 0),
-            ('LIST_APPEND', 1, 0),
-            ('LOAD_SMALL_INT', 2, 0),
-            ('LIST_APPEND', 1, 0),
-            ('CALL_INTRINSIC_1', INTRINSIC_LIST_TO_TUPLE, 0),
-            ('RETURN_VALUE', None, 0)
-        ]
-        self.cfg_optimization_test(same, same, consts=[])
-
-        # nested folding: (1, 1+1, 3)
-        before = [
-            ('BUILD_LIST', 0, 0),
-            ('LOAD_SMALL_INT', 1, 0),
-            ('LIST_APPEND', 1, 0),
-            ('LOAD_SMALL_INT', 1, 0),
-            ('LOAD_SMALL_INT', 1, 0),
-            ('BINARY_OP', get_binop_argval('NB_ADD'), 0),
-            ('LIST_APPEND', 1, 0),
-            ('LOAD_SMALL_INT', 3, 0),
-            ('LIST_APPEND', 1, 0),
-            ('CALL_INTRINSIC_1', INTRINSIC_LIST_TO_TUPLE, 0),
-            ('RETURN_VALUE', None, 0)
-        ]
-        after = [
-            ('LOAD_CONST', 0, 0),
-            ('RETURN_VALUE', None, 0)
-        ]
-        self.cfg_optimization_test(before, after, consts=[], expected_consts=[(1, 2, 3)])
-
     def test_optimize_if_const_list(self):
         before = [
             ('NOP', None, 0),

Python/codegen.c

@@ -3250,6 +3250,25 @@ starunpack_helper_impl(compiler *c, location loc,
     }
     int sequence_built = 0;
     if (big) {
+        if (tuple) {
+            PyObject *newconst = PyTuple_New(n);
+            if (newconst == NULL) {
+                return ERROR;
+            }
+            bool is_const = true;
+            for (Py_ssize_t i = 0; i < n; i++) {
+                expr_ty elt = asdl_seq_GET(elts, i);
+                if (elt->kind != Constant_kind) {
+                    is_const = false;
+                    Py_DECREF(newconst);
+                    break;
+                }
+                PyTuple_SET_ITEM(newconst, i, Py_NewRef(elt->v.Constant.value));
+            }
+            if (is_const) {
+                return codegen_addop_load_const(c, loc, newconst);
+            }
+        }
         ADDOP_I(c, loc, build, pushed);
         sequence_built = 1;
     }

Python/flowgraph.c

@@ -1452,95 +1452,6 @@ fold_tuple_of_constants(basicblock *bb, int i, PyObject *consts, PyObject *const
     return SUCCESS;
 }
 
-/* Replace:
-    BUILD_LIST 0
-    LOAD_CONST c1
-    LIST_APPEND 1
-    LOAD_CONST c2
-    LIST_APPEND 1
-    ...
-    LOAD_CONST cN
-    LIST_APPEND 1
-    CALL_INTRINSIC_1 INTRINSIC_LIST_TO_TUPLE
-   with:
-    LOAD_CONST (c1, c2, ... cN)
-*/
-static int
-fold_constant_intrinsic_list_to_tuple(basicblock *bb, int i,
-                                      PyObject *consts, PyObject *const_cache)
-{
-    assert(PyDict_CheckExact(const_cache));
-    assert(PyList_CheckExact(consts));
-    assert(i >= 0);
-    assert(i < bb->b_iused);
-    cfg_instr *intrinsic = &bb->b_instr[i];
-    assert(intrinsic->i_opcode == CALL_INTRINSIC_1);
-    assert(intrinsic->i_oparg == INTRINSIC_LIST_TO_TUPLE);
-
-    PyObject *list = PyList_New(0);
-    if (list == NULL) {
-        return ERROR;
-    }
-
-    bool expect_append = true;
-
-    for (int pos = i-1; pos >= 0; pos--) {
-        cfg_instr *instr = &bb->b_instr[pos];
-
-        if (instr->i_opcode == NOP) {
-            continue;
-        }
-
-        if (instr->i_opcode == BUILD_LIST && instr->i_oparg == 0) {
-            if (!expect_append) {
-                /* Not a sequence start */
-                goto exit;
-            }
-            /* Sequence start, we are done. */
-            if (PyList_Reverse(list) < 0) {
-                goto error;
-            }
-            PyObject *newconst = PyList_AsTuple(list);
-            if (newconst == NULL) {
-                goto error;
-            }
-            Py_DECREF(list);
-            int nops = (int)PyTuple_Size(newconst) * 2 + 1;
-            nop_out(bb, i-1, nops);
-            return instr_make_load_const(intrinsic, newconst, consts, const_cache);
-        }
-
-        if (expect_append) {
-            if (!(instr->i_opcode == LIST_APPEND && instr->i_oparg == 1)) {
-                goto exit;
-            }
-        }
-        else {
-            if (!loads_const(instr->i_opcode)) {
-                goto exit;
-            }
-            PyObject *constant = get_const_value(instr->i_opcode, instr->i_oparg, consts);
-            if (constant == NULL) {
-                goto error;
-            }
-            int r = PyList_Append(list, constant);
-            Py_DECREF(constant);
-            if (r < 0) {
-                goto error;
-            }
-        }
-
-        expect_append = !expect_append;
-    }
-
-exit:
-    Py_DECREF(list);
-    return SUCCESS;
-error:
-    Py_DECREF(list);
-    return ERROR;
-}
-
 #define MIN_CONST_SEQUENCE_SIZE 3
 /*
 Optimize lists and sets for:
@@ -2388,9 +2299,6 @@ optimize_basic_block(PyObject *const_cache, basicblock *bb, PyObject *consts)
                     if (nextop == GET_ITER) {
                         INSTR_SET_OP0(inst, NOP);
                     }
-                    else {
-                        fold_constant_intrinsic_list_to_tuple(bb, i, consts, const_cache);
-                    }
                 }
                 else if (oparg == INTRINSIC_UNARY_POSITIVE) {
                     RETURN_IF_ERROR(fold_const_unaryop(bb, i, consts, const_cache));