/*

* This file compiles an abstract syntax tree (AST) into Python bytecode.

*

* The primary entry point is _PyAST_Compile(), which returns a

* PyCodeObject. The compiler makes several passes to build the code

* object:

* 1. Checks for future statements. See future.c

* 2. Builds a symbol table. See symtable.c.

* 3. Generate code for basic blocks. See compiler_mod() in this file.

* 4. Assemble the basic blocks into final code. See assemble() in

* this file.

* 5. Optimize the byte code (peephole optimizations).

*

* Note that compiler_mod() suggests module, but the module ast type

* (mod_ty) has cases for expressions and interactive statements.

*

* CAUTION: The VISIT_* macros abort the current function when they

* encounter a problem. So don't invoke them when there is memory

* which needs to be released. Code blocks are OK, as the compiler

* structure takes care of releasing those. Use the arena to manage

* objects.

*/

#include <stdbool.h>

// Need _PyOpcode_RelativeJump of pycore_opcode.h

#define NEED_OPCODE_TABLES

#include "Python.h"

#include "pycore_ast.h" // _PyAST_GetDocString()

#include "pycore_code.h" // _PyCode_New()

#include "pycore_compile.h" // _PyFuture_FromAST()

#include "pycore_long.h" // _PyLong_GetZero()

#include "pycore_opcode.h" // _PyOpcode_Caches

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

#include "pycore_symtable.h" // PySTEntryObject

#define DEFAULT_BLOCK_SIZE 16

#define DEFAULT_CODE_SIZE 128

#define DEFAULT_LNOTAB_SIZE 16

#define DEFAULT_CNOTAB_SIZE 32

#define COMP_GENEXP 0

#define COMP_LISTCOMP 1

#define COMP_SETCOMP 2

#define COMP_DICTCOMP 3

/* A soft limit for stack use, to avoid excessive

* memory use for large constants, etc.

*

* The value 30 is plucked out of thin air.

* Code that could use more stack than this is

* rare, so the exact value is unimportant.

*/

#define STACK_USE_GUIDELINE 30

/* If we exceed this limit, it should

* be considered a compiler bug.

* Currently it should be impossible

* to exceed STACK_USE_GUIDELINE * 100,

* as 100 is the maximum parse depth.

* For performance reasons we will

* want to reduce this to a

* few hundred in the future.

*

* NOTE: Whatever MAX_ALLOWED_STACK_USE is

* set to, it should never restrict what Python

* we can write, just how we compile it.

*/

#define MAX_ALLOWED_STACK_USE (STACK_USE_GUIDELINE * 100)

#define MAX_REAL_OPCODE 254

#define IS_WITHIN_OPCODE_RANGE(opcode) \

(((opcode) >= 0 && (opcode) <= MAX_REAL_OPCODE) || \

IS_PSEUDO_OPCODE(opcode))

#define IS_JUMP_OPCODE(opcode) \

is_bit_set_in_table(_PyOpcode_Jump, opcode)

#define IS_BLOCK_PUSH_OPCODE(opcode) \

((opcode) == SETUP_FINALLY || \

(opcode) == SETUP_WITH || \

(opcode) == SETUP_CLEANUP)

#define HAS_TARGET(opcode) \

(IS_JUMP_OPCODE(opcode) || IS_BLOCK_PUSH_OPCODE(opcode))

/* opcodes that must be last in the basicblock */

#define IS_TERMINATOR_OPCODE(opcode) \

(IS_JUMP_OPCODE(opcode) || IS_SCOPE_EXIT_OPCODE(opcode))

/* opcodes which are not emitted in codegen stage, only by the assembler */

#define IS_ASSEMBLER_OPCODE(opcode) \

((opcode) == JUMP_FORWARD || \

(opcode) == JUMP_BACKWARD || \

(opcode) == JUMP_BACKWARD_NO_INTERRUPT)

#define IS_BACKWARDS_JUMP_OPCODE(opcode) \

((opcode) == JUMP_BACKWARD || \

(opcode) == JUMP_BACKWARD_NO_INTERRUPT)

#define IS_UNCONDITIONAL_JUMP_OPCODE(opcode) \

((opcode) == JUMP || \

(opcode) == JUMP_NO_INTERRUPT || \

(opcode) == JUMP_FORWARD || \

(opcode) == JUMP_BACKWARD || \

(opcode) == JUMP_BACKWARD_NO_INTERRUPT)

