/*

* 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 an instruction sequence. See compiler_mod() in this file.

* 4. Generate a control flow graph and run optimizations on it. See flowgraph.c.

* 5. Assemble the basic blocks into final code. See optimize_and_assemble() in

* this file, and assembler.c.

*

* 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>

#include "Python.h"

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

#define NEED_OPCODE_TABLES

#include "pycore_opcode_utils.h"

#undef NEED_OPCODE_TABLES

#include "pycore_flowgraph.h"

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

#include "pycore_compile.h"

#include "pycore_intrinsics.h"

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

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

#include "pycore_symtable.h" // PySTEntryObject, _PyFuture_FromAST()

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

#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

#undef SUCCESS

#undef ERROR

#define SUCCESS 0

#define ERROR -1

#define RETURN_IF_ERROR(X) \

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

return ERROR; \

}

/* 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 IS_TOP_LEVEL_AWAIT(C) ( \

((C)->c_flags.cf_flags & PyCF_ALLOW_TOP_LEVEL_AWAIT) \

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

typedef _PyCompilerSrcLocation location;

typedef _PyCfgInstruction cfg_instr;

typedef _PyCfgBasicblock basicblock;

typedef _PyCfgBuilder cfg_builder;

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

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

/* Return true if loc1 starts after loc2 ends. */

static inline bool

location_is_after(location loc1, location loc2) {

return (loc1.lineno > loc2.end_lineno) ||

((loc1.lineno == loc2.end_lineno) &&

(loc1.col_offset > loc2.end_col_offset));

}

#define LOC(x) SRC_LOCATION_FROM_AST(x)

typedef _PyCfgJumpTargetLabel jump_target_label;

static 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 = instr_sequence_new_label(INSTR_SEQUENCE(C)); \

if (!IS_LABEL(NAME)) { \

return ERROR; \

}

#define USE_LABEL(C, LBL) \

RETURN_IF_ERROR(instr_sequence_use_label(INSTR_SEQUENCE(C), (LBL).id))

/* 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,

};

int

_PyCompile_InstrSize(int opcode, int oparg)

{

assert(!IS_PSEUDO_OPCODE(opcode));

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

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

int caches = _PyOpcode_Caches[opcode];

return extended_args + 1 + caches;

}

typedef _PyCompile_Instruction instruction;

typedef _PyCompile_InstructionSequence instr_sequence;

#define INITIAL_INSTR_SEQUENCE_SIZE 100

#define INITIAL_INSTR_SEQUENCE_LABELS_MAP_SIZE 10

/*

* Resize the array if index is out of range.

*

* idx: the index we want to access

* arr: pointer to the array

* alloc: pointer to the capacity of the array

* default_alloc: initial number of items

* item_size: size of each item

*

*/

int

_PyCompile_EnsureArrayLargeEnough(int idx, void **array, int *alloc,

int default_alloc, size_t item_size)

{

void *arr = *array;

if (arr == NULL) {

int new_alloc = default_alloc;

if (idx >= new_alloc) {

new_alloc = idx + default_alloc;

}

arr = PyObject_Calloc(new_alloc, item_size);

if (arr == NULL) {

PyErr_NoMemory();

return ERROR;

}

*alloc = new_alloc;

}

else if (idx >= *alloc) {

size_t oldsize = *alloc * item_size;

int new_alloc = *alloc << 1;

if (idx >= new_alloc) {

new_alloc = idx + default_alloc;

}

size_t newsize = new_alloc * item_size;

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

PyErr_NoMemory();

return ERROR;

}

assert(newsize > 0);

void *tmp = PyObject_Realloc(arr, newsize);

if (tmp == NULL) {

PyErr_NoMemory();

return ERROR;

}

*alloc = new_alloc;

arr = tmp;

memset((char *)arr + oldsize, 0, newsize - oldsize);

}

*array = arr;

return SUCCESS;

}

static int

