8000 gh-121404: rename compiler_addop* to codegen_addop*, and replace dire… · python/cpython@e2f2dc7 · GitHub
[go: up one dir, main page]
Skip to content

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Appearance settings

Commit e2f2dc7

Browse files
iritkatrieliritkatriel
authored
gh-121404: rename compiler_addop* to codegen_addop*, and replace direct usages by the macros (#123043)
1 parent a07cf4c commit e2f2dc7

File tree

1 file changed

+102
-96
lines changed

1 file changed

+102
-96
lines changed

‎102Lines changed: 102 additions & 96 deletions

Original file line numberDiff line numberDiff line change
@@ -67,6 +67,13 @@
6767
return ERROR; \
6868
}
6969

70+
#define RETURN_IF_ERROR_IN_SCOPE(C, CALL) { \
71+
if ((CALL) < 0) { \
72+
compiler_exit_scope((C)); \
73+
return ERROR; \
74+
} \
75+
}
76+
7077
#define IS_TOP_LEVEL_AWAIT(C) ( \
7178
((C)->c_flags.cf_flags & PyCF_ALLOW_TOP_LEVEL_AWAIT) \
7279
&& ((C)->u->u_ste->ste_type == ModuleBlock))
@@ -291,8 +298,6 @@ typedef struct {
291298
Py_ssize_t on_top;
292299
} pattern_context;
293300

294-
static int codegen_addop_i(instr_sequence *seq, int opcode, Py_ssize_t oparg, location loc);
295-
296301
static void compiler_free(struct compiler *);
297302
static int compiler_error(struct compiler *, location loc, const char *, ...);
298303
static int compiler_warn(struct compiler *, location loc, const char *, ...);
@@ -685,6 +690,29 @@ compiler_set_qualname(struct compiler *c)
685690
return SUCCESS;
686691
}
687692

693+
/* Add an opcode with an integer argument */
694+
static int
695+
codegen_addop_i(instr_sequence *seq, int opcode, Py_ssize_t oparg, location loc)
696+
{
697+
/* oparg value is unsigned, but a signed C int is usually used to store
698+
it in the C code (like Python/ceval.c).
699+
700+
Limit to 32-bit signed C int (rather than INT_MAX) for portability.
701+
702+
The argument of a concrete bytecode instruction is limited to 8-bit.
703+
EXTENDED_ARG is used for 16, 24, and 32-bit arguments. */
704+
705+
int oparg_ = Py_SAFE_DOWNCAST(oparg, Py_ssize_t, int);
706+
assert(!IS_ASSEMBLER_OPCODE(opcode));
707+
return _PyInstructionSequence_Addop(seq, opcode, oparg_, loc);
708+
}
709+
710+
#define ADDOP_I(C, LOC, OP, O) \
711+
RETURN_IF_ERROR(codegen_addop_i(INSTR_SEQUENCE(C), (OP), (O), (LOC)))
712+
713+
#define ADDOP_I_IN_SCOPE(C, LOC, OP, O) \
714+
RETURN_IF_ERROR_IN_SCOPE(C, codegen_addop_i(INSTR_SEQUENCE(C), (OP), (O), (LOC)));
715+
688716
static int
689717
codegen_addop_noarg(instr_sequence *seq, int opcode, location loc)
690718
{
@@ -693,6 +721,12 @@ codegen_addop_noarg(instr_sequence *seq, int opcode, location loc)
693721
return _PyInstructionSequence_Addop(seq, opcode, 0, loc);
694722
}
695723

724+
#define ADDOP(C, LOC, OP) \
725+
RETURN_IF_ERROR(codegen_addop_noarg(INSTR_SEQUENCE(C), (OP), (LOC)))
726+
727+
#define ADDOP_IN_SCOPE(C, LOC, OP) \
728+
RETURN_IF_ERROR_IN_SCOPE((C), codegen_addop_noarg(INSTR_SEQUENCE(C), (OP), (LOC)))
729+
696730
static Py_ssize_t
697731
dict_add_o(PyObject *dict, PyObject *o)
698732
{
@@ -854,24 +888,57 @@ compiler_add_const(struct compiler *c, PyObject *o)
854888
}
855889