#define IS_SCOPE_EXIT_OPCODE(opcode) \

((opcode) == RETURN_VALUE || \

(opcode) == RAISE_VARARGS || \

(opcode) == RERAISE)

#define IS_SUPERINSTRUCTION_OPCODE(opcode) \

((opcode) == LOAD_FAST__LOAD_FAST || \

(opcode) == LOAD_FAST__LOAD_CONST || \

(opcode) == LOAD_CONST__LOAD_FAST || \

(opcode) == STORE_FAST__LOAD_FAST || \

(opcode) == STORE_FAST__STORE_FAST)

#define IS_TOP_LEVEL_AWAIT(c) ( \

(c->c_flags->cf_flags & PyCF_ALLOW_TOP_LEVEL_AWAIT) \

&& (c->u->u_ste->ste_type == ModuleBlock))

typedef struct location_ {

int lineno;

int end_lineno;

int col_offset;

int end_col_offset;

} location;

#define LOCATION(LNO, END_LNO, COL, END_COL) \

((const location){(LNO), (END_LNO), (COL), (END_COL)})

static location NO_LOCATION = {-1, -1, -1, -1};

typedef struct jump_target_label_ {

int id;

} jump_target_label;

static struct jump_target_label_ NO_LABEL = {-1};

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

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

#define NEW_JUMP_TARGET_LABEL(C, NAME) \

jump_target_label NAME = cfg_new_label(CFG_BUILDER(C)); \

if (!IS_LABEL(NAME)) { \

return 0; \

}

#define USE_LABEL(C, LBL) \

if (cfg_builder_use_label(CFG_BUILDER(C), LBL) < 0) { \

return 0; \

}

struct instr {

int i_opcode;

int i_oparg;

location i_loc;

/* The following fields should not be set by the front-end: */

struct basicblock_ *i_target; /* target block (if jump instruction) */

struct basicblock_ *i_except; /* target block when exception is raised */

};

typedef struct exceptstack {

struct basicblock_ *handlers[CO_MAXBLOCKS+1];

int depth;

} ExceptStack;

#define LOG_BITS_PER_INT 5

#define MASK_LOW_LOG_BITS 31

static inline int

is_bit_set_in_table(const uint32_t *table, int bitindex) {

/* Is the relevant bit set in the relevant word? */

/* 512 bits fit into 9 32-bits words.

* Word is indexed by (bitindex>>ln(size of int in bits)).

* Bit within word is the low bits of bitindex.

*/

if (bitindex >= 0 && bitindex < 512) {

uint32_t word = table[bitindex >> LOG_BITS_PER_INT];

return (word >> (bitindex & MASK_LOW_LOG_BITS)) & 1;

}

else {

return 0;

}

}

static inline int

is_relative_jump(struct instr *i)

{

return is_bit_set_in_table(_PyOpcode_RelativeJump, i->i_opcode);

}

static inline int

is_block_push(struct instr *i)

{

return IS_BLOCK_PUSH_OPCODE(i->i_opcode);

}

static inline int

is_jump(struct instr *i)

{

return IS_JUMP_OPCODE(i->i_opcode);

}

static int

instr_size(struct instr *instruction)

{

int opcode = instruction->i_opcode;

assert(!IS_PSEUDO_OPCODE(opcode));

int oparg = HAS_ARG(opcode) ? instruction->i_oparg : 0;

int extended_args = (0xFFFFFF < oparg) + (0xFFFF < oparg) + (0xFF < oparg);

int caches = _PyOpcode_Caches[opcode];

return extended_args + 1 + caches;

}

static void

write_instr(_Py_CODEUNIT *codestr, struct instr *instruction, int ilen)

{

int opcode = instruction->i_opcode;

assert(!IS_PSEUDO_OPCODE(opcode));

int oparg = HAS_ARG(opcode) ? instruction->i_oparg : 0;

int caches = _PyOpcode_Caches[opcode];

switch (ilen - caches) {

case 4:

*codestr++ = _Py_MAKECODEUNIT(EXTENDED_ARG, (oparg >> 24) & 0xFF);

/* fall through */

case 3:

*codestr++ = _Py_MAKECODEUNIT(EXTENDED_ARG, (oparg >> 16) & 0xFF);

/* fall through */

case 2:

*codestr++ = _Py_MAKECODEUNIT(EXTENDED_ARG, (oparg >> 8) & 0xFF);

/* fall through */

case 1:

*codestr++ = _Py_MAKECODEUNIT(opcode, oparg & 0xFF);

break;

default:

Py_UNREACHABLE();

}

while (caches--) {

*codestr++ = _Py_MAKECODEUNIT(CACHE, 0);

}

}

