mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-07-08 03:45:36 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 8

GH-118910: Less boilerplate in the tier 2 optimizer (#118913)

Browse source
This commit is contained in:
Mark Shannon 2024-05-10 17:43:23 +01:00 • committed by GitHub
parent 941eea0a27
commit f5c6b9977a
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
7 changed files with 275 additions and 473 deletions
Download patch file Download diff file Expand all files Collapse all files

234
Python/optimizer_bytecodes.c
View file

@ -23,10 +23,10 @@ typedef struct _Py_UOpsAbstractFrame _Py_UOpsAbstractFrame;
#define sym_matches_type _Py_uop_sym_matches_type
#define sym_get_type _Py_uop_sym_get_type
#define sym_has_type _Py_uop_sym_has_type
#define sym_set_null _Py_uop_sym_set_null
#define sym_set_non_null _Py_uop_sym_set_non_null
#define sym_set_type _Py_uop_sym_set_type
#define sym_set_const _Py_uop_sym_set_const
#define sym_set_null(SYM) _Py_uop_sym_set_null(ctx, SYM)
#define sym_set_non_null(SYM) _Py_uop_sym_set_non_null(ctx, SYM)
#define sym_set_type(SYM, TYPE) _Py_uop_sym_set_type(ctx, SYM, TYPE)
#define sym_set_const(SYM, CNST) _Py_uop_sym_set_const(ctx, SYM, CNST)
#define sym_is_bottom _Py_uop_sym_is_bottom
#define frame_new _Py_uop_frame_new
#define frame_pop _Py_uop_frame_pop
@ -73,7 +73,7 @@ dummy_func(void) {
value = GETLOCAL(oparg);
// We guarantee this will error - just bail and don't optimize it.
if (sym_is_null(value)) {
goto out_of_space;
ctx->done = true;
}
}
@ -83,8 +83,7 @@ dummy_func(void) {
op(_LOAD_FAST_AND_CLEAR, (-- value)) {
value = GETLOCAL(oparg);
_Py_UopsSymbol *temp;
OUT_OF_SPACE_IF_NULL(temp = sym_new_null(ctx));
_Py_UopsSymbol *temp = sym_new_null(ctx);
GETLOCAL(oparg) = temp;
}
@ -94,9 +93,6 @@ dummy_func(void) {
op(_PUSH_NULL, (-- res)) {
res = sym_new_null(ctx);
if (res == NULL) {
goto out_of_space;
};
}
op(_GUARD_BOTH_INT, (left, right -- left, right)) {
@ -113,12 +109,8 @@ dummy_func(void) {
REPLACE_OP(this_instr, _GUARD_NOS_INT, 0, 0);
}
}
if (!sym_set_type(left, &PyLong_Type)) {
goto hit_bottom;
}
if (!sym_set_type(right, &PyLong_Type)) {
goto hit_bottom;
}
sym_set_type(left, &PyLong_Type);
sym_set_type(right, &PyLong_Type);
}
op(_GUARD_BOTH_FLOAT, (left, right -- left, right)) {
@ -135,12 +127,9 @@ dummy_func(void) {
REPLACE_OP(this_instr, _GUARD_NOS_FLOAT, 0, 0);
}
}
if (!sym_set_type(left, &PyFloat_Type)) {
goto hit_bottom;
}
if (!sym_set_type(right, &PyFloat_Type)) {
goto hit_bottom;
}
sym_set_type(left, &PyFloat_Type);
sym_set_type(right, &PyFloat_Type);
}
op(_GUARD_BOTH_UNICODE, (left, right -- left, right)) {
@ -148,12 +137,8 @@ dummy_func(void) {
sym_matches_type(right, &PyUnicode_Type)) {
REPLACE_OP(this_instr, _NOP, 0 ,0);
}
if (!sym_set_type(left, &PyUnicode_Type)) {
goto hit_bottom;
}
if (!sym_set_type(right, &PyUnicode_Type)) {
goto hit_bottom;
}
sym_set_type(left, &PyUnicode_Type);
sym_set_type(left, &PyUnicode_Type);
}
op(_BINARY_OP, (left, right -- res)) {
@ -165,14 +150,14 @@ dummy_func(void) {
if (oparg != NB_TRUE_DIVIDE && oparg != NB_INPLACE_TRUE_DIVIDE &&
ltype == &PyLong_Type && rtype == &PyLong_Type) {
/* If both inputs are ints and the op is not division the result is an int */
OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyLong_Type));
res = sym_new_type(ctx, &PyLong_Type);
}
else {
/* For any other op combining ints/floats the result is a float */
OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyFloat_Type));
res = sym_new_type(ctx, &PyFloat_Type);
}
}
OUT_OF_SPACE_IF_NULL(res = sym_new_unknown(ctx));
res = sym_new_unknown(ctx);
}
op(_BINARY_OP_ADD_INT, (left, right -- res)) {
@ -188,12 +173,11 @@ dummy_func(void) {
}
res = sym_new_const(ctx, temp);
Py_DECREF(temp);
OUT_OF_SPACE_IF_NULL(res);
// TODO gh-115506:
// replace opcode with constant propagated one and add tests!
}
else {
OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyLong_Type));
res = sym_new_type(ctx, &PyLong_Type);
}
}
@ -210,12 +194,11 @@ dummy_func(void) {
}
res = sym_new_const(ctx, temp);
Py_DECREF(temp);
OUT_OF_SPACE_IF_NULL(res);
// TODO gh-115506:
// replace opcode with constant propagated one and add tests!
}
else {
OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyLong_Type));
res = sym_new_type(ctx, &PyLong_Type);
}
}
@ -232,12 +215,11 @@ dummy_func(void) {
}
res = sym_new_const(ctx, temp);
Py_DECREF(temp);
OUT_OF_SPACE_IF_NULL(res);
// TODO gh-115506:
// replace opcode with constant propagated one and add tests!
}
else {
OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyLong_Type));
res = sym_new_type(ctx, &PyLong_Type);
}
}
@ -255,12 +237,11 @@ dummy_func(void) {
}
res = sym_new_const(ctx, temp);
Py_DECREF(temp);
OUT_OF_SPACE_IF_NULL(res);
// TODO gh-115506:
// replace opcode with constant propagated one and update tests!
}
else {
OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyFloat_Type));
res = sym_new_type(ctx, &PyFloat_Type);
}
}
@ -278,12 +259,11 @@ dummy_func(void) {
}
res = sym_new_const(ctx, temp);
Py_DECREF(temp);
OUT_OF_SPACE_IF_NULL(res);
// TODO gh-115506:
// replace opcode with constant propagated one and update tests!
}
else {
OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyFloat_Type));
res = sym_new_type(ctx, &PyFloat_Type);
}
}
@ -301,12 +281,11 @@ dummy_func(void) {
}
res = sym_new_const(ctx, temp);
Py_DECREF(temp);
OUT_OF_SPACE_IF_NULL(res);
// TODO gh-115506:
// replace opcode with constant propagated one and update tests!
}
else {
OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyFloat_Type));
res = sym_new_type(ctx, &PyFloat_Type);
}
}
@ -319,80 +298,50 @@ dummy_func(void) {
}
res = sym_new_const(ctx, temp);
Py_DECREF(temp);
OUT_OF_SPACE_IF_NULL(res);
}
else {
OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyUnicode_Type));
res = sym_new_type(ctx, &PyUnicode_Type);
}
}
op(_TO_BOOL, (value -- res)) {
if (optimize_to_bool(this_instr, ctx, value, &res)) {
OUT_OF_SPACE_IF_NULL(res);
}
else {
if (!optimize_to_bool(this_instr, ctx, value, &res)) {
res = sym_new_type(ctx, &PyBool_Type);
OUT_OF_SPACE_IF_NULL(res);
}
}
op(_TO_BOOL_BOOL, (value -- res)) {
if (optimize_to_bool(this_instr, ctx, value, &res)) {
OUT_OF_SPACE_IF_NULL(res);
}
else {
if(!sym_set_type(value, &PyBool_Type)) {
goto hit_bottom;
}
if (!optimize_to_bool(this_instr, ctx, value, &res)) {
sym_set_type(value, &PyBool_Type);
res = value;
}
}
op(_TO_BOOL_INT, (value -- res)) {
if (optimize_to_bool(this_instr, ctx, value, &res)) {
OUT_OF_SPACE_IF_NULL(res);
}
else {
if(!sym_set_type(value, &PyLong_Type)) {
goto hit_bottom;
}
OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyBool_Type));
if (!optimize_to_bool(this_instr, ctx, value, &res)) {
sym_set_type(value, &PyLong_Type);
res = sym_new_type(ctx, &PyBool_Type);
}
}
op(_TO_BOOL_LIST, (value -- res)) {
if (optimize_to_bool(this_instr, ctx, value, &res)) {
OUT_OF_SPACE_IF_NULL(res);
}
else {
if(!sym_set_type(value, &PyList_Type)) {
goto hit_bottom;
}
OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyBool_Type));
if (!optimize_to_bool(this_instr, ctx, value, &res)) {
sym_set_type(value, &PyList_Type);
res = sym_new_type(ctx, &PyBool_Type);
}
}
op(_TO_BOOL_NONE, (value -- res)) {
if (optimize_to_bool(this_instr, ctx, value, &res)) {
OUT_OF_SPACE_IF_NULL(res);
}
else {
if (!sym_set_const(value, Py_None)) {
goto hit_bottom;
}
OUT_OF_SPACE_IF_NULL(res = sym_new_const(ctx, Py_False));
if (!optimize_to_bool(this_instr, ctx, value, &res)) {
sym_set_const(value, Py_None);
res = sym_new_const(ctx, Py_False);
}
}
op(_TO_BOOL_STR, (value -- res)) {
if (optimize_to_bool(this_instr, ctx, value, &res)) {
OUT_OF_SPACE_IF_NULL(res);
}
else {
OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyBool_Type));
if(!sym_set_type(value, &PyUnicode_Type)) {
goto hit_bottom;
}
if (!optimize_to_bool(this_instr, ctx, value, &res)) {
res = sym_new_type(ctx, &PyBool_Type);
sym_set_type(value, &PyUnicode_Type);
}
}
@ -400,66 +349,66 @@ dummy_func(void) {
(void)left;
(void)right;
if (oparg & 16) {
OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyBool_Type));
res = sym_new_type(ctx, &PyBool_Type);
}
else {
OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_not_null(ctx));
res = _Py_uop_sym_new_not_null(ctx);
}
}
op(_COMPARE_OP_INT, (left, right -- res)) {
(void)left;
(void)right;
OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyBool_Type));
res = sym_new_type(ctx, &PyBool_Type);
}
op(_COMPARE_OP_FLOAT, (left, right -- res)) {
(void)left;
(void)right;
OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyBool_Type));
res = sym_new_type(ctx, &PyBool_Type);
}
op(_COMPARE_OP_STR, (left, right -- res)) {
(void)left;
(void)right;
OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyBool_Type));
res = sym_new_type(ctx, &PyBool_Type);
}
op(_IS_OP, (left, right -- res)) {
(void)left;
(void)right;
OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyBool_Type));
res = sym_new_type(ctx, &PyBool_Type);
}
op(_CONTAINS_OP, (left, right -- res)) {
(void)left;
(void)right;
OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyBool_Type));
res = sym_new_type(ctx, &PyBool_Type);
}
op(_LOAD_CONST, (-- value)) {
PyObject *val = PyTuple_GET_ITEM(co->co_consts, this_instr->oparg);
int opcode = _Py_IsImmortal(val) ? _LOAD_CONST_INLINE_BORROW : _LOAD_CONST_INLINE;
REPLACE_OP(this_instr, opcode, 0, (uintptr_t)val);
OUT_OF_SPACE_IF_NULL(value = sym_new_const(ctx, val));
value = sym_new_const(ctx, val);
}
op(_LOAD_CONST_INLINE, (ptr/4 -- value)) {
OUT_OF_SPACE_IF_NULL(value = sym_new_const(ctx, ptr));
value = sym_new_const(ctx, ptr);
}
op(_LOAD_CONST_INLINE_BORROW, (ptr/4 -- value)) {
OUT_OF_SPACE_IF_NULL(value = sym_new_const(ctx, ptr));
value = sym_new_const(ctx, ptr);
}
op(_LOAD_CONST_INLINE_WITH_NULL, (ptr/4 -- value, null)) {
OUT_OF_SPACE_IF_NULL(value = sym_new_const(ctx, ptr));
OUT_OF_SPACE_IF_NULL(null = sym_new_null(ctx));
value = sym_new_const(ctx, ptr);
null = sym_new_null(ctx);
}
op(_LOAD_CONST_INLINE_BORROW_WITH_NULL, (ptr/4 -- value, null)) {
OUT_OF_SPACE_IF_NULL(value = sym_new_const(ctx, ptr));
OUT_OF_SPACE_IF_NULL(null = sym_new_null(ctx));
value = sym_new_const(ctx, ptr);
null = sym_new_null(ctx);
}
op(_COPY, (bottom, unused[oparg-1] -- bottom, unused[oparg-1], top)) {
@ -472,7 +421,8 @@ dummy_func(void) {
}
op(_LOAD_ATTR_INSTANCE_VALUE, (index/1, owner -- attr, null if (oparg & 1))) {
_LOAD_ATTR_NOT_NULL
attr = sym_new_not_null(ctx);
null = sym_new_null(ctx);
(void)index;
(void)owner;
}
@ -496,15 +446,15 @@ dummy_func(void) {
op(_LOAD_ATTR, (owner -- attr, self_or_null if (oparg & 1))) {
(void)owner;
OUT_OF_SPACE_IF_NULL(attr = sym_new_not_null(ctx));
attr = sym_new_not_null(ctx);
if (oparg & 1) {
OUT_OF_SPACE_IF_NULL(self_or_null = sym_new_unknown(ctx));
self_or_null = sym_new_unknown(ctx);
}
}
op(_LOAD_ATTR_MODULE, (index/1, owner -- attr, null if (oparg & 1))) {
(void)index;
OUT_OF_SPACE_IF_NULL(null = sym_new_null(ctx));
null = sym_new_null(ctx);
attr = NULL;
if (this_instr[-1].opcode == _NOP) {
// Preceding _CHECK_ATTR_MODULE was removed: mod is const and dict is watched.
@ -515,72 +465,69 @@ dummy_func(void) {
PyObject *res = convert_global_to_const(this_instr, dict);
if (res != NULL) {
this_instr[-1].opcode = _POP_TOP;
OUT_OF_SPACE_IF_NULL(attr = sym_new_const(ctx, res));
attr = sym_new_const(ctx, res);
}
}
if (attr == NULL) {
/* No conversion made. We don't know what `attr` is. */
OUT_OF_SPACE_IF_NULL(attr = sym_new_not_null(ctx));
attr = sym_new_not_null(ctx);
}
}
op(_LOAD_ATTR_WITH_HINT, (hint/1, owner -- attr, null if (oparg & 1))) {
_LOAD_ATTR_NOT_NULL
attr = sym_new_not_null(ctx);
null = sym_new_null(ctx);
(void)hint;
(void)owner;
}
op(_LOAD_ATTR_SLOT, (index/1, owner -- attr, null if (oparg & 1))) {
_LOAD_ATTR_NOT_NULL
attr = sym_new_not_null(ctx);
null = sym_new_null(ctx);
(void)index;
(void)owner;
}
op(_LOAD_ATTR_CLASS, (descr/4, owner -- attr, null if (oparg & 1))) {
_LOAD_ATTR_NOT_NULL
attr = sym_new_not_null(ctx);
null = sym_new_null(ctx);
(void)descr;
(void)owner;
}
op(_LOAD_ATTR_METHOD_WITH_VALUES, (descr/4, owner -- attr, self if (1))) {
(void)descr;
OUT_OF_SPACE_IF_NULL(attr = sym_new_not_null(ctx));
attr = sym_new_not_null(ctx);
self = owner;
}
op(_LOAD_ATTR_METHOD_NO_DICT, (descr/4, owner -- attr, self if (1))) {
(void)descr;
OUT_OF_SPACE_IF_NULL(attr = sym_new_not_null(ctx));
attr = sym_new_not_null(ctx);
self = owner;
}
op(_LOAD_ATTR_METHOD_LAZY_DICT, (descr/4, owner -- attr, self if (1))) {
(void)descr;
OUT_OF_SPACE_IF_NULL(attr = sym_new_not_null(ctx));
attr = sym_new_not_null(ctx);
self = owner;
}
op(_INIT_CALL_BOUND_METHOD_EXACT_ARGS, (callable, unused, unused[oparg] -- func, self, unused[oparg])) {
(void)callable;
OUT_OF_SPACE_IF_NULL(func = sym_new_not_null(ctx));
OUT_OF_SPACE_IF_NULL(self = sym_new_not_null(ctx));
func = sym_new_not_null(ctx);
self = sym_new_not_null(ctx);
}
op(_CHECK_FUNCTION_EXACT_ARGS, (func_version/2, callable, self_or_null, unused[oparg] -- callable, self_or_null, unused[oparg])) {
if (!sym_set_type(callable, &PyFunction_Type)) {
goto hit_bottom;
}
sym_set_type(callable, &PyFunction_Type);
(void)self_or_null;
(void)func_version;
}
op(_CHECK_CALL_BOUND_METHOD_EXACT_ARGS, (callable, null, unused[oparg] -- callable, null, unused[oparg])) {
if (!sym_set_null(null)) {
goto hit_bottom;
}
if (!sym_set_type(callable, &PyMethod_Type)) {
goto hit_bottom;
}
sym_set_null(null);
sym_set_type(callable, &PyMethod_Type);
}
op(_INIT_CALL_PY_EXACT_ARGS, (callable, self_or_null, args[oparg] -- new_frame: _Py_UOpsAbstractFrame *)) {
@ -602,7 +549,8 @@ dummy_func(void) {
if (func == NULL) {
DPRINTF(3, "\n");
DPRINTF(1, "Missing function\n");
goto done;
ctx->done = true;
break;
}
co = (PyCodeObject *)func->func_code;
DPRINTF(3, "code=%p ", co);
@ -625,8 +573,7 @@ dummy_func(void) {
localsplus_start = args;
n_locals_already_filled = argcount;
}
OUT_OF_SPACE_IF_NULL(new_frame =
frame_new(ctx, co, localsplus_start, n_locals_already_filled, 0));
new_frame = frame_new(ctx, co, localsplus_start, n_locals_already_filled, 0);
}
op(_PY_FRAME_GENERAL, (callable, self_or_null, args[oparg] -- new_frame: _Py_UOpsAbstractFrame *)) {
@ -635,7 +582,8 @@ dummy_func(void) {
(void)self_or_null;
(void)args;
first_valid_check_stack = NULL;
goto done;
new_frame = NULL;
ctx->done = true;
}
op(_POP_FRAME, (retval -- res)) {
@ -656,7 +604,7 @@ dummy_func(void) {
co = get_code(this_instr);
if (co == NULL) {
// might be impossible, but bailing is still safe
goto done;
ctx->done = true;
}
}
@ -665,7 +613,7 @@ dummy_func(void) {
ctx->frame->stack_pointer = stack_pointer;
frame_pop(ctx);
stack_pointer = ctx->frame->stack_pointer;
OUT_OF_SPACE_IF_NULL(res = sym_new_unknown(ctx));
res = sym_new_unknown(ctx);
/* Stack space handling */
assert(corresponding_check_stack == NULL);
@ -678,17 +626,17 @@ dummy_func(void) {
co = get_code(this_instr);
if (co == NULL) {
// might be impossible, but bailing is still safe
goto done;
ctx->done = true;
}
}
op(_YIELD_VALUE, (unused -- res)) {
OUT_OF_SPACE_IF_NULL(res = sym_new_unknown(ctx));
res = sym_new_unknown(ctx);
}
op(_FOR_ITER_GEN_FRAME, ( -- )) {
/* We are about to hit the end of the trace */
goto done;
ctx->done = true;
}
op(_CHECK_STACK_SPACE, ( --)) {
@ -712,7 +660,8 @@ dummy_func(void) {
co = get_code(this_instr);
if (co == NULL) {
// should be about to _EXIT_TRACE anyway
goto done;
ctx->done = true;
break;
}
/* Stack space handling */
@ -721,7 +670,8 @@ dummy_func(void) {
curr_space += framesize;
if (curr_space < 0 || curr_space > INT32_MAX) {
// won't fit in signed 32-bit int
goto done;
ctx->done = true;
break;
}
max_space = curr_space > max_space ? curr_space : max_space;
if (first_valid_check_stack == NULL) {
@ -738,7 +688,7 @@ dummy_func(void) {
/* This has to be done manually */
(void)seq;
for (int i = 0; i < oparg; i++) {
OUT_OF_SPACE_IF_NULL(values[i] = sym_new_unknown(ctx));
values[i] = sym_new_unknown(ctx);
}
}
@ -747,12 +697,12 @@ dummy_func(void) {
(void)seq;
int totalargs = (oparg & 0xFF) + (oparg >> 8) + 1;
for (int i = 0; i < totalargs; i++) {
OUT_OF_SPACE_IF_NULL(values[i] = sym_new_unknown(ctx));
values[i] = sym_new_unknown(ctx);
}
}
op(_ITER_NEXT_RANGE, (iter -- iter, next)) {
OUT_OF_SPACE_IF_NULL(next = sym_new_type(ctx, &PyLong_Type));
next = sym_new_type(ctx, &PyLong_Type);
(void)iter;
}
@ -805,11 +755,11 @@ dummy_func(void) {
}
op(_JUMP_TO_TOP, (--)) {
goto done;
ctx->done = true;
}
op(_EXIT_TRACE, (--)) {
goto done;
ctx->done = true;
}