Remove all references to max stack

Author: markshannon

Lib/test/test_generated_cases.py

@@ -77,171 +77,6 @@ def test_effect_sizes(self):
         self.assertEqual(stack.top_offset.to_c(), "1 - oparg - oparg*2 + oparg*4")
 
 
-class TestGenerateMaxStackEffect(unittest.TestCase):
-    def check(self, input, output):
-        analysis = analyze_forest(parse_src(input))
-        buf = StringIO()
-        writer = CWriter(buf, 0, False)
-        opcode_metadata_generator.generate_max_stack_effect_function(analysis, writer)
-        buf.seek(0)
-        generated = buf.read()
-        matches = re.search(r"(case OP: {[^}]+})", generated)
-        if matches is None:
-            self.fail(f"Couldn't find case statement for OP in:\n {generated}")
-        self.assertEqual(output.strip(), matches.group(1))
-
-    def test_push_one(self):
-        input = """
-        inst(OP, (a -- b, c)) {
-            SPAM();
-        }
-        """
-        output = """
-        case OP: {
-            *effect = 1;
-            return 0;
-        }
-        """
-        self.check(input, output)
-
-    def test_cond_push(self):
-        input = """
-        inst(OP, (a -- b, c if (oparg))) {
-            SPAM();
-        }
-        """
-        output = """
-        case OP: {
-            *effect = ((oparg) ? 1 : 0);
-            return 0;
-        }
-        """
-        self.check(input, output)
-
-    def test_ops_pass_two(self):
-        input = """
-        op(A, (-- val1)) {
-            val1 = SPAM();
-        }
-        op(B, (-- val2)) {
-            val2 = SPAM();
-        }
-        op(C, (val1, val2 --)) {
-        }
-        macro(OP) = A + B + C;
-        """
-        output = """
-        case OP: {
-            *effect = 2;
-            return 0;
-        }
-        """
-        self.check(input, output)
-
-    def test_ops_pass_two_cond_push(self):
-        input = """
-        op(A, (-- val1, val2)) {
-            val1 = 0;
-            val2 = 1;
-        }
-        op(B, (val1, val2 -- val1, val2, val3 if (oparg))) {
-            val3 = SPAM();
-        }
-        macro(OP) = A + B;
-        """
-        output = """
-        case OP: {
-            *effect = Py_MAX(2, 2 + ((oparg) ? 1 : 0));
-            return 0;
-        }
-        """
-        self.check(input, output)
-
-    def test_pop_push_array(self):
-        input = """
-        inst(OP, (values[oparg] -- values[oparg], above)) {
-            SPAM(values, oparg);
-            above = 0;
-        }
-        """
-        output = """
-        case OP: {
-            *effect = 1;
-            return 0;
-        }
-        """
-        self.check(input, output)
-
-    def test_family(self):
-        input = """
-        op(A, (-- val1, val2)) {
-            val1 = 0;
-            val2 = 1;
-        }
-        op(B, (val1, val2 -- val3)) {
-            val3 = 2;
-        }
-        macro(OP1) = A + B;
-
-        inst(OP, (-- val)) {
-            val = 0;
-        }
-
-        family(OP, 0) = { OP1 };
-        """
-        output = """
-        case OP: {
-            *effect = 2;
-            return 0;
-        }
-        """
-        self.check(input, output)
-
-    def test_family_intermediate_array(self):
-        input = """
-        op(A, (-- values[oparg])) {
-            val1 = 0;
-            val2 = 1;
-        }
-        op(B, (values[oparg] -- val3)) {
-            val3 = 2;
-        }
-        macro(OP1) = A + B;
-
-        inst(OP, (-- val)) {
-            val = 0;
-        }
-
-        family(OP, 0) = { OP1 };
-        """
-        output = """
-        case OP: {
-            *effect = Py_MAX(1, oparg);
-            return 0;
-        }
-        """
-        self.check(input, output)
-
-    def test_negative_effect(self):
-        input = """
-        op(A, (val1 -- )) {
-        }
-        op(B, (val2 --)) {
-        }
-        op(C, (val3 --)) {
-        }
-
-        macro(OP) = A + B + C;
-        """
-        output = """
-        case OP: {
-            *effect = -1;
-            return 0;
-        }
-        """
-        self.check(input, output)
-
-
 class TestGeneratedCases(unittest.TestCase):
     def setUp(self) -> None:
         super().setUp()
@@ -287,12 +122,6 @@ def run_cases_test(self, input: str, expected: str):
             _, labels_with_postlude = labels_with_prelude_and_postlude.split(tier1_generator.LABEL_START_MARKER)
             labels, _ = labels_with_postlude.split(tier1_generator.LABEL_END_MARKER)
             actual = instructions.strip() + "\n\n        " + labels.strip()
-        # if actual.strip() != expected.strip():
-        #     print("Actual:")
-        #     print(actual)
-        #     print("Expected:")
-        #     print(expected)
-        #     print("End")
 
         self.assertEqual(actual.strip(), expected.strip())
 

Python/flowgraph.c

@@ -760,11 +760,6 @@ make_cfg_traversal_stack(basicblock *entryblock) {
 typedef struct {
     /* The stack effect of the instruction. */
     int net;
-
-    /* The maximum stack usage of the instruction. Some instructions may
-     * temporarily push extra values to the stack while they are executing.
-     */
-    int max;
 } stack_effects;
 
 Py_LOCAL(int)
@@ -784,11 +779,9 @@ get_stack_effects(int opcode, int oparg, int jump, stack_effects *effects)
     }
     if (IS_BLOCK_PUSH_OPCODE(opcode) && !jump) {
         effects->net = 0;
-        effects->max = 0;
         return 0;
     }
     effects->net = pushed - popped;
-    assert(effects->max >= effects->net);
     return 0;
 }
 
@@ -849,7 +842,7 @@ calculate_stackdepth(cfg_builder *g)
                              "Invalid CFG, stack underflow");
                 goto error;
             }
-            maxdepth = Py_MAX(maxdepth, depth + effects.max);
+            maxdepth = Py_MAX(maxdepth, depth);
             if (HAS_TARGET(instr->i_opcode) && instr->i_opcode != END_ASYNC_FOR) {
                 if (get_stack_effects(instr->i_opcode, instr->i_oparg, 1, &effects) < 0) {
                     PyErr_Format(PyExc_SystemError,
@@ -859,7 +852,7 @@ calculate_stackdepth(cfg_builder *g)
                 }
                 int target_depth = depth + effects.net;
                 assert(target_depth >= 0); /* invalid code or bug in stackdepth() */
-                maxdepth = Py_MAX(maxdepth, depth + effects.max);
+                maxdepth = Py_MAX(maxdepth, depth);
                 if (stackdepth_push(&sp, instr->i_target, target_depth) < 0) {
                     goto error;
                 }