typedef struct basicblock_ {

/* Each basicblock in a compilation unit is linked via b_list in the

reverse order that the block are allocated. b_list points to the next

block, not to be confused with b_next, which is next by control flow. */

struct basicblock_ *b_list;

/* The label of this block if it is a jump target, -1 otherwise */

int b_label;

/* Exception stack at start of block, used by assembler to create the exception handling table */

ExceptStack *b_exceptstack;

/* pointer to an array of instructions, initially NULL */

struct instr *b_instr;

/* If b_next is non-NULL, it is a pointer to the next

block reached by normal control flow. */

struct basicblock_ *b_next;

/* number of instructions used */

int b_iused;

/* length of instruction array (b_instr) */

int b_ialloc;

/* Used by add_checks_for_loads_of_unknown_variables */

uint64_t b_unsafe_locals_mask;

/* Number of predecessors that a block has. */

int b_predecessors;

/* depth of stack upon entry of block, computed by stackdepth() */

int b_startdepth;

/* instruction offset for block, computed by assemble_jump_offsets() */

int b_offset;

/* Basic block is an exception handler that preserves lasti */

unsigned b_preserve_lasti : 1;

/* Used by compiler passes to mark whether they have visited a basic block. */

unsigned b_visited : 1;

/* b_except_handler is used by the cold-detection algorithm to mark exception targets */

unsigned b_except_handler : 1;

/* b_cold is true if this block is not perf critical (like an exception handler) */

unsigned b_cold : 1;

/* b_warm is used by the cold-detection algorithm to mark blocks which are definitely not cold */

unsigned b_warm : 1;

} basicblock;

static struct instr *