instr_sequence_next_inst(instr_sequence *seq) {

assert(seq->s_instrs != NULL || seq->s_used == 0);

RETURN_IF_ERROR(

_PyCompile_EnsureArrayLargeEnough(seq->s_used + 1,

(void**)&seq->s_instrs,

&seq->s_allocated,

INITIAL_INSTR_SEQUENCE_SIZE,

sizeof(instruction)));

assert(seq->s_used < seq->s_allocated);

return seq->s_used++;

}

static jump_target_label

instr_sequence_new_label(instr_sequence *seq)

{

jump_target_label lbl = {++seq->s_next_free_label};

return lbl;

}

static int

instr_sequence_use_label(instr_sequence *seq, int lbl) {

int old_size = seq->s_labelmap_size;

RETURN_IF_ERROR(

_PyCompile_EnsureArrayLargeEnough(lbl,

(void**)&seq->s_labelmap,

&seq->s_labelmap_size,

INITIAL_INSTR_SEQUENCE_LABELS_MAP_SIZE,

sizeof(int)));

for(int i = old_size; i < seq->s_labelmap_size; i++) {

seq->s_labelmap[i] = -111; /* something weird, for debugging */

}

seq->s_labelmap[lbl] = seq->s_used; /* label refers to the next instruction */

return SUCCESS;

}

static int

instr_sequence_addop(instr_sequence *seq, int opcode, int oparg, location loc)

{

assert(IS_WITHIN_OPCODE_RANGE(opcode));

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

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

int idx = instr_sequence_next_inst(seq);

RETURN_IF_ERROR(idx);

instruction *ci = &seq->s_instrs[idx];

ci->i_opcode = opcode;

ci->i_oparg = oparg;

ci->i_loc = loc;

return SUCCESS;

}

static int

instr_sequence_insert_instruction(instr_sequence *seq, int pos,

int opcode, int oparg, location loc)

{

assert(pos >= 0 && pos <= seq->s_used);

int last_idx = instr_sequence_next_inst(seq);

RETURN_IF_ERROR(last_idx);

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

seq->s_instrs[i+1] = seq->s_instrs[i];

}

instruction *ci = &seq->s_instrs[pos];

ci->i_opcode = opcode;

ci->i_oparg = oparg;

ci->i_loc = loc;

/* fix the labels map */

for(int lbl=0; lbl < seq->s_labelmap_size; lbl++) {

if (seq->s_labelmap[lbl] >= pos) {

seq->s_labelmap[lbl]++;

}

}

return SUCCESS;

}

static void

instr_sequence_fini(instr_sequence *seq) {

PyObject_Free(seq->s_labelmap);

seq->s_labelmap = NULL;

PyObject_Free(seq->s_instrs);

seq->s_instrs = NULL;

}

static int

instr_sequence_to_cfg(instr_sequence *seq, cfg_builder *g) {

memset(g, 0, sizeof(cfg_builder));

RETURN_IF_ERROR(_PyCfgBuilder_Init(g));

/* There can be more than one label for the same offset. The

* offset2lbl maping selects one of them which we use consistently.

*/

int *offset2lbl = PyMem_Malloc(seq->s_used * sizeof(int));

if (offset2lbl == NULL) {

PyErr_NoMemory();

return ERROR;

}

for (int i = 0; i < seq->s_used; i++) {

offset2lbl[i] = -1;

}

for (int lbl=0; lbl < seq->s_labelmap_size; lbl++) {

int offset = seq->s_labelmap[lbl];

if (offset >= 0) {

assert(offset < seq->s_used);

offset2lbl[offset] = lbl;

}

}

for (int i = 0; i < seq->s_used; i++) {

int lbl = offset2lbl[i];

if (lbl >= 0) {

assert (lbl < seq->s_labelmap_size);

jump_target_label lbl_ = {lbl};

if (_PyCfgBuilder_UseLabel(g, lbl_) < 0) {

goto error;

}

}

instruction *instr = &seq->s_instrs[i];

int opcode = instr->i_opcode;

int oparg = instr->i_oparg;

if (HAS_TARGET(opcode)) {

int offset = seq->s_labelmap[oparg];

assert(offset >= 0 && offset < seq->s_used);

int lbl = offset2lbl[offset];

assert(lbl >= 0 && lbl < seq->s_labelmap_size);

oparg = lbl;

}

if (_PyCfgBuilder_Addop(g, opcode, oparg, instr->i_loc) < 0) {

goto error;

}

}

PyMem_Free(offset2lbl);

int nblocks = 0;

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

nblocks++;

}