856890
static int
857-
compiler_addop_load_const(struct compiler *c, location loc, PyObject *o)
891+
codegen_addop_load_const(struct compiler *c, location loc, PyObject *o)
858892
{
859893
Py_ssize_t arg = compiler_add_const(c, o);
860894
if (arg < 0) {
861895
return ERROR;
862896
}
863-
return codegen_addop_i(INSTR_SEQUENCE(c), LOAD_CONST, arg, loc);
897+
ADDOP_I(c, loc, LOAD_CONST, arg);
898+
return SUCCESS;
899+
}
900+
901+
#define ADDOP_LOAD_CONST(C, LOC, O) \
902+
RETURN_IF_ERROR(codegen_addop_load_const((C), (LOC), (O)))
903+
904+
#define ADDOP_LOAD_CONST_IN_SCOPE(C, LOC, O) \
905+
RETURN_IF_ERROR_IN_SCOPE((C), codegen_addop_load_const((C), (LOC), (O)))
906+
907+
/* Same as ADDOP_LOAD_CONST, but steals a reference. */
908+
#define ADDOP_LOAD_CONST_NEW(C, LOC, O) { \
909+
PyObject *__new_const = (O); \
910+
if (__new_const == NULL) { \
911+
return ERROR; \
912+
} \
913+
if (codegen_addop_load_const((C), (LOC), __new_const) < 0) { \
914+
Py_DECREF(__new_const); \
915+
return ERROR; \
916+
} \
917+
Py_DECREF(__new_const); \
864918
}
865919

866920
static int
867-
compiler_addop_o(struct compiler *c, location loc,
868-
int opcode, PyObject *dict, PyObject *o)
921+
codegen_addop_o(struct compiler *c, location loc,
922+
int opcode, PyObject *dict, PyObject *o)
869923
{
870924
Py_ssize_t arg = dict_add_o(dict, o);
871-
if (arg < 0) {
872-
return ERROR;
873-
}
874-
return codegen_addop_i(INSTR_SEQUENCE(c), opcode, arg, loc);
925+
RETURN_IF_ERROR(arg);
926+
ADDOP_I(c, loc, opcode, arg);
927+
return SUCCESS;
928+
}
929+
930+
#define ADDOP_N(C, LOC, OP, O, TYPE) { \
931+
assert(!OPCODE_HAS_CONST(OP)); /* use ADDOP_LOAD_CONST_NEW */ \
932+
int ret = codegen_addop_o((C), (LOC), (OP), (C)->u->u_metadata.u_ ## TYPE, (O)); \
933+
Py_DECREF((O)); \
934+
RETURN_IF_ERROR(ret); \
935+
}
936+
937+
#define ADDOP_N_IN_SCOPE(C, LOC, OP, O, TYPE) { \
938+
assert(!OPCODE_HAS_CONST(OP)); /* use ADDOP_LOAD_CONST_NEW */ \
939+
int ret = codegen_addop_o((C), (LOC), (OP), (C)->u->u_metadata.u_ ## TYPE, (O)); \
940+
Py_DECREF((O)); \
941+
RETURN_IF_ERROR_IN_SCOPE((C), ret); \
875942
}
876943

