#include <stdbool.h>

#include "Python.h"

#include "pycore_flowgraph.h"

#include "pycore_compile.h"

#include "pycore_pymem.h" // _PyMem_IsPtrFreed()

#include "pycore_opcode_utils.h"

#define NEED_OPCODE_METADATA

#include "opcode_metadata.h" // _PyOpcode_opcode_metadata, _PyOpcode_num_popped/pushed

#undef NEED_OPCODE_METADATA

#undef SUCCESS

#undef ERROR

#define SUCCESS 0

#define ERROR -1

#define RETURN_IF_ERROR(X) \

if ((X) == -1) { \

return ERROR; \

}

#define DEFAULT_BLOCK_SIZE 16

typedef _PyCompilerSrcLocation location;

typedef _PyCfgJumpTargetLabel jump_target_label;

typedef _PyCfgBasicblock basicblock;

typedef _PyCfgBuilder cfg_builder;

typedef _PyCfgInstruction cfg_instr;

static const jump_target_label NO_LABEL = {-1};

#define SAME_LABEL(L1, L2) ((L1).id == (L2).id)

#define IS_LABEL(L) (!SAME_LABEL((L), (NO_LABEL)))

static inline int

is_block_push(cfg_instr *i)

{

return IS_BLOCK_PUSH_OPCODE(i->i_opcode);

}

static inline int

is_jump(cfg_instr *i)

{

return IS_JUMP_OPCODE(i->i_opcode);

}

/* One arg*/

#define INSTR_SET_OP1(I, OP, ARG) \

do { \

assert(HAS_ARG(OP)); \

_PyCfgInstruction *_instr__ptr_ = (I); \

_instr__ptr_->i_opcode = (OP); \

_instr__ptr_->i_oparg = (ARG); \

} while (0);

/* No args*/

#define INSTR_SET_OP0(I, OP) \

do { \

assert(!HAS_ARG(OP)); \

_PyCfgInstruction *_instr__ptr_ = (I); \

_instr__ptr_->i_opcode = (OP); \

_instr__ptr_->i_oparg = 0; \

} while (0);

/***** Blocks *****/

/* Returns the offset of the next instruction in the current block's

b_instr array. Resizes the b_instr as necessary.

Returns -1 on failure.

*/

static int

basicblock_next_instr(basicblock *b)

{

assert(b != NULL);

RETURN_IF_ERROR(

_PyCompile_EnsureArrayLargeEnough(

b->b_iused + 1,

(void**)&b->b_instr,

&b->b_ialloc,

DEFAULT_BLOCK_SIZE,

sizeof(cfg_instr)));

return b->b_iused++;

}

/* Allocate a new block and return a pointer to it.

Returns NULL on error.

*/

static basicblock *

cfg_builder_new_block(cfg_builder *g)

{

basicblock *b = (basicblock *)PyObject_Calloc(1, sizeof(basicblock));

if (b == NULL) {

PyErr_NoMemory();

return NULL;

}

/* Extend the singly linked list of blocks with new block. */

b->b_list = g->g_block_list;

g->g_block_list = b;

b->b_label = NO_LABEL;

return b;

}

static int

basicblock_addop(basicblock *b, int opcode, int oparg, location loc)

{

assert(IS_WITHIN_OPCODE_RANGE(opcode));

assert(!IS_ASSEMBLER_OPCODE(opcode));

assert(HAS_ARG(opcode) || HAS_TARGET(opcode) || oparg == 0);

assert(0 <= oparg && oparg < (1 << 30));

int off = basicblock_next_instr(b);

if (off < 0) {

return ERROR;

}

cfg_instr *i = &b->b_instr[off];

i->i_opcode = opcode;

i->i_oparg = oparg;

i->i_target = NULL;

i->i_loc = loc;

return SUCCESS;

}

static inline int

basicblock_append_instructions(basicblock *target, basicblock *source)

{

for (int i = 0; i < source->b_iused; i++) {

int n = basicblock_next_instr(target);

if (n < 0) {

return ERROR;

}

target->b_instr[n] = source->b_instr[i];

}

return SUCCESS;

}

static basicblock *

copy_basicblock(cfg_builder *g, basicblock *block)

