mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-07-19 09:15:34 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

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

80
Python/optimizer_analysis.c
View file

@ -297,20 +297,6 @@ remove_globals(_PyInterpreterFrame *frame, _PyUOpInstruction *buffer,
INST->oparg = ARG; \
INST->operand = OPERAND;
#define OUT_OF_SPACE_IF_NULL(EXPR) \
do { \
if ((EXPR) == NULL) { \
goto out_of_space; \
} \
} while (0);
#define _LOAD_ATTR_NOT_NULL \
do { \
OUT_OF_SPACE_IF_NULL(attr = _Py_uop_sym_new_not_null(ctx)); \
OUT_OF_SPACE_IF_NULL(null = _Py_uop_sym_new_null(ctx)); \
} while (0);
/* Shortened forms for convenience, used in optimizer_bytecodes.c */
#define sym_is_not_null _Py_uop_sym_is_not_null
#define sym_is_const _Py_uop_sym_is_const
@ -324,10 +310,10 @@ remove_globals(_PyInterpreterFrame *frame, _PyUOpInstruction *buffer,
#define sym_has_type _Py_uop_sym_has_type
#define sym_get_type _Py_uop_sym_get_type
#define sym_matches_type _Py_uop_sym_matches_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 sym_truthiness _Py_uop_sym_truthiness
#define frame_new _Py_uop_frame_new
@ -408,18 +394,20 @@ optimize_uops(
_PyUOpInstruction *first_valid_check_stack = NULL;
_PyUOpInstruction *corresponding_check_stack = NULL;
if (_Py_uop_abstractcontext_init(ctx) < 0) {
goto out_of_space;
}
_Py_uop_abstractcontext_init(ctx);
_Py_UOpsAbstractFrame *frame = _Py_uop_frame_new(ctx, co, ctx->n_consumed, 0, curr_stacklen);
if (frame == NULL) {
return -1;
}
ctx->curr_frame_depth++;
ctx->frame = frame;
ctx->done = false;
ctx->out_of_space = false;
ctx->contradiction = false;
_PyUOpInstruction *this_instr = NULL;
for (int i = 0; i < trace_len; i++) {
for (int i = 0; !ctx->done; i++) {
assert(i < trace_len);
this_instr = &trace[i];
int oparg = this_instr->oparg;
@ -447,32 +435,22 @@ optimize_uops(
ctx->frame->stack_pointer = stack_pointer;
assert(STACK_LEVEL() >= 0);
}
Py_UNREACHABLE();
out_of_space:
DPRINTF(3, "\n");
DPRINTF(1, "Out of space in abstract interpreter\n");
goto done;
error:
DPRINTF(3, "\n");
DPRINTF(1, "Encountered error in abstract interpreter\n");
if (opcode <= MAX_UOP_ID) {
OPT_ERROR_IN_OPCODE(opcode);
if (ctx->out_of_space) {
DPRINTF(3, "\n");
DPRINTF(1, "Out of space in abstract interpreter\n");
}
if (ctx->contradiction) {
// Attempted to push a "bottom" (contradiction) symbol onto the stack.
// This means that the abstract interpreter has hit unreachable code.
// We *could* generate an _EXIT_TRACE or _FATAL_ERROR here, but hitting
// bottom indicates type instability, so we are probably better off
// retrying later.
DPRINTF(3, "\n");
DPRINTF(1, "Hit bottom in abstract interpreter\n");
_Py_uop_abstractcontext_fini(ctx);
return 0;
}
_Py_uop_abstractcontext_fini(ctx);
return -1;
hit_bottom:
// Attempted to push a "bottom" (contradition) symbol onto the stack.
// This means that the abstract interpreter has hit unreachable code.
// We *could* generate an _EXIT_TRACE or _FATAL_ERROR here, but hitting
// bottom indicates type instability, so we are probably better off
// retrying later.
DPRINTF(3, "\n");
DPRINTF(1, "Hit bottom in abstract interpreter\n");
_Py_uop_abstractcontext_fini(ctx);
return 0;
done:
/* Either reached the end or cannot optimize further, but there
* would be no benefit in retrying later */
_Py_uop_abstractcontext_fini(ctx);
@ -485,6 +463,16 @@ done:
first_valid_check_stack->operand = max_space;
}
return trace_len;
error:
DPRINTF(3, "\n");
DPRINTF(1, "Encountered error in abstract interpreter\n");
if (opcode <= MAX_UOP_ID) {
OPT_ERROR_IN_OPCODE(opcode);
}
_Py_uop_abstractcontext_fini(ctx);
return -1;
}

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

309
Python/optimizer_cases.c.h generated
View file

File diff suppressed because it is too large Load diff

106
Python/optimizer_symbols.c
View file

@ -32,6 +32,7 @@
// Flags for below.
#define IS_NULL 1 << 0
#define NOT_NULL 1 << 1
#define NO_SPACE 1 << 2
#ifdef Py_DEBUG
static inline int get_lltrace(void) {
@ -48,6 +49,20 @@ static inline int get_lltrace(void) {
#define DPRINTF(level, ...)
#endif
static _Py_UopsSymbol NO_SPACE_SYMBOL = {
.flags = IS_NULL | NOT_NULL | NO_SPACE,
.typ = NULL,
.const_val = NULL
};
_Py_UopsSymbol *
out_of_space(_Py_UOpsContext *ctx)
{
ctx->done = true;
ctx->out_of_space = true;
return &NO_SPACE_SYMBOL;
}
static _Py_UopsSymbol *
sym_new(_Py_UOpsContext *ctx)
{
@ -72,11 +87,13 @@ sym_set_flag(_Py_UopsSymbol *sym, int flag)
}
static inline void
sym_set_bottom(_Py_UopsSymbol *sym)
sym_set_bottom(_Py_UOpsContext *ctx, _Py_UopsSymbol *sym)
{
sym_set_flag(sym, IS_NULL | NOT_NULL);
sym->typ = NULL;
Py_CLEAR(sym->const_val);
ctx->done = true;
ctx->contradiction = true;
}
bool
@ -115,45 +132,41 @@ _Py_uop_sym_get_const(_Py_UopsSymbol *sym)
return sym->const_val;
}
bool
_Py_uop_sym_set_type(_Py_UopsSymbol *sym, PyTypeObject *typ)
void
_Py_uop_sym_set_type(_Py_UOpsContext *ctx, _Py_UopsSymbol *sym, PyTypeObject *typ)
{
assert(typ != NULL && PyType_Check(typ));
if (sym->flags & IS_NULL) {
sym_set_bottom(sym);
return false;
sym_set_bottom(ctx, sym);
return;
}
if (sym->typ != NULL) {
if (sym->typ != typ) {
sym_set_bottom(sym);
return false;
sym_set_bottom(ctx, sym);
return;
}
}
else {
sym_set_flag(sym, NOT_NULL);
sym->typ = typ;
}
return true;
}
bool
_Py_uop_sym_set_const(_Py_UopsSymbol *sym, PyObject *const_val)
void
_Py_uop_sym_set_const(_Py_UOpsContext *ctx, _Py_UopsSymbol *sym, PyObject *const_val)
{
assert(const_val != NULL);
if (sym->flags & IS_NULL) {
sym_set_bottom(sym);
return false;
sym_set_bottom(ctx, sym);
}
PyTypeObject *typ = Py_TYPE(const_val);
if (sym->typ != NULL && sym->typ != typ) {
sym_set_bottom(sym);
return false;
sym_set_bottom(ctx, sym);
}
if (sym->const_val != NULL) {
if (sym->const_val != const_val) {
// TODO: What if they're equal?
sym_set_bottom(sym);
return false;
sym_set_bottom(ctx, sym);
}
}
else {
@ -161,29 +174,24 @@ _Py_uop_sym_set_const(_Py_UopsSymbol *sym, PyObject *const_val)
sym->typ = typ;
sym->const_val = Py_NewRef(const_val);
}
return true;
}
bool
_Py_uop_sym_set_null(_Py_UopsSymbol *sym)
void
_Py_uop_sym_set_null(_Py_UOpsContext *ctx, _Py_UopsSymbol *sym)
{
if (_Py_uop_sym_is_not_null(sym)) {
sym_set_bottom(sym);
return false;
sym_set_bottom(ctx, sym);
}
sym_set_flag(sym, IS_NULL);
return true;
}
bool
_Py_uop_sym_set_non_null(_Py_UopsSymbol *sym)
void
_Py_uop_sym_set_non_null(_Py_UOpsContext *ctx, _Py_UopsSymbol *sym)
{
if (_Py_uop_sym_is_null(sym)) {
sym_set_bottom(sym);
return false;
sym_set_bottom(ctx, sym);
}
sym_set_flag(sym, NOT_NULL);
return true;
}
@ -198,7 +206,7 @@ _Py_uop_sym_new_not_null(_Py_UOpsContext *ctx)
{
_Py_UopsSymbol *res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) {
return NULL;
return out_of_space(ctx);
}
sym_set_flag(res, NOT_NULL);
return res;
@ -209,9 +217,9 @@ _Py_uop_sym_new_type(_Py_UOpsContext *ctx, PyTypeObject *typ)
{
_Py_UopsSymbol *res = sym_new(ctx);
if (res == NULL) {
return NULL;
return out_of_space(ctx);
}
_Py_uop_sym_set_type(res, typ);
_Py_uop_sym_set_type(ctx, res, typ);
return res;
}
@ -222,9 +230,9 @@ _Py_uop_sym_new_const(_Py_UOpsContext *ctx, PyObject *const_val)
assert(const_val != NULL);
_Py_UopsSymbol *res = sym_new(ctx);
if (res == NULL) {
return NULL;
return out_of_space(ctx);
}
_Py_uop_sym_set_const(res, const_val);
_Py_uop_sym_set_const(ctx, res, const_val);
return res;
}
@ -233,9 +241,9 @@ _Py_uop_sym_new_null(_Py_UOpsContext *ctx)
{
_Py_UopsSymbol *null_sym = _Py_uop_sym_new_unknown(ctx);
if (null_sym == NULL) {
return NULL;
return out_of_space(ctx);
}
_Py_uop_sym_set_null(null_sym);
_Py_uop_sym_set_null(ctx, null_sym);
return null_sym;
}
@ -318,6 +326,8 @@ _Py_uop_frame_new(
frame->stack_pointer = frame->stack + curr_stackentries;
ctx->n_consumed = localsplus_start + (co->co_nlocalsplus + co->co_stacksize);
if (ctx->n_consumed >= ctx->limit) {
ctx->done = true;
ctx->out_of_space = true;
return NULL;
}
@ -325,9 +335,6 @@ _Py_uop_frame_new(
// Initialize with the initial state of all local variables
for (int i = n_locals_already_filled; i < co->co_nlocalsplus; i++) {
_Py_UopsSymbol *local = _Py_uop_sym_new_unknown(ctx);
if (local == NULL) {
return NULL;
}
frame->locals[i] = local;
}
@ -335,9 +342,6 @@ _Py_uop_frame_new(
// Initialize the stack as well
for (int i = 0; i < curr_stackentries; i++) {
_Py_UopsSymbol *stackvar = _Py_uop_sym_new_unknown(ctx);
if (stackvar == NULL) {
return NULL;
}
frame->stack[i] = stackvar;
}
@ -357,7 +361,7 @@ _Py_uop_abstractcontext_fini(_Py_UOpsContext *ctx)
}
}
int
void
_Py_uop_abstractcontext_init(_Py_UOpsContext *ctx)
{
ctx->limit = ctx->locals_and_stack + MAX_ABSTRACT_INTERP_SIZE;
@ -374,8 +378,6 @@ _Py_uop_abstractcontext_init(_Py_UOpsContext *ctx)
// Frame setup
ctx->curr_frame_depth = 0;
return 0;
}
int
@ -404,8 +406,8 @@ static _Py_UopsSymbol *
make_bottom(_Py_UOpsContext *ctx)
{
_Py_UopsSymbol *sym = _Py_uop_sym_new_unknown(ctx);
_Py_uop_sym_set_null(sym);
_Py_uop_sym_set_non_null(sym);
_Py_uop_sym_set_null(ctx, sym);
_Py_uop_sym_set_non_null(ctx, sym);
return sym;
}
@ -452,10 +454,10 @@ _Py_uop_symbols_test(PyObject *Py_UNUSED(self), PyObject *Py_UNUSED(ignored))
TEST_PREDICATE(!_Py_uop_sym_is_const(sym), "int is a constant");
TEST_PREDICATE(_Py_uop_sym_get_const(sym) == NULL, "int as constant is not NULL");
_Py_uop_sym_set_type(sym, &PyLong_Type); // Should be a no-op
_Py_uop_sym_set_type(ctx, sym, &PyLong_Type); // Should be a no-op
TEST_PREDICATE(_Py_uop_sym_matches_type(sym, &PyLong_Type), "(int and int) isn't int");
_Py_uop_sym_set_type(sym, &PyFloat_Type); // Should make it bottom
_Py_uop_sym_set_type(ctx, sym, &PyFloat_Type); // Should make it bottom
TEST_PREDICATE(_Py_uop_sym_is_bottom(sym), "(int and float) isn't bottom");
val_42 = PyLong_FromLong(42);
@ -470,7 +472,7 @@ _Py_uop_symbols_test(PyObject *Py_UNUSED(self), PyObject *Py_UNUSED(ignored))
if (sym == NULL) {
goto fail;
}
_Py_uop_sym_set_const(sym, val_42);
_Py_uop_sym_set_const(ctx, sym, val_42);
TEST_PREDICATE(_Py_uop_sym_truthiness(sym) == 1, "bool(42) is not True");
TEST_PREDICATE(!_Py_uop_sym_is_null(sym), "42 is NULL");
TEST_PREDICATE(_Py_uop_sym_is_not_null(sym), "42 isn't not NULL");
@ -480,19 +482,19 @@ _Py_uop_symbols_test(PyObject *Py_UNUSED(self), PyObject *Py_UNUSED(ignored))
TEST_PREDICATE(_Py_uop_sym_get_const(sym) != NULL, "42 as constant is NULL");
TEST_PREDICATE(_Py_uop_sym_get_const(sym) == val_42, "42 as constant isn't 42");
_Py_uop_sym_set_type(sym, &PyLong_Type); // Should be a no-op
_Py_uop_sym_set_type(ctx, sym, &PyLong_Type); // Should be a no-op
TEST_PREDICATE(_Py_uop_sym_matches_type(sym, &PyLong_Type), "(42 and 42) isn't an int");
TEST_PREDICATE(_Py_uop_sym_get_const(sym) == val_42, "(42 and 42) as constant isn't 42");
_Py_uop_sym_set_type(sym, &PyFloat_Type); // Should make it bottom
_Py_uop_sym_set_type(ctx, sym, &PyFloat_Type); // Should make it bottom
TEST_PREDICATE(_Py_uop_sym_is_bottom(sym), "(42 and float) isn't bottom");
sym = _Py_uop_sym_new_type(ctx, &PyLong_Type);
if (sym == NULL) {
goto fail;
}
_Py_uop_sym_set_const(sym, val_42);
_Py_uop_sym_set_const(sym, val_43); // Should make it bottom
_Py_uop_sym_set_const(ctx, sym, val_42);
_Py_uop_sym_set_const(ctx, sym, val_43); // Should make it bottom
TEST_PREDICATE(_Py_uop_sym_is_bottom(sym), "(42 and 43) isn't bottom");