compile.c

/*
 * 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"Python.h"
#include"opcode.h"
#include"pycore_ast.h"// _PyAST_GetDocString()
#defineNEED_OPCODE_TABLES
#include"pycore_opcode_utils.h"
#undef NEED_OPCODE_TABLES
#include"pycore_code.h"// _PyCode_New()
#include"pycore_compile.h"
#include"pycore_flowgraph.h"
#include"pycore_instruction_sequence.h"// _PyInstructionSequence_New()
#include"pycore_intrinsics.h"
#include"pycore_long.h"// _PyLong_GetZero()
#include"pycore_pystate.h"// _Py_GetConfig()
#include"pycore_setobject.h"// _PySet_NextEntry()
#include"pycore_symtable.h"// PySTEntryObject, _PyFuture_FromAST()

#defineNEED_OPCODE_METADATA
#include"pycore_opcode_metadata.h"// _PyOpcode_opcode_metadata, _PyOpcode_num_popped/pushed
#undef NEED_OPCODE_METADATA

#defineCOMP_GENEXP 0
#defineCOMP_LISTCOMP 1
#defineCOMP_SETCOMP 2
#defineCOMP_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.
 */
#defineSTACK_USE_GUIDELINE 30

#include<stdbool.h>

#undef SUCCESS
#undef ERROR
#defineSUCCESS 0
#defineERROR -1

#defineRETURN_IF_ERROR(X) \
 if ((X) == -1) { \
 return ERROR; \
 }

#defineIS_TOP_LEVEL_AWAIT(C) ( \
 ((C)->c_flags.cf_flags & PyCF_ALLOW_TOP_LEVEL_AWAIT) \
 && ((C)->u->u_ste->ste_type == ModuleBlock))

typedef_Py_SourceLocationlocation;
typedefstruct_PyCfgBuildercfg_builder;

#defineLOCATION(LNO, END_LNO, COL, END_COL) \
 ((const _Py_SourceLocation){(LNO), (END_LNO), (COL), (END_COL)})

/* Return true if loc1 starts after loc2 ends. */
staticinlinebool
location_is_after(locationloc1, locationloc2) {
return (loc1.lineno>loc2.end_lineno) ||
 ((loc1.lineno==loc2.end_lineno) &&
 (loc1.col_offset>loc2.end_col_offset));
}

#defineLOC(x) SRC_LOCATION_FROM_AST(x)

typedef_PyJumpTargetLabeljump_target_label;

staticjump_target_labelNO_LABEL= {-1};

#defineSAME_LABEL(L1, L2) ((L1).id == (L2).id)
#defineIS_LABEL(L) (!SAME_LABEL((L), (NO_LABEL)))

#defineNEW_JUMP_TARGET_LABEL(C, NAME) \
 jump_target_label NAME = _PyInstructionSequence_NewLabel(INSTR_SEQUENCE(C)); \
 if (!IS_LABEL(NAME)) { \
 return ERROR; \
 }