basicblock_last_instr(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_returns(const basicblock *b) {

struct instr *last = basicblock_last_instr(b);

return last && last->i_opcode == RETURN_VALUE;

}

static inline int

basicblock_exits_scope(const basicblock *b) {

struct instr *last = basicblock_last_instr(b);

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

}

static inline int

basicblock_nofallthrough(const basicblock *b) {

struct instr *last = basicblock_last_instr(b);

return (last &&

(IS_SCOPE_EXIT_OPCODE(last->i_opcode) ||

IS_UNCONDITIONAL_JUMP_OPCODE(last->i_opcode)));

}

#define BB_NO_FALLTHROUGH(B) (basicblock_nofallthrough(B))

#define BB_HAS_FALLTHROUGH(B) (!basicblock_nofallthrough(B))

/* fblockinfo tracks the current frame block.

A frame block is used to handle loops, try/except, and try/finally.

It's called a frame block to distinguish it from a basic block in the

compiler IR.

*/

enum fblocktype { WHILE_LOOP, FOR_LOOP, TRY_EXCEPT, FINALLY_TRY, FINALLY_END,

WITH, ASYNC_WITH, HANDLER_CLEANUP, POP_VALUE, EXCEPTION_HANDLER,

EXCEPTION_GROUP_HANDLER, ASYNC_COMPREHENSION_GENERATOR };

struct fblockinfo {

enum fblocktype fb_type;

jump_target_label fb_block;

/* (optional) type-specific exit or cleanup block */

jump_target_label fb_exit;

/* (optional) additional information required for unwinding */

void *fb_datum;

};

enum {

COMPILER_SCOPE_MODULE,

COMPILER_SCOPE_CLASS,

COMPILER_SCOPE_FUNCTION,

COMPILER_SCOPE_ASYNC_FUNCTION,

COMPILER_SCOPE_LAMBDA,

COMPILER_SCOPE_COMPREHENSION,

};

typedef struct cfg_builder_ {

/* The entryblock, at which control flow begins. All blocks of the

CFG are reachable through the b_next links */

basicblock *g_entryblock;

/* Pointer to the most recently allocated block. By following

b_list links, you can reach all allocated blocks. */

basicblock *g_block_list;

/* pointer to the block currently being constructed */

basicblock *g_curblock;

/* label for the next instruction to be placed */

jump_target_label g_current_label;

/* next free label id */

int g_next_free_label;

} cfg_builder;

/* The following items change on entry and exit of code blocks.

They must be saved and restored when returning to a block.

*/

struct compiler_unit {

PySTEntryObject *u_ste;

PyObject *u_name;

PyObject *u_qualname; /* dot-separated qualified name (lazy) */

int u_scope_type;

/* The following fields are dicts that map objects to

the index of them in co_XXX. The index is used as

the argument for opcodes that refer to those collections.

*/

PyObject *u_consts; /* all constants */

PyObject *u_names; /* all names */

PyObject *u_varnames; /* local variables */

PyObject *u_cellvars; /* cell variables */

PyObject *u_freevars; /* free variables */

PyObject *u_private; /* for private name mangling */

Py_ssize_t u_argcount; /* number of arguments for block */

Py_ssize_t u_posonlyargcount; /* number of positional only arguments for block */

Py_ssize_t u_kwonlyargcount; /* number of keyword only arguments for block */

cfg_builder u_cfg_builder; /* The control flow graph */

int u_nfblocks;

struct fblockinfo u_fblock[CO_MAXBLOCKS];

int u_firstlineno; /* the first lineno of the block */

};

/* This struct captures the global state of a compilation.

The u pointer points to the current compilation unit, while units

for enclosing blocks are stored in c_stack. The u and c_stack are

managed by compiler_enter_scope() and compiler_exit_scope().

Note that we don't track recursion levels during compilation - the

task of detecting and rejecting excessive levels of nesting is

handled by the symbol analysis pass.

*/

struct compiler {

PyObject *c_filename;

struct symtable *c_st;

PyFutureFeatures *c_future; /* pointer to module's __future__ */

PyCompilerFlags *c_flags;

int c_optimize; /* optimization level */

int c_interactive; /* true if in interactive mode */

int c_nestlevel;

PyObject *c_const_cache; /* Python dict holding all constants,

including names tuple */

struct compiler_unit *u; /* compiler state for current block */

PyObject *c_stack; /* Python list holding compiler_unit ptrs */

PyArena *c_arena; /* pointer to memory allocation arena */

};

#define CFG_BUILDER(c) (&((c)->u->u_cfg_builder))

typedef struct {

// A list of strings corresponding to name captures. It is used to track:

// - Repeated name assignments in the same pattern.

// - Different name assignments in alternatives.

// - The order of name assignments in alternatives.

PyObject *stores;

// If 0, any name captures against our subject will raise.

int allow_irrefutable;

// An array of blocks to jump to on failure. Jumping to fail_pop[i] will pop

// i items off of the stack. The end result looks like this (with each block

// falling through to the next):

// fail_pop[4]: POP_TOP

// fail_pop[3]: POP_TOP

// fail_pop[2]: POP_TOP

// fail_pop[1]: POP_TOP

// fail_pop[0]: NOP

jump_target_label *fail_pop;

// The current length of fail_pop.

Py_ssize_t fail_pop_size;

// The number of items on top of the stack that need to *stay* on top of the

// stack. Variable captures go beneath these. All of them will be popped on

// failure.

Py_ssize_t on_top;

} pattern_context;

static int basicblock_next_instr(basicblock *);

static basicblock *cfg_builder_new_block(cfg_builder *g);

static int cfg_builder_maybe_start_new_block(cfg_builder *g);

static int cfg_builder_addop_i(cfg_builder *g, int opcode, Py_ssize_t oparg, location loc);

static void compiler_free(struct compiler *);

static int compiler_error(struct compiler *, location loc, const char *, ...);

static int compiler_warn(struct compiler *, location loc, const char *, ...);

static int compiler_nameop(struct compiler *, location, identifier, expr_context_ty);

static PyCodeObject *compiler_mod(struct compiler *, mod_ty);

static int compiler_visit_stmt(struct compiler *, stmt_ty);

static int compiler_visit_keyword(struct compiler *, keyword_ty);

static int compiler_visit_expr(struct compiler *, expr_ty);

static int compiler_augassign(struct compiler *, stmt_ty);

static int compiler_annassign(struct compiler *, stmt_ty);

static int compiler_subscript(struct compiler *, expr_ty);

static int compiler_slice(struct compiler *, expr_ty);

static int are_all_items_const(asdl_expr_seq *, Py_ssize_t, Py_ssize_t);

static int compiler_with(struct compiler *, stmt_ty, int);

static int compiler_async_with(struct compiler *, stmt_ty, int);

static int compiler_async_for(struct compiler *, stmt_ty);

static int compiler_call_simple_kw_helper(struct compiler *c,

location loc,

asdl_keyword_seq *keywords,

Py_ssize_t nkwelts);

static int compiler_call_helper(struct compiler *c, location loc,

int n, asdl_expr_seq *args,

asdl_keyword_seq *keywords);

static int compiler_try_except(struct compiler *, stmt_ty);

static int compiler_try_star_except(struct compiler *, stmt_ty);

static int compiler_set_qualname(struct compiler *);

static int compiler_sync_comprehension_generator(

struct compiler *c, location loc,

asdl_comprehension_seq *generators, int gen_index,

int depth,

expr_ty elt, expr_ty val, int type);

static int compiler_async_comprehension_generator(

struct compiler *c, location loc,

asdl_comprehension_seq *generators, int gen_index,

int depth,

expr_ty elt, expr_ty val, int type);

static int compiler_pattern(struct compiler *, location *,

pattern_ty, pattern_context *);

static int compiler_match(struct compiler *, stmt_ty);

static int compiler_pattern_subpattern(struct compiler *, location *,

pattern_ty, pattern_context *);

static void remove_redundant_nops(basicblock *bb);

static PyCodeObject *assemble(struct compiler *, int addNone);

#define CAPSULE_NAME "compile.c compiler unit"

PyObject *

_Py_Mangle(PyObject *privateobj, PyObject *ident)

{

/* Name mangling: __private becomes _classname__private.

This is independent from how the name is used. */

PyObject *result;

size_t nlen, plen, ipriv;

Py_UCS4 maxchar;

if (privateobj == NULL || !PyUnicode_Check(privateobj) ||

PyUnicode_READ_CHAR(ident, 0) != '_' ||

PyUnicode_READ_CHAR(ident, 1) != '_') {

Py_INCREF(ident);

return ident;

}

nlen = PyUnicode_GET_LENGTH(ident);

plen = PyUnicode_GET_LENGTH(privateobj);

/* Don't mangle __id__ or names with dots.

The only time a name with a dot can occur is when

we are compiling an import statement that has a

package name.

TODO(jhylton): Decide whether we want to support

mangling of the module name, e.g. __M.X.

*/

if ((PyUnicode_READ_CHAR(ident, nlen-1) == '_' &&

PyUnicode_READ_CHAR(ident, nlen-2) == '_') ||

PyUnicode_FindChar(ident, '.', 0, nlen, 1) != -1) {

Py_INCREF(ident);

return ident; /* Don't mangle __whatever__ */

}

/* Strip leading underscores from class name */

ipriv = 0;

while (PyUnicode_READ_CHAR(privateobj, ipriv) == '_')

ipriv++;

if (ipriv == plen) {

Py_INCREF(ident);

return ident; /* Don't mangle if class is just underscores */

}

plen -= ipriv;

if (plen + nlen >= PY_SSIZE_T_MAX - 1) {

PyErr_SetString(PyExc_OverflowError,

"private identifier too large to be mangled");

return NULL;

}

maxchar = PyUnicode_MAX_CHAR_VALUE(ident);

if (PyUnicode_MAX_CHAR_VALUE(privateobj) > maxchar)

maxchar = PyUnicode_MAX_CHAR_VALUE(privateobj);

result = PyUnicode_New(1 + nlen + plen, maxchar);

if (!result)

return 0;

/* ident = "_" + priv[ipriv:] + ident # i.e. 1+plen+nlen bytes */

PyUnicode_WRITE(PyUnicode_KIND(result), PyUnicode_DATA(result), 0, '_');

if (PyUnicode_CopyCharacters(result, 1, privateobj, ipriv, plen) < 0) {

Py_DECREF(result);

return NULL;

}

if (PyUnicode_CopyCharacters(result, plen+1, ident, 0, nlen) < 0) {

Py_DECREF(result);

return NULL;

}

assert(_PyUnicode_CheckConsistency(result, 1));

return result;

}

static int

compiler_init(struct compiler *c)

{

memset(c, 0, sizeof(struct compiler));

c->c_const_cache = PyDict_New();

if (!c->c_const_cache) {

return 0;

}

c->c_stack = PyList_New(0);

if (!c->c_stack) {

Py_CLEAR(c->c_const_cache);

return 0;

}

return 1;

}

PyCodeObject *

_PyAST_Compile(mod_ty mod, PyObject *filename, PyCompilerFlags *flags,

int optimize, PyArena *arena)

{

struct compiler c;

PyCodeObject *co = NULL;

PyCompilerFlags local_flags = _PyCompilerFlags_INIT;

int merged;

if (!compiler_init(&c))

return NULL;

Py_INCREF(filename);

c.c_filename = filename;

c.c_arena = arena;

c.c_future = _PyFuture_FromAST(mod, filename);

if (c.c_future == NULL)

goto finally;

if (!flags) {

flags = &local_flags;

}

merged = c.c_future->ff_features | flags->cf_flags;

c.c_future->ff_features = merged;

flags->cf_flags = merged;

c.c_flags = flags;

c.c_optimize = (optimize == -1) ? _Py_GetConfig()->optimization_level : optimize;

c.c_nestlevel = 0;

_PyASTOptimizeState state;

state.optimize = c.c_optimize;

state.ff_features = merged;

if (!_PyAST_Optimize(mod, arena, &state)) {

goto finally;

}

c.c_st = _PySymtable_Build(mod, filename, c.c_future);

if (c.c_st == NULL) {

if (!PyErr_Occurred())

PyErr_SetString(PyExc_SystemError, "no symtable");

goto finally;

}

co = compiler_mod(&c, mod);

finally:

compiler_free(&c);

assert(co || PyErr_Occurred());

return co;

}

static void

compiler_free(struct compiler *c)

{

if (c->c_st)

_PySymtable_Free(c->c_st);

if (c->c_future)

PyObject_Free(c->c_future);

Py_XDECREF(c->c_filename);

Py_DECREF(c->c_const_cache);

Py_DECREF(c->c_stack);

}

static PyObject *

list2dict(PyObject *list)

{

Py_ssize_t i, n;

PyObject *v, *k;

PyObject *dict = PyDict_New();

if (!dict) return NULL;

n = PyList_Size(list);

for (i = 0; i < n; i++) {

v = PyLong_FromSsize_t(i);

if (!v) {

Py_DECREF(dict);

return NULL;

}

k = PyList_GET_ITEM(list, i);

if (PyDict_SetItem(dict, k, v) < 0) {

Py_DECREF(v);

Py_DECREF(dict);

return NULL;

}

Py_DECREF(v);

}

return dict;

}

/* Return new dict containing names from src that match scope(s).

src is a symbol table dictionary. If the scope of a name matches

either scope_type or flag is set, insert it into the new dict. The

values are integers, starting at offset and increasing by one for

each key.

*/

static PyObject *

dictbytype(PyObject *src, int scope_type, int flag, Py_ssize_t offset)

{

Py_ssize_t i = offset, scope, num_keys, key_i;

PyObject *k, *v, *dest = PyDict_New();

PyObject *sorted_keys;

assert(offset >= 0);

if (dest == NULL)

return NULL;

/* Sort the keys so that we have a deterministic order on the indexes

saved in the returned dictionary. These indexes are used as indexes

into the free and cell var storage. Therefore if they aren't

deterministic, then the generated bytecode is not deterministic.

*/

sorted_keys = PyDict_Keys(src);

if (sorted_keys == NULL)

return NULL;

if (PyList_Sort(sorted_keys) != 0) {

Py_DECREF(sorted_keys);

return NULL;

}

num_keys = PyList_GET_SIZE(sorted_keys);

for (key_i = 0; key_i < num_keys; key_i++) {

/* XXX this should probably be a macro in symtable.h */

long vi;

k = PyList_GET_ITEM(sorted_keys, key_i);

v = PyDict_GetItemWithError(src, k);

assert(v && PyLong_Check(v));

vi = PyLong_AS_LONG(v);

scope = (vi >> SCOPE_OFFSET) & SCOPE_MASK;

if (scope == scope_type || vi & flag) {

PyObject *item = PyLong_FromSsize_t(i);

if (item == NULL) {

Py_DECREF(sorted_keys);

Py_DECREF(dest);

return NULL;

}

i++;

if (PyDict_SetItem(dest, k, item) < 0) {

Py_DECREF(sorted_keys);

Py_DECREF(item);

Py_DECREF(dest);

return NULL;

}

Py_DECREF(item);

}

}

Py_DECREF(sorted_keys);

return dest;

}

static void

cfg_builder_check(cfg_builder *g)

{

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);

}

}

}