877944
#define LOAD_METHOD -1
@@ -880,8 +947,8 @@ compiler_addop_o(struct compiler *c, location loc,
880947
#define LOAD_ZERO_SUPER_METHOD -4
881948

882949
static int
883-
compiler_addop_name(struct compiler *c, location loc,
884-
int opcode, PyObject *dict, PyObject *o)
950+
codegen_addop_name(struct compiler *c, location loc,
951+
int opcode, PyObject *dict, PyObject *o)
885952
{
886953
PyObject *mangled = compiler_maybe_mangle(c, o);
887954
if (!mangled) {
@@ -918,25 +985,12 @@ compiler_addop_name(struct compiler *c, location loc,
918985
arg <<= 2;
919986
arg |= 1;
920987
}
921-
return codegen_addop_i(INSTR_SEQUENCE(c), opcode, arg, loc);
988+
ADDOP_I(c, loc, opcode, arg);
989+
return SUCCESS;
922990
}
923991

924-
/* Add an opcode with an integer argument */
925-
static int
926-
codegen_addop_i(instr_sequence *seq, int opcode, Py_ssize_t oparg, location loc)
927-
{
928-
/* oparg value is unsigned, but a signed C int is usually used to store
929-
it in the C code (like Python/ceval.c).
930-
931-
Limit to 32-bit signed C int (rather than INT_MAX) for portability.
932-
933-
The argument of a concrete bytecode instruction is limited to 8-bit.
934-
EXTENDED_ARG is used for 16, 24, and 32-bit arguments. */
935-
936-
int oparg_ = Py_SAFE_DOWNCAST(oparg, Py_ssize_t, int);
937-
assert(!IS_ASSEMBLER_OPCODE(opcode));
938-
return _PyInstructionSequence_Addop(seq, opcode, oparg_, loc);
939-
}
992+
#define ADDOP_NAME(C, LOC, OP, O, TYPE) \
993+
RETURN_IF_ERROR(codegen_addop_name((C), (LOC), (OP), (C)->u->u_metadata.u_ ## TYPE, (O)))
940994

941995
static int
942996
codegen_addop_j(instr_sequence *seq, location loc,
@@ -948,49 +1002,6 @@ codegen_addop_j(instr_sequence *seq, location loc,
9481002
return _PyInstructionSequence_Addop(seq, opcode, target.id, loc);
9491003
}
9501004

951-
#define RETURN_IF_ERROR_IN_SCOPE(C, CALL) { \
952-
if ((CALL) < 0) { \
953-
compiler_exit_scope((C)); \
954-
return ERROR; \
955-
} \
956-
}
957-
958-
#define ADDOP(C, LOC, OP) \
959-
RETURN_IF_ERROR(codegen_addop_noarg(INSTR_SEQUENCE(C), (OP), (LOC)))
960-
961-
#define ADDOP_IN_SCOPE(C, LOC, OP) RETURN_IF_ERROR_IN_SCOPE((C), codegen_addop_noarg(INSTR_SEQUENCE(C), (OP), (LOC)))
962-
963-
#define ADDOP_LOAD_CONST(C, LOC, O) \
964-
RETURN_IF_ERROR(compiler_addop_load_const((C), (LOC), (O)))
965-
966-
/* Same as ADDOP_LOAD_CONST, but steals a reference. */
967-
#define ADDOP_LOAD_CONST_NEW(C, LOC, O) { \
968-
PyObject *__new_const = (O); \
969-
if (__new_const == NULL) { \
970-
return ERROR; \
971-
} \
972-
if (compiler_addop_load_const((C), (LOC), __new_const) < 0) { \
973-
Py_DECREF(__new_const); \
974-
return ERROR; \
975-
} \
976-
Py_DECREF(__new_const); \
977-
}
978-
979-
#define ADDOP_N(C, LOC, OP, O, TYPE) { \
980-
assert(!OPCODE_HAS_CONST(OP)); /* use ADDOP_LOAD_CONST_NEW */ \
981-
if (compiler_addop_o((C), (LOC), (OP), (C)->u->u_metadata.u_ ## TYPE, (O)) < 0) { \
982-
Py_DECREF((O)); \
983-
return ERROR; \
984-
} \
985-
Py_DECREF((O)); \
986-
}
987-
988-
#define ADDOP_NAME(C, LOC, OP, O, TYPE) \
989-
RETURN_IF_ERROR(compiler_addop_name((C), (LOC), (OP), (C)->u->u_metadata.u_ ## TYPE, (O)))
990-
991-
#define ADDOP_I(C, LOC, OP, O) \
992-
RETURN_IF_ERROR(codegen_addop_i(INSTR_SEQUENCE(C), (OP), (O), (LOC)))
993-
9941005
#define ADDOP_JUMP(C, LOC, OP, O) \
9951006
RETURN_IF_ERROR(codegen_addop_j(INSTR_SEQUENCE(C), (LOC), (OP), (O)))
9961007

@@ -2279,7 +2290,7 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async)
22792290
Py_DECREF(type_params_name);
22802291
RETURN_IF_ERROR_IN_SCOPE(c, compiler_type_params(c, type_params));
22812292
for (int i = 0; i < num_typeparam_args; i++) {
2282-
RETURN_IF_ERROR_IN_SCOPE(c, codegen_addop_i(INSTR_SEQUENCE(c), LOAD_FAST, i, loc));
2293+
ADDOP_I_IN_SCOPE(c, loc, LOAD_FAST, i);
22832294
}
22842295
}
22852296

@@ -2300,10 +2311,8 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async)
23002311
}
23012312

23022313
if (is_generic) {
2303-
RETURN_IF_ERROR_IN_SCOPE(c, codegen_addop_i(
2304-
INSTR_SEQUENCE(c), SWAP, 2, loc));
2305-
RETURN_IF_ERROR_IN_SCOPE(c, codegen_addop_i(
2306-
INSTR_SEQUENCE(c), CALL_INTRINSIC_2, INTRINSIC_SET_FUNCTION_TYPE_PARAMS, loc));
2314+
ADDOP_I_IN_SCOPE(c, loc, SWAP, 2);
2315+
ADDOP_I_IN_SCOPE(c, loc, CALL_INTRINSIC_2, INTRINSIC_SET_FUNCTION_TYPE_PARAMS);
23072316

23082317
c->u->u_metadata.u_argcount = num_typeparam_args;
23092318
PyCodeObject *co = optimize_and_assemble(c, 0);
@@ -2393,12 +2402,7 @@ compiler_class_body(struct compiler *c, stmt_ty s, int firstlineno)
23932402
// We can't use compiler_nameop here because we need to generate a
23942403
// STORE_DEREF in a class namespace, and compiler_nameop() won't do
23952404
// that by default.
2396-
PyObject *cellvars = c->u->u_metadata.u_cellvars;
2397-
if (compiler_addop_o(c, loc, STORE_DEREF, cellvars,
2398-
&_Py_ID(__classdict__)) < 0) {
2399-
compiler_exit_scope(c);
2400-
return ERROR;
2401-
}
2405+
ADDOP_N_IN_SCOPE(c, loc, STORE_DEREF, &_Py_ID(__classdict__), cellvars);
24022406
}
24032407
/* compile the body proper */
24042408
if (compiler_body(c, loc, s->v.ClassDef.body) < 0) {
@@ -2527,9 +2531,7 @@ compiler_class(struct compiler *c, stmt_ty s)
25272531
_Py_DECLARE_STR(type_params, ".type_params");
25282532
_Py_DECLARE_STR(generic_base, ".generic_base");
25292533
RETURN_IF_ERROR_IN_SCOPE(c, compiler_nameop(c, loc, &_Py_STR(type_params), Load));
2530-
RETURN_IF_ERROR_IN_SCOPE(
2531-
c, codegen_addop_i(INSTR_SEQUENCE(c), CALL_INTRINSIC_1, INTRINSIC_SUBSCRIPT_GENERIC, loc)
2532-
)
2534+
ADDOP_I_IN_SCOPE(c, loc, CALL_INTRINSIC_1, INTRINSIC_SUBSCRIPT_GENERIC);
25332535
RETURN_IF_ERROR_IN_SCOPE(c, compiler_nameop(c, loc, &_Py_STR(generic_base), Store));
25342536

25352537
Py_ssize_t original_len = asdl_seq_LEN(s->v.ClassDef.bases);
@@ -2630,9 +2632,7 @@ compiler_typealias(struct compiler *c, stmt_ty s)
26302632
return ERROR;
26312633
}
26322634
Py_DECREF(type_params_name);
2633-
RETURN_IF_ERROR_IN_SCOPE(
2634-
c, compiler_addop_load_const(c, loc, name)
2635-
);
2635+
ADDOP_LOAD_CONST_IN_SCOPE(c, loc, name);
26362636
RETURN_IF_ERROR_IN_SCOPE(c, compiler_type_params(c, type_params));
26372637
}
26382638
else {
@@ -2713,8 +2713,8 @@ check_compare(struct compiler *c, expr_ty e)
27132713
return SUCCESS;
27142714
}
27152715

