The peephole optimizer computes 2**(2**100), but if I press CTRL+c (the result will probably kills my memory anyway), I get an assertion error (with a Python compiled in debug mode).

$ ./python
>>> 2**(2**100)
^C
python: Python/ceval.c:1218: PyEval_EvalFrameEx: Assertion `!PyErr_Occurred()' failed.
Abandon (core dumped)

fold_binops_on_constants() returns 0 with an exception (KeyboardInterrupt) raised. The problem is in the caller which doesn't handle the exception properly:

                if (h >= 0 &&
                    ISBASICBLOCK(blocks, h, i-h+1)  &&
                    fold_binops_on_constants(&codestr[i], consts, CONST_STACK_LASTN(2))) {
                    i -= 2;
                    memset(&codestr[h], NOP, i - h);
                    assert(codestr[i] == LOAD_CONST);
                    CONST_STACK_POP(2);
                    CONST_STACK_PUSH_OP(i);
                }

There is probably the same error on fold_unaryops_on_constants().


Python 2.7 looks to behave correctly:

$ python2.7
>>> 2**(2**100)
^C
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyboardInterrupt


But in fact Python 2.7 is much worse :-D Peephole optimizer of Python 2.7 clears *all* exceptions (!) and it only optimizes 2**100, but not 2**(2**100). That's why the bug is not easily reproduced on Python 2.7. fold_binops_on_constants():

    if (newconst == NULL) {
        if(!PyErr_ExceptionMatches(PyExc_KeyboardInterrupt))
            PyErr_Clear();
        return 0;
    }

FYI.

> Peephole optimizer of Python 2.7 (...) only optimizes 2**100, but not 2**(2**100).

This optimizer is dummy, it's only able to replace "LOAD_CONST x; LOAD_CONST y; OPERATION" with the result, whereas the optimizer replaces the bytecode with "NOP; NOP; NOP; NOP; LOAD_CONST z".

So "LOAD_CONST x; LOAD_CONST y; LOAD_CONST z; OPERATION1; OPERATION2" cannot be optimized. But it's enough to optimize 1+2+3 or 1*2*3 for example.

Python 3 peephole optimize does better thanks to a better design:
---
changeset:   68375:14205d0fee45
user:        Antoine Pitrou <solipsis@pitrou.net>
date:        Fri Mar 11 17:27:02 2011 +0100
files:       Lib/test/test_peepholer.py Misc/NEWS Python/peephole.c
description:
Issue #11244: The peephole optimizer is now able to constant-fold
arbitrarily complex expressions.  This also fixes a 3.2 regression where
operations involving negative numbers were not constant-folded.
---

It uses a stack for constants, so it's able to optimize more cases.

I can reproduce a crash in 3.5, but not in 3.6. Seems it was fixed in issue30416.

Can this issue be closed now?

Yeah, let's close this issue.

stage: needs patch -> resolved

components: + Interpreter Core
stage: needs patch