if ((size_t)nblocks > SIZE_MAX / sizeof(basicblock *)) {

PyErr_NoMemory();

return ERROR;

}

return SUCCESS;

error:

PyMem_Free(offset2lbl);

return ERROR;

}

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

int u_scope_type;

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

instr_sequence u_instr_sequence; /* codegen output */

int u_nfblocks;

struct fblockinfo u_fblock[CO_MAXBLOCKS];

_PyCompile_CodeUnitMetadata u_metadata;

};

/* 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; /* 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 INSTR_SEQUENCE(C) (&((C)->u->u_instr_sequence))

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 codegen_addop_i(instr_sequence *seq, 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 bool 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,

int iter_on_stack);

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,

int iter_on_stack);

static int compiler_pattern(struct compiler *, pattern_ty, pattern_context *);

static int compiler_match(struct compiler *, stmt_ty);

static int compiler_pattern_subpattern(struct compiler *,

pattern_ty, pattern_context *);

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

#define CAPSULE_NAME "compile.c compiler unit"

static int

compiler_setup(struct compiler *c, mod_ty mod, PyObject *filename,

PyCompilerFlags flags, int optimize, PyArena *arena)

{

c->c_const_cache = PyDict_New();

if (!c->c_const_cache) {

return ERROR;

}

c->c_stack = PyList_New(0);

if (!c->c_stack) {

return ERROR;

}

c->c_filename = Py_NewRef(filename);

c->c_arena = arena;

if (!_PyFuture_FromAST(mod, filename, &c->c_future)) {

return ERROR;

}

int 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)) {

return ERROR;

}

c->c_st = _PySymtable_Build(mod, filename, &c->c_future);

if (c->c_st == NULL) {

if (!PyErr_Occurred()) {

PyErr_SetString(PyExc_SystemError, "no symtable");

}

return ERROR;

}

return SUCCESS;

}

static struct compiler*

new_compiler(mod_ty mod, PyObject *filename, PyCompilerFlags *pflags,

int optimize, PyArena *arena)

{

PyCompilerFlags flags = pflags ? *pflags : _PyCompilerFlags_INIT;

struct compiler *c = PyMem_Calloc(1, sizeof(struct compiler));

if (c == NULL) {

return NULL;

}

if (compiler_setup(c, mod, filename, flags, optimize, arena) < 0) {

compiler_free(c);

return NULL;

}

return c;

}

PyCodeObject *

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

int optimize, PyArena *arena)

{

assert(!PyErr_Occurred());

struct compiler *c = new_compiler(mod, filename, pflags, optimize, arena);

if (c == NULL) {

return NULL;

}

PyCodeObject *co = compiler_mod(c, mod);

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

Py_XDECREF(c->c_filename);

Py_XDECREF(c->c_const_cache);

Py_XDECREF(c->c_stack);

PyMem_Free(c);

}

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

compiler_unit_free(struct compiler_unit *u)

{

instr_sequence_fini(&u->u_instr_sequence);

Py_CLEAR(u->u_ste);

Py_CLEAR(u->u_metadata.u_name);

Py_CLEAR(u->u_metadata.u_qualname);

Py_CLEAR(u->u_metadata.u_consts);

Py_CLEAR(u->u_metadata.u_names);

Py_CLEAR(u->u_metadata.u_varnames);

Py_CLEAR(u->u_metadata.u_freevars);

Py_CLEAR(u->u_metadata.u_cellvars);

Py_CLEAR(u->u_metadata.u_fasthidden);

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_metadata.u_name);

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

if (!mangled) {

return ERROR;

}

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_metadata.u_qualname,

&_Py_STR(dot_locals));

if (base == NULL) {

return ERROR;

}

}

else {

base = Py_NewRef(parent->u_metadata.u_qualname);

}

}

}

if (base != NULL) {

_Py_DECLARE_STR(dot, ".");

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

Py_DECREF(base);

if (name == NULL) {

return ERROR;

}

PyUnicode_Append(&name, u->u_metadata.u_name);

if (name == NULL) {

return ERROR;

}

}

else {

name = Py_NewRef(u->u_metadata.u_name);

}

u->u_metadata.u_qualname = name;

return SUCCESS;

}

/* Return the stack effect of opcode with argument oparg.

Some opcodes have different stack effect when jump to the target and

when not jump. The 'jump' parameter specifies the case:

* 0 -- when not jump

* 1 -- when jump

* -1 -- maximal

*/