static int

cfg_builder_init(cfg_builder *g)

{

g->g_block_list = NULL;

basicblock *block = cfg_builder_new_block(g);

if (block == NULL)

return 0;

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

g->g_current_label = NO_LABEL;

return 1;

}

static void

cfg_builder_fini(cfg_builder* g)

{

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;

}

}

static void

compiler_unit_free(struct compiler_unit *u)

{

cfg_builder_fini(&u->u_cfg_builder);

Py_CLEAR(u->u_ste);

Py_CLEAR(u->u_name);

Py_CLEAR(u->u_qualname);

Py_CLEAR(u->u_consts);

Py_CLEAR(u->u_names);

Py_CLEAR(u->u_varnames);

Py_CLEAR(u->u_freevars);

Py_CLEAR(u->u_cellvars);

Py_CLEAR(u->u_private);

PyObject_Free(u);

}

static int

compiler_set_qualname(struct compiler *c)

{

Py_ssize_t stack_size;

struct compiler_unit *u = c->u;

PyObject *name, *base;

base = NULL;

stack_size = PyList_GET_SIZE(c->c_stack);

assert(stack_size >= 1);

if (stack_size > 1) {

int scope, force_global = 0;

struct compiler_unit *parent;

PyObject *mangled, *capsule;

capsule = PyList_GET_ITEM(c->c_stack, stack_size - 1);

parent = (struct compiler_unit *)PyCapsule_GetPointer(capsule, CAPSULE_NAME);

assert(parent);

if (u->u_scope_type == COMPILER_SCOPE_FUNCTION

|| u->u_scope_type == COMPILER_SCOPE_ASYNC_FUNCTION

|| u->u_scope_type == COMPILER_SCOPE_CLASS) {

assert(u->u_name);

mangled = _Py_Mangle(parent->u_private, u->u_name);

if (!mangled)

return 0;

scope = _PyST_GetScope(parent->u_ste, mangled);

Py_DECREF(mangled);

assert(scope != GLOBAL_IMPLICIT);

if (scope == GLOBAL_EXPLICIT)

force_global = 1;

}

if (!force_global) {

if (parent->u_scope_type == COMPILER_SCOPE_FUNCTION

|| parent->u_scope_type == COMPILER_SCOPE_ASYNC_FUNCTION

|| parent->u_scope_type == COMPILER_SCOPE_LAMBDA)

{

_Py_DECLARE_STR(dot_locals, ".<locals>");

base = PyUnicode_Concat(parent->u_qualname,

&_Py_STR(dot_locals));

if (base == NULL)

return 0;

}

else {

Py_INCREF(parent->u_qualname);

base = parent->u_qualname;

}

}

}

if (base != NULL) {

_Py_DECLARE_STR(dot, ".");

name = PyUnicode_Concat(base, &_Py_STR(dot));

Py_DECREF(base);

if (name == NULL)

return 0;

PyUnicode_Append(&name, u->u_name);

if (name == NULL)

return 0;

}

else {

Py_INCREF(u->u_name);

name = u->u_name;

}

u->u_qualname = name;

return 1;

}