#defineUSE_LABEL(C, LBL) \
 RETURN_IF_ERROR(_PyInstructionSequence_UseLabel(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.
*/

enumfblocktype { 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,
STOP_ITERATION };

structfblockinfo {
enumfblocktypefb_type;
jump_target_labelfb_block;
locationfb_loc;
/* (optional) type-specific exit or cleanup block */
jump_target_labelfb_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,
COMPILER_SCOPE_TYPEPARAMS,
};


typedef_PyInstructioninstruction;
typedef_PyInstructionSequenceinstr_sequence;

#defineINITIAL_INSTR_SEQUENCE_SIZE 100
#defineINITIAL_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(intidx, void**array, int*alloc,
intdefault_alloc, size_titem_size)
{
void*arr=*array;
if (arr==NULL) {
intnew_alloc=default_alloc;
if (idx >= new_alloc) {
new_alloc=idx+default_alloc;
 }
arr=PyMem_Calloc(new_alloc, item_size);
if (arr==NULL) {
PyErr_NoMemory();
returnERROR;
 }
*alloc=new_alloc;
 }
elseif (idx >= *alloc) {
size_toldsize=*alloc*item_size;
intnew_alloc=*alloc << 1;
if (idx >= new_alloc) {
new_alloc=idx+default_alloc;
 }
size_tnewsize=new_alloc*item_size;

if (oldsize> (SIZE_MAX >> 1)) {
PyErr_NoMemory();
returnERROR;
 }

assert(newsize>0);
void*tmp=PyMem_Realloc(arr, newsize);
if (tmp==NULL) {
PyErr_NoMemory();
returnERROR;
 }
*alloc=new_alloc;
arr=tmp;
memset((char*)arr+oldsize, 0, newsize-oldsize);
 }

*array=arr;
returnSUCCESS;
}

staticcfg_builder*
instr_sequence_to_cfg(instr_sequence*seq) {
if (_PyInstructionSequence_ApplyLabelMap(seq) <0) {
returnNULL;
 }
cfg_builder*g=_PyCfgBuilder_New();
if (g==NULL) {
returnNULL;
 }
for (inti=0; i<seq->s_used; i++) {
seq->s_instrs[i].i_target=0;
 }
for (inti=0; i<seq->s_used; i++) {
instruction*instr=&seq->s_instrs[i];
if (HAS_TARGET(instr->i_opcode)) {
assert(instr->i_oparg >= 0&&instr->i_oparg<seq->s_used);
seq->s_instrs[instr->i_oparg].i_target=1;
 }
 }
for (inti=0; i<seq->s_used; i++) {
instruction*instr=&seq->s_instrs[i];
if (instr->i_target) {
jump_target_labellbl_= {i};
if (_PyCfgBuilder_UseLabel(g, lbl_) <0) {
 goto error;
 }
 }
intopcode=instr->i_opcode;
intoparg=instr->i_oparg;
if (_PyCfgBuilder_Addop(g, opcode, oparg, instr->i_loc) <0) {
 goto error;
 }
 }
if (_PyCfgBuilder_CheckSize(g) <0) {
 goto error;
 }
returng;
error:
_PyCfgBuilder_Free(g);
returnNULL;
}

/* The following items change on entry and exit of code blocks.
 They must be saved and restored when returning to a block.
*/
structcompiler_unit {
PySTEntryObject*u_ste;

intu_scope_type;

PyObject*u_private; /* for private name mangling */
PyObject*u_static_attributes; /* for class: attributes accessed via self.X */

instr_sequence*u_instr_sequence; /* codegen output */

intu_nfblocks;
intu_in_inlined_comp;

structfblockinfou_fblock[CO_MAXBLOCKS];

_PyCompile_CodeUnitMetadatau_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.

*/

structcompiler {
PyObject*c_filename;
structsymtable*c_st;
_PyFutureFeaturesc_future; /* module's __future__ */
PyCompilerFlagsc_flags;

intc_optimize; /* optimization level */
intc_interactive; /* true if in interactive mode */
intc_nestlevel;
PyObject*c_const_cache; /* Python dict holding all constants,
 including names tuple */
structcompiler_unit*u; /* compiler state for current block */
PyObject*c_stack; /* Python list holding compiler_unit ptrs */
PyArena*c_arena; /* pointer to memory allocation arena */

boolc_save_nested_seqs; /* if true, construct recursive instruction sequences
 * (including instructions for nested code objects)
 */
};

#defineINSTR_SEQUENCE(C) ((C)->u->u_instr_sequence)


typedefstruct {
// 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.
intallow_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_tfail_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_ton_top;
} pattern_context;

staticintcodegen_addop_i(instr_sequence*seq, intopcode, Py_ssize_toparg, locationloc);

staticvoidcompiler_free(structcompiler*);
staticintcompiler_error(structcompiler*, locationloc, constchar*, ...);
staticintcompiler_warn(structcompiler*, locationloc, constchar*, ...);
staticintcompiler_nameop(structcompiler*, location, identifier, expr_context_ty);

staticPyCodeObject*compiler_mod(structcompiler*, mod_ty);
staticintcompiler_visit_stmt(structcompiler*, stmt_ty);
staticintcompiler_visit_keyword(structcompiler*, keyword_ty);
staticintcompiler_visit_expr(structcompiler*, expr_ty);
staticintcompiler_augassign(structcompiler*, stmt_ty);
staticintcompiler_annassign(structcompiler*, stmt_ty);
staticintcompiler_subscript(structcompiler*, expr_ty);
staticintcompiler_slice(structcompiler*, expr_ty);

staticboolare_all_items_const(asdl_expr_seq*, Py_ssize_t, Py_ssize_t);


staticintcompiler_with(structcompiler*, stmt_ty, int);
staticintcompiler_async_with(structcompiler*, stmt_ty, int);
staticintcompiler_async_for(structcompiler*, stmt_ty);
staticintcompiler_call_simple_kw_helper(structcompiler*c,
locationloc,
asdl_keyword_seq*keywords,
Py_ssize_tnkwelts);
staticintcompiler_call_helper(structcompiler*c, locationloc,
intn, asdl_expr_seq*args,
asdl_keyword_seq*keywords);
staticintcompiler_try_except(structcompiler*, stmt_ty);
staticintcompiler_try_star_except(structcompiler*, stmt_ty);
staticintcompiler_set_qualname(structcompiler*);

staticintcompiler_sync_comprehension_generator(
structcompiler*c, locationloc,
asdl_comprehension_seq*generators, intgen_index,
intdepth,
expr_tyelt, expr_tyval, inttype,
intiter_on_stack);

staticintcompiler_async_comprehension_generator(
structcompiler*c, locationloc,
asdl_comprehension_seq*generators, intgen_index,
intdepth,
expr_tyelt, expr_tyval, inttype,
intiter_on_stack);

staticintcompiler_pattern(structcompiler*, pattern_ty, pattern_context*);
staticintcompiler_match(structcompiler*, stmt_ty);
staticintcompiler_pattern_subpattern(structcompiler*,
pattern_ty, pattern_context*);

staticPyCodeObject*optimize_and_assemble(structcompiler*, intaddNone);

#defineCAPSULE_NAME "compile.c compiler unit"


staticint
compiler_setup(structcompiler*c, mod_tymod, PyObject*filename,
PyCompilerFlags*flags, intoptimize, PyArena*arena)
{
PyCompilerFlagslocal_flags=_PyCompilerFlags_INIT;

c->c_const_cache=PyDict_New();
if (!c->c_const_cache) {
returnERROR;
 }

c->c_stack=PyList_New(0);
if (!c->c_stack) {
returnERROR;
 }

c->c_filename=Py_NewRef(filename);
c->c_arena=arena;
if (!_PyFuture_FromAST(mod, filename, &c->c_future)) {
returnERROR;
 }
if (!flags) {
flags=&local_flags;
 }
intmerged=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;
c->c_save_nested_seqs= false;

if (!_PyAST_Optimize(mod, arena, c->c_optimize, merged)) {
returnERROR;
 }
c->c_st=_PySymtable_Build(mod, filename, &c->c_future);
if (c->c_st==NULL) {
if (!PyErr_Occurred()) {
PyErr_SetString(PyExc_SystemError, "no symtable");
 }
returnERROR;
 }
returnSUCCESS;
}

staticstructcompiler*
new_compiler(mod_tymod, PyObject*filename, PyCompilerFlags*pflags,
intoptimize, PyArena*arena)
{
structcompiler*c=PyMem_Calloc(1, sizeof(structcompiler));
if (c==NULL) {
returnNULL;
 }
if (compiler_setup(c, mod, filename, pflags, optimize, arena) <0) {
compiler_free(c);
returnNULL;
 }
returnc;
}

PyCodeObject*
_PyAST_Compile(mod_tymod, PyObject*filename, PyCompilerFlags*pflags,
intoptimize, PyArena*arena)
{
assert(!PyErr_Occurred());
structcompiler*c=new_compiler(mod, filename, pflags, optimize, arena);
if (c==NULL) {
returnNULL;
 }

PyCodeObject*co=compiler_mod(c, mod);
compiler_free(c);
assert(co||PyErr_Occurred());
returnco;
}

int
_PyCompile_AstOptimize(mod_tymod, PyObject*filename, PyCompilerFlags*cf,
intoptimize, PyArena*arena)
{
_PyFutureFeaturesfuture;
if (!_PyFuture_FromAST(mod, filename, &future)) {
return-1;
 }
intflags=future.ff_features | cf->cf_flags;
if (optimize==-1) {
optimize=_Py_GetConfig()->optimization_level;
 }
if (!_PyAST_Optimize(mod, arena, optimize, flags)) {
return-1;
 }
return0;
}

staticvoid
compiler_free(structcompiler*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);
}

staticPyObject*
list2dict(PyObject*list)
{
Py_ssize_ti, n;
PyObject*v, *k;
PyObject*dict=PyDict_New();
if (!dict) returnNULL;

n=PyList_Size(list);
for (i=0; i<n; i++) {
v=PyLong_FromSsize_t(i);
if (!v) {
Py_DECREF(dict);
returnNULL;
 }
k=PyList_GET_ITEM(list, i);
if (PyDict_SetItem(dict, k, v) <0) {
Py_DECREF(v);
Py_DECREF(dict);
returnNULL;
 }
Py_DECREF(v);
 }
returndict;
}

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

staticPyObject*
dictbytype(PyObject*src, intscope_type, intflag, Py_ssize_toffset)
{
Py_ssize_ti=offset, scope, num_keys, key_i;
PyObject*k, *v, *dest=PyDict_New();
PyObject*sorted_keys;

assert(offset >= 0);
if (dest==NULL)
returnNULL;

/* 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)
returnNULL;
if (PyList_Sort(sorted_keys) !=0) {
Py_DECREF(sorted_keys);
returnNULL;
 }
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 */
longvi;
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);
returnNULL;
 }
