Remove block stack from frames add convert SETUP/POP_BLOCK instructio…

…ns into NOPs.

Include/cpython/frameobject.h

@@ -43,9 +43,7 @@ struct _frame {
 
  int f_lasti; /* Last instruction if called */
  int f_lineno; /* Current line number. Only valid if non-zero */
- int f_iblock; /* index in f_blockstack */
  PyFrameState f_state; /* What state the frame is in */
- PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
  PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
 };
 
@@ -77,11 +75,6 @@ _PyFrame_New_NoTrack(PyThreadState *, PyFrameConstructor *, PyObject *);
 
 /* The rest of the interface is specific for frame objects */
 
-/* Block management functions */
-
-PyAPI_FUNC(void) PyFrame_BlockSetup(PyFrameObject *, int, int, int);
-PyAPI_FUNC(PyTryBlock *) PyFrame_BlockPop(PyFrameObject *);
-
 /* Conversions between "fast locals" and locals in dictionary */
 
 PyAPI_FUNC(void) PyFrame_LocalsToFast(PyFrameObject *, int);

Lib/test/test_sys.py

@@ -1278,7 +1278,7 @@ class C(object): pass
  nfrees = len(x.f_code.co_freevars)
  extras = x.f_code.co_stacksize + x.f_code.co_nlocals +\
  ncells + nfrees - 1
- check(x, vsize('4Pi2c4P3ic' + CO_MAXBLOCKS*'3i' + 'P' + extras*'P'))
+ check(x, vsize('4Pi2c4P3ic' + 'P' + extras*'P'))
  # function
  def func(): pass
  check(func, size('14P'))

Objects/frameobject.c

@@ -301,15 +301,7 @@ frame_stack_pop(PyFrameObject *f)
 static void
 frame_block_unwind(PyFrameObject *f)
 {
- assert(f->f_stackdepth >= 0);
- assert(f->f_iblock > 0);
- f->f_iblock--;
- PyTryBlock *b = &f->f_blockstack[f->f_iblock];
- intptr_t delta = f->f_stackdepth - b->b_level;
- while (delta > 0) {
- frame_stack_pop(f);
- delta--;
- }
+ (void)f;
 }
 
 
@@ -845,7 +837,6 @@ _PyFrame_New_NoTrack(PyThreadState *tstate, PyFrameConstructor *con, PyObject *l
  f->f_gen = NULL;
  f->f_lasti = -1;
  f->f_lineno = 0;
- f->f_iblock = 0;
  f->f_state = FRAME_CREATED;
  // f_blockstack and f_localsplus initialized by frame_alloc()
  return f;
@@ -877,33 +868,6 @@ PyFrame_New(PyThreadState *tstate, PyCodeObject *code,
  return f;
 }
 
-
-/* Block management */
-
-void
-PyFrame_BlockSetup(PyFrameObject *f, int type, int handler, int level)
-{
- PyTryBlock *b;
- if (f->f_iblock >= CO_MAXBLOCKS) {
- Py_FatalError("block stack overflow");
- }
- b = &f->f_blockstack[f->f_iblock++];
- b->b_type = type;
- b->b_level = level;
- b->b_handler = handler;
-}
-
-PyTryBlock *
-PyFrame_BlockPop(PyFrameObject *f)
-{
- PyTryBlock *b;
- if (f->f_iblock <= 0) {
- Py_FatalError("block stack underflow");
- }
- b = &f->f_blockstack[--f->f_iblock];
- return b;
-}
-
 /* Convert between "fast" version of locals and dictionary version.
 
  map and values are input arguments. map is a tuple of strings.

Python/ceval.c

@@ -1711,7 +1711,6 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
  assert(!_PyErr_Occurred(tstate));
 #endif
 
-main_loop:
  for (;;) {
  assert(stack_pointer >= f->f_valuestack); /* else underflow */
  assert(STACK_LEVEL() <= co->co_stacksize); /* else overflow */
@@ -2398,7 +2397,6 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
 
  case TARGET(RETURN_VALUE): {
  retval = POP();
- assert(f->f_iblock == 0);
  assert(EMPTY());
  f->f_state = FRAME_RETURNED;
  f->f_stackdepth = 0;
@@ -2660,10 +2658,8 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
  _PyErr_SetString(tstate, PyExc_SystemError, "lasti is not an int");
  goto error;
  }
- PyTryBlock *b = &f->f_blockstack[f->f_iblock];
  PyObject *type, *value, *traceback;
  _PyErr_StackItem *exc_info;
- assert(STACK_LEVEL() == (b)->b_level + 4);
  type = POP();
  value = POP();
  traceback = POP();
@@ -2683,7 +2679,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
  }
 
  case TARGET(POP_BLOCK): {
- PyFrame_BlockPop(f);
+ /* PyFrame_BlockPop(f); */
  DISPATCH();
  }
 
