/*

* 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 "opcode.h"

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

#define NEED_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()

#define NEED_OPCODE_METADATA

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

#undef NEED_OPCODE_METADATA

#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; \

}

#define RETURN_IF_ERROR_IN_SCOPE(C, CALL) { \

if ((CALL) < 0) { \

compiler_exit_scope((C)); \

return ERROR; \

} \

}

struct compiler;

typedef _PyInstruction instruction;

typedef _PyInstructionSequence instr_sequence;

static instr_sequence *compiler_instr_sequence(struct compiler *c);

static int compiler_future_features(struct compiler *c);

static struct symtable *compiler_symtable(struct compiler *c);

static PySTEntryObject *compiler_symtable_entry(struct compiler *c);

#define IS_TOP_LEVEL_AWAIT(C) compiler_is_top_level_await(C)

#define INSTR_SEQUENCE(C) compiler_instr_sequence(C)

#define FUTURE_FEATURES(C) compiler_future_features(C)

#define SYMTABLE(C) compiler_symtable(C)

#define SYMTABLE_ENTRY(C) compiler_symtable_entry(C)

#define OPTIMIZATION_LEVEL(C) compiler_optimization_level(C)

#define IS_INTERACTIVE(C) compiler_is_interactive(C)

#define IS_NESTED_SCOPE(C) compiler_is_nested_scope(C)

#define SCOPE_TYPE(C) compiler_scope_type(C)

#define QUALNAME(C) compiler_qualname(C)

#define METADATA(C) compiler_unit_metadata(C)

typedef _Py_SourceLocation location;

typedef struct _PyCfgBuilder cfg_builder;

typedef _PyJumpTargetLabel jump_target_label;

enum fblocktype;

#ifndef NDEBUG

static int compiler_is_top_level_await(struct compiler *c);

#endif

static PyObject *compiler_mangle(struct compiler *c, PyObject *name);

static PyObject *compiler_maybe_mangle(struct compiler *c, PyObject *name);

static int compiler_optimization_level(struct compiler *c);

static int compiler_is_interactive(struct compiler *c);

static int compiler_is_nested_scope(struct compiler *c);

static int compiler_scope_type(struct compiler *c);

static int compiler_is_in_inlined_comp(struct compiler *c);

static PyObject *compiler_qualname(struct compiler *c);

static PyObject *compiler_static_attributes_tuple(struct compiler *c);

static int compiler_lookup_arg(struct compiler *c, PyCodeObject *co, PyObject *name);

static int compiler_get_ref_type(struct compiler *c, PyObject *name);

static int compiler_lookup_cellvar(struct compiler *c, PyObject *name);

static PyObject *compiler_deferred_annotations(struct compiler *c);

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

enum fblocktype t, jump_target_label block_label,

jump_target_label exit, void *datum);

static void compiler_pop_fblock(struct compiler *c, enum fblocktype t,

jump_target_label block_label);

static struct fblockinfo *compiler_top_fblock(struct compiler *c);

static int compiler_enter_scope(struct compiler *c, identifier name, int scope_type,

void *key, int lineno, PyObject *private,

_PyCompile_CodeUnitMetadata *umd);

static void compiler_exit_scope(struct compiler *c);

static Py_ssize_t compiler_add_const(struct compiler *c, PyObject *o);

static int compiler_maybe_add_static_attribute_to_class(struct compiler *c, expr_ty e);

static _PyCompile_CodeUnitMetadata *compiler_unit_metadata(struct compiler *c);

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

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

#define LOC(x) SRC_LOCATION_FROM_AST(x)

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

if (!IS_LABEL(NAME)) { \

return ERROR; \

}

#define USE_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.

*/

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,

STOP_ITERATION };

struct fblockinfo {

enum fblocktype fb_type;

jump_target_label fb_block;

location fb_loc;

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

COMPILER_SCOPE_ANNOTATIONS,

};

static const int compare_masks[] = {

[Py_LT] = COMPARISON_LESS_THAN,

[Py_LE] = COMPARISON_LESS_THAN | COMPARISON_EQUALS,

[Py_EQ] = COMPARISON_EQUALS,

[Py_NE] = COMPARISON_NOT_EQUALS,

[Py_GT] = COMPARISON_GREATER_THAN,

[Py_GE] = COMPARISON_GREATER_THAN | COMPARISON_EQUALS,

};