i++;
if (PyDict_SetItem(dest, k, item) <0) {
Py_DECREF(sorted_keys);
Py_DECREF(item);
Py_DECREF(dest);
returnNULL;
 }
Py_DECREF(item);
 }
 }
Py_DECREF(sorted_keys);
returndest;
}

staticvoid
compiler_unit_free(structcompiler_unit*u)
{
Py_CLEAR(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);
Py_CLEAR(u->u_static_attributes);
PyMem_Free(u);
}

staticint
compiler_maybe_add_static_attribute_to_class(structcompiler*c, expr_tye)
{
assert(e->kind==Attribute_kind);
expr_tyattr_value=e->v.Attribute.value;
if (attr_value->kind!=Name_kind||
e->v.Attribute.ctx!=Store||
 !_PyUnicode_EqualToASCIIString(attr_value->v.Name.id, "self"))
 {
returnSUCCESS;
 }
Py_ssize_tstack_size=PyList_GET_SIZE(c->c_stack);
for (Py_ssize_ti=stack_size-1; i >= 0; i--) {
PyObject*capsule=PyList_GET_ITEM(c->c_stack, i);
structcompiler_unit*u= (structcompiler_unit*)PyCapsule_GetPointer(
capsule, CAPSULE_NAME);
assert(u);
if (u->u_scope_type==COMPILER_SCOPE_CLASS) {
assert(u->u_static_attributes);
RETURN_IF_ERROR(PySet_Add(u->u_static_attributes, e->v.Attribute.attr));
break;
 }
 }
returnSUCCESS;
}