2716-
static int compiler_addcompare(struct compiler *c, location loc,
2717-
cmpop_ty op)
2716+
static int
2717+
compiler_addcompare(struct compiler *c, location loc, cmpop_ty op)
27182718
{
27192719
int cmp;
27202720
switch (op) {
@@ -4040,6 +4040,13 @@ addop_yield(struct compiler *c, location loc) {
40404040
return SUCCESS;
40414041
}
40424042

4043+
static int
4044+
compiler_load_classdict_freevar(struct compiler *c, location loc)
4045+
{
4046+
ADDOP_N(c, loc, LOAD_DEREF, &_Py_ID(__classdict__), freevars);
4047+
return SUCCESS;
4048+
}
4049+
40434050
static int
40444051
compiler_nameop(struct compiler *c, location loc,
40454052
identifier name, expr_context_ty ctx)
@@ -4119,8 +4126,7 @@ compiler_nameop(struct compiler *c, location loc,
41194126
else if (SYMTABLE_ENTRY(c)->ste_can_see_class_scope) {
41204127
op = LOAD_FROM_DICT_OR_DEREF;
41214128
// First load the classdict
4122-
if (compiler_addop_o(c, loc, LOAD_DEREF,
4123-
c->u->u_metadata.u_freevars, &_Py_ID(__classdict__)) < 0) {
4129+
if (compiler_load_classdict_freevar(c, loc) < 0) {
41244130
goto error;
41254131
}
41264132
}
@@ -4146,8 +4152,7 @@ compiler_nameop(struct compiler *c, location loc,
41464152
if (SYMTABLE_ENTRY(c)->ste_can_see_class_scope && scope == GLOBAL_IMPLICIT) {
41474153
op = LOAD_FROM_DICT_OR_GLOBALS;
41484154
// First load the classdict
4149-
if (compiler_addop_o(c, loc, LOAD_DEREF,
4150-
c->u->u_metadata.u_freevars, &_Py_ID(__classdict__)) < 0) {
4155+
if (compiler_load_classdict_freevar(c, loc) < 0) {
41514156
goto error;
41524157
}
41534158
} else {
@@ -4181,7 +4186,8 @@ compiler_nameop(struct compiler *c, location loc,
41814186
if (op == LOAD_GLOBAL) {
41824187
arg <<= 1;
41834188
}
4184-
return codegen_addop_i(INSTR_SEQUENCE(c), op, arg, loc);
4189+
ADDOP_I(c, loc, op, arg);
4190+
return SUCCESS;
41854191

41864192
error:
41874193
Py_DECREF(mangled);

0 commit comments

Comments
 (0)
0