static jump_target_label

cfg_new_label(cfg_builder *g)

{

jump_target_label lbl = {g->g_next_free_label++};

return lbl;

}

/* 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 = -1;

return b;

}

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;

}

static int

cfg_builder_use_label(cfg_builder *g, jump_target_label lbl)

{

g->g_current_label = lbl;

return cfg_builder_maybe_start_new_block(g);

}

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 -1;

}

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

}

return 0;

}

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;

}

/* 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);

if (b->b_instr == NULL) {

b->b_instr = (struct instr *)PyObject_Calloc(

DEFAULT_BLOCK_SIZE, sizeof(struct instr));

if (b->b_instr == NULL) {

PyErr_NoMemory();

return -1;

}

b->b_ialloc = DEFAULT_BLOCK_SIZE;

}

else if (b->b_iused == b->b_ialloc) {

struct instr *tmp;

size_t oldsize, newsize;

oldsize = b->b_ialloc * sizeof(struct instr);

newsize = oldsize << 1;

if (oldsize > (SIZE_MAX >> 1)) {

PyErr_NoMemory();

return -1;

}

if (newsize == 0) {

PyErr_NoMemory();

return -1;

}

b->b_ialloc <<= 1;

tmp = (struct instr *)PyObject_Realloc(

(void *)b->b_instr, newsize);

if (tmp == NULL) {

PyErr_NoMemory();

return -1;

}

b->b_instr = tmp;

memset((char *)b->b_instr + oldsize, 0, newsize - oldsize);

}

return b->b_iused++;

}