staticint
compiler_set_qualname(structcompiler*c)
{
Py_ssize_tstack_size;
structcompiler_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) {
intscope, force_global=0;
structcompiler_unit*parent;
PyObject*mangled, *capsule;

capsule=PyList_GET_ITEM(c->c_stack, stack_size-1);
parent= (structcompiler_unit*)PyCapsule_GetPointer(capsule, CAPSULE_NAME);
assert(parent);
if (parent->u_scope_type==COMPILER_SCOPE_TYPEPARAMS) {
/* The parent is a type parameter scope, so we need to
 look at the grandparent. */
if (stack_size==2) {
// If we're immediately within the module, we can skip
// the rest and just set the qualname to be the same as name.
u->u_metadata.u_qualname=Py_NewRef(u->u_metadata.u_name);
returnSUCCESS;
 }
capsule=PyList_GET_ITEM(c->c_stack, stack_size-2);
parent= (structcompiler_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) {
returnERROR;
 }

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) {
returnERROR;
 }
 }
else {
base=Py_NewRef(parent->u_metadata.u_qualname);
 }
 }
 }

if (base!=NULL) {
name=PyUnicode_Concat(base, _Py_LATIN1_CHR('.'));
Py_DECREF(base);
if (name==NULL) {
returnERROR;
 }
PyUnicode_Append(&name, u->u_metadata.u_name);
if (name==NULL) {
returnERROR;
 }
 }