{

/* Cannot copy a block if it has a fallthrough, since

* a block can only have one fallthrough predecessor.

*/

assert(BB_NO_FALLTHROUGH(block));

basicblock *result = cfg_builder_new_block(g);

if (result == NULL) {

return NULL;

}

if (basicblock_append_instructions(result, block) < 0) {

return NULL;

}

return result;

}

int

_PyBasicblock_InsertInstruction(basicblock *block, int pos, cfg_instr *instr) {

RETURN_IF_ERROR(basicblock_next_instr(block));

for (int i = block->b_iused - 1; i > pos; i--) {

block->b_instr[i] = block->b_instr[i-1];

}

block->b_instr[pos] = *instr;

return SUCCESS;

}

static int

instr_size(cfg_instr *instruction)

{

return _PyCompile_InstrSize(instruction->i_opcode, instruction->i_oparg);

}

static int

blocksize(basicblock *b)

{

int size = 0;

for (int i = 0; i < b->b_iused; i++) {

size += instr_size(&b->b_instr[i]);

}

return size;

}

/* For debugging purposes only */

#if 0

static void

dump_instr(cfg_instr *i)

{

const char *jump = is_jump(i) ? "jump " : "";

char arg[128];

*arg = '\0';

if (HAS_ARG(i->i_opcode)) {

sprintf(arg, "arg: %d ", i->i_oparg);

}

if (HAS_TARGET(i->i_opcode)) {

sprintf(arg, "target: %p [%d] ", i->i_target, i->i_oparg);

}

fprintf(stderr, "line: %d, opcode: %d %s%s\n",

i->i_loc.lineno, i->i_opcode, arg, jump);

}

static inline int

basicblock_returns(const basicblock *b) {

cfg_instr *last = _PyCfg_BasicblockLastInstr(b);

return last && (last->i_opcode == RETURN_VALUE || last->i_opcode == RETURN_CONST);

}

static void

dump_basicblock(const basicblock *b)

{

const char *b_return = basicblock_returns(b) ? "return " : "";

fprintf(stderr, "%d: [EH=%d CLD=%d WRM=%d NO_FT=%d %p] used: %d, depth: %d, offset: %d %s\n",

b->b_label.id, b->b_except_handler, b->b_cold, b->b_warm, BB_NO_FALLTHROUGH(b), b, b->b_iused,

b->b_startdepth, b->b_offset, b_return);

if (b->b_instr) {

int i;

for (i = 0; i < b->b_iused; i++) {

fprintf(stderr, " [%02d] ", i);

dump_instr(b->b_instr + i);

}

}

}

void

_PyCfgBuilder_DumpGraph(const basicblock *entryblock)

{

for (const basicblock *b = entryblock; b != NULL; b = b->b_next) {

dump_basicblock(b);

}

}

#endif

/***** CFG construction and modification *****/

static basicblock *

cfg_builder_use_next_block(cfg_builder *g, basicblock *block)

{

assert(block != NULL);

g->g_curblock->b_next = block;

g->g_curblock = block;

return block;

}

cfg_instr *

_PyCfg_BasicblockLastInstr(const basicblock *b) {

assert(b->b_iused >= 0);

if (b->b_iused > 0) {

assert(b->b_instr != NULL);

return &b->b_instr[b->b_iused - 1];

}

return NULL;

}

static inline int

basicblock_exits_scope(const basicblock *b) {

cfg_instr *last = _PyCfg_BasicblockLastInstr(b);

return last && IS_SCOPE_EXIT_OPCODE(last->i_opcode);

}

static bool

cfg_builder_current_block_is_terminated(cfg_builder *g)

{

cfg_instr *last = _PyCfg_BasicblockLastInstr(g->g_curblock);

if (last && IS_TERMINATOR_OPCODE(last->i_opcode)) {

return true;

}

if (IS_LABEL(g->g_current_label)) {

if (last || IS_LABEL(g->g_curblock->b_label)) {

return true;

}

else {

/* current block is empty, label it */

g->g_curblock->b_label = g->g_current_label;

g->g_current_label = NO_LABEL;

}

}

return false;

}

static int

cfg_builder_maybe_start_new_block(cfg_builder *g)

{

if (cfg_builder_current_block_is_terminated(g)) {

basicblock *b = cfg_builder_new_block(g);

if (b == NULL) {

return ERROR;

}

b->b_label = g->g_current_label;

g->g_current_label = NO_LABEL;

cfg_builder_use_next_block(g, b);

}

return SUCCESS;

}