static int

stack_effect(int opcode, int oparg, int jump)

{

if (0 <= opcode && opcode <= MAX_REAL_OPCODE) {

if (_PyOpcode_Deopt[opcode] != opcode) {

// Specialized instructions are not supported.

return PY_INVALID_STACK_EFFECT;

}

int popped, pushed;

if (jump > 0) {

popped = _PyOpcode_num_popped(opcode, oparg, true);

pushed = _PyOpcode_num_pushed(opcode, oparg, true);

}

else {

popped = _PyOpcode_num_popped(opcode, oparg, false);

pushed = _PyOpcode_num_pushed(opcode, oparg, false);

}

if (popped < 0 || pushed < 0) {

return PY_INVALID_STACK_EFFECT;

}

if (jump >= 0) {

return pushed - popped;

}

if (jump < 0) {

// Compute max(pushed - popped, alt_pushed - alt_popped)

int alt_popped = _PyOpcode_num_popped(opcode, oparg, true);

int alt_pushed = _PyOpcode_num_pushed(opcode, oparg, true);

if (alt_popped < 0 || alt_pushed < 0) {

return PY_INVALID_STACK_EFFECT;

}

int diff = pushed - popped;

int alt_diff = alt_pushed - alt_popped;

if (alt_diff > diff) {

return alt_diff;

}

return diff;

}

}

// Pseudo ops

switch (opcode) {

case POP_BLOCK:

case JUMP:

case JUMP_NO_INTERRUPT:

return 0;

/* Exception handling pseudo-instructions */

case SETUP_FINALLY:

/* 0 in the normal flow.

* Restore the stack position and push 1 value before jumping to

* the handler if an exception be raised. */

return jump ? 1 : 0;

case SETUP_CLEANUP:

/* As SETUP_FINALLY, but pushes lasti as well */

return jump ? 2 : 0;

case SETUP_WITH:

/* 0 in the normal flow.

* Restore the stack position to the position before the result

* of __(a)enter__ and push 2 values before jumping to the handler

* if an exception be raised. */

return jump ? 1 : 0;

case STORE_FAST_MAYBE_NULL:

return -1;

case LOAD_METHOD:

return 1;

case LOAD_SUPER_METHOD:

case LOAD_ZERO_SUPER_METHOD:

case LOAD_ZERO_SUPER_ATTR:

return -1;

default:

return PY_INVALID_STACK_EFFECT;

}

return PY_INVALID_STACK_EFFECT; /* not reachable */

}

int

PyCompile_OpcodeStackEffectWithJump(int opcode, int oparg, int jump)

{

return stack_effect(opcode, oparg, jump);

}

int