else {
name=Py_NewRef(u->u_metadata.u_name);
 }
u->u_metadata.u_qualname=name;

returnSUCCESS;
}

/* 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
 */
staticint
stack_effect(intopcode, intoparg, intjump)
{
if (0 <= opcode&&opcode <= MAX_REAL_OPCODE) {
if (_PyOpcode_Deopt[opcode] !=opcode) {
// Specialized instructions are not supported.
returnPY_INVALID_STACK_EFFECT;
 }
intpopped=_PyOpcode_num_popped(opcode, oparg);
intpushed=_PyOpcode_num_pushed(opcode, oparg);
if (popped<0||pushed<0) {
returnPY_INVALID_STACK_EFFECT;
 }
returnpushed-popped;
 }

// Pseudo ops
switch (opcode) {
casePOP_BLOCK:
caseJUMP:
caseJUMP_NO_INTERRUPT:
return0;

caseEXIT_INIT_CHECK:
return-1;

/* Exception handling pseudo-instructions */
caseSETUP_FINALLY:
/* 0 in the normal flow.
 * Restore the stack position and push 1 value before jumping to
 * the handler if an exception be raised. */
returnjump ? 1 : 0;
caseSETUP_CLEANUP:
/* As SETUP_FINALLY, but pushes lasti as well */
returnjump ? 2 : 0;
caseSETUP_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. */
returnjump ? 1 : 0;

caseSTORE_FAST_MAYBE_NULL:
return-1;
caseLOAD_CLOSURE:
return1;
caseLOAD_METHOD:
return1;
caseLOAD_SUPER_METHOD:
caseLOAD_ZERO_SUPER_METHOD:
caseLOAD_ZERO_SUPER_ATTR:
return-1;
default:
returnPY_INVALID_STACK_EFFECT;
 }

returnPY_INVALID_STACK_EFFECT; /* not reachable */
}

int
PyCompile_OpcodeStackEffectWithJump(intopcode, intoparg, intjump)
{
returnstack_effect(opcode, oparg, jump);
}

int
PyCompile_OpcodeStackEffect(intopcode, intoparg)
{
returnstack_effect(opcode, oparg, -1);
}

int
_PyCompile_OpcodeIsValid(intopcode)
{
returnIS_VALID_OPCODE(opcode);
}

int
_PyCompile_OpcodeHasArg(intopcode)
{
returnOPCODE_HAS_ARG(opcode);
}

int
_PyCompile_OpcodeHasConst(intopcode)
{
returnOPCODE_HAS_CONST(opcode);
}

int
_PyCompile_OpcodeHasName(intopcode)
{
returnOPCODE_HAS_NAME(opcode);
}

int
_PyCompile_OpcodeHasJump(intopcode)
{
returnOPCODE_HAS_JUMP(opcode);
}