#ifndef NDEBUG

static bool

cfg_builder_check(cfg_builder *g)

{

assert(g->g_entryblock->b_iused > 0);

for (basicblock *block = g->g_block_list; block != NULL; block = block->b_list) {

assert(!_PyMem_IsPtrFreed(block));

if (block->b_instr != NULL) {

assert(block->b_ialloc > 0);

assert(block->b_iused >= 0);

assert(block->b_ialloc >= block->b_iused);

}

else {

assert (block->b_iused == 0);

assert (block->b_ialloc == 0);

}

}

return true;

}

#endif

int

_PyCfgBuilder_Init(cfg_builder *g)

{

g->g_block_list = NULL;

basicblock *block = cfg_builder_new_block(g);

if (block == NULL) {

return ERROR;

}

g->g_curblock = g->g_entryblock = block;

g->g_current_label = NO_LABEL;

return SUCCESS;

}

void

_PyCfgBuilder_Fini(cfg_builder* g)

{

assert(cfg_builder_check(g));

basicblock *b = g->g_block_list;

while (b != NULL) {

if (b->b_instr) {

PyObject_Free((void *)b->b_instr);

}

basicblock *next = b->b_list;

PyObject_Free((void *)b);

b = next;

}

}

int

_PyCfgBuilder_UseLabel(cfg_builder *g, jump_target_label lbl)

{

g->g_current_label = lbl;

return cfg_builder_maybe_start_new_block(g);

}

int

_PyCfgBuilder_Addop(cfg_builder *g, int opcode, int oparg, location loc)

{

RETURN_IF_ERROR(cfg_builder_maybe_start_new_block(g));

return basicblock_addop(g->g_curblock, opcode, oparg, loc);

}

/***** debugging helpers *****/

#ifndef NDEBUG

static int remove_redundant_nops(basicblock *bb);

/*

static bool

no_redundant_nops(cfg_builder *g) {

for (basicblock *b = g->g_entryblock; b != NULL; b = b->b_next) {

if (remove_redundant_nops(b) != 0) {

return false;

}

}

return true;

}

*/

static bool

no_empty_basic_blocks(cfg_builder *g) {

for (basicblock *b = g->g_entryblock; b != NULL; b = b->b_next) {

if (b->b_iused == 0) {

return false;

}

}

return true;

}

static bool

no_redundant_jumps(cfg_builder *g) {

for (basicblock *b = g->g_entryblock; b != NULL; b = b->b_next) {

cfg_instr *last = _PyCfg_BasicblockLastInstr(b);

if (last != NULL) {

if (IS_UNCONDITIONAL_JUMP_OPCODE(last->i_opcode)) {

assert(last->i_target != b->b_next);

if (last->i_target == b->b_next) {

return false;

}

}

}

}

return true;

}

#endif

/***** CFG preprocessing (jump targets and exceptions) *****/

static int

normalize_jumps_in_block(cfg_builder *g, basicblock *b) {

cfg_instr *last = _PyCfg_BasicblockLastInstr(b);

if (last == NULL || !is_jump(last)) {

return SUCCESS;

}

assert(!IS_ASSEMBLER_OPCODE(last->i_opcode));

bool is_forward = last->i_target->b_visited == 0;

switch(last->i_opcode) {

case JUMP:

last->i_opcode = is_forward ? JUMP_FORWARD : JUMP_BACKWARD;

return SUCCESS;

case JUMP_NO_INTERRUPT:

last->i_opcode = is_forward ?

JUMP_FORWARD : JUMP_BACKWARD_NO_INTERRUPT;

return SUCCESS;

}

int reversed_opcode = 0;

switch(last->i_opcode) {

case POP_JUMP_IF_NOT_NONE:

reversed_opcode = POP_JUMP_IF_NONE;

break;

case POP_JUMP_IF_NONE:

reversed_opcode = POP_JUMP_IF_NOT_NONE;

break;

case POP_JUMP_IF_FALSE:

reversed_opcode = POP_JUMP_IF_TRUE;

break;

case POP_JUMP_IF_TRUE:

reversed_opcode = POP_JUMP_IF_FALSE;

break;

}

if (is_forward) {

return SUCCESS;

}

/* transform 'conditional jump T' to

* 'reversed_jump b_next' followed by 'jump_backwards T'

*/

basicblock *target = last->i_target;

basicblock *backwards_jump = cfg_builder_new_block(g);

if (backwards_jump == NULL) {

return ERROR;

}

basicblock_addop(backwards_jump, JUMP, target->b_label.id, last->i_loc);

backwards_jump->b_instr[0].i_target = target;

last->i_opcode = reversed_opcode;

last->i_target = b->b_next;

backwards_jump->b_cold = b->b_cold;

backwards_jump->b_next = b->b_next;

b->b_next = backwards_jump;

return SUCCESS;

}