PyCompile_OpcodeStackEffect(int opcode, int oparg)

{

return stack_effect(opcode, oparg, -1);

}

static int

codegen_addop_noarg(instr_sequence *seq, int opcode, location loc)

{

assert(!HAS_ARG(opcode));

assert(!IS_ASSEMBLER_OPCODE(opcode));

return instr_sequence_addop(seq, opcode, 0, loc);

}

static Py_ssize_t

dict_add_o(PyObject *dict, PyObject *o)

{

PyObject *v;

Py_ssize_t arg;

v = PyDict_GetItemWithError(dict, o);

if (!v) {

if (PyErr_Occurred()) {

return ERROR;

}

arg = PyDict_GET_SIZE(dict);

v = PyLong_FromSsize_t(arg);

if (!v) {

return ERROR;

}

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

Py_DECREF(v);

return ERROR;

}

Py_DECREF(v);

}

else

arg = PyLong_AsLong(v);

return arg;

}

// Merge const *o* recursively and return constant key object.

static PyObject*

merge_consts_recursive(PyObject *const_cache, PyObject *o)

{

assert(PyDict_CheckExact(const_cache));

// None and Ellipsis are singleton, and key is the singleton.

// No need to merge object and key.

if (o == Py_None || o == Py_Ellipsis) {

return Py_NewRef(o);

}

PyObject *key = _PyCode_ConstantKey(o);

if (key == NULL) {

return NULL;

}

// t is borrowed reference

PyObject *t = PyDict_SetDefault(const_cache, key, key);

if (t != key) {

// o is registered in const_cache. Just use it.

Py_XINCREF(t);

Py_DECREF(key);

return t;

}

// We registered o in const_cache.

// When o is a tuple or frozenset, we want to merge its

// items too.

if (PyTuple_CheckExact(o)) {

Py_ssize_t len = PyTuple_GET_SIZE(o);

for (Py_ssize_t i = 0; i < len; i++) {

PyObject *item = PyTuple_GET_ITEM(o, i);

PyObject *u = merge_consts_recursive(const_cache, item);

if (u == NULL) {

Py_DECREF(key);

return NULL;

}

// See _PyCode_ConstantKey()

PyObject *v; // borrowed

if (PyTuple_CheckExact(u)) {

v = PyTuple_GET_ITEM(u, 1);

}

else {

v = u;

}

if (v != item) {

PyTuple_SET_ITEM(o, i, Py_NewRef(v));

Py_DECREF(item);

}

Py_DECREF(u);

}

}

else if (PyFrozenSet_CheckExact(o)) {

// *key* is tuple. And its first item is frozenset of

// constant keys.

// See _PyCode_ConstantKey() for detail.

assert(PyTuple_CheckExact(key));

assert(PyTuple_GET_SIZE(key) == 2);

Py_ssize_t len = PySet_GET_SIZE(o);

if (len == 0) { // empty frozenset should not be re-created.

return key;

}

PyObject *tuple = PyTuple_New(len);

if (tuple == NULL) {

Py_DECREF(key);

return NULL;

}

Py_ssize_t i = 0, pos = 0;

PyObject *item;

Py_hash_t hash;

while (_PySet_NextEntry(o, &pos, &item, &hash)) {

PyObject *k = merge_consts_recursive(const_cache, item);

if (k == NULL) {

Py_DECREF(tuple);

Py_DECREF(key);

return NULL;

}

PyObject *u;

if (PyTuple_CheckExact(k)) {

u = Py_NewRef(PyTuple_GET_ITEM(k, 1));

Py_DECREF(k);

}

else {

u = k;

}

PyTuple_SET_ITEM(tuple, i, u); // Steals reference of u.

i++;

}

// Instead of rewriting o, we create new frozenset and embed in the

// key tuple. Caller should get merged frozenset from the key tuple.

PyObject *new = PyFrozenSet_New(tuple);

Py_DECREF(tuple);