/*

* 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 = PyMem_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 = PyMem_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;

}

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

PyObject *u_static_attributes; /* for class: attributes accessed via self.X */

PyObject *u_deferred_annotations; /* AnnAssign nodes deferred to the end of compilation */

instr_sequence *u_instr_sequence; /* codegen output */

int u_nfblocks;

int u_in_inlined_comp;

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

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

bool c_save_nested_seqs; /* if true, construct recursive instruction sequences

* (including instructions for nested code objects)

*/

};

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 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 codegen_nameop(struct compiler *, location, identifier, expr_context_ty);

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

static int codegen_visit_stmt(struct compiler *, stmt_ty);

static int codegen_visit_keyword(struct compiler *, keyword_ty);

static int codegen_visit_expr(struct compiler *, expr_ty);

static int codegen_augassign(struct compiler *, stmt_ty);

static int codegen_annassign(struct compiler *, stmt_ty);

static int codegen_subscript(struct compiler *, expr_ty);

static int codegen_slice(struct compiler *, expr_ty);

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

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

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

static int codegen_async_for(struct compiler *, stmt_ty);

static int codegen_call_simple_kw_helper(struct compiler *c,

location loc,

asdl_keyword_seq *keywords,

Py_ssize_t nkwelts);

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

int n, asdl_expr_seq *args,

asdl_keyword_seq *keywords);

static int codegen_try_except(struct compiler *, stmt_ty);

static int codegen_try_star_except(struct compiler *, stmt_ty);

static int codegen_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 codegen_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 codegen_pattern(struct compiler *, pattern_ty, pattern_context *);

static int codegen_match(struct compiler *, stmt_ty);

static int codegen_pattern_subpattern(struct compiler *,

pattern_ty, pattern_context *);

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

PyCodeObject *co, Py_ssize_t flags);

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

/* Add an opcode with an integer argument */

static int

codegen_addop_i(instr_sequence *seq, int opcode, Py_ssize_t oparg, location loc)

{

/* oparg value is unsigned, but a signed C int is usually used to store

it in the C code (like Python/ceval.c).

Limit to 32-bit signed C int (rather than INT_MAX) for portability.

The argument of a concrete bytecode instruction is limited to 8-bit.

EXTENDED_ARG is used for 16, 24, and 32-bit arguments. */

int oparg_ = Py_SAFE_DOWNCAST(oparg, Py_ssize_t, int);

assert(!IS_ASSEMBLER_OPCODE(opcode));

return _PyInstructionSequence_Addop(seq, opcode, oparg_, loc);

}

#define ADDOP_I(C, LOC, OP, O) \

RETURN_IF_ERROR(codegen_addop_i(INSTR_SEQUENCE(C), (OP), (O), (LOC)))

#define ADDOP_I_IN_SCOPE(C, LOC, OP, O) \

RETURN_IF_ERROR_IN_SCOPE(C, codegen_addop_i(INSTR_SEQUENCE(C), (OP), (O), (LOC)));

static int

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

{

assert(!OPCODE_HAS_ARG(opcode));

assert(!IS_ASSEMBLER_OPCODE(opcode));

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

}

#define ADDOP(C, LOC, OP) \

RETURN_IF_ERROR(codegen_addop_noarg(INSTR_SEQUENCE(C), (OP), (LOC)))

#define ADDOP_IN_SCOPE(C, LOC, OP) \

RETURN_IF_ERROR_IN_SCOPE((C), codegen_addop_noarg(INSTR_SEQUENCE(C), (OP), (LOC)))

static Py_ssize_t

dict_add_o(PyObject *dict, PyObject *o)

{

PyObject *v;

Py_ssize_t arg;

if (PyDict_GetItemRef(dict, o, &v) < 0) {

return ERROR;

}

if (!v) {

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;

}

}

else

arg = PyLong_AsLong(v);

Py_DECREF(v);

return arg;

}

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

* If recursive, insert all elements if o is a tuple or frozen set.

*/

static PyObject*

const_cache_insert(PyObject *const_cache, PyObject *o, bool recursive)

{

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

return o;

}

PyObject *key = _PyCode_ConstantKey(o);

if (key == NULL) {

return NULL;

}

PyObject *t;

int res = 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);

return t;

}

Py_DECREF(t);

if (!recursive) {

return key;

}

// 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 = const_cache_insert(const_cache, item, recursive);

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 = const_cache_insert(const_cache, item, recursive);

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