static int

normalize_jumps(_PyCfgBuilder *g)

{

basicblock *entryblock = g->g_entryblock;

for (basicblock *b = entryblock; b != NULL; b = b->b_next) {

b->b_visited = 0;

}

for (basicblock *b = entryblock; b != NULL; b = b->b_next) {

b->b_visited = 1;

RETURN_IF_ERROR(normalize_jumps_in_block(g, b));

}

return SUCCESS;

}

static void

resolve_jump_offsets(basicblock *entryblock)

{

int bsize, totsize, extended_arg_recompile;

/* Compute the size of each block and fixup jump args.

Replace block pointer with position in bytecode. */

do {

totsize = 0;

for (basicblock *b = entryblock; b != NULL; b = b->b_next) {

bsize = blocksize(b);

b->b_offset = totsize;

totsize += bsize;

}

extended_arg_recompile = 0;

for (basicblock *b = entryblock; b != NULL; b = b->b_next) {

bsize = b->b_offset;

for (int i = 0; i < b->b_iused; i++) {

cfg_instr *instr = &b->b_instr[i];

int isize = instr_size(instr);

/* jump offsets are computed relative to

* the instruction pointer after fetching

* the jump instruction.

*/

bsize += isize;

if (is_jump(instr)) {

instr->i_oparg = instr->i_target->b_offset;

if (instr->i_oparg < bsize) {

assert(IS_BACKWARDS_JUMP_OPCODE(instr->i_opcode));

instr->i_oparg = bsize - instr->i_oparg;

}

else {

assert(!IS_BACKWARDS_JUMP_OPCODE(instr->i_opcode));

instr->i_oparg -= bsize;

}

if (instr_size(instr) != isize) {

extended_arg_recompile = 1;

}

}

}

}

/* XXX: This is an awful hack that could hurt performance, but

on the bright side it should work until we come up

with a better solution.

The issue is that in the first loop blocksize() is called

which calls instr_size() which requires i_oparg be set

appropriately. There is a bootstrap problem because

i_oparg is calculated in the second loop above.

So we loop until we stop seeing new EXTENDED_ARGs.

The only EXTENDED_ARGs that could be popping up are

ones in jump instructions. So this should converge

fairly quickly.

*/

} while (extended_arg_recompile);

}

int

_PyCfg_ResolveJumps(_PyCfgBuilder *g)

{

RETURN_IF_ERROR(normalize_jumps(g));

assert(no_redundant_jumps(g));

resolve_jump_offsets(g->g_entryblock);

return SUCCESS;

}

static int

check_cfg(cfg_builder *g) {

for (basicblock *b = g->g_entryblock; b != NULL; b = b->b_next) {

/* Raise SystemError if jump or exit is not last instruction in the block. */

for (int i = 0; i < b->b_iused; i++) {

int opcode = b->b_instr[i].i_opcode;

assert(!IS_ASSEMBLER_OPCODE(opcode));

if (IS_TERMINATOR_OPCODE(opcode)) {

if (i != b->b_iused - 1) {

PyErr_SetString(PyExc_SystemError, "malformed control flow graph.");

return ERROR;

}

}

}

}

return SUCCESS;

}

static int

get_max_label(basicblock *entryblock)

{

int lbl = -1;

for (basicblock *b = entryblock; b != NULL; b = b->b_next) {

if (b->b_label.id > lbl) {

lbl = b->b_label.id;

}

}

return lbl;

}

/* Calculate the actual jump target from the target_label */

static int

translate_jump_labels_to_targets(basicblock *entryblock)