int
_PyCompile_OpcodeHasFree(intopcode)
{
returnOPCODE_HAS_FREE(opcode);
}

int
_PyCompile_OpcodeHasLocal(intopcode)
{
returnOPCODE_HAS_LOCAL(opcode);
}

int
_PyCompile_OpcodeHasExc(intopcode)
{
returnIS_BLOCK_PUSH_OPCODE(opcode);
}

staticint
codegen_addop_noarg(instr_sequence*seq, intopcode, locationloc)
{
assert(!OPCODE_HAS_ARG(opcode));
assert(!IS_ASSEMBLER_OPCODE(opcode));
return_PyInstructionSequence_Addop(seq, opcode, 0, loc);
}

staticPy_ssize_t
dict_add_o(PyObject*dict, PyObject*o)
{
PyObject*v;
Py_ssize_targ;

if (PyDict_GetItemRef(dict, o, &v) <0) {
returnERROR;
 }
if (!v) {
arg=PyDict_GET_SIZE(dict);
v=PyLong_FromSsize_t(arg);
if (!v) {
returnERROR;
 }
if (PyDict_SetItem(dict, o, v) <0) {
Py_DECREF(v);
returnERROR;
 }
 }
else
arg=PyLong_AsLong(v);
Py_DECREF(v);
returnarg;
}

// Merge const *o* recursively and return constant key object.
staticPyObject*
merge_consts_recursive(PyObject*const_cache, PyObject*o)
{
assert(PyDict_CheckExact(const_cache));
// None and Ellipsis are immortal objects, and key is the singleton.
// No need to merge object and key.
if (o==Py_None||o==Py_Ellipsis) {
returno;
 }

PyObject*key=_PyCode_ConstantKey(o);
if (key==NULL) {
returnNULL;
 }

PyObject*t;
intres=PyDict_SetDefaultRef(const_cache, key, key, &t);
if (res!=0) {
// o was not inserted into const_cache. t is either the existing value
// or NULL (on error).
Py_DECREF(key);
returnt;
 }
Py_DECREF(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_tlen=PyTuple_GET_SIZE(o);
for (Py_ssize_ti=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);
returnNULL;
 }

// 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);
 }
 }
elseif (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_tlen=PySet_GET_SIZE(o);
if (len==0) { // empty frozenset should not be re-created.
returnkey;
 }
PyObject*tuple=PyTuple_New(len);
if (tuple==NULL) {
Py_DECREF(key);
returnNULL;
 }
Py_ssize_ti=0, pos=0;
PyObject*item;
Py_hash_thash;
while (_PySet_NextEntry(o, &pos, &item, &hash)) {
PyObject*k=merge_consts_recursive(const_cache, item);
if (k==NULL) {
Py_DECREF(tuple);
Py_DECREF(key);
returnNULL;
 }
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);
if (new==NULL) {
Py_DECREF(key);
returnNULL;
 }
assert(PyTuple_GET_ITEM(key, 1) ==o);
Py_DECREF(o);
PyTuple_SET_ITEM(key, 1, new);
 }

returnkey;
}

staticPy_ssize_t
compiler_add_const(PyObject*const_cache, structcompiler_unit*u, PyObject*o)
{
assert(PyDict_CheckExact(const_cache));
PyObject*key=merge_consts_recursive(const_cache, o);
if (key==NULL) {
returnERROR;
 }

Py_ssize_targ=dict_add_o(u->u_metadata.u_consts, key);
Py_DECREF(key);
returnarg;
}

staticint
compiler_addop_load_const(PyObject*const_cache, structcompiler_unit*u, locationloc, PyObject*o)
{
Py_ssize_targ=compiler_add_const(const_cache, u, o);
if (arg<0) {
returnERROR;
 }
returncodegen_addop_i(u->u_instr_sequence, LOAD_CONST, arg, loc);
}

staticint
compiler_addop_o(structcompiler_unit*u, locationloc,