if (new == NULL) {

Py_DECREF(key);

return NULL;

}

assert(PyTuple_GET_ITEM(key, 1) == o);

Py_DECREF(o);

PyTuple_SET_ITEM(key, 1, new);

}

return key;

}

static PyObject*

merge_consts_recursive(PyObject *const_cache, PyObject *o)

{

return const_cache_insert(const_cache, o, true);

}

static int

codegen_addop_load_const(struct compiler *c, location loc, PyObject *o)

{

Py_ssize_t arg = compiler_add_const(c, o);

if (arg < 0) {

return ERROR;

}

ADDOP_I(c, loc, LOAD_CONST, arg);

return SUCCESS;

}

#define ADDOP_LOAD_CONST(C, LOC, O) \

RETURN_IF_ERROR(codegen_addop_load_const((C), (LOC), (O)))

#define ADDOP_LOAD_CONST_IN_SCOPE(C, LOC, O) \

RETURN_IF_ERROR_IN_SCOPE((C), codegen_addop_load_const((C), (LOC), (O)))

/* Same as ADDOP_LOAD_CONST, but steals a reference. */

#define ADDOP_LOAD_CONST_NEW(C, LOC, O) { \

PyObject *__new_const = (O); \

if (__new_const == NULL) { \

return ERROR; \

} \

if (codegen_addop_load_const((C), (LOC), __new_const) < 0) { \

Py_DECREF(__new_const); \

return ERROR; \

} \

Py_DECREF(__new_const); \

}

static int

codegen_addop_o(struct compiler *c, location loc,

int opcode, PyObject *dict, PyObject *o)

{

Py_ssize_t arg = dict_add_o(dict, o);

RETURN_IF_ERROR(arg);

ADDOP_I(c, loc, opcode, arg);

return SUCCESS;

}

#define ADDOP_N(C, LOC, OP, O, TYPE) { \

assert(!OPCODE_HAS_CONST(OP)); /* use ADDOP_LOAD_CONST_NEW */ \

int ret = codegen_addop_o((C), (LOC), (OP), METADATA(C)->u_ ## TYPE, (O)); \

Py_DECREF((O)); \

RETURN_IF_ERROR(ret); \

}

#define ADDOP_N_IN_SCOPE(C, LOC, OP, O, TYPE) { \

assert(!OPCODE_HAS_CONST(OP)); /* use ADDOP_LOAD_CONST_NEW */ \

int ret = codegen_addop_o((C), (LOC), (OP), METADATA(C)->u_ ## TYPE, (O)); \

Py_DECREF((O)); \

RETURN_IF_ERROR_IN_SCOPE((C), ret); \

}

#define LOAD_METHOD -1

#define LOAD_SUPER_METHOD -2

#define LOAD_ZERO_SUPER_ATTR -3

#define LOAD_ZERO_SUPER_METHOD -4

static int

codegen_addop_name(struct compiler *c, location loc,

int opcode, PyObject *dict, PyObject *o)

{

PyObject *mangled = compiler_maybe_mangle(c, o);

if (!mangled) {

return ERROR;

}

Py_ssize_t arg = dict_add_o(dict, mangled);

Py_DECREF(mangled);

if (arg < 0) {

return ERROR;

}

if (opcode == LOAD_ATTR) {

arg <<= 1;

}

if (opcode == LOAD_METHOD) {

opcode = LOAD_ATTR;

arg <<= 1;

arg |= 1;

}

if (opcode == LOAD_SUPER_ATTR) {

arg <<= 2;

arg |= 2;

}

if (opcode == LOAD_SUPER_METHOD) {

opcode = LOAD_SUPER_ATTR;

arg <<= 2;

arg |= 3;

}

if (opcode == LOAD_ZERO_SUPER_ATTR) {

opcode = LOAD_SUPER_ATTR;

arg <<= 2;

}

if (opcode == LOAD_ZERO_SUPER_METHOD) {

opcode = LOAD_SUPER_ATTR;

arg <<= 2;

arg |= 1;

}

ADDOP_I(c, loc, opcode, arg);

return SUCCESS;

}

#define ADDOP_NAME(C, LOC, OP, O, TYPE) \