{

int max_label = get_max_label(entryblock);

size_t mapsize = sizeof(basicblock *) * (max_label + 1);

basicblock **label2block = (basicblock **)PyMem_Malloc(mapsize);

if (!label2block) {

PyErr_NoMemory();

return ERROR;

}

memset(label2block, 0, mapsize);

for (basicblock *b = entryblock; b != NULL; b = b->b_next) {

if (b->b_label.id >= 0) {

label2block[b->b_label.id] = b;

}

}

for (basicblock *b = entryblock; b != NULL; b = b->b_next) {

for (int i = 0; i < b->b_iused; i++) {

cfg_instr *instr = &b->b_instr[i];

assert(instr->i_target == NULL);

if (HAS_TARGET(instr->i_opcode)) {

int lbl = instr->i_oparg;

assert(lbl >= 0 && lbl <= max_label);

instr->i_target = label2block[lbl];

assert(instr->i_target != NULL);

assert(instr->i_target->b_label.id == lbl);

}

}

}

PyMem_Free(label2block);

return SUCCESS;

}

int

_PyCfg_JumpLabelsToTargets(basicblock *entryblock)

{

return translate_jump_labels_to_targets(entryblock);

}

static int

mark_except_handlers(basicblock *entryblock) {

#ifndef NDEBUG

for (basicblock *b = entryblock; b != NULL; b = b->b_next) {

assert(!b->b_except_handler);

}

#endif

for (basicblock *b = entryblock; b != NULL; b = b->b_next) {

for (int i=0; i < b->b_iused; i++) {

cfg_instr *instr = &b->b_instr[i];

if (is_block_push(instr)) {

instr->i_target->b_except_handler = 1;

}

}

}

return SUCCESS;

}

typedef _PyCfgExceptStack ExceptStack;

static basicblock *

push_except_block(ExceptStack *stack, cfg_instr *setup) {

assert(is_block_push(setup));

int opcode = setup->i_opcode;

basicblock * target = setup->i_target;

if (opcode == SETUP_WITH || opcode == SETUP_CLEANUP) {

target->b_preserve_lasti = 1;

}

assert(stack->depth <= CO_MAXBLOCKS);

stack->handlers[++stack->depth] = target;

return target;

}

static basicblock *

pop_except_block(ExceptStack *stack) {

assert(stack->depth > 0);

return stack->handlers[--stack->depth];

}

static basicblock *

except_stack_top(ExceptStack *stack) {

return stack->handlers[stack->depth];

}

static ExceptStack *

make_except_stack(void) {

ExceptStack *new = PyMem_Malloc(sizeof(ExceptStack));

if (new == NULL) {

PyErr_NoMemory();

return NULL;

}

new->depth = 0;

new->handlers[0] = NULL;

return new;

}

static ExceptStack *

copy_except_stack(ExceptStack *stack) {

ExceptStack *copy = PyMem_Malloc(sizeof(ExceptStack));

if (copy == NULL) {

PyErr_NoMemory();

return NULL;

}

memcpy(copy, stack, sizeof(ExceptStack));

return copy;

}

static basicblock**

make_cfg_traversal_stack(basicblock *entryblock) {

int nblocks = 0;

for (basicblock *b = entryblock; b != NULL; b = b->b_next) {

b->b_visited = 0;

nblocks++;

}

basicblock **stack = (basicblock **)PyMem_Malloc(sizeof(basicblock *) * nblocks);

if (!stack) {

PyErr_NoMemory();

}

return stack;

}

Py_LOCAL_INLINE(void)

stackdepth_push(basicblock ***sp, basicblock *b, int depth)

{

assert(b->b_startdepth < 0 || b->b_startdepth == depth);

if (b->b_startdepth < depth && b->b_startdepth < 100) {

assert(b->b_startdepth < 0);

b->b_startdepth = depth;

*(*sp)++ = b;

}

}

/* Find the flow path that needs the largest stack. We assume that

* cycles in the flow graph have no net effect on the stack depth.

*/

int

_PyCfg_Stackdepth(basicblock *entryblock, int code_flags)