@@ -4082,23 +4078,15 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
  }
 
  case TARGET(SETUP_FINALLY): {
- PyFrame_BlockSetup(f, SETUP_FINALLY, INSTR_OFFSET() + oparg,
- STACK_LEVEL());
  DISPATCH();
  }
 
  case TARGET(SETUP_CLEANUP): {
- PyFrame_BlockSetup(f, SETUP_CLEANUP, INSTR_OFFSET() + oparg,
- STACK_LEVEL());
  DISPATCH();
  }
 
  case TARGET(SETUP_ASYNC_WITH): {
  PREDICTED(SETUP_ASYNC_WITH);
- /* Setup the finally block before pushing the result
- of __aenter__ on the stack. */
- PyFrame_BlockSetup(f, SETUP_CLEANUP, INSTR_OFFSET() + oparg,
- STACK_LEVEL()-1);
  DISPATCH();
  }
 
@@ -4541,27 +4529,23 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
  }
 exception_unwind:
  f->f_state = FRAME_UNWINDING;
- if (f->f_iblock == 0) {
- // No handlers, so exit.
- break;
- }
- /* Pop the current block. */
- PyTryBlock *b = &f->f_blockstack[--f->f_iblock];
  /* We can't use f->f_lasti here, as RERAISE may have set it */
  int lasti = INSTR_OFFSET()-1;
  PyTryBlock from_table = get_exception_handler(co, lasti);
- assert(from_table.b_handler == b->b_handler);
- assert(from_table.b_type == b->b_type);
- assert(from_table.b_level == b->b_level);
- assert(b->b_type == SETUP_FINALLY || b->b_type == SETUP_CLEANUP);
- assert(STACK_LEVEL() >= b->b_level);
- while (STACK_LEVEL() > (b)->b_level) {
+ if (from_table.b_handler < 0) {
+ // No handlers, so exit.
+ break;
+ }
+
+ assert(from_table.b_type == SETUP_FINALLY || from_table.b_type == SETUP_CLEANUP);
+ assert(STACK_LEVEL() >= from_table.b_level);
+ while (STACK_LEVEL() > from_table.b_level) {
  PyObject *v = POP();
  Py_XDECREF(v);
  }
  PyObject *exc, *val, *tb;
- int handler = b->b_handler;
- if (b->b_type == SETUP_CLEANUP) {
+ int handler = from_table.b_handler;
+ if (from_table.b_type == SETUP_CLEANUP) {
  PyObject *lasti = PyLong_FromLong(f->f_lasti);
  if (lasti == NULL) {
  goto exception_unwind;

Python/compile.c

@@ -6589,6 +6589,19 @@ label_exception_targets(basicblock *entry) {
  return 0;
 }
 
+
+static void
+convert_exception_handlers_to_nops(basicblock *entry) {
+ for (basicblock *b = entry; b != NULL; b = b->b_next) {
+ for (int i = 0; i < b->b_iused; i++) {
+ struct instr *instr = &b->b_instr[i];
+ if (is_block_push(instr) || instr->i_opcode == POP_BLOCK) {
+ instr->i_opcode = NOP;
+ }
+ }
+ }
+}
+
 static inline void
 write_except_byte(struct assembler *a, int byte) {
  unsigned char *p = (unsigned char *) PyBytes_AS_STRING(a->a_except_table);
@@ -7141,13 +7154,6 @@ assemble(struct compiler *c, int addNone)
  /* Can't modify the bytecode after computing jump offsets. */
  assemble_jump_offsets(&a, c);
 
- /* Emit code. */
- for(b = entryblock; b != NULL; b = b->b_next) {
- for (j = 0; j < b->b_iused; j++)
- if (!assemble_emit(&a, &b->b_instr[j]))
- goto error;
- }
- /* We need to compute stack depths before the exception table */
  int maxdepth = stackdepth(c);
  if (maxdepth < 0) {
  goto error;
@@ -7158,6 +7164,15 @@ assemble(struct compiler *c, int addNone)
  maxdepth);
  goto error;
  }
+ convert_exception_handlers_to_nops(entryblock);
+
+ /* Emit code. */
+ for(b = entryblock; b != NULL; b = b->b_next) {
+ for (j = 0; j < b->b_iused; j++)
+ if (!assemble_emit(&a, &b->b_instr[j]))
+ goto error;
+ }
+
  if (!assemble_exception_table(&a)) {
  return 0;
  }