RETURN_IF_ERROR(codegen_addop_name((C), (LOC), (OP), METADATA(C)->u_ ## TYPE, (O)))

static int

codegen_addop_j(instr_sequence *seq, location loc,

int opcode, jump_target_label target)

{

assert(IS_LABEL(target));

assert(OPCODE_HAS_JUMP(opcode) || IS_BLOCK_PUSH_OPCODE(opcode));

assert(!IS_ASSEMBLER_OPCODE(opcode));

return _PyInstructionSequence_Addop(seq, opcode, target.id, loc);

}

#define ADDOP_JUMP(C, LOC, OP, O) \

RETURN_IF_ERROR(codegen_addop_j(INSTR_SEQUENCE(C), (LOC), (OP), (O)))

#define ADDOP_COMPARE(C, LOC, CMP) \

RETURN_IF_ERROR(codegen_addcompare((C), (LOC), (cmpop_ty)(CMP)))

#define ADDOP_BINARY(C, LOC, BINOP) \

RETURN_IF_ERROR(addop_binary((C), (LOC), (BINOP), false))

#define ADDOP_INPLACE(C, LOC, BINOP) \

RETURN_IF_ERROR(addop_binary((C), (LOC), (BINOP), true))

#define ADD_YIELD_FROM(C, LOC, await) \

RETURN_IF_ERROR(codegen_add_yield_from((C), (LOC), (await)))

#define POP_EXCEPT_AND_RERAISE(C, LOC) \

RETURN_IF_ERROR(codegen_pop_except_and_reraise((C), (LOC)))

#define ADDOP_YIELD(C, LOC) \

RETURN_IF_ERROR(codegen_addop_yield((C), (LOC)))

/* VISIT and VISIT_SEQ takes an ASDL type as their second argument. They use

the ASDL name to synthesize the name of the C type and the visit function.

*/

#define VISIT(C, TYPE, V) \

RETURN_IF_ERROR(codegen_visit_ ## TYPE((C), (V)));

#define VISIT_IN_SCOPE(C, TYPE, V) \

RETURN_IF_ERROR_IN_SCOPE((C), codegen_visit_ ## TYPE((C), (V)))

#define VISIT_SEQ(C, TYPE, SEQ) { \

int _i; \

asdl_ ## TYPE ## _seq *seq = (SEQ); /* avoid variable capture */ \

for (_i = 0; _i < asdl_seq_LEN(seq); _i++) { \

TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, _i); \

RETURN_IF_ERROR(codegen_visit_ ## TYPE((C), elt)); \

} \

}

#define VISIT_SEQ_IN_SCOPE(C, TYPE, SEQ) { \

int _i; \

asdl_ ## TYPE ## _seq *seq = (SEQ); /* avoid variable capture */ \

for (_i = 0; _i < asdl_seq_LEN(seq); _i++) { \

TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, _i); \

if (codegen_visit_ ## TYPE((C), elt) < 0) { \

compiler_exit_scope(C); \

return ERROR; \

} \

} \

}

static int

codegen_call_exit_with_nones(struct compiler *c, location loc)

{

ADDOP_LOAD_CONST(c, loc, Py_None);

ADDOP_LOAD_CONST(c, loc, Py_None);

ADDOP_LOAD_CONST(c, loc, Py_None);

ADDOP_I(c, loc, CALL, 3);

return SUCCESS;

}

static int

codegen_add_yield_from(struct compiler *c, location loc, int await)

{

NEW_JUMP_TARGET_LABEL(c, send);

NEW_JUMP_TARGET_LABEL(c, fail);

NEW_JUMP_TARGET_LABEL(c, exit);

USE_LABEL(c, send);

ADDOP_JUMP(c, loc, SEND, exit);

// Set up a virtual try/except to handle when StopIteration is raised during

// a close or throw call. The only way YIELD_VALUE raises if they do!

ADDOP_JUMP(c, loc, SETUP_FINALLY, fail);

ADDOP_I(c, loc, YIELD_VALUE, 1);

ADDOP(c, NO_LOCATION, POP_BLOCK);

ADDOP_I(c, loc, RESUME, await ? RESUME_AFTER_AWAIT : RESUME_AFTER_YIELD_FROM);

ADDOP_JUMP(c, loc, JUMP_NO_INTERRUPT, send);

USE_LABEL(c, fail);

ADDOP(c, loc, CLEANUP_THROW);

USE_LABEL(c, exit);

ADDOP(c, loc, END_SEND);

return SUCCESS;

}

static int

codegen_pop_except_and_reraise(struct compiler *c, location loc)

{

/* Stack contents

* [exc_info, lasti, exc] COPY 3

* [exc_info, lasti, exc, exc_info] POP_EXCEPT

* [exc_info, lasti, exc] RERAISE 1

* (exception_unwind clears the stack)

*/

ADDOP_I(c, loc, COPY, 3);

ADDOP(c, loc, POP_EXCEPT);

ADDOP_I(c, loc, RERAISE, 1);

return SUCCESS;

}

/* Unwind a frame block. If preserve_tos is true, the TOS before

* popping the blocks will be restored afterwards, unless another

* return, break or continue is found. In which case, the TOS will

* be popped.

*/

static int

codegen_unwind_fblock(struct compiler *c, location *ploc,

struct fblockinfo *info, int preserve_tos)

{

switch (info->fb_type) {

case WHILE_LOOP:

case EXCEPTION_HANDLER:

case EXCEPTION_GROUP_HANDLER:

case ASYNC_COMPREHENSION_GENERATOR:

case STOP_ITERATION:

return SUCCESS;

case FOR_LOOP:

/* Pop the iterator */

if (preserve_tos) {

ADDOP_I(c, *ploc, SWAP, 2);

}

ADDOP(c, *ploc, POP_TOP);

return SUCCESS;

case TRY_EXCEPT:

ADDOP(c, *ploc, POP_BLOCK);

return SUCCESS;

case FINALLY_TRY:

/* This POP_BLOCK gets the line number of the unwinding statement */

ADDOP(c, *ploc, POP_BLOCK);

if (preserve_tos) {

RETURN_IF_ERROR(

compiler_push_fblock(c, *ploc, POP_VALUE, NO_LABEL, NO_LABEL, NULL));

}

/* Emit the finally block */

VISIT_SEQ(c, stmt, info->fb_datum);

if (preserve_tos) {

compiler_pop_fblock(c, POP_VALUE, NO_LABEL);

}

/* The finally block should appear to execute after the

* statement causing the unwinding, so make the unwinding

* instruction artificial */

*ploc = NO_LOCATION;

return SUCCESS;

case FINALLY_END:

if (preserve_tos) {

ADDOP_I(c, *ploc, SWAP, 2);

}

ADDOP(c, *ploc, POP_TOP); /* exc_value */

if (preserve_tos) {

ADDOP_I(c, *ploc, SWAP, 2);

}

ADDOP(c, *ploc, POP_BLOCK);

ADDOP(c, *ploc, POP_EXCEPT);

return SUCCESS;

case WITH:

case ASYNC_WITH:

*ploc = info->fb_loc;

ADDOP(c, *ploc, POP_BLOCK);

if (preserve_tos) {

ADDOP_I(c, *ploc, SWAP, 3);

ADDOP_I(c, *ploc, SWAP, 2);

}

RETURN_IF_ERROR(codegen_call_exit_with_nones(c, *ploc));

if (info->fb_type == ASYNC_WITH) {

ADDOP_I(c, *ploc, GET_AWAITABLE, 2);

ADDOP_LOAD_CONST(c, *ploc, Py_None);

ADD_YIELD_FROM(c, *ploc, 1);

}

ADDOP(c, *ploc, POP_TOP);

/* The exit block should appear to execute after the

* statement causing the unwinding, so make the unwinding

* instruction artificial */

*ploc = NO_LOCATION;

return SUCCESS;

case HANDLER_CLEANUP: {

if (info->fb_datum) {

ADDOP(c, *ploc, POP_BLOCK);

}

if (preserve_tos) {

ADDOP_I(c, *ploc, SWAP, 2);

}

ADDOP(c, *ploc, POP_BLOCK);

ADDOP(c, *ploc, POP_EXCEPT);

if (info->fb_datum) {

ADDOP_LOAD_CONST(c, *ploc, Py_None);

RETURN_IF_ERROR(codegen_nameop(c, *ploc, info->fb_datum, Store));

RETURN_IF_ERROR(codegen_nameop(c, *ploc, info->fb_datum, Del));

}

return SUCCESS;

}

case POP_VALUE: {

if (preserve_tos) {

ADDOP_I(c, *ploc, SWAP, 2);

}

ADDOP(c, *ploc, POP_TOP);

return SUCCESS;

}

}

Py_UNREACHABLE();

}

/** Unwind block stack. If loop is not NULL, then stop when the first loop is encountered. */

static int

codegen_unwind_fblock_stack(struct compiler *c, location *ploc,

int preserve_tos, struct fblockinfo **loop)

{

struct fblockinfo *top = compiler_top_fblock(c);

if (top == NULL) {

return SUCCESS;

}

if (top->fb_type == EXCEPTION_GROUP_HANDLER) {

return compiler_error(

c, *ploc, "'break', 'continue' and 'return' cannot appear in an except* block");

}

if (loop != NULL && (top->fb_type == WHILE_LOOP || top->fb_type == FOR_LOOP)) {

*loop = top;

return SUCCESS;

}

struct fblockinfo copy = *top;

compiler_pop_fblock(c, top->fb_type, top->fb_block);

RETURN_IF_ERROR(codegen_unwind_fblock(c, ploc, &copy, preserve_tos));

RETURN_IF_ERROR(codegen_unwind_fblock_stack(c, ploc, preserve_tos, loop));

compiler_push_fblock(c, copy.fb_loc, copy.fb_type, copy.fb_block,

copy.fb_exit, copy.fb_datum);

return SUCCESS;

}

static int

codegen_setup_annotations_scope(struct compiler *c, location loc,

void *key, PyObject *name)

{

_PyCompile_CodeUnitMetadata umd = {

.u_posonlyargcount = 1,

};

RETURN_IF_ERROR(

compiler_enter_scope(c, name, COMPILER_SCOPE_ANNOTATIONS,

key, loc.lineno, NULL, &umd));

// if .format != 1: raise NotImplementedError

_Py_DECLARE_STR(format, ".format");

ADDOP_I(c, loc, LOAD_FAST, 0);

ADDOP_LOAD_CONST(c, loc, _PyLong_GetOne());

ADDOP_I(c, loc, COMPARE_OP, (Py_NE << 5) | compare_masks[Py_NE]);

NEW_JUMP_TARGET_LABEL(c, body);

ADDOP_JUMP(c, loc, POP_JUMP_IF_FALSE, body);

ADDOP_I(c, loc, LOAD_COMMON_CONSTANT, CONSTANT_NOTIMPLEMENTEDERROR);

ADDOP_I(c, loc, RAISE_VARARGS, 1);

USE_LABEL(c, body);

return SUCCESS;

}

static int

codegen_leave_annotations_scope(struct compiler *c, location loc,

Py_ssize_t annotations_len)

{

ADDOP_I(c, loc, BUILD_MAP, annotations_len);

ADDOP_IN_SCOPE(c, loc, RETURN_VALUE);

PyCodeObject *co = optimize_and_assemble(c, 1);

compiler_exit_scope(c);

if (co == NULL) {

return ERROR;

}

int ret = codegen_make_closure(c, loc, co, 0);

Py_DECREF(co);

RETURN_IF_ERROR(ret);

return SUCCESS;

}

static int

codegen_process_deferred_annotations(struct compiler *c, location loc)

{

PyObject *deferred_anno = compiler_deferred_annotations(c);

if (deferred_anno == NULL) {

return SUCCESS;

}

Py_INCREF(deferred_anno);

// It's possible that ste_annotations_block is set but

// u_deferred_annotations is not, because the former is still

// set if there are only non-simple annotations (i.e., annotations

// for attributes, subscripts, or parenthesized names). However, the

// reverse should not be possible.

PySTEntryObject *ste = SYMTABLE_ENTRY(c);

assert(ste->ste_annotation_block != NULL);

void *key = (void *)((uintptr_t)ste->ste_id + 1);

if (codegen_setup_annotations_scope(c, loc, key,

ste->ste_annotation_block->ste_name) < 0) {

Py_DECREF(deferred_anno);

return ERROR;

}

Py_ssize_t annotations_len = PyList_Size(deferred_anno);

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

PyObject *ptr = PyList_GET_ITEM(deferred_anno, i);

stmt_ty st = (stmt_ty)PyLong_AsVoidPtr(ptr);

if (st == NULL) {

compiler_exit_scope(c);

Py_DECREF(deferred_anno);

return ERROR;

}

PyObject *mangled = compiler_mangle(c, st->v.AnnAssign.target->v.Name.id);

if (!mangled) {

compiler_exit_scope(c);

Py_DECREF(deferred_anno);

return ERROR;

}

ADDOP_LOAD_CONST_NEW(c, LOC(st), mangled);

VISIT(c, expr, st->v.AnnAssign.annotation);

}