{

for (basicblock *b = entryblock; b != NULL; b = b->b_next) {

b->b_startdepth = INT_MIN;

}

basicblock **stack = make_cfg_traversal_stack(entryblock);

if (!stack) {

return ERROR;

}

int maxdepth = 0;

basicblock **sp = stack;

if (code_flags & (CO_GENERATOR | CO_COROUTINE | CO_ASYNC_GENERATOR)) {

stackdepth_push(&sp, entryblock, 1);

} else {

stackdepth_push(&sp, entryblock, 0);

}

while (sp != stack) {

basicblock *b = *--sp;

int depth = b->b_startdepth;

assert(depth >= 0);

basicblock *next = b->b_next;

for (int i = 0; i < b->b_iused; i++) {

cfg_instr *instr = &b->b_instr[i];

int effect = PyCompile_OpcodeStackEffectWithJump(instr->i_opcode, instr->i_oparg, 0);

if (effect == PY_INVALID_STACK_EFFECT) {

PyErr_Format(PyExc_SystemError,

"compiler PyCompile_OpcodeStackEffectWithJump(opcode=%d, arg=%i) failed",

instr->i_opcode, instr->i_oparg);

return ERROR;

}

int new_depth = depth + effect;

assert(new_depth >= 0); /* invalid code or bug in stackdepth() */

if (new_depth > maxdepth) {

maxdepth = new_depth;

}

if (HAS_TARGET(instr->i_opcode)) {

effect = PyCompile_OpcodeStackEffectWithJump(instr->i_opcode, instr->i_oparg, 1);

assert(effect != PY_INVALID_STACK_EFFECT);

int target_depth = depth + effect;

assert(target_depth >= 0); /* invalid code or bug in stackdepth() */

if (target_depth > maxdepth) {

maxdepth = target_depth;

}

stackdepth_push(&sp, instr->i_target, target_depth);

}

depth = new_depth;

assert(!IS_ASSEMBLER_OPCODE(instr->i_opcode));

if (IS_UNCONDITIONAL_JUMP_OPCODE(instr->i_opcode) ||

IS_SCOPE_EXIT_OPCODE(instr->i_opcode))

{

/* remaining code is dead */

next = NULL;

break;

}

}

if (next != NULL) {

assert(BB_HAS_FALLTHROUGH(b));

stackdepth_push(&sp, next, depth);

}

}

PyMem_Free(stack);

return maxdepth;

}

static int

label_exception_targets(basicblock *entryblock) {

basicblock **todo_stack = make_cfg_traversal_stack(entryblock);

if (todo_stack == NULL) {

return ERROR;

}

ExceptStack *except_stack = make_except_stack();

if (except_stack == NULL) {

PyMem_Free(todo_stack);

PyErr_NoMemory();

return ERROR;

}

except_stack->depth = 0;

todo_stack[0] = entryblock;

entryblock->b_visited = 1;

entryblock->b_exceptstack = except_stack;

basicblock **todo = &todo_stack[1];

basicblock *handler = NULL;

while (todo > todo_stack) {

todo--;

basicblock *b = todo[0];

assert(b->b_visited == 1);

except_stack = b->b_exceptstack;

assert(except_stack != NULL);

b->b_exceptstack = NULL;

handler = except_stack_top(except_stack);

for (int i = 0; i < b->b_iused; i++) {

cfg_instr *instr = &b->b_instr[i];

if (is_block_push(instr)) {

if (!instr->i_target->b_visited) {

ExceptStack *copy = copy_except_stack(except_stack);

if (copy == NULL) {

goto error;

}

instr->i_target->b_exceptstack = copy;

todo[0] = instr->i_target;

instr->i_target->b_visited = 1;

todo++;

}

handler = push_except_block(except_stack, instr);

}

else if (instr->i_opcode == POP_BLOCK) {

handler = pop_except_block(except_stack);

}

else if (is_jump(instr)) {

instr->i_except = handler;

assert(i == b->b_iused -1);

if (!instr->i_target->b_visited) {

if (BB_HAS_FALLTHROUGH(b)) {

ExceptStack *copy = copy_except_stack(except_stack);

if (copy == NULL) {

goto error;

}

instr->i_target->b_exceptstack = copy;

}

else {

instr->i_target->b_exceptstack = except_stack;

except_stack = NULL;

}

todo[0] = instr->i_target;

instr->i_target->b_visited = 1;

todo++;

}

}

else {

if (instr->i_opcode == YIELD_VALUE) {

instr->i_oparg = except_stack->depth;

}

instr->i_except = handler;

}

}

if (BB_HAS_FALLTHROUGH(b) && !b->b_next->b_visited) {

assert(except_stack != NULL);

b->b_next->b_exceptstack = except_stack;

todo[0] = b->b_next;

b->b_next->b_visited = 1;

todo++;

}

else if (except_stack != NULL) {

PyMem_Free(except_stack);

}

}

#ifdef Py_DEBUG

for (basicblock *b = entryblock; b != NULL; b = b->b_next) {

assert(b->b_exceptstack == NULL);

}

#endif

PyMem_Free(todo_stack);

return SUCCESS;

error:

PyMem_Free(todo_stack);

PyMem_Free(except_stack);

return ERROR;

}

