#include "Python.h"
+#include "pycore_optimizer.h"
#include "pycore_uops.h"
#include "pycore_uop_ids.h"
#include "internal/pycore_moduleobject.h"
#define op(name, ...) /* NAME is ignored */
-typedef struct _Py_UOpsSymType _Py_UOpsSymType;
-typedef struct _Py_UOpsAbstractInterpContext _Py_UOpsAbstractInterpContext;
+typedef struct _Py_UopsSymbol _Py_UopsSymbol;
+typedef struct _Py_UOpsContext _Py_UOpsContext;
typedef struct _Py_UOpsAbstractFrame _Py_UOpsAbstractFrame;
+/* Shortened forms for convenience */
+#define sym_is_not_null _Py_uop_sym_is_not_null
+#define sym_is_const _Py_uop_sym_is_const
+#define sym_get_const _Py_uop_sym_get_const
+#define sym_new_unknown _Py_uop_sym_new_unknown
+#define sym_new_not_null _Py_uop_sym_new_not_null
+#define sym_new_type _Py_uop_sym_new_type
+#define sym_is_null _Py_uop_sym_is_null
+#define sym_new_const _Py_uop_sym_new_const
+#define sym_new_null _Py_uop_sym_new_null
+#define sym_matches_type _Py_uop_sym_matches_type
+#define sym_set_null _Py_uop_sym_set_null
+#define sym_set_type _Py_uop_sym_set_type
+#define frame_new _Py_uop_frame_new
+#define frame_pop _Py_uop_frame_pop
+
static int
dummy_func(void) {
PyCodeObject *code;
int oparg;
- _Py_UOpsSymType *flag;
- _Py_UOpsSymType *left;
- _Py_UOpsSymType *right;
- _Py_UOpsSymType *value;
- _Py_UOpsSymType *res;
- _Py_UOpsSymType *iter;
- _Py_UOpsSymType *top;
- _Py_UOpsSymType *bottom;
+ _Py_UopsSymbol *flag;
+ _Py_UopsSymbol *left;
+ _Py_UopsSymbol *right;
+ _Py_UopsSymbol *value;
+ _Py_UopsSymbol *res;
+ _Py_UopsSymbol *iter;
+ _Py_UopsSymbol *top;
+ _Py_UopsSymbol *bottom;
_Py_UOpsAbstractFrame *frame;
- _Py_UOpsAbstractInterpContext *ctx;
+ _Py_UOpsContext *ctx;
_PyUOpInstruction *this_instr;
_PyBloomFilter *dependencies;
int modified;
op(_LOAD_FAST_CHECK, (-- value)) {
value = GETLOCAL(oparg);
// We guarantee this will error - just bail and don't optimize it.
- if (_Py_uop_sym_is_null(value)) {
+ if (sym_is_null(value)) {
goto out_of_space;
}
}
op(_LOAD_FAST_AND_CLEAR, (-- value)) {
value = GETLOCAL(oparg);
- _Py_UOpsSymType *temp;
- OUT_OF_SPACE_IF_NULL(temp = _Py_uop_sym_new_null(ctx));
+ _Py_UopsSymbol *temp;
+ OUT_OF_SPACE_IF_NULL(temp = sym_new_null(ctx));
GETLOCAL(oparg) = temp;
}
}
op(_PUSH_NULL, (-- res)) {
- res = _Py_uop_sym_new_null(ctx);
+ res = sym_new_null(ctx);
if (res == NULL) {
goto out_of_space;
};
}
op(_GUARD_BOTH_INT, (left, right -- left, right)) {
- if (_Py_uop_sym_matches_type(left, &PyLong_Type) &&
- _Py_uop_sym_matches_type(right, &PyLong_Type)) {
+ if (sym_matches_type(left, &PyLong_Type) &&
+ sym_matches_type(right, &PyLong_Type)) {
REPLACE_OP(this_instr, _NOP, 0, 0);
}
- _Py_uop_sym_set_type(left, &PyLong_Type);
- _Py_uop_sym_set_type(right, &PyLong_Type);
+ sym_set_type(left, &PyLong_Type);
+ sym_set_type(right, &PyLong_Type);
}
op(_GUARD_BOTH_FLOAT, (left, right -- left, right)) {
- if (_Py_uop_sym_matches_type(left, &PyFloat_Type) &&
- _Py_uop_sym_matches_type(right, &PyFloat_Type)) {
+ if (sym_matches_type(left, &PyFloat_Type) &&
+ sym_matches_type(right, &PyFloat_Type)) {
REPLACE_OP(this_instr, _NOP, 0 ,0);
}
- _Py_uop_sym_set_type(left, &PyFloat_Type);
- _Py_uop_sym_set_type(right, &PyFloat_Type);
+ sym_set_type(left, &PyFloat_Type);
+ sym_set_type(right, &PyFloat_Type);
}
op(_GUARD_BOTH_UNICODE, (left, right -- left, right)) {
- if (_Py_uop_sym_matches_type(left, &PyUnicode_Type) &&
- _Py_uop_sym_matches_type(right, &PyUnicode_Type)) {
+ if (sym_matches_type(left, &PyUnicode_Type) &&
+ sym_matches_type(right, &PyUnicode_Type)) {
REPLACE_OP(this_instr, _NOP, 0 ,0);
}
- _Py_uop_sym_set_type(left, &PyUnicode_Type);
- _Py_uop_sym_set_type(right, &PyUnicode_Type);
+ sym_set_type(left, &PyUnicode_Type);
+ sym_set_type(right, &PyUnicode_Type);
}
op(_BINARY_OP_ADD_INT, (left, right -- res)) {
- if (_Py_uop_sym_is_const(left) && _Py_uop_sym_is_const(right)) {
- assert(PyLong_CheckExact(_Py_uop_sym_get_const(left)));
- assert(PyLong_CheckExact(_Py_uop_sym_get_const(right)));
- PyObject *temp = _PyLong_Add((PyLongObject *)_Py_uop_sym_get_const(left),
- (PyLongObject *)_Py_uop_sym_get_const(right));
+ if (sym_is_const(left) && sym_is_const(right)) {
+ assert(PyLong_CheckExact(sym_get_const(left)));
+ assert(PyLong_CheckExact(sym_get_const(right)));
+ PyObject *temp = _PyLong_Add((PyLongObject *)sym_get_const(left),
+ (PyLongObject *)sym_get_const(right));
if (temp == NULL) {
goto error;
}
- OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_const(ctx, temp));
+ OUT_OF_SPACE_IF_NULL(res = sym_new_const(ctx, temp));
// TODO gh-115506:
// replace opcode with constant propagated one and add tests!
}
else {
- OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_type(ctx, &PyLong_Type));
+ OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyLong_Type));
}
}
op(_BINARY_OP_SUBTRACT_INT, (left, right -- res)) {
- if (_Py_uop_sym_is_const(left) && _Py_uop_sym_is_const(right)) {
- assert(PyLong_CheckExact(_Py_uop_sym_get_const(left)));
- assert(PyLong_CheckExact(_Py_uop_sym_get_const(right)));
- PyObject *temp = _PyLong_Subtract((PyLongObject *)_Py_uop_sym_get_const(left),
- (PyLongObject *)_Py_uop_sym_get_const(right));
+ if (sym_is_const(left) && sym_is_const(right)) {
+ assert(PyLong_CheckExact(sym_get_const(left)));
+ assert(PyLong_CheckExact(sym_get_const(right)));
+ PyObject *temp = _PyLong_Subtract((PyLongObject *)sym_get_const(left),
+ (PyLongObject *)sym_get_const(right));
if (temp == NULL) {
goto error;
}
- OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_const(ctx, temp));
+ OUT_OF_SPACE_IF_NULL(res = sym_new_const(ctx, temp));
// TODO gh-115506:
// replace opcode with constant propagated one and add tests!
}
else {
- OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_type(ctx, &PyLong_Type));
+ OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyLong_Type));
}
}
op(_BINARY_OP_MULTIPLY_INT, (left, right -- res)) {
- if (_Py_uop_sym_is_const(left) && _Py_uop_sym_is_const(right)) {
- assert(PyLong_CheckExact(_Py_uop_sym_get_const(left)));
- assert(PyLong_CheckExact(_Py_uop_sym_get_const(right)));
- PyObject *temp = _PyLong_Multiply((PyLongObject *)_Py_uop_sym_get_const(left),
- (PyLongObject *)_Py_uop_sym_get_const(right));
+ if (sym_is_const(left) && sym_is_const(right)) {
+ assert(PyLong_CheckExact(sym_get_const(left)));
+ assert(PyLong_CheckExact(sym_get_const(right)));
+ PyObject *temp = _PyLong_Multiply((PyLongObject *)sym_get_const(left),
+ (PyLongObject *)sym_get_const(right));
if (temp == NULL) {
goto error;
}
- OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_const(ctx, temp));
+ OUT_OF_SPACE_IF_NULL(res = sym_new_const(ctx, temp));
// TODO gh-115506:
// replace opcode with constant propagated one and add tests!
}
else {
- OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_type(ctx, &PyLong_Type));
+ OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyLong_Type));
}
}
op(_BINARY_OP_ADD_FLOAT, (left, right -- res)) {
- if (_Py_uop_sym_is_const(left) && _Py_uop_sym_is_const(right)) {
- assert(PyFloat_CheckExact(_Py_uop_sym_get_const(left)));
- assert(PyFloat_CheckExact(_Py_uop_sym_get_const(right)));
+ if (sym_is_const(left) && sym_is_const(right)) {
+ assert(PyFloat_CheckExact(sym_get_const(left)));
+ assert(PyFloat_CheckExact(sym_get_const(right)));
PyObject *temp = PyFloat_FromDouble(
- PyFloat_AS_DOUBLE(_Py_uop_sym_get_const(left)) +
- PyFloat_AS_DOUBLE(_Py_uop_sym_get_const(right)));
+ PyFloat_AS_DOUBLE(sym_get_const(left)) +
+ PyFloat_AS_DOUBLE(sym_get_const(right)));
if (temp == NULL) {
goto error;
}
- res = _Py_uop_sym_new_const(ctx, temp);
+ res = sym_new_const(ctx, temp);
// TODO gh-115506:
// replace opcode with constant propagated one and update tests!
}
else {
- OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_type(ctx, &PyFloat_Type));
+ OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyFloat_Type));
}
}
op(_BINARY_OP_SUBTRACT_FLOAT, (left, right -- res)) {
- if (_Py_uop_sym_is_const(left) && _Py_uop_sym_is_const(right)) {
- assert(PyFloat_CheckExact(_Py_uop_sym_get_const(left)));
- assert(PyFloat_CheckExact(_Py_uop_sym_get_const(right)));
+ if (sym_is_const(left) && sym_is_const(right)) {
+ assert(PyFloat_CheckExact(sym_get_const(left)));
+ assert(PyFloat_CheckExact(sym_get_const(right)));
PyObject *temp = PyFloat_FromDouble(
- PyFloat_AS_DOUBLE(_Py_uop_sym_get_const(left)) -
- PyFloat_AS_DOUBLE(_Py_uop_sym_get_const(right)));
+ PyFloat_AS_DOUBLE(sym_get_const(left)) -
+ PyFloat_AS_DOUBLE(sym_get_const(right)));
if (temp == NULL) {
goto error;
}
- res = _Py_uop_sym_new_const(ctx, temp);
+ res = sym_new_const(ctx, temp);
// TODO gh-115506:
// replace opcode with constant propagated one and update tests!
}
else {
- OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_type(ctx, &PyFloat_Type));
+ OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyFloat_Type));
}
}
op(_BINARY_OP_MULTIPLY_FLOAT, (left, right -- res)) {
- if (_Py_uop_sym_is_const(left) && _Py_uop_sym_is_const(right)) {
- assert(PyFloat_CheckExact(_Py_uop_sym_get_const(left)));
- assert(PyFloat_CheckExact(_Py_uop_sym_get_const(right)));
+ if (sym_is_const(left) && sym_is_const(right)) {
+ assert(PyFloat_CheckExact(sym_get_const(left)));
+ assert(PyFloat_CheckExact(sym_get_const(right)));
PyObject *temp = PyFloat_FromDouble(
- PyFloat_AS_DOUBLE(_Py_uop_sym_get_const(left)) *
- PyFloat_AS_DOUBLE(_Py_uop_sym_get_const(right)));
+ PyFloat_AS_DOUBLE(sym_get_const(left)) *
+ PyFloat_AS_DOUBLE(sym_get_const(right)));
if (temp == NULL) {
goto error;
}
- res = _Py_uop_sym_new_const(ctx, temp);
+ res = sym_new_const(ctx, temp);
// TODO gh-115506:
// replace opcode with constant propagated one and update tests!
}
else {
- OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_type(ctx, &PyFloat_Type));
+ OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyFloat_Type));
}
}
}
op(_LOAD_CONST_INLINE, (ptr/4 -- value)) {
- OUT_OF_SPACE_IF_NULL(value = _Py_uop_sym_new_const(ctx, ptr));
+ OUT_OF_SPACE_IF_NULL(value = sym_new_const(ctx, ptr));
}
op(_LOAD_CONST_INLINE_BORROW, (ptr/4 -- value)) {
- OUT_OF_SPACE_IF_NULL(value = _Py_uop_sym_new_const(ctx, ptr));
+ OUT_OF_SPACE_IF_NULL(value = sym_new_const(ctx, ptr));
}
op(_LOAD_CONST_INLINE_WITH_NULL, (ptr/4 -- value, null)) {
- OUT_OF_SPACE_IF_NULL(value = _Py_uop_sym_new_const(ctx, ptr));
- OUT_OF_SPACE_IF_NULL(null = _Py_uop_sym_new_null(ctx));
+ OUT_OF_SPACE_IF_NULL(value = sym_new_const(ctx, ptr));
+ OUT_OF_SPACE_IF_NULL(null = sym_new_null(ctx));
}
op(_LOAD_CONST_INLINE_BORROW_WITH_NULL, (ptr/4 -- value, null)) {
- OUT_OF_SPACE_IF_NULL(value = _Py_uop_sym_new_const(ctx, ptr));
- OUT_OF_SPACE_IF_NULL(null = _Py_uop_sym_new_null(ctx));
+ OUT_OF_SPACE_IF_NULL(value = sym_new_const(ctx, ptr));
+ OUT_OF_SPACE_IF_NULL(null = sym_new_null(ctx));
}
op(_CHECK_ATTR_MODULE, (dict_version/2, owner -- owner)) {
(void)dict_version;
- if (_Py_uop_sym_is_const(owner)) {
- PyObject *cnst = _Py_uop_sym_get_const(owner);
+ if (sym_is_const(owner)) {
+ PyObject *cnst = sym_get_const(owner);
if (PyModule_CheckExact(cnst)) {
PyModuleObject *mod = (PyModuleObject *)cnst;
PyObject *dict = mod->md_dict;
op(_LOAD_ATTR_MODULE, (index/1, owner -- attr, null if (oparg & 1))) {
(void)index;
- OUT_OF_SPACE_IF_NULL(null = _Py_uop_sym_new_null(ctx));
+ OUT_OF_SPACE_IF_NULL(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.
- assert(_Py_uop_sym_is_const(owner));
- PyModuleObject *mod = (PyModuleObject *)_Py_uop_sym_get_const(owner);
+ assert(sym_is_const(owner));
+ PyModuleObject *mod = (PyModuleObject *)sym_get_const(owner);
assert(PyModule_CheckExact(mod));
PyObject *dict = mod->md_dict;
PyObject *res = convert_global_to_const(this_instr, dict);
if (res != NULL) {
this_instr[-1].opcode = _POP_TOP;
- OUT_OF_SPACE_IF_NULL(attr = _Py_uop_sym_new_const(ctx, res));
+ OUT_OF_SPACE_IF_NULL(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 = _Py_uop_sym_new_not_null(ctx));
+ OUT_OF_SPACE_IF_NULL(attr = sym_new_not_null(ctx));
}
}
op(_LOAD_ATTR_METHOD_WITH_VALUES, (descr/4, owner -- attr, self if (1))) {
(void)descr;
- OUT_OF_SPACE_IF_NULL(attr = _Py_uop_sym_new_not_null(ctx));
+ OUT_OF_SPACE_IF_NULL(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 = _Py_uop_sym_new_not_null(ctx));
+ OUT_OF_SPACE_IF_NULL(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 = _Py_uop_sym_new_not_null(ctx));
+ OUT_OF_SPACE_IF_NULL(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 = _Py_uop_sym_new_not_null(ctx));
- OUT_OF_SPACE_IF_NULL(self = _Py_uop_sym_new_not_null(ctx));
+ OUT_OF_SPACE_IF_NULL(func = sym_new_not_null(ctx));
+ OUT_OF_SPACE_IF_NULL(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])) {
- _Py_uop_sym_set_type(callable, &PyFunction_Type);
+ 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])) {
- _Py_uop_sym_set_null(null);
- _Py_uop_sym_set_type(callable, &PyMethod_Type);
+ 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 *)) {
assert(self_or_null != NULL);
assert(args != NULL);
- if (_Py_uop_sym_is_not_null(self_or_null)) {
+ if (sym_is_not_null(self_or_null)) {
// Bound method fiddling, same as _INIT_CALL_PY_EXACT_ARGS in VM
args--;
argcount++;
}
- _Py_UOpsSymType **localsplus_start = ctx->n_consumed;
+ _Py_UopsSymbol **localsplus_start = ctx->n_consumed;
int n_locals_already_filled = 0;
// Can determine statically, so we interleave the new locals
// and make the current stack the new locals.
// This also sets up for true call inlining.
- if (_Py_uop_sym_is_null(self_or_null) || _Py_uop_sym_is_not_null(self_or_null)) {
+ if (sym_is_null(self_or_null) || sym_is_not_null(self_or_null)) {
localsplus_start = args;
n_locals_already_filled = argcount;
}
OUT_OF_SPACE_IF_NULL(new_frame =
- _Py_uop_ctx_frame_new(ctx, co, localsplus_start, n_locals_already_filled, 0));
+ frame_new(ctx, co, localsplus_start, n_locals_already_filled, 0));
}
op(_POP_FRAME, (retval -- res)) {
SYNC_SP();
ctx->frame->stack_pointer = stack_pointer;
- _Py_uop_ctx_frame_pop(ctx);
+ frame_pop(ctx);
stack_pointer = ctx->frame->stack_pointer;
res = retval;
}
/* This has to be done manually */
(void)seq;
for (int i = 0; i < oparg; i++) {
- OUT_OF_SPACE_IF_NULL(values[i] = _Py_uop_sym_new_unknown(ctx));
+ OUT_OF_SPACE_IF_NULL(values[i] = sym_new_unknown(ctx));
}
}
(void)seq;
int totalargs = (oparg & 0xFF) + (oparg >> 8) + 1;
for (int i = 0; i < totalargs; i++) {
- OUT_OF_SPACE_IF_NULL(values[i] = _Py_uop_sym_new_unknown(ctx));
+ OUT_OF_SPACE_IF_NULL(values[i] = sym_new_unknown(ctx));
}
}
op(_ITER_NEXT_RANGE, (iter -- iter, next)) {
- OUT_OF_SPACE_IF_NULL(next = _Py_uop_sym_new_type(ctx, &PyLong_Type));
+ OUT_OF_SPACE_IF_NULL(next = sym_new_type(ctx, &PyLong_Type));
(void)iter;
}
/* _INSTRUMENTED_RESUME is not a viable micro-op for tier 2 */
case _LOAD_FAST_CHECK: {
- _Py_UOpsSymType *value;
+ _Py_UopsSymbol *value;
value = GETLOCAL(oparg);
// We guarantee this will error - just bail and don't optimize it.
- if (_Py_uop_sym_is_null(value)) {
+ if (sym_is_null(value)) {
goto out_of_space;
}
stack_pointer[0] = value;
}
case _LOAD_FAST: {
- _Py_UOpsSymType *value;
+ _Py_UopsSymbol *value;
value = GETLOCAL(oparg);
stack_pointer[0] = value;
stack_pointer += 1;
}
case _LOAD_FAST_AND_CLEAR: {
- _Py_UOpsSymType *value;
+ _Py_UopsSymbol *value;
value = GETLOCAL(oparg);
- _Py_UOpsSymType *temp;
- OUT_OF_SPACE_IF_NULL(temp = _Py_uop_sym_new_null(ctx));
+ _Py_UopsSymbol *temp;
+ OUT_OF_SPACE_IF_NULL(temp = sym_new_null(ctx));
GETLOCAL(oparg) = temp;
stack_pointer[0] = value;
stack_pointer += 1;
}
case _LOAD_CONST: {
- _Py_UOpsSymType *value;
+ _Py_UopsSymbol *value;
// There should be no LOAD_CONST. It should be all
// replaced by peephole_opt.
Py_UNREACHABLE();
}
case _STORE_FAST: {
- _Py_UOpsSymType *value;
+ _Py_UopsSymbol *value;
value = stack_pointer[-1];
GETLOCAL(oparg) = value;
stack_pointer += -1;
}
case _PUSH_NULL: {
- _Py_UOpsSymType *res;
- res = _Py_uop_sym_new_null(ctx);
+ _Py_UopsSymbol *res;
+ res = sym_new_null(ctx);
if (res == NULL) {
goto out_of_space;
};
}
case _END_SEND: {
- _Py_UOpsSymType *value;
+ _Py_UopsSymbol *value;
value = _Py_uop_sym_new_unknown(ctx);
if (value == NULL) goto out_of_space;
stack_pointer[-2] = value;
}
case _UNARY_NEGATIVE: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-1] = res;
}
case _UNARY_NOT: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-1] = res;
}
case _TO_BOOL: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-1] = res;
}
case _TO_BOOL_INT: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-1] = res;
}
case _TO_BOOL_LIST: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-1] = res;
}
case _TO_BOOL_NONE: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-1] = res;
}
case _TO_BOOL_STR: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-1] = res;
}
case _TO_BOOL_ALWAYS_TRUE: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-1] = res;
}
case _UNARY_INVERT: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-1] = res;
}
case _GUARD_BOTH_INT: {
- _Py_UOpsSymType *right;
- _Py_UOpsSymType *left;
+ _Py_UopsSymbol *right;
+ _Py_UopsSymbol *left;
right = stack_pointer[-1];
left = stack_pointer[-2];
- if (_Py_uop_sym_matches_type(left, &PyLong_Type) &&
- _Py_uop_sym_matches_type(right, &PyLong_Type)) {
+ if (sym_matches_type(left, &PyLong_Type) &&
+ sym_matches_type(right, &PyLong_Type)) {
REPLACE_OP(this_instr, _NOP, 0, 0);
}
- _Py_uop_sym_set_type(left, &PyLong_Type);
- _Py_uop_sym_set_type(right, &PyLong_Type);
+ sym_set_type(left, &PyLong_Type);
+ sym_set_type(right, &PyLong_Type);
break;
}
case _BINARY_OP_MULTIPLY_INT: {
- _Py_UOpsSymType *right;
- _Py_UOpsSymType *left;
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *right;
+ _Py_UopsSymbol *left;
+ _Py_UopsSymbol *res;
right = stack_pointer[-1];
left = stack_pointer[-2];
- if (_Py_uop_sym_is_const(left) && _Py_uop_sym_is_const(right)) {
- assert(PyLong_CheckExact(_Py_uop_sym_get_const(left)));
- assert(PyLong_CheckExact(_Py_uop_sym_get_const(right)));
- PyObject *temp = _PyLong_Multiply((PyLongObject *)_Py_uop_sym_get_const(left),
- (PyLongObject *)_Py_uop_sym_get_const(right));
+ if (sym_is_const(left) && sym_is_const(right)) {
+ assert(PyLong_CheckExact(sym_get_const(left)));
+ assert(PyLong_CheckExact(sym_get_const(right)));
+ PyObject *temp = _PyLong_Multiply((PyLongObject *)sym_get_const(left),
+ (PyLongObject *)sym_get_const(right));
if (temp == NULL) {
goto error;
}
- OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_const(ctx, temp));
+ OUT_OF_SPACE_IF_NULL(res = sym_new_const(ctx, temp));
// TODO gh-115506:
// replace opcode with constant propagated one and add tests!
}
else {
- OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_type(ctx, &PyLong_Type));
+ OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyLong_Type));
}
stack_pointer[-2] = res;
stack_pointer += -1;
}
case _BINARY_OP_ADD_INT: {
- _Py_UOpsSymType *right;
- _Py_UOpsSymType *left;
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *right;
+ _Py_UopsSymbol *left;
+ _Py_UopsSymbol *res;
right = stack_pointer[-1];
left = stack_pointer[-2];
- if (_Py_uop_sym_is_const(left) && _Py_uop_sym_is_const(right)) {
- assert(PyLong_CheckExact(_Py_uop_sym_get_const(left)));
- assert(PyLong_CheckExact(_Py_uop_sym_get_const(right)));
- PyObject *temp = _PyLong_Add((PyLongObject *)_Py_uop_sym_get_const(left),
- (PyLongObject *)_Py_uop_sym_get_const(right));
+ if (sym_is_const(left) && sym_is_const(right)) {
+ assert(PyLong_CheckExact(sym_get_const(left)));
+ assert(PyLong_CheckExact(sym_get_const(right)));
+ PyObject *temp = _PyLong_Add((PyLongObject *)sym_get_const(left),
+ (PyLongObject *)sym_get_const(right));
if (temp == NULL) {
goto error;
}
- OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_const(ctx, temp));
+ OUT_OF_SPACE_IF_NULL(res = sym_new_const(ctx, temp));
// TODO gh-115506:
// replace opcode with constant propagated one and add tests!
}
else {
- OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_type(ctx, &PyLong_Type));
+ OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyLong_Type));
}
stack_pointer[-2] = res;
stack_pointer += -1;
}
case _BINARY_OP_SUBTRACT_INT: {
- _Py_UOpsSymType *right;
- _Py_UOpsSymType *left;
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *right;
+ _Py_UopsSymbol *left;
+ _Py_UopsSymbol *res;
right = stack_pointer[-1];
left = stack_pointer[-2];
- if (_Py_uop_sym_is_const(left) && _Py_uop_sym_is_const(right)) {
- assert(PyLong_CheckExact(_Py_uop_sym_get_const(left)));
- assert(PyLong_CheckExact(_Py_uop_sym_get_const(right)));
- PyObject *temp = _PyLong_Subtract((PyLongObject *)_Py_uop_sym_get_const(left),
- (PyLongObject *)_Py_uop_sym_get_const(right));
+ if (sym_is_const(left) && sym_is_const(right)) {
+ assert(PyLong_CheckExact(sym_get_const(left)));
+ assert(PyLong_CheckExact(sym_get_const(right)));
+ PyObject *temp = _PyLong_Subtract((PyLongObject *)sym_get_const(left),
+ (PyLongObject *)sym_get_const(right));
if (temp == NULL) {
goto error;
}
- OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_const(ctx, temp));
+ OUT_OF_SPACE_IF_NULL(res = sym_new_const(ctx, temp));
// TODO gh-115506:
// replace opcode with constant propagated one and add tests!
}
else {
- OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_type(ctx, &PyLong_Type));
+ OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyLong_Type));
}
stack_pointer[-2] = res;
stack_pointer += -1;
}
case _GUARD_BOTH_FLOAT: {
- _Py_UOpsSymType *right;
- _Py_UOpsSymType *left;
+ _Py_UopsSymbol *right;
+ _Py_UopsSymbol *left;
right = stack_pointer[-1];
left = stack_pointer[-2];
- if (_Py_uop_sym_matches_type(left, &PyFloat_Type) &&
- _Py_uop_sym_matches_type(right, &PyFloat_Type)) {
+ if (sym_matches_type(left, &PyFloat_Type) &&
+ sym_matches_type(right, &PyFloat_Type)) {
REPLACE_OP(this_instr, _NOP, 0 ,0);
}
- _Py_uop_sym_set_type(left, &PyFloat_Type);
- _Py_uop_sym_set_type(right, &PyFloat_Type);
+ sym_set_type(left, &PyFloat_Type);
+ sym_set_type(right, &PyFloat_Type);
break;
}
case _BINARY_OP_MULTIPLY_FLOAT: {
- _Py_UOpsSymType *right;
- _Py_UOpsSymType *left;
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *right;
+ _Py_UopsSymbol *left;
+ _Py_UopsSymbol *res;
right = stack_pointer[-1];
left = stack_pointer[-2];
- if (_Py_uop_sym_is_const(left) && _Py_uop_sym_is_const(right)) {
- assert(PyFloat_CheckExact(_Py_uop_sym_get_const(left)));
- assert(PyFloat_CheckExact(_Py_uop_sym_get_const(right)));
+ if (sym_is_const(left) && sym_is_const(right)) {
+ assert(PyFloat_CheckExact(sym_get_const(left)));
+ assert(PyFloat_CheckExact(sym_get_const(right)));
PyObject *temp = PyFloat_FromDouble(
- PyFloat_AS_DOUBLE(_Py_uop_sym_get_const(left)) *
- PyFloat_AS_DOUBLE(_Py_uop_sym_get_const(right)));
+ PyFloat_AS_DOUBLE(sym_get_const(left)) *
+ PyFloat_AS_DOUBLE(sym_get_const(right)));
if (temp == NULL) {
goto error;
}
- res = _Py_uop_sym_new_const(ctx, temp);
+ res = sym_new_const(ctx, temp);
// TODO gh-115506:
// replace opcode with constant propagated one and update tests!
}
else {
- OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_type(ctx, &PyFloat_Type));
+ OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyFloat_Type));
}
stack_pointer[-2] = res;
stack_pointer += -1;
}
case _BINARY_OP_ADD_FLOAT: {
- _Py_UOpsSymType *right;
- _Py_UOpsSymType *left;
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *right;
+ _Py_UopsSymbol *left;
+ _Py_UopsSymbol *res;
right = stack_pointer[-1];
left = stack_pointer[-2];
- if (_Py_uop_sym_is_const(left) && _Py_uop_sym_is_const(right)) {
- assert(PyFloat_CheckExact(_Py_uop_sym_get_const(left)));
- assert(PyFloat_CheckExact(_Py_uop_sym_get_const(right)));
+ if (sym_is_const(left) && sym_is_const(right)) {
+ assert(PyFloat_CheckExact(sym_get_const(left)));
+ assert(PyFloat_CheckExact(sym_get_const(right)));
PyObject *temp = PyFloat_FromDouble(
- PyFloat_AS_DOUBLE(_Py_uop_sym_get_const(left)) +
- PyFloat_AS_DOUBLE(_Py_uop_sym_get_const(right)));
+ PyFloat_AS_DOUBLE(sym_get_const(left)) +
+ PyFloat_AS_DOUBLE(sym_get_const(right)));
if (temp == NULL) {
goto error;
}
- res = _Py_uop_sym_new_const(ctx, temp);
+ res = sym_new_const(ctx, temp);
// TODO gh-115506:
// replace opcode with constant propagated one and update tests!
}
else {
- OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_type(ctx, &PyFloat_Type));
+ OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyFloat_Type));
}
stack_pointer[-2] = res;
stack_pointer += -1;
}
case _BINARY_OP_SUBTRACT_FLOAT: {
- _Py_UOpsSymType *right;
- _Py_UOpsSymType *left;
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *right;
+ _Py_UopsSymbol *left;
+ _Py_UopsSymbol *res;
right = stack_pointer[-1];
left = stack_pointer[-2];
- if (_Py_uop_sym_is_const(left) && _Py_uop_sym_is_const(right)) {
- assert(PyFloat_CheckExact(_Py_uop_sym_get_const(left)));
- assert(PyFloat_CheckExact(_Py_uop_sym_get_const(right)));
+ if (sym_is_const(left) && sym_is_const(right)) {
+ assert(PyFloat_CheckExact(sym_get_const(left)));
+ assert(PyFloat_CheckExact(sym_get_const(right)));
PyObject *temp = PyFloat_FromDouble(
- PyFloat_AS_DOUBLE(_Py_uop_sym_get_const(left)) -
- PyFloat_AS_DOUBLE(_Py_uop_sym_get_const(right)));
+ PyFloat_AS_DOUBLE(sym_get_const(left)) -
+ PyFloat_AS_DOUBLE(sym_get_const(right)));
if (temp == NULL) {
goto error;
}
- res = _Py_uop_sym_new_const(ctx, temp);
+ res = sym_new_const(ctx, temp);
// TODO gh-115506:
// replace opcode with constant propagated one and update tests!
}
else {
- OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_type(ctx, &PyFloat_Type));
+ OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyFloat_Type));
}
stack_pointer[-2] = res;
stack_pointer += -1;
}
case _GUARD_BOTH_UNICODE: {
- _Py_UOpsSymType *right;
- _Py_UOpsSymType *left;
+ _Py_UopsSymbol *right;
+ _Py_UopsSymbol *left;
right = stack_pointer[-1];
left = stack_pointer[-2];
- if (_Py_uop_sym_matches_type(left, &PyUnicode_Type) &&
- _Py_uop_sym_matches_type(right, &PyUnicode_Type)) {
+ if (sym_matches_type(left, &PyUnicode_Type) &&
+ sym_matches_type(right, &PyUnicode_Type)) {
REPLACE_OP(this_instr, _NOP, 0 ,0);
}
- _Py_uop_sym_set_type(left, &PyUnicode_Type);
- _Py_uop_sym_set_type(right, &PyUnicode_Type);
+ sym_set_type(left, &PyUnicode_Type);
+ sym_set_type(right, &PyUnicode_Type);
break;
}
case _BINARY_OP_ADD_UNICODE: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2] = res;
}
case _BINARY_SUBSCR: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2] = res;
}
case _BINARY_SLICE: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-3] = res;
}
case _BINARY_SUBSCR_LIST_INT: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2] = res;
}
case _BINARY_SUBSCR_STR_INT: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2] = res;
}
case _BINARY_SUBSCR_TUPLE_INT: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2] = res;
}
case _BINARY_SUBSCR_DICT: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2] = res;
}
case _CALL_INTRINSIC_1: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-1] = res;
}
case _CALL_INTRINSIC_2: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2] = res;
}
case _POP_FRAME: {
- _Py_UOpsSymType *retval;
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *retval;
+ _Py_UopsSymbol *res;
retval = stack_pointer[-1];
stack_pointer += -1;
ctx->frame->stack_pointer = stack_pointer;
- _Py_uop_ctx_frame_pop(ctx);
+ frame_pop(ctx);
stack_pointer = ctx->frame->stack_pointer;
res = retval;
stack_pointer[0] = res;
/* _INSTRUMENTED_RETURN_CONST is not a viable micro-op for tier 2 */
case _GET_AITER: {
- _Py_UOpsSymType *iter;
+ _Py_UopsSymbol *iter;
iter = _Py_uop_sym_new_unknown(ctx);
if (iter == NULL) goto out_of_space;
stack_pointer[-1] = iter;
}
case _GET_ANEXT: {
- _Py_UOpsSymType *awaitable;
+ _Py_UopsSymbol *awaitable;
awaitable = _Py_uop_sym_new_unknown(ctx);
if (awaitable == NULL) goto out_of_space;
stack_pointer[0] = awaitable;
}
case _GET_AWAITABLE: {
- _Py_UOpsSymType *iter;
+ _Py_UopsSymbol *iter;
iter = _Py_uop_sym_new_unknown(ctx);
if (iter == NULL) goto out_of_space;
stack_pointer[-1] = iter;
}
case _LOAD_ASSERTION_ERROR: {
- _Py_UOpsSymType *value;
+ _Py_UopsSymbol *value;
value = _Py_uop_sym_new_unknown(ctx);
if (value == NULL) goto out_of_space;
stack_pointer[0] = value;
}
case _LOAD_BUILD_CLASS: {
- _Py_UOpsSymType *bc;
+ _Py_UopsSymbol *bc;
bc = _Py_uop_sym_new_unknown(ctx);
if (bc == NULL) goto out_of_space;
stack_pointer[0] = bc;
}
case _UNPACK_SEQUENCE: {
- _Py_UOpsSymType *seq;
- _Py_UOpsSymType **values;
+ _Py_UopsSymbol *seq;
+ _Py_UopsSymbol **values;
seq = stack_pointer[-1];
values = &stack_pointer[-1];
/* This has to be done manually */
(void)seq;
for (int i = 0; i < oparg; i++) {
- OUT_OF_SPACE_IF_NULL(values[i] = _Py_uop_sym_new_unknown(ctx));
+ OUT_OF_SPACE_IF_NULL(values[i] = sym_new_unknown(ctx));
}
stack_pointer += -1 + oparg;
break;
}
case _UNPACK_SEQUENCE_TWO_TUPLE: {
- _Py_UOpsSymType **values;
+ _Py_UopsSymbol **values;
values = &stack_pointer[-1];
for (int _i = oparg; --_i >= 0;) {
values[_i] = _Py_uop_sym_new_unknown(ctx);
}
case _UNPACK_SEQUENCE_TUPLE: {
- _Py_UOpsSymType **values;
+ _Py_UopsSymbol **values;
values = &stack_pointer[-1];
for (int _i = oparg; --_i >= 0;) {
values[_i] = _Py_uop_sym_new_unknown(ctx);
}
case _UNPACK_SEQUENCE_LIST: {
- _Py_UOpsSymType **values;
+ _Py_UopsSymbol **values;
values = &stack_pointer[-1];
for (int _i = oparg; --_i >= 0;) {
values[_i] = _Py_uop_sym_new_unknown(ctx);
}
case _UNPACK_EX: {
- _Py_UOpsSymType *seq;
- _Py_UOpsSymType **values;
+ _Py_UopsSymbol *seq;
+ _Py_UopsSymbol **values;
seq = stack_pointer[-1];
values = &stack_pointer[-1];
/* This has to be done manually */
(void)seq;
int totalargs = (oparg & 0xFF) + (oparg >> 8) + 1;
for (int i = 0; i < totalargs; i++) {
- OUT_OF_SPACE_IF_NULL(values[i] = _Py_uop_sym_new_unknown(ctx));
+ OUT_OF_SPACE_IF_NULL(values[i] = sym_new_unknown(ctx));
}
stack_pointer += (oparg >> 8) + (oparg & 0xFF);
break;
}
case _LOAD_LOCALS: {
- _Py_UOpsSymType *locals;
+ _Py_UopsSymbol *locals;
locals = _Py_uop_sym_new_unknown(ctx);
if (locals == NULL) goto out_of_space;
stack_pointer[0] = locals;
}
case _LOAD_FROM_DICT_OR_GLOBALS: {
- _Py_UOpsSymType *v;
+ _Py_UopsSymbol *v;
v = _Py_uop_sym_new_unknown(ctx);
if (v == NULL) goto out_of_space;
stack_pointer[-1] = v;
}
case _LOAD_NAME: {
- _Py_UOpsSymType *v;
+ _Py_UopsSymbol *v;
v = _Py_uop_sym_new_unknown(ctx);
if (v == NULL) goto out_of_space;
stack_pointer[0] = v;
}
case _LOAD_GLOBAL: {
- _Py_UOpsSymType *res;
- _Py_UOpsSymType *null = NULL;
+ _Py_UopsSymbol *res;
+ _Py_UopsSymbol *null = NULL;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
null = _Py_uop_sym_new_null(ctx);
}
case _LOAD_GLOBAL_MODULE: {
- _Py_UOpsSymType *res;
- _Py_UOpsSymType *null = NULL;
+ _Py_UopsSymbol *res;
+ _Py_UopsSymbol *null = NULL;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
null = _Py_uop_sym_new_null(ctx);
}
case _LOAD_GLOBAL_BUILTINS: {
- _Py_UOpsSymType *res;
- _Py_UOpsSymType *null = NULL;
+ _Py_UopsSymbol *res;
+ _Py_UopsSymbol *null = NULL;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
null = _Py_uop_sym_new_null(ctx);
}
case _LOAD_FROM_DICT_OR_DEREF: {
- _Py_UOpsSymType *value;
+ _Py_UopsSymbol *value;
value = _Py_uop_sym_new_unknown(ctx);
if (value == NULL) goto out_of_space;
stack_pointer[-1] = value;
}
case _LOAD_DEREF: {
- _Py_UOpsSymType *value;
+ _Py_UopsSymbol *value;
value = _Py_uop_sym_new_unknown(ctx);
if (value == NULL) goto out_of_space;
stack_pointer[0] = value;
}
case _BUILD_STRING: {
- _Py_UOpsSymType *str;
+ _Py_UopsSymbol *str;
str = _Py_uop_sym_new_unknown(ctx);
if (str == NULL) goto out_of_space;
stack_pointer[-oparg] = str;
}
case _BUILD_TUPLE: {
- _Py_UOpsSymType *tup;
+ _Py_UopsSymbol *tup;
tup = _Py_uop_sym_new_unknown(ctx);
if (tup == NULL) goto out_of_space;
stack_pointer[-oparg] = tup;
}
case _BUILD_LIST: {
- _Py_UOpsSymType *list;
+ _Py_UopsSymbol *list;
list = _Py_uop_sym_new_unknown(ctx);
if (list == NULL) goto out_of_space;
stack_pointer[-oparg] = list;
}
case _BUILD_SET: {
- _Py_UOpsSymType *set;
+ _Py_UopsSymbol *set;
set = _Py_uop_sym_new_unknown(ctx);
if (set == NULL) goto out_of_space;
stack_pointer[-oparg] = set;
}
case _BUILD_MAP: {
- _Py_UOpsSymType *map;
+ _Py_UopsSymbol *map;
map = _Py_uop_sym_new_unknown(ctx);
if (map == NULL) goto out_of_space;
stack_pointer[-oparg*2] = map;
}
case _BUILD_CONST_KEY_MAP: {
- _Py_UOpsSymType *map;
+ _Py_UopsSymbol *map;
map = _Py_uop_sym_new_unknown(ctx);
if (map == NULL) goto out_of_space;
stack_pointer[-1 - oparg] = map;
/* _INSTRUMENTED_LOAD_SUPER_ATTR is not a viable micro-op for tier 2 */
case _LOAD_SUPER_ATTR_ATTR: {
- _Py_UOpsSymType *attr;
+ _Py_UopsSymbol *attr;
attr = _Py_uop_sym_new_unknown(ctx);
if (attr == NULL) goto out_of_space;
stack_pointer[-3] = attr;
}
case _LOAD_SUPER_ATTR_METHOD: {
- _Py_UOpsSymType *attr;
- _Py_UOpsSymType *self_or_null;
+ _Py_UopsSymbol *attr;
+ _Py_UopsSymbol *self_or_null;
attr = _Py_uop_sym_new_unknown(ctx);
if (attr == NULL) goto out_of_space;
self_or_null = _Py_uop_sym_new_unknown(ctx);
}
case _LOAD_ATTR: {
- _Py_UOpsSymType *attr;
- _Py_UOpsSymType *self_or_null = NULL;
+ _Py_UopsSymbol *attr;
+ _Py_UopsSymbol *self_or_null = NULL;
attr = _Py_uop_sym_new_unknown(ctx);
if (attr == NULL) goto out_of_space;
self_or_null = _Py_uop_sym_new_unknown(ctx);
}
case _LOAD_ATTR_INSTANCE_VALUE: {
- _Py_UOpsSymType *owner;
- _Py_UOpsSymType *attr;
- _Py_UOpsSymType *null = NULL;
+ _Py_UopsSymbol *owner;
+ _Py_UopsSymbol *attr;
+ _Py_UopsSymbol *null = NULL;
owner = stack_pointer[-1];
uint16_t index = (uint16_t)this_instr->operand;
_LOAD_ATTR_NOT_NULL
}
case _CHECK_ATTR_MODULE: {
- _Py_UOpsSymType *owner;
+ _Py_UopsSymbol *owner;
owner = stack_pointer[-1];
uint32_t dict_version = (uint32_t)this_instr->operand;
(void)dict_version;
- if (_Py_uop_sym_is_const(owner)) {
- PyObject *cnst = _Py_uop_sym_get_const(owner);
+ if (sym_is_const(owner)) {
+ PyObject *cnst = sym_get_const(owner);
if (PyModule_CheckExact(cnst)) {
PyModuleObject *mod = (PyModuleObject *)cnst;
PyObject *dict = mod->md_dict;
}
case _LOAD_ATTR_MODULE: {
- _Py_UOpsSymType *owner;
- _Py_UOpsSymType *attr;
- _Py_UOpsSymType *null = NULL;
+ _Py_UopsSymbol *owner;
+ _Py_UopsSymbol *attr;
+ _Py_UopsSymbol *null = NULL;
owner = stack_pointer[-1];
uint16_t index = (uint16_t)this_instr->operand;
(void)index;
- OUT_OF_SPACE_IF_NULL(null = _Py_uop_sym_new_null(ctx));
+ OUT_OF_SPACE_IF_NULL(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.
- assert(_Py_uop_sym_is_const(owner));
- PyModuleObject *mod = (PyModuleObject *)_Py_uop_sym_get_const(owner);
+ assert(sym_is_const(owner));
+ PyModuleObject *mod = (PyModuleObject *)sym_get_const(owner);
assert(PyModule_CheckExact(mod));
PyObject *dict = mod->md_dict;
PyObject *res = convert_global_to_const(this_instr, dict);
if (res != NULL) {
this_instr[-1].opcode = _POP_TOP;
- OUT_OF_SPACE_IF_NULL(attr = _Py_uop_sym_new_const(ctx, res));
+ OUT_OF_SPACE_IF_NULL(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 = _Py_uop_sym_new_not_null(ctx));
+ OUT_OF_SPACE_IF_NULL(attr = sym_new_not_null(ctx));
}
stack_pointer[-1] = attr;
if (oparg & 1) stack_pointer[0] = null;
}
case _LOAD_ATTR_WITH_HINT: {
- _Py_UOpsSymType *owner;
- _Py_UOpsSymType *attr;
- _Py_UOpsSymType *null = NULL;
+ _Py_UopsSymbol *owner;
+ _Py_UopsSymbol *attr;
+ _Py_UopsSymbol *null = NULL;
owner = stack_pointer[-1];
uint16_t hint = (uint16_t)this_instr->operand;
_LOAD_ATTR_NOT_NULL
}
case _LOAD_ATTR_SLOT: {
- _Py_UOpsSymType *owner;
- _Py_UOpsSymType *attr;
- _Py_UOpsSymType *null = NULL;
+ _Py_UopsSymbol *owner;
+ _Py_UopsSymbol *attr;
+ _Py_UopsSymbol *null = NULL;
owner = stack_pointer[-1];
uint16_t index = (uint16_t)this_instr->operand;
_LOAD_ATTR_NOT_NULL
}
case _LOAD_ATTR_CLASS: {
- _Py_UOpsSymType *owner;
- _Py_UOpsSymType *attr;
- _Py_UOpsSymType *null = NULL;
+ _Py_UopsSymbol *owner;
+ _Py_UopsSymbol *attr;
+ _Py_UopsSymbol *null = NULL;
owner = stack_pointer[-1];
PyObject *descr = (PyObject *)this_instr->operand;
_LOAD_ATTR_NOT_NULL
}
case _COMPARE_OP: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2] = res;
}
case _COMPARE_OP_FLOAT: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2] = res;
}
case _COMPARE_OP_INT: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2] = res;
}
case _COMPARE_OP_STR: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2] = res;
}
case _IS_OP: {
- _Py_UOpsSymType *b;
+ _Py_UopsSymbol *b;
b = _Py_uop_sym_new_unknown(ctx);
if (b == NULL) goto out_of_space;
stack_pointer[-2] = b;
}
case _CONTAINS_OP: {
- _Py_UOpsSymType *b;
+ _Py_UopsSymbol *b;
b = _Py_uop_sym_new_unknown(ctx);
if (b == NULL) goto out_of_space;
stack_pointer[-2] = b;
}
case _CHECK_EG_MATCH: {
- _Py_UOpsSymType *rest;
- _Py_UOpsSymType *match;
+ _Py_UopsSymbol *rest;
+ _Py_UopsSymbol *match;
rest = _Py_uop_sym_new_unknown(ctx);
if (rest == NULL) goto out_of_space;
match = _Py_uop_sym_new_unknown(ctx);
}
case _CHECK_EXC_MATCH: {
- _Py_UOpsSymType *b;
+ _Py_UopsSymbol *b;
b = _Py_uop_sym_new_unknown(ctx);
if (b == NULL) goto out_of_space;
stack_pointer[-1] = b;
/* _POP_JUMP_IF_TRUE is not a viable micro-op for tier 2 */
case _IS_NONE: {
- _Py_UOpsSymType *b;
+ _Py_UopsSymbol *b;
b = _Py_uop_sym_new_unknown(ctx);
if (b == NULL) goto out_of_space;
stack_pointer[-1] = b;
}
case _GET_LEN: {
- _Py_UOpsSymType *len_o;
+ _Py_UopsSymbol *len_o;
len_o = _Py_uop_sym_new_unknown(ctx);
if (len_o == NULL) goto out_of_space;
stack_pointer[0] = len_o;
}
case _MATCH_CLASS: {
- _Py_UOpsSymType *attrs;
+ _Py_UopsSymbol *attrs;
attrs = _Py_uop_sym_new_unknown(ctx);
if (attrs == NULL) goto out_of_space;
stack_pointer[-3] = attrs;
}
case _MATCH_MAPPING: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[0] = res;
}
case _MATCH_SEQUENCE: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[0] = res;
}
case _MATCH_KEYS: {
- _Py_UOpsSymType *values_or_none;
+ _Py_UopsSymbol *values_or_none;
values_or_none = _Py_uop_sym_new_unknown(ctx);
if (values_or_none == NULL) goto out_of_space;
stack_pointer[0] = values_or_none;
}
case _GET_ITER: {
- _Py_UOpsSymType *iter;
+ _Py_UopsSymbol *iter;
iter = _Py_uop_sym_new_unknown(ctx);
if (iter == NULL) goto out_of_space;
stack_pointer[-1] = iter;
}
case _GET_YIELD_FROM_ITER: {
- _Py_UOpsSymType *iter;
+ _Py_UopsSymbol *iter;
iter = _Py_uop_sym_new_unknown(ctx);
if (iter == NULL) goto out_of_space;
stack_pointer[-1] = iter;
/* _FOR_ITER is not a viable micro-op for tier 2 */
case _FOR_ITER_TIER_TWO: {
- _Py_UOpsSymType *next;
+ _Py_UopsSymbol *next;
next = _Py_uop_sym_new_unknown(ctx);
if (next == NULL) goto out_of_space;
stack_pointer[0] = next;
}
case _ITER_NEXT_LIST: {
- _Py_UOpsSymType *next;
+ _Py_UopsSymbol *next;
next = _Py_uop_sym_new_unknown(ctx);
if (next == NULL) goto out_of_space;
stack_pointer[0] = next;
}
case _ITER_NEXT_TUPLE: {
- _Py_UOpsSymType *next;
+ _Py_UopsSymbol *next;
next = _Py_uop_sym_new_unknown(ctx);
if (next == NULL) goto out_of_space;
stack_pointer[0] = next;
}
case _ITER_NEXT_RANGE: {
- _Py_UOpsSymType *iter;
- _Py_UOpsSymType *next;
+ _Py_UopsSymbol *iter;
+ _Py_UopsSymbol *next;
iter = stack_pointer[-1];
- OUT_OF_SPACE_IF_NULL(next = _Py_uop_sym_new_type(ctx, &PyLong_Type));
+ OUT_OF_SPACE_IF_NULL(next = sym_new_type(ctx, &PyLong_Type));
(void)iter;
stack_pointer[0] = next;
stack_pointer += 1;
/* _FOR_ITER_GEN is not a viable micro-op for tier 2 */
case _BEFORE_ASYNC_WITH: {
- _Py_UOpsSymType *exit;
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *exit;
+ _Py_UopsSymbol *res;
exit = _Py_uop_sym_new_unknown(ctx);
if (exit == NULL) goto out_of_space;
res = _Py_uop_sym_new_unknown(ctx);
}
case _BEFORE_WITH: {
- _Py_UOpsSymType *exit;
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *exit;
+ _Py_UopsSymbol *res;
exit = _Py_uop_sym_new_unknown(ctx);
if (exit == NULL) goto out_of_space;
res = _Py_uop_sym_new_unknown(ctx);
}
case _WITH_EXCEPT_START: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[0] = res;
}
case _PUSH_EXC_INFO: {
- _Py_UOpsSymType *prev_exc;
- _Py_UOpsSymType *new_exc;
+ _Py_UopsSymbol *prev_exc;
+ _Py_UopsSymbol *new_exc;
prev_exc = _Py_uop_sym_new_unknown(ctx);
if (prev_exc == NULL) goto out_of_space;
new_exc = _Py_uop_sym_new_unknown(ctx);
}
case _LOAD_ATTR_METHOD_WITH_VALUES: {
- _Py_UOpsSymType *owner;
- _Py_UOpsSymType *attr;
- _Py_UOpsSymType *self = NULL;
+ _Py_UopsSymbol *owner;
+ _Py_UopsSymbol *attr;
+ _Py_UopsSymbol *self = NULL;
owner = stack_pointer[-1];
PyObject *descr = (PyObject *)this_instr->operand;
(void)descr;
- OUT_OF_SPACE_IF_NULL(attr = _Py_uop_sym_new_not_null(ctx));
+ OUT_OF_SPACE_IF_NULL(attr = sym_new_not_null(ctx));
self = owner;
stack_pointer[-1] = attr;
stack_pointer[0] = self;
}
case _LOAD_ATTR_METHOD_NO_DICT: {
- _Py_UOpsSymType *owner;
- _Py_UOpsSymType *attr;
- _Py_UOpsSymType *self = NULL;
+ _Py_UopsSymbol *owner;
+ _Py_UopsSymbol *attr;
+ _Py_UopsSymbol *self = NULL;
owner = stack_pointer[-1];
PyObject *descr = (PyObject *)this_instr->operand;
(void)descr;
- OUT_OF_SPACE_IF_NULL(attr = _Py_uop_sym_new_not_null(ctx));
+ OUT_OF_SPACE_IF_NULL(attr = sym_new_not_null(ctx));
self = owner;
stack_pointer[-1] = attr;
stack_pointer[0] = self;
}
case _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES: {
- _Py_UOpsSymType *attr;
+ _Py_UopsSymbol *attr;
attr = _Py_uop_sym_new_unknown(ctx);
if (attr == NULL) goto out_of_space;
stack_pointer[-1] = attr;
}
case _LOAD_ATTR_NONDESCRIPTOR_NO_DICT: {
- _Py_UOpsSymType *attr;
+ _Py_UopsSymbol *attr;
attr = _Py_uop_sym_new_unknown(ctx);
if (attr == NULL) goto out_of_space;
stack_pointer[-1] = attr;
}
case _LOAD_ATTR_METHOD_LAZY_DICT: {
- _Py_UOpsSymType *owner;
- _Py_UOpsSymType *attr;
- _Py_UOpsSymType *self = NULL;
+ _Py_UopsSymbol *owner;
+ _Py_UopsSymbol *attr;
+ _Py_UopsSymbol *self = NULL;
owner = stack_pointer[-1];
PyObject *descr = (PyObject *)this_instr->operand;
(void)descr;
- OUT_OF_SPACE_IF_NULL(attr = _Py_uop_sym_new_not_null(ctx));
+ OUT_OF_SPACE_IF_NULL(attr = sym_new_not_null(ctx));
self = owner;
stack_pointer[-1] = attr;
stack_pointer[0] = self;
/* _CALL is not a viable micro-op for tier 2 */
case _CHECK_CALL_BOUND_METHOD_EXACT_ARGS: {
- _Py_UOpsSymType *null;
- _Py_UOpsSymType *callable;
+ _Py_UopsSymbol *null;
+ _Py_UopsSymbol *callable;
null = stack_pointer[-1 - oparg];
callable = stack_pointer[-2 - oparg];
- _Py_uop_sym_set_null(null);
- _Py_uop_sym_set_type(callable, &PyMethod_Type);
+ sym_set_null(null);
+ sym_set_type(callable, &PyMethod_Type);
break;
}
case _INIT_CALL_BOUND_METHOD_EXACT_ARGS: {
- _Py_UOpsSymType *callable;
- _Py_UOpsSymType *func;
- _Py_UOpsSymType *self;
+ _Py_UopsSymbol *callable;
+ _Py_UopsSymbol *func;
+ _Py_UopsSymbol *self;
callable = stack_pointer[-2 - oparg];
(void)callable;
- OUT_OF_SPACE_IF_NULL(func = _Py_uop_sym_new_not_null(ctx));
- OUT_OF_SPACE_IF_NULL(self = _Py_uop_sym_new_not_null(ctx));
+ OUT_OF_SPACE_IF_NULL(func = sym_new_not_null(ctx));
+ OUT_OF_SPACE_IF_NULL(self = sym_new_not_null(ctx));
stack_pointer[-2 - oparg] = func;
stack_pointer[-1 - oparg] = self;
break;
}
case _CHECK_FUNCTION_EXACT_ARGS: {
- _Py_UOpsSymType *self_or_null;
- _Py_UOpsSymType *callable;
+ _Py_UopsSymbol *self_or_null;
+ _Py_UopsSymbol *callable;
self_or_null = stack_pointer[-1 - oparg];
callable = stack_pointer[-2 - oparg];
uint32_t func_version = (uint32_t)this_instr->operand;
- _Py_uop_sym_set_type(callable, &PyFunction_Type);
+ sym_set_type(callable, &PyFunction_Type);
(void)self_or_null;
(void)func_version;
break;
}
case _INIT_CALL_PY_EXACT_ARGS: {
- _Py_UOpsSymType **args;
- _Py_UOpsSymType *self_or_null;
- _Py_UOpsSymType *callable;
+ _Py_UopsSymbol **args;
+ _Py_UopsSymbol *self_or_null;
+ _Py_UopsSymbol *callable;
_Py_UOpsAbstractFrame *new_frame;
args = &stack_pointer[-oparg];
self_or_null = stack_pointer[-1 - oparg];
PyCodeObject *co = (PyCodeObject *)func->func_code;
assert(self_or_null != NULL);
assert(args != NULL);
- if (_Py_uop_sym_is_not_null(self_or_null)) {
+ if (sym_is_not_null(self_or_null)) {
// Bound method fiddling, same as _INIT_CALL_PY_EXACT_ARGS in VM
args--;
argcount++;
}
- _Py_UOpsSymType **localsplus_start = ctx->n_consumed;
+ _Py_UopsSymbol **localsplus_start = ctx->n_consumed;
int n_locals_already_filled = 0;
// Can determine statically, so we interleave the new locals
// and make the current stack the new locals.
// This also sets up for true call inlining.
- if (_Py_uop_sym_is_null(self_or_null) || _Py_uop_sym_is_not_null(self_or_null)) {
+ if (sym_is_null(self_or_null) || sym_is_not_null(self_or_null)) {
localsplus_start = args;
n_locals_already_filled = argcount;
}
OUT_OF_SPACE_IF_NULL(new_frame =
- _Py_uop_ctx_frame_new(ctx, co, localsplus_start, n_locals_already_filled, 0));
- stack_pointer[-2 - oparg] = (_Py_UOpsSymType *)new_frame;
+ frame_new(ctx, co, localsplus_start, n_locals_already_filled, 0));
+ stack_pointer[-2 - oparg] = (_Py_UopsSymbol *)new_frame;
stack_pointer += -1 - oparg;
break;
}
/* _CALL_PY_WITH_DEFAULTS is not a viable micro-op for tier 2 */
case _CALL_TYPE_1: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2 - oparg] = res;
}
case _CALL_STR_1: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2 - oparg] = res;
}
case _CALL_TUPLE_1: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2 - oparg] = res;
}
case _CALL_BUILTIN_CLASS: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2 - oparg] = res;
}
case _CALL_BUILTIN_O: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2 - oparg] = res;
}
case _CALL_BUILTIN_FAST: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2 - oparg] = res;
}
case _CALL_BUILTIN_FAST_WITH_KEYWORDS: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2 - oparg] = res;
}
case _CALL_LEN: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2 - oparg] = res;
}
case _CALL_ISINSTANCE: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2 - oparg] = res;
}
case _CALL_METHOD_DESCRIPTOR_O: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2 - oparg] = res;
}
case _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2 - oparg] = res;
}
case _CALL_METHOD_DESCRIPTOR_NOARGS: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2 - oparg] = res;
}
case _CALL_METHOD_DESCRIPTOR_FAST: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2 - oparg] = res;
/* _CALL_FUNCTION_EX is not a viable micro-op for tier 2 */
case _MAKE_FUNCTION: {
- _Py_UOpsSymType *func;
+ _Py_UopsSymbol *func;
func = _Py_uop_sym_new_unknown(ctx);
if (func == NULL) goto out_of_space;
stack_pointer[-1] = func;
}
case _SET_FUNCTION_ATTRIBUTE: {
- _Py_UOpsSymType *func;
+ _Py_UopsSymbol *func;
func = _Py_uop_sym_new_unknown(ctx);
if (func == NULL) goto out_of_space;
stack_pointer[-2] = func;
}
case _BUILD_SLICE: {
- _Py_UOpsSymType *slice;
+ _Py_UopsSymbol *slice;
slice = _Py_uop_sym_new_unknown(ctx);
if (slice == NULL) goto out_of_space;
stack_pointer[-2 - ((oparg == 3) ? 1 : 0)] = slice;
}
case _CONVERT_VALUE: {
- _Py_UOpsSymType *result;
+ _Py_UopsSymbol *result;
result = _Py_uop_sym_new_unknown(ctx);
if (result == NULL) goto out_of_space;
stack_pointer[-1] = result;
}
case _FORMAT_SIMPLE: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-1] = res;
}
case _FORMAT_WITH_SPEC: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2] = res;
}
case _COPY: {
- _Py_UOpsSymType *bottom;
- _Py_UOpsSymType *top;
+ _Py_UopsSymbol *bottom;
+ _Py_UopsSymbol *top;
bottom = stack_pointer[-1 - (oparg-1)];
assert(oparg > 0);
top = bottom;
}
case _BINARY_OP: {
- _Py_UOpsSymType *res;
+ _Py_UopsSymbol *res;
res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) goto out_of_space;
stack_pointer[-2] = res;
}
case _SWAP: {
- _Py_UOpsSymType *top;
- _Py_UOpsSymType *bottom;
+ _Py_UopsSymbol *top;
+ _Py_UopsSymbol *bottom;
top = stack_pointer[-1];
bottom = stack_pointer[-2 - (oparg-2)];
stack_pointer[-2 - (oparg-2)] = top;
}
case _LOAD_CONST_INLINE: {
- _Py_UOpsSymType *value;
+ _Py_UopsSymbol *value;
PyObject *ptr = (PyObject *)this_instr->operand;
- OUT_OF_SPACE_IF_NULL(value = _Py_uop_sym_new_const(ctx, ptr));
+ OUT_OF_SPACE_IF_NULL(value = sym_new_const(ctx, ptr));
stack_pointer[0] = value;
stack_pointer += 1;
break;
}
case _LOAD_CONST_INLINE_BORROW: {
- _Py_UOpsSymType *value;
+ _Py_UopsSymbol *value;
PyObject *ptr = (PyObject *)this_instr->operand;
- OUT_OF_SPACE_IF_NULL(value = _Py_uop_sym_new_const(ctx, ptr));
+ OUT_OF_SPACE_IF_NULL(value = sym_new_const(ctx, ptr));
stack_pointer[0] = value;
stack_pointer += 1;
break;
}
case _LOAD_CONST_INLINE_WITH_NULL: {
- _Py_UOpsSymType *value;
- _Py_UOpsSymType *null;
+ _Py_UopsSymbol *value;
+ _Py_UopsSymbol *null;
PyObject *ptr = (PyObject *)this_instr->operand;
- OUT_OF_SPACE_IF_NULL(value = _Py_uop_sym_new_const(ctx, ptr));
- OUT_OF_SPACE_IF_NULL(null = _Py_uop_sym_new_null(ctx));
+ OUT_OF_SPACE_IF_NULL(value = sym_new_const(ctx, ptr));
+ OUT_OF_SPACE_IF_NULL(null = sym_new_null(ctx));
stack_pointer[0] = value;
stack_pointer[1] = null;
stack_pointer += 2;
}
case _LOAD_CONST_INLINE_BORROW_WITH_NULL: {
- _Py_UOpsSymType *value;
- _Py_UOpsSymType *null;
+ _Py_UopsSymbol *value;
+ _Py_UopsSymbol *null;
PyObject *ptr = (PyObject *)this_instr->operand;
- OUT_OF_SPACE_IF_NULL(value = _Py_uop_sym_new_const(ctx, ptr));
- OUT_OF_SPACE_IF_NULL(null = _Py_uop_sym_new_null(ctx));
+ OUT_OF_SPACE_IF_NULL(value = sym_new_const(ctx, ptr));
+ OUT_OF_SPACE_IF_NULL(null = sym_new_null(ctx));
stack_pointer[0] = value;
stack_pointer[1] = null;
stack_pointer += 2;
#endif
// Takes a borrowed reference to const_val, turns that into a strong reference.
-static _Py_UOpsSymType*
-sym_new(_Py_UOpsAbstractInterpContext *ctx, PyObject *const_val)
+static _Py_UopsSymbol *
+sym_new(_Py_UOpsContext *ctx, PyObject *const_val)
{
- _Py_UOpsSymType *self = &ctx->t_arena.arena[ctx->t_arena.ty_curr_number];
+ _Py_UopsSymbol *self = &ctx->t_arena.arena[ctx->t_arena.ty_curr_number];
if (ctx->t_arena.ty_curr_number >= ctx->t_arena.ty_max_number) {
OPT_STAT_INC(optimizer_failure_reason_no_memory);
DPRINTF(1, "out of space for symbolic expression type\n");
}
static inline void
-sym_set_flag(_Py_UOpsSymType *sym, int flag)
+sym_set_flag(_Py_UopsSymbol *sym, int flag)
{
sym->flags |= flag;
}
static inline bool
-sym_has_flag(_Py_UOpsSymType *sym, int flag)
+sym_has_flag(_Py_UopsSymbol *sym, int flag)
{
return (sym->flags & flag) != 0;
}
bool
-_Py_uop_sym_is_not_null(_Py_UOpsSymType *sym)
+_Py_uop_sym_is_not_null(_Py_UopsSymbol *sym)
{
return (sym->flags & (IS_NULL | NOT_NULL)) == NOT_NULL;
}
bool
-_Py_uop_sym_is_null(_Py_UOpsSymType *sym)
+_Py_uop_sym_is_null(_Py_UopsSymbol *sym)
{
return (sym->flags & (IS_NULL | NOT_NULL)) == IS_NULL;
}
bool
-_Py_uop_sym_is_const(_Py_UOpsSymType *sym)
+_Py_uop_sym_is_const(_Py_UopsSymbol *sym)
{
return (sym->flags & TRUE_CONST) != 0;
}
PyObject *
-_Py_uop_sym_get_const(_Py_UOpsSymType *sym)
+_Py_uop_sym_get_const(_Py_UopsSymbol *sym)
{
assert(_Py_uop_sym_is_const(sym));
assert(sym->const_val);
}
void
-_Py_uop_sym_set_type(_Py_UOpsSymType *sym, PyTypeObject *tp)
+_Py_uop_sym_set_type(_Py_UopsSymbol *sym, PyTypeObject *tp)
{
assert(PyType_Check(tp));
sym->typ = tp;
}
void
-_Py_uop_sym_set_null(_Py_UOpsSymType *sym)
+_Py_uop_sym_set_null(_Py_UopsSymbol *sym)
{
sym_set_flag(sym, IS_NULL);
sym_set_flag(sym, KNOWN);
}
-_Py_UOpsSymType *
-_Py_uop_sym_new_unknown(_Py_UOpsAbstractInterpContext *ctx)
+_Py_UopsSymbol *
+_Py_uop_sym_new_unknown(_Py_UOpsContext *ctx)
{
- return sym_new(ctx,NULL);
+ return sym_new(ctx, NULL);
}
-_Py_UOpsSymType *
-_Py_uop_sym_new_not_null(_Py_UOpsAbstractInterpContext *ctx)
+_Py_UopsSymbol *
+_Py_uop_sym_new_not_null(_Py_UOpsContext *ctx)
{
- _Py_UOpsSymType *res = _Py_uop_sym_new_unknown(ctx);
+ _Py_UopsSymbol *res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) {
return NULL;
}
return res;
}
-_Py_UOpsSymType *
-_Py_uop_sym_new_type(_Py_UOpsAbstractInterpContext *ctx,
+_Py_UopsSymbol *
+_Py_uop_sym_new_type(_Py_UOpsContext *ctx,
PyTypeObject *typ)
{
- _Py_UOpsSymType *res = sym_new(ctx,NULL);
+ _Py_UopsSymbol *res = sym_new(ctx,NULL);
if (res == NULL) {
return NULL;
}
}
// Takes a borrowed reference to const_val.
-_Py_UOpsSymType*
-_Py_uop_sym_new_const(_Py_UOpsAbstractInterpContext *ctx, PyObject *const_val)
+_Py_UopsSymbol *
+_Py_uop_sym_new_const(_Py_UOpsContext *ctx, PyObject *const_val)
{
assert(const_val != NULL);
- _Py_UOpsSymType *temp = sym_new(
- ctx,
- const_val
- );
+ _Py_UopsSymbol *temp = sym_new(ctx, const_val);
if (temp == NULL) {
return NULL;
}
return temp;
}
-_Py_UOpsSymType*
-_Py_uop_sym_new_null(_Py_UOpsAbstractInterpContext *ctx)
+_Py_UopsSymbol *
+_Py_uop_sym_new_null(_Py_UOpsContext *ctx)
{
- _Py_UOpsSymType *null_sym = _Py_uop_sym_new_unknown(ctx);
+ _Py_UopsSymbol *null_sym = _Py_uop_sym_new_unknown(ctx);
if (null_sym == NULL) {
return NULL;
}
}
bool
-_Py_uop_sym_matches_type(_Py_UOpsSymType *sym, PyTypeObject *typ)
+_Py_uop_sym_matches_type(_Py_UopsSymbol *sym, PyTypeObject *typ)
{
assert(typ == NULL || PyType_Check(typ));
if (!sym_has_flag(sym, KNOWN)) {
// 0 on success, -1 on error.
_Py_UOpsAbstractFrame *
-_Py_uop_ctx_frame_new(
- _Py_UOpsAbstractInterpContext *ctx,
+_Py_uop_frame_new(
+ _Py_UOpsContext *ctx,
PyCodeObject *co,
- _Py_UOpsSymType **localsplus_start,
+ _Py_UopsSymbol **localsplus_start,
int n_locals_already_filled,
- int curr_stackentries
-)
+ int curr_stackentries)
{
assert(ctx->curr_frame_depth < MAX_ABSTRACT_FRAME_DEPTH);
_Py_UOpsAbstractFrame *frame = &ctx->frames[ctx->curr_frame_depth];
// Initialize with the initial state of all local variables
for (int i = n_locals_already_filled; i < co->co_nlocalsplus; i++) {
- _Py_UOpsSymType *local = _Py_uop_sym_new_unknown(ctx);
+ _Py_UopsSymbol *local = _Py_uop_sym_new_unknown(ctx);
if (local == NULL) {
return NULL;
}
// Initialize the stack as well
for (int i = 0; i < curr_stackentries; i++) {
- _Py_UOpsSymType *stackvar = _Py_uop_sym_new_unknown(ctx);
+ _Py_UopsSymbol *stackvar = _Py_uop_sym_new_unknown(ctx);
if (stackvar == NULL) {
return NULL;
}
}
void
-_Py_uop_abstractcontext_fini(_Py_UOpsAbstractInterpContext *ctx)
+_Py_uop_abstractcontext_fini(_Py_UOpsContext *ctx)
{
if (ctx == NULL) {
return;
}
int
-_Py_uop_abstractcontext_init(
- _Py_UOpsAbstractInterpContext *ctx
-)
+_Py_uop_abstractcontext_init(_Py_UOpsContext *ctx)
{
ctx->limit = ctx->locals_and_stack + MAX_ABSTRACT_INTERP_SIZE;
ctx->n_consumed = ctx->locals_and_stack;
}
int
-_Py_uop_ctx_frame_pop(
- _Py_UOpsAbstractInterpContext *ctx
-)
+_Py_uop_frame_pop(_Py_UOpsContext *ctx)
{
_Py_UOpsAbstractFrame *frame = ctx->frame;
-
ctx->n_consumed = frame->locals;
ctx->curr_frame_depth--;
assert(ctx->curr_frame_depth >= 1);
} while (0)
/*
-static _Py_UOpsSymType *
-make_bottom(_Py_UOpsAbstractInterpContext *ctx)
+static _Py_UopsSymbol *
+make_contradiction(_Py_UOpsContext *ctx)
{
- _Py_UOpsSymType *sym = _Py_uop_sym_new_unknown(ctx);
+ _Py_UopsSymbol *sym = _Py_uop_sym_new_unknown(ctx);
_Py_uop_sym_set_null(sym);
_Py_uop_sym_set_type(sym, &PyLong_Type);
return sym;
PyObject *
_Py_uop_symbols_test(PyObject *Py_UNUSED(self), PyObject *Py_UNUSED(ignored))
{
- _Py_UOpsAbstractInterpContext context;
- _Py_UOpsAbstractInterpContext *ctx = &context;
+ _Py_UOpsContext context;
+ _Py_UOpsContext *ctx = &context;
_Py_uop_abstractcontext_init(ctx);
- _Py_UOpsSymType *top = _Py_uop_sym_new_unknown(ctx);
+ _Py_UopsSymbol *top = _Py_uop_sym_new_unknown(ctx);
if (top == NULL) {
return NULL;
}
TEST_PREDICATE(!_Py_uop_sym_is_const(top), "unknown is a constant");
// TEST_PREDICATE(_Py_uop_sym_get_const(top) == NULL, "unknown as constant is not NULL");
- // _Py_UOpsSymType *bottom = make_bottom(ctx);
- // TEST_PREDICATE(_Py_uop_sym_is_null(bottom), "bottom is NULL is not true");
- // TEST_PREDICATE(_Py_uop_sym_is_not_null(bottom), "bottom is not NULL is not true");
- // TEST_PREDICATE(_Py_uop_sym_is_const(bottom), "bottom is a constant is not true");
+ // _Py_UopsSymbol *contradiction = make_contradiction(ctx);
+ // TEST_PREDICATE(_Py_uop_sym_is_null(contradiction), "contradiction is NULL is not true");
+ // TEST_PREDICATE(_Py_uop_sym_is_not_null(contradiction), "contradiction is not NULL is not true");
+ // TEST_PREDICATE(_Py_uop_sym_is_const(contradiction), "contradiction is a constant is not true");
- _Py_UOpsSymType *int_type = _Py_uop_sym_new_type(ctx, &PyLong_Type);
+ _Py_UopsSymbol *int_type = _Py_uop_sym_new_type(ctx, &PyLong_Type);
TEST_PREDICATE(_Py_uop_sym_matches_type(int_type, &PyLong_Type), "inconsistent type");
_Py_uop_sym_set_type(int_type, &PyLong_Type);
TEST_PREDICATE(_Py_uop_sym_matches_type(int_type, &PyLong_Type), "inconsistent type");
_Py_uop_sym_set_type(int_type, &PyFloat_Type);
- // TEST_PREDICATE(_Py_uop_sym_matches_type(int_type, &PyLong_Type), "bottom doesn't match int");
+ // TEST_PREDICATE(_Py_uop_sym_matches_type(int_type, &PyLong_Type), "(int and float) doesn't match int");
_Py_uop_abstractcontext_fini(ctx);
Py_RETURN_NONE;
projects / thirdparty / Python / cpython.git / commitdiff