/***** CFG optimizations *****/

static int

mark_reachable(basicblock *entryblock) {

basicblock **stack = make_cfg_traversal_stack(entryblock);

if (stack == NULL) {

return ERROR;

}

basicblock **sp = stack;

entryblock->b_predecessors = 1;

*sp++ = entryblock;

while (sp > stack) {

basicblock *b = *(--sp);

b->b_visited = 1;

if (b->b_next && BB_HAS_FALLTHROUGH(b)) {

if (!b->b_next->b_visited) {

assert(b->b_next->b_predecessors == 0);

*sp++ = b->b_next;

}

b->b_next->b_predecessors++;

}

for (int i = 0; i < b->b_iused; i++) {

basicblock *target;

cfg_instr *instr = &b->b_instr[i];

if (is_jump(instr) || is_block_push(instr)) {

target = instr->i_target;

if (!target->b_visited) {

assert(target->b_predecessors == 0 || target == b->b_next);

*sp++ = target;

}

target->b_predecessors++;

}

}

}

PyMem_Free(stack);

return SUCCESS;

}

static void

eliminate_empty_basic_blocks(cfg_builder *g) {

/* Eliminate empty blocks */

for (basicblock *b = g->g_entryblock; b != NULL; b = b->b_next) {

basicblock *next = b->b_next;

while (next && next->b_iused == 0) {

next = next->b_next;

}

b->b_next = next;

}

while(g->g_entryblock && g->g_entryblock->b_iused == 0) {

g->g_entryblock = g->g_entryblock->b_next;

}

int next_lbl = get_max_label(g->g_entryblock) + 1;

for (basicblock *b = g->g_entryblock; b != NULL; b = b->b_next) {

assert(b->b_iused > 0);

for (int i = 0; i < b->b_iused; i++) {

cfg_instr *instr = &b->b_instr[i];

if (HAS_TARGET(instr->i_opcode)) {

basicblock *target = instr->i_target;

while (target->b_iused == 0) {

target = target->b_next;

}

if (instr->i_target != target) {

if (!IS_LABEL(target->b_label)) {

target->b_label.id = next_lbl++;

}

instr->i_target = target;

instr->i_oparg = target->b_label.id;

}

assert(instr->i_target && instr->i_target->b_iused > 0);

}

}

}

}

static int

remove_redundant_nops(basicblock *bb) {

/* Remove NOPs when legal to do so. */

int dest = 0;

int prev_lineno = -1;

for (int src = 0; src < bb->b_iused; src++) {

int lineno = bb->b_instr[src].i_loc.lineno;

if (bb->b_instr[src].i_opcode == NOP) {

/* Eliminate no-op if it doesn't have a line number */

if (lineno < 0) {

continue;

}

/* or, if the previous instruction had the same line number. */

if (prev_lineno == lineno) {

continue;

}

/* or, if the next instruction has same line number or no line number */

if (src < bb->b_iused - 1) {

int next_lineno = bb->b_instr[src+1].i_loc.lineno;

if (next_lineno == lineno) {

continue;

}

if (next_lineno < 0) {

bb->b_instr[src+1].i_loc = bb->b_instr[src].i_loc;

continue;

}

}

else {

basicblock* next = bb->b_next;

while (next && next->b_iused == 0) {

next = next->b_next;

}

/* or if last instruction in BB and next BB has same line number */

if (next) {

location next_loc = NO_LOCATION;

for (int next_i=0; next_i < next->b_iused; next_i++) {

cfg_instr *instr = &next->b_instr[next_i];

if (instr->i_opcode == NOP && instr->i_loc.lineno == NO_LOCATION.lineno) {

/* Skip over NOPs without location, they will be removed */

continue;

}

next_loc = instr->i_loc;

break;

}

if (lineno == next_loc.lineno) {

continue;

}

}

}