Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

GH-115816: Make tier2 optimizer symbols testable, and add a few tests. (GH-115953)

This commit is contained in:
Mark Shannon 2024-02-27 10:51:26 +00:00 committed by GitHub
parent af5f9d682c
commit 10fbcd6c5d
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
15 changed files with 720 additions and 607 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
Include/internal/pycore_optimizer.h
View File

@ -9,6 +9,7 @@ extern "C" {
#endif
#include "pycore_uop_ids.h"
#include <stdbool.h>
// This is the length of the trace we project initially.
#define UOP_MAX_TRACE_LENGTH 512
@ -25,6 +26,90 @@ extern PyTypeObject _PyDefaultOptimizer_Type;
extern PyTypeObject _PyUOpExecutor_Type;
extern PyTypeObject _PyUOpOptimizer_Type;
/* Symbols */
struct _Py_UOpsSymType {
int flags;
PyTypeObject *typ;
// constant propagated value (might be NULL)
PyObject *const_val;
};
// Holds locals, stack, locals, stack ... co_consts (in that order)
#define MAX_ABSTRACT_INTERP_SIZE 4096
#define OVERALLOCATE_FACTOR 5
#define TY_ARENA_SIZE (UOP_MAX_TRACE_LENGTH * OVERALLOCATE_FACTOR)
// Need extras for root frame and for overflow frame (see TRACE_STACK_PUSH())
#define MAX_ABSTRACT_FRAME_DEPTH (TRACE_STACK_SIZE + 2)
typedef struct _Py_UOpsSymType _Py_UOpsSymType;
struct _Py_UOpsAbstractFrame {
// Max stacklen
int stack_len;
int locals_len;
_Py_UOpsSymType **stack_pointer;
_Py_UOpsSymType **stack;
_Py_UOpsSymType **locals;
};
typedef struct _Py_UOpsAbstractFrame _Py_UOpsAbstractFrame;
typedef struct ty_arena {
int ty_curr_number;
int ty_max_number;
_Py_UOpsSymType arena[TY_ARENA_SIZE];
} ty_arena;
struct _Py_UOpsAbstractInterpContext {
PyObject_HEAD
// The current "executing" frame.
_Py_UOpsAbstractFrame *frame;
_Py_UOpsAbstractFrame frames[MAX_ABSTRACT_FRAME_DEPTH];
int curr_frame_depth;
// Arena for the symbolic types.
ty_arena t_arena;
_Py_UOpsSymType **n_consumed;
_Py_UOpsSymType **limit;
_Py_UOpsSymType *locals_and_stack[MAX_ABSTRACT_INTERP_SIZE];
};
typedef struct _Py_UOpsAbstractInterpContext _Py_UOpsAbstractInterpContext;
extern bool _Py_uop_sym_is_null(_Py_UOpsSymType *sym);
extern bool _Py_uop_sym_is_not_null(_Py_UOpsSymType *sym);
extern bool _Py_uop_sym_is_const(_Py_UOpsSymType *sym);
extern PyObject *_Py_uop_sym_get_const(_Py_UOpsSymType *sym);
extern _Py_UOpsSymType *_Py_uop_sym_new_unknown(_Py_UOpsAbstractInterpContext *ctx);
extern _Py_UOpsSymType *_Py_uop_sym_new_not_null(_Py_UOpsAbstractInterpContext *ctx);
extern _Py_UOpsSymType *_Py_uop_sym_new_type(
_Py_UOpsAbstractInterpContext *ctx, PyTypeObject *typ);
extern _Py_UOpsSymType *_Py_uop_sym_new_const(_Py_UOpsAbstractInterpContext *ctx, PyObject *const_val);
extern _Py_UOpsSymType *_Py_uop_sym_new_null(_Py_UOpsAbstractInterpContext *ctx);
extern bool _Py_uop_sym_matches_type(_Py_UOpsSymType *sym, PyTypeObject *typ);
extern void _Py_uop_sym_set_null(_Py_UOpsSymType *sym);
extern void _Py_uop_sym_set_type(_Py_UOpsSymType *sym, PyTypeObject *tp);
extern int _Py_uop_abstractcontext_init(_Py_UOpsAbstractInterpContext *ctx);
extern void _Py_uop_abstractcontext_fini(_Py_UOpsAbstractInterpContext *ctx);
extern _Py_UOpsAbstractFrame *_Py_uop_ctx_frame_new(
_Py_UOpsAbstractInterpContext *ctx,
PyCodeObject *co,
_Py_UOpsSymType **localsplus_start,
int n_locals_already_filled,
int curr_stackentries);
extern int _Py_uop_ctx_frame_pop(_Py_UOpsAbstractInterpContext *ctx);
PyAPI_FUNC(PyObject *)
_Py_uop_symbols_test(PyObject *self, PyObject *ignored);
#ifdef __cplusplus
}
#endif

4
Lib/test/test_generated_cases.py
View File

@ -900,7 +900,7 @@ class TestGeneratedAbstractCases(unittest.TestCase):
case OP2: {
_Py_UOpsSymType *out;
out = sym_new_unknown(ctx);
out = _Py_uop_sym_new_unknown(ctx);
if (out == NULL) goto out_of_space;
stack_pointer[-1] = out;
break;
@ -925,7 +925,7 @@ class TestGeneratedAbstractCases(unittest.TestCase):
output = """
case OP: {
_Py_UOpsSymType *out;
out = sym_new_unknown(ctx);
out = _Py_uop_sym_new_unknown(ctx);
if (out == NULL) goto out_of_space;
stack_pointer[-1] = out;
break;

7
Lib/test/test_optimizer.py
View File

@ -77,5 +77,12 @@ class TestRareEventCounters(unittest.TestCase):
_testinternalcapi.get_rare_event_counters()["func_modification"]
)
class TestOptimizerSymbols(unittest.TestCase):
def test_optimizer_symbols(self):
_testinternalcapi.uop_symbols_test()
if __name__ == "__main__":
unittest.main()

1
Makefile.pre.in
View File

@ -446,6 +446,7 @@ PYTHON_OBJS= \
Python/object_stack.o \
Python/optimizer.o \
Python/optimizer_analysis.o \
Python/optimizer_symbols.o \
Python/parking_lot.o \
Python/pathconfig.o \
Python/preconfig.o \

3
Modules/_testinternalcapi.c
View File

@ -24,6 +24,7 @@
#include "pycore_interp.h" // _PyInterpreterState_GetConfigCopy()
#include "pycore_long.h" // _PyLong_Sign()
#include "pycore_object.h" // _PyObject_IsFreed()
#include "pycore_optimizer.h" // _Py_UOpsSymType, etc.
#include "pycore_pathconfig.h" // _PyPathConfig_ClearGlobal()
#include "pycore_pyerrors.h" // _PyErr_ChainExceptions1()
#include "pycore_pystate.h" // _PyThreadState_GET()
@ -1677,7 +1678,6 @@ get_py_thread_id(PyObject *self, PyObject *Py_UNUSED(ignored))
}
#endif
static PyMethodDef module_functions[] = {
{"get_configs", get_configs, METH_NOARGS},
{"get_recursion_depth", get_recursion_depth, METH_NOARGS},
@ -1747,6 +1747,7 @@ static PyMethodDef module_functions[] = {
#ifdef Py_GIL_DISABLED
{"py_thread_id", get_py_thread_id, METH_NOARGS},
#endif
{"uop_symbols_test", _Py_uop_symbols_test, METH_NOARGS},
{NULL, NULL} /* sentinel */
};

1
PCbuild/_freeze_module.vcxproj
View File

@ -235,6 +235,7 @@
<ClCompile Include="..\Python\object_stack.c" />
<ClCompile Include="..\Python\optimizer.c" />
<ClCompile Include="..\Python\optimizer_analysis.c" />
<ClCompile Include="..\Python\optimizer_symbols.c" />
<ClCompile Include="..\Python\parking_lot.c" />
<ClCompile Include="..\Python\pathconfig.c" />
<ClCompile Include="..\Python\perf_trampoline.c" />

3
PCbuild/_freeze_module.vcxproj.filters
View File

@ -310,6 +310,9 @@
<ClCompile Include="..\Python\optimizer_analysis.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\Python\optimizer_symbols.c">
<Filter>Python</Filter>
</ClCompile>
<ClCompile Include="..\Parser\parser.c">
<Filter>Source Files</Filter>
</ClCompile>

1
PCbuild/pythoncore.vcxproj
View File

@ -601,6 +601,7 @@
<ClCompile Include="..\Python\object_stack.c" />
<ClCompile Include="..\Python\optimizer.c" />
<ClCompile Include="..\Python\optimizer_analysis.c" />
<ClCompile Include="..\Python\optimizer_symbols.c" />
<ClCompile Include="..\Python\parking_lot.c" />
<ClCompile Include="..\Python\pathconfig.c" />
<ClCompile Include="..\Python\perf_trampoline.c" />

3
PCbuild/pythoncore.vcxproj.filters
View File

@ -1382,6 +1382,9 @@
<ClCompile Include="..\Python\optimizer_analysis.c">
<Filter>Python</Filter>
</ClCompile>
<ClCompile Include="..\Python\optimizer_symbols.c">
<Filter>Python</Filter>
</ClCompile>
<ClCompile Include="..\Python\parking_lot.c">
<Filter>Python</Filter>
</ClCompile>

343
Python/optimizer_analysis.c
View File

@ -33,16 +33,6 @@
#include <stdint.h>
#include <stddef.h>
// Holds locals, stack, locals, stack ... co_consts (in that order)
#define MAX_ABSTRACT_INTERP_SIZE 4096
#define OVERALLOCATE_FACTOR 5
#define TY_ARENA_SIZE (UOP_MAX_TRACE_LENGTH * OVERALLOCATE_FACTOR)
// Need extras for root frame and for overflow frame (see TRACE_STACK_PUSH())
#define MAX_ABSTRACT_FRAME_DEPTH (TRACE_STACK_SIZE + 2)
#ifdef Py_DEBUG
extern const char *_PyUOpName(int index);
static const char *const DEBUG_ENV = "PYTHON_OPT_DEBUG";
@ -61,318 +51,6 @@
#endif
// Flags for below.
#define KNOWN 1 << 0
#define TRUE_CONST 1 << 1
#define IS_NULL 1 << 2
#define NOT_NULL 1 << 3
typedef struct {
int flags;
PyTypeObject *typ;
// constant propagated value (might be NULL)
PyObject *const_val;
} _Py_UOpsSymType;
typedef struct _Py_UOpsAbstractFrame {
// Max stacklen
int stack_len;
int locals_len;
_Py_UOpsSymType **stack_pointer;
_Py_UOpsSymType **stack;
_Py_UOpsSymType **locals;
} _Py_UOpsAbstractFrame;
typedef struct ty_arena {
int ty_curr_number;
int ty_max_number;
_Py_UOpsSymType arena[TY_ARENA_SIZE];
} ty_arena;
// Tier 2 types meta interpreter
typedef struct _Py_UOpsAbstractInterpContext {
PyObject_HEAD
// The current "executing" frame.
_Py_UOpsAbstractFrame *frame;
_Py_UOpsAbstractFrame frames[MAX_ABSTRACT_FRAME_DEPTH];
int curr_frame_depth;
// Arena for the symbolic types.
ty_arena t_arena;
_Py_UOpsSymType **n_consumed;
_Py_UOpsSymType **limit;
_Py_UOpsSymType *locals_and_stack[MAX_ABSTRACT_INTERP_SIZE];
} _Py_UOpsAbstractInterpContext;
static inline _Py_UOpsSymType* sym_new_unknown(_Py_UOpsAbstractInterpContext *ctx);
// 0 on success, -1 on error.
static _Py_UOpsAbstractFrame *
ctx_frame_new(
_Py_UOpsAbstractInterpContext *ctx,
PyCodeObject *co,
_Py_UOpsSymType **localsplus_start,
int n_locals_already_filled,
int curr_stackentries
)
{
assert(ctx->curr_frame_depth < MAX_ABSTRACT_FRAME_DEPTH);
_Py_UOpsAbstractFrame *frame = &ctx->frames[ctx->curr_frame_depth];
frame->stack_len = co->co_stacksize;
frame->locals_len = co->co_nlocalsplus;
frame->locals = localsplus_start;
frame->stack = frame->locals + co->co_nlocalsplus;
frame->stack_pointer = frame->stack + curr_stackentries;
ctx->n_consumed = localsplus_start + (co->co_nlocalsplus + co->co_stacksize);
if (ctx->n_consumed >= ctx->limit) {
return NULL;
}
// Initialize with the initial state of all local variables
for (int i = n_locals_already_filled; i < co->co_nlocalsplus; i++) {
_Py_UOpsSymType *local = sym_new_unknown(ctx);
if (local == NULL) {
return NULL;
}
frame->locals[i] = local;
}
// Initialize the stack as well
for (int i = 0; i < curr_stackentries; i++) {
_Py_UOpsSymType *stackvar = sym_new_unknown(ctx);
if (stackvar == NULL) {
return NULL;
}
frame->stack[i] = stackvar;
}
return frame;
}
static void
abstractcontext_fini(_Py_UOpsAbstractInterpContext *ctx)
{
if (ctx == NULL) {
return;
}
ctx->curr_frame_depth = 0;
int tys = ctx->t_arena.ty_curr_number;
for (int i = 0; i < tys; i++) {
Py_CLEAR(ctx->t_arena.arena[i].const_val);
}
}
static int
abstractcontext_init(
_Py_UOpsAbstractInterpContext *ctx,
PyCodeObject *co,
int curr_stacklen,
int ir_entries
)
{
ctx->limit = ctx->locals_and_stack + MAX_ABSTRACT_INTERP_SIZE;
ctx->n_consumed = ctx->locals_and_stack;
#ifdef Py_DEBUG // Aids debugging a little. There should never be NULL in the abstract interpreter.
for (int i = 0 ; i < MAX_ABSTRACT_INTERP_SIZE; i++) {
ctx->locals_and_stack[i] = NULL;
}
#endif
// Setup the arena for sym expressions.
ctx->t_arena.ty_curr_number = 0;
ctx->t_arena.ty_max_number = TY_ARENA_SIZE;
// Frame setup
ctx->curr_frame_depth = 0;
_Py_UOpsAbstractFrame *frame = ctx_frame_new(ctx, co, ctx->n_consumed, 0, curr_stacklen);
if (frame == NULL) {
return -1;
}
ctx->curr_frame_depth++;
ctx->frame = frame;
return 0;
}
static int
ctx_frame_pop(
_Py_UOpsAbstractInterpContext *ctx
)
{
_Py_UOpsAbstractFrame *frame = ctx->frame;
ctx->n_consumed = frame->locals;
ctx->curr_frame_depth--;
assert(ctx->curr_frame_depth >= 1);
ctx->frame = &ctx->frames[ctx->curr_frame_depth - 1];
return 0;
}
// Takes a borrowed reference to const_val, turns that into a strong reference.
static _Py_UOpsSymType*
sym_new(_Py_UOpsAbstractInterpContext *ctx,
PyObject *const_val)
{
_Py_UOpsSymType *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");
return NULL;
}
ctx->t_arena.ty_curr_number++;
self->const_val = NULL;
self->typ = NULL;
self->flags = 0;
if (const_val != NULL) {
self->const_val = Py_NewRef(const_val);
}
return self;
}
static inline void
sym_set_flag(_Py_UOpsSymType *sym, int flag)
{
sym->flags |= flag;
}
static inline bool
sym_has_flag(_Py_UOpsSymType *sym, int flag)
{
return (sym->flags & flag) != 0;
}
static inline bool
sym_is_known(_Py_UOpsSymType *sym)
{
return sym_has_flag(sym, KNOWN);
}
static inline bool
sym_is_not_null(_Py_UOpsSymType *sym)
{
return (sym->flags & (IS_NULL | NOT_NULL)) == NOT_NULL;
}
static inline bool
sym_is_null(_Py_UOpsSymType *sym)
{
return (sym->flags & (IS_NULL | NOT_NULL)) == IS_NULL;
}
static inline bool
sym_is_const(_Py_UOpsSymType *sym)
{
return (sym->flags & TRUE_CONST) != 0;
}
static inline PyObject *
sym_get_const(_Py_UOpsSymType *sym)
{
assert(sym_is_const(sym));
assert(sym->const_val);
return sym->const_val;
}
static inline void
sym_set_type(_Py_UOpsSymType *sym, PyTypeObject *tp)
{
assert(PyType_Check(tp));
sym->typ = tp;
sym_set_flag(sym, KNOWN);
sym_set_flag(sym, NOT_NULL);
}
static inline void
sym_set_null(_Py_UOpsSymType *sym)
{
sym_set_flag(sym, IS_NULL);
sym_set_flag(sym, KNOWN);
}
static inline _Py_UOpsSymType*
sym_new_unknown(_Py_UOpsAbstractInterpContext *ctx)
{
return sym_new(ctx,NULL);
}
static inline _Py_UOpsSymType*
sym_new_known_notnull(_Py_UOpsAbstractInterpContext *ctx)
{
_Py_UOpsSymType *res = sym_new_unknown(ctx);
if (res == NULL) {
return NULL;
}
sym_set_flag(res, KNOWN);
sym_set_flag(res, NOT_NULL);
return res;
}
static inline _Py_UOpsSymType*
sym_new_known_type(_Py_UOpsAbstractInterpContext *ctx,
PyTypeObject *typ)
{
_Py_UOpsSymType *res = sym_new(ctx,NULL);
if (res == NULL) {
return NULL;
}
sym_set_type(res, typ);
return res;
}
// Takes a borrowed reference to const_val.
static inline _Py_UOpsSymType*
sym_new_const(_Py_UOpsAbstractInterpContext *ctx, PyObject *const_val)
{
assert(const_val != NULL);
_Py_UOpsSymType *temp = sym_new(
ctx,
const_val
);
if (temp == NULL) {
return NULL;
}
sym_set_type(temp, Py_TYPE(const_val));
sym_set_flag(temp, TRUE_CONST);
sym_set_flag(temp, KNOWN);
sym_set_flag(temp, NOT_NULL);
return temp;
}
static _Py_UOpsSymType*
sym_new_null(_Py_UOpsAbstractInterpContext *ctx)
{
_Py_UOpsSymType *null_sym = sym_new_unknown(ctx);
if (null_sym == NULL) {
return NULL;
}
sym_set_null(null_sym);
return null_sym;
}
static inline bool
sym_matches_type(_Py_UOpsSymType *sym, PyTypeObject *typ)
{
assert(typ == NULL || PyType_Check(typ));
if (!sym_has_flag(sym, KNOWN)) {
return false;
}
return sym->typ == typ;
}
static inline bool
op_is_end(uint32_t opcode)
@ -599,8 +277,8 @@ remove_globals(_PyInterpreterFrame *frame, _PyUOpInstruction *buffer,
#define _LOAD_ATTR_NOT_NULL \
do { \
OUT_OF_SPACE_IF_NULL(attr = sym_new_known_notnull(ctx)); \
OUT_OF_SPACE_IF_NULL(null = sym_new_null(ctx)); \
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);
@ -618,12 +296,15 @@ optimize_uops(
_Py_UOpsAbstractInterpContext context;
_Py_UOpsAbstractInterpContext *ctx = &context;
if (abstractcontext_init(
ctx,
co, curr_stacklen,
trace_len) < 0) {
if (_Py_uop_abstractcontext_init(ctx) < 0) {
goto out_of_space;
}
_Py_UOpsAbstractFrame *frame = _Py_uop_ctx_frame_new(ctx, co, ctx->n_consumed, 0, curr_stacklen);
if (frame == NULL) {
return -1;
}
ctx->curr_frame_depth++;
ctx->frame = frame;
for (_PyUOpInstruction *this_instr = trace;
this_instr < trace + trace_len && !op_is_end(this_instr->opcode);
@ -650,17 +331,17 @@ optimize_uops(
assert(STACK_LEVEL() >= 0);
}
abstractcontext_fini(ctx);
_Py_uop_abstractcontext_fini(ctx);
return 1;
out_of_space:
DPRINTF(1, "Out of space in abstract interpreter\n");
abstractcontext_fini(ctx);
_Py_uop_abstractcontext_fini(ctx);
return 0;
error:
DPRINTF(1, "Encountered error in abstract interpreter\n");
abstractcontext_fini(ctx);
_Py_uop_abstractcontext_fini(ctx);
return 0;
}

170
Python/optimizer_bytecodes.c
View File

@ -33,7 +33,7 @@ dummy_func(void) {
op(_LOAD_FAST_CHECK, (-- value)) {
value = GETLOCAL(oparg);
// We guarantee this will error - just bail and don't optimize it.
if (sym_is_null(value)) {
if (_Py_uop_sym_is_null(value)) {
goto out_of_space;
}
}
@ -45,7 +45,7 @@ dummy_func(void) {
op(_LOAD_FAST_AND_CLEAR, (-- value)) {
value = GETLOCAL(oparg);
_Py_UOpsSymType *temp;
OUT_OF_SPACE_IF_NULL(temp = sym_new_null(ctx));
OUT_OF_SPACE_IF_NULL(temp = _Py_uop_sym_new_null(ctx));
GETLOCAL(oparg) = temp;
}
@ -54,147 +54,147 @@ dummy_func(void) {
}
op(_PUSH_NULL, (-- res)) {
res = sym_new_null(ctx);
res = _Py_uop_sym_new_null(ctx);
if (res == NULL) {
goto out_of_space;
};
}
op(_GUARD_BOTH_INT, (left, right -- left, right)) {
if (sym_matches_type(left, &PyLong_Type) &&
sym_matches_type(right, &PyLong_Type)) {
if (_Py_uop_sym_matches_type(left, &PyLong_Type) &&
_Py_uop_sym_matches_type(right, &PyLong_Type)) {
REPLACE_OP(this_instr, _NOP, 0, 0);
}
sym_set_type(left, &PyLong_Type);
sym_set_type(right, &PyLong_Type);
_Py_uop_sym_set_type(left, &PyLong_Type);
_Py_uop_sym_set_type(right, &PyLong_Type);
}
op(_GUARD_BOTH_FLOAT, (left, right -- left, right)) {
if (sym_matches_type(left, &PyFloat_Type) &&
sym_matches_type(right, &PyFloat_Type)) {
if (_Py_uop_sym_matches_type(left, &PyFloat_Type) &&
_Py_uop_sym_matches_type(right, &PyFloat_Type)) {
REPLACE_OP(this_instr, _NOP, 0 ,0);
}
sym_set_type(left, &PyFloat_Type);
sym_set_type(right, &PyFloat_Type);
_Py_uop_sym_set_type(left, &PyFloat_Type);
_Py_uop_sym_set_type(right, &PyFloat_Type);
}
op(_GUARD_BOTH_UNICODE, (left, right -- left, right)) {
if (sym_matches_type(left, &PyUnicode_Type) &&
sym_matches_type(right, &PyUnicode_Type)) {
if (_Py_uop_sym_matches_type(left, &PyUnicode_Type) &&
_Py_uop_sym_matches_type(right, &PyUnicode_Type)) {
REPLACE_OP(this_instr, _NOP, 0 ,0);
}
sym_set_type(left, &PyUnicode_Type);
sym_set_type(right, &PyUnicode_Type);
_Py_uop_sym_set_type(left, &PyUnicode_Type);
_Py_uop_sym_set_type(right, &PyUnicode_Type);
}
op(_BINARY_OP_ADD_INT, (left, right -- res)) {
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 (_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 (temp == NULL) {
goto error;
}
OUT_OF_SPACE_IF_NULL(res = sym_new_const(ctx, temp));
OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_const(ctx, temp));
// TODO gh-115506:
// replace opcode with constant propagated one and add tests!
}
else {
OUT_OF_SPACE_IF_NULL(res = sym_new_known_type(ctx, &PyLong_Type));
OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_type(ctx, &PyLong_Type));
}
}
op(_BINARY_OP_SUBTRACT_INT, (left, right -- res)) {
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 (_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 (temp == NULL) {
goto error;
}
OUT_OF_SPACE_IF_NULL(res = sym_new_const(ctx, temp));
OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_const(ctx, temp));
// TODO gh-115506:
// replace opcode with constant propagated one and add tests!
}
else {
OUT_OF_SPACE_IF_NULL(res = sym_new_known_type(ctx, &PyLong_Type));
OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_type(ctx, &PyLong_Type));
}
}
op(_BINARY_OP_MULTIPLY_INT, (left, right -- res)) {
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 (_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 (temp == NULL) {
goto error;
}
OUT_OF_SPACE_IF_NULL(res = sym_new_const(ctx, temp));
OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_const(ctx, temp));
// TODO gh-115506:
// replace opcode with constant propagated one and add tests!
}
else {
OUT_OF_SPACE_IF_NULL(res = sym_new_known_type(ctx, &PyLong_Type));
OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_type(ctx, &PyLong_Type));
}
}
op(_BINARY_OP_ADD_FLOAT, (left, right -- res)) {
if (sym_is_const(left) && sym_is_const(right)) {
assert(PyFloat_CheckExact(sym_get_const(left)));
assert(PyFloat_CheckExact(sym_get_const(right)));
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)));
PyObject *temp = PyFloat_FromDouble(
PyFloat_AS_DOUBLE(sym_get_const(left)) +
PyFloat_AS_DOUBLE(sym_get_const(right)));
PyFloat_AS_DOUBLE(_Py_uop_sym_get_const(left)) +
PyFloat_AS_DOUBLE(_Py_uop_sym_get_const(right)));
if (temp == NULL) {
goto error;
}
res = sym_new_const(ctx, temp);
res = _Py_uop_sym_new_const(ctx, temp);
// TODO gh-115506:
// replace opcode with constant propagated one and update tests!
}
else {
OUT_OF_SPACE_IF_NULL(res = sym_new_known_type(ctx, &PyFloat_Type));
OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_type(ctx, &PyFloat_Type));
}
}
op(_BINARY_OP_SUBTRACT_FLOAT, (left, right -- res)) {
if (sym_is_const(left) && sym_is_const(right)) {
assert(PyFloat_CheckExact(sym_get_const(left)));
assert(PyFloat_CheckExact(sym_get_const(right)));
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)));
PyObject *temp = PyFloat_FromDouble(
PyFloat_AS_DOUBLE(sym_get_const(left)) -
PyFloat_AS_DOUBLE(sym_get_const(right)));
PyFloat_AS_DOUBLE(_Py_uop_sym_get_const(left)) -
PyFloat_AS_DOUBLE(_Py_uop_sym_get_const(right)));
if (temp == NULL) {
goto error;
}
res = sym_new_const(ctx, temp);
res = _Py_uop_sym_new_const(ctx, temp);
// TODO gh-115506:
// replace opcode with constant propagated one and update tests!
}
else {
OUT_OF_SPACE_IF_NULL(res = sym_new_known_type(ctx, &PyFloat_Type));
OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_type(ctx, &PyFloat_Type));
}
}
op(_BINARY_OP_MULTIPLY_FLOAT, (left, right -- res)) {
if (sym_is_const(left) && sym_is_const(right)) {
assert(PyFloat_CheckExact(sym_get_const(left)));
assert(PyFloat_CheckExact(sym_get_const(right)));
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)));
PyObject *temp = PyFloat_FromDouble(
PyFloat_AS_DOUBLE(sym_get_const(left)) *
PyFloat_AS_DOUBLE(sym_get_const(right)));
PyFloat_AS_DOUBLE(_Py_uop_sym_get_const(left)) *
PyFloat_AS_DOUBLE(_Py_uop_sym_get_const(right)));
if (temp == NULL) {
goto error;
}
res = sym_new_const(ctx, temp);
res = _Py_uop_sym_new_const(ctx, temp);
// TODO gh-115506:
// replace opcode with constant propagated one and update tests!
}
else {
OUT_OF_SPACE_IF_NULL(res = sym_new_known_type(ctx, &PyFloat_Type));
OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_type(ctx, &PyFloat_Type));
}
}
@ -205,21 +205,21 @@ dummy_func(void) {
}
op(_LOAD_CONST_INLINE, (ptr/4 -- value)) {
OUT_OF_SPACE_IF_NULL(value = sym_new_const(ctx, ptr));
OUT_OF_SPACE_IF_NULL(value = _Py_uop_sym_new_const(ctx, ptr));
}
op(_LOAD_CONST_INLINE_BORROW, (ptr/4 -- value)) {
OUT_OF_SPACE_IF_NULL(value = sym_new_const(ctx, ptr));
OUT_OF_SPACE_IF_NULL(value = _Py_uop_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));
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));
}
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));
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));
}
@ -240,8 +240,8 @@ dummy_func(void) {
op(_CHECK_ATTR_MODULE, (dict_version/2, owner -- owner)) {
(void)dict_version;
if (sym_is_const(owner)) {
PyObject *cnst = sym_get_const(owner);
if (_Py_uop_sym_is_const(owner)) {
PyObject *cnst = _Py_uop_sym_get_const(owner);
if (PyModule_CheckExact(cnst)) {
PyModuleObject *mod = (PyModuleObject *)cnst;
PyObject *dict = mod->md_dict;
@ -257,23 +257,23 @@ dummy_func(void) {
op(_LOAD_ATTR_MODULE, (index/1, owner -- attr, null if (oparg & 1))) {
(void)index;
OUT_OF_SPACE_IF_NULL(null = sym_new_null(ctx));
OUT_OF_SPACE_IF_NULL(null = _Py_uop_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(sym_is_const(owner));
PyModuleObject *mod = (PyModuleObject *)sym_get_const(owner);
assert(_Py_uop_sym_is_const(owner));
PyModuleObject *mod = (PyModuleObject *)_Py_uop_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 = sym_new_const(ctx, res));
OUT_OF_SPACE_IF_NULL(attr = _Py_uop_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_known_notnull(ctx));
OUT_OF_SPACE_IF_NULL(attr = _Py_uop_sym_new_not_null(ctx));
}
}
@ -297,38 +297,38 @@ dummy_func(void) {
op(_LOAD_ATTR_METHOD_WITH_VALUES, (descr/4, owner -- attr, self if (1))) {
(void)descr;
OUT_OF_SPACE_IF_NULL(attr = sym_new_known_notnull(ctx));
OUT_OF_SPACE_IF_NULL(attr = _Py_uop_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_known_notnull(ctx));
OUT_OF_SPACE_IF_NULL(attr = _Py_uop_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_known_notnull(ctx));
OUT_OF_SPACE_IF_NULL(attr = _Py_uop_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_known_notnull(ctx));
OUT_OF_SPACE_IF_NULL(self = sym_new_known_notnull(ctx));
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));
}
op(_CHECK_FUNCTION_EXACT_ARGS, (func_version/2, callable, self_or_null, unused[oparg] -- callable, self_or_null, unused[oparg])) {
sym_set_type(callable, &PyFunction_Type);
_Py_uop_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])) {
sym_set_null(null);
sym_set_type(callable, &PyMethod_Type);
_Py_uop_sym_set_null(null);
_Py_uop_sym_set_type(callable, &PyMethod_Type);
}
op(_INIT_CALL_PY_EXACT_ARGS, (callable, self_or_null, args[oparg] -- new_frame: _Py_UOpsAbstractFrame *)) {
@ -344,7 +344,7 @@ dummy_func(void) {
assert(self_or_null != NULL);
assert(args != NULL);
if (sym_is_not_null(self_or_null)) {
if (_Py_uop_sym_is_not_null(self_or_null)) {
// Bound method fiddling, same as _INIT_CALL_PY_EXACT_ARGS in VM
args--;
argcount++;
@ -355,18 +355,18 @@ dummy_func(void) {
// 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 (sym_is_known(self_or_null)) {
if (_Py_uop_sym_is_null(self_or_null) || _Py_uop_sym_is_not_null(self_or_null)) {
localsplus_start = args;
n_locals_already_filled = argcount;
}
OUT_OF_SPACE_IF_NULL(new_frame =
ctx_frame_new(ctx, co, localsplus_start, n_locals_already_filled, 0));
_Py_uop_ctx_frame_new(ctx, co, localsplus_start, n_locals_already_filled, 0));
}
op(_POP_FRAME, (retval -- res)) {
SYNC_SP();
ctx->frame->stack_pointer = stack_pointer;
ctx_frame_pop(ctx);
_Py_uop_ctx_frame_pop(ctx);
stack_pointer = ctx->frame->stack_pointer;
res = retval;
}
@ -383,7 +383,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));
OUT_OF_SPACE_IF_NULL(values[i] = _Py_uop_sym_new_unknown(ctx));
}
}
@ -392,12 +392,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));
OUT_OF_SPACE_IF_NULL(values[i] = _Py_uop_sym_new_unknown(ctx));
}
}
op(_ITER_NEXT_RANGE, (iter -- iter, next)) {
OUT_OF_SPACE_IF_NULL(next = sym_new_known_type(ctx, &PyLong_Type));
OUT_OF_SPACE_IF_NULL(next = _Py_uop_sym_new_type(ctx, &PyLong_Type));
(void)iter;
}

366
Python/optimizer_cases.c.h generated
View File

File diff suppressed because it is too large Load Diff

332
Python/optimizer_symbols.c Normal file
View File

@ -0,0 +1,332 @@
#include "Python.h"
#include "cpython/optimizer.h"
#include "pycore_code.h"
#include "pycore_frame.h"
#include "pycore_optimizer.h"
#include <stdbool.h>
#include <stdint.h>
#include <stddef.h>
// Flags for below.
#define KNOWN 1 << 0
#define TRUE_CONST 1 << 1
#define IS_NULL 1 << 2
#define NOT_NULL 1 << 3
#ifdef Py_DEBUG
static inline int get_lltrace(void) {
char *uop_debug = Py_GETENV("PYTHON_OPT_DEBUG");
int lltrace = 0;
if (uop_debug != NULL && *uop_debug >= '0') {
lltrace = *uop_debug - '0'; // TODO: Parse an int and all that
}
return lltrace;
}
#define DPRINTF(level, ...) \
if (get_lltrace() >= (level)) { printf(__VA_ARGS__); }
#else
#define DPRINTF(level, ...)
#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)
{
_Py_UOpsSymType *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");
return NULL;
}
ctx->t_arena.ty_curr_number++;
self->const_val = NULL;
self->typ = NULL;
self->flags = 0;
if (const_val != NULL) {
self->const_val = Py_NewRef(const_val);
}
return self;
}
static inline void
sym_set_flag(_Py_UOpsSymType *sym, int flag)
{
sym->flags |= flag;
}
static inline bool
sym_has_flag(_Py_UOpsSymType *sym, int flag)
{
return (sym->flags & flag) != 0;
}
bool
_Py_uop_sym_is_not_null(_Py_UOpsSymType *sym)
{
return (sym->flags & (IS_NULL | NOT_NULL)) == NOT_NULL;
}
bool
_Py_uop_sym_is_null(_Py_UOpsSymType *sym)
{
return (sym->flags & (IS_NULL | NOT_NULL)) == IS_NULL;
}
bool
_Py_uop_sym_is_const(_Py_UOpsSymType *sym)
{
return (sym->flags & TRUE_CONST) != 0;
}
PyObject *
_Py_uop_sym_get_const(_Py_UOpsSymType *sym)
{
assert(_Py_uop_sym_is_const(sym));
assert(sym->const_val);
return sym->const_val;
}
void
_Py_uop_sym_set_type(_Py_UOpsSymType *sym, PyTypeObject *tp)
{
assert(PyType_Check(tp));
sym->typ = tp;
sym_set_flag(sym, KNOWN);
sym_set_flag(sym, NOT_NULL);
}
void
_Py_uop_sym_set_null(_Py_UOpsSymType *sym)
{
sym_set_flag(sym, IS_NULL);
sym_set_flag(sym, KNOWN);
}
_Py_UOpsSymType *
_Py_uop_sym_new_unknown(_Py_UOpsAbstractInterpContext *ctx)
{
return sym_new(ctx,NULL);
}
_Py_UOpsSymType *
_Py_uop_sym_new_not_null(_Py_UOpsAbstractInterpContext *ctx)
{
_Py_UOpsSymType *res = _Py_uop_sym_new_unknown(ctx);
if (res == NULL) {
return NULL;
}
sym_set_flag(res, KNOWN);
sym_set_flag(res, NOT_NULL);
return res;
}
_Py_UOpsSymType *
_Py_uop_sym_new_type(_Py_UOpsAbstractInterpContext *ctx,
PyTypeObject *typ)
{
_Py_UOpsSymType *res = sym_new(ctx,NULL);
if (res == NULL) {
return NULL;
}
_Py_uop_sym_set_type(res, typ);
return res;
}
// Takes a borrowed reference to const_val.
_Py_UOpsSymType*
_Py_uop_sym_new_const(_Py_UOpsAbstractInterpContext *ctx, PyObject *const_val)
{
assert(const_val != NULL);
_Py_UOpsSymType *temp = sym_new(
ctx,
const_val
);
if (temp == NULL) {
return NULL;
}
_Py_uop_sym_set_type(temp, Py_TYPE(const_val));
sym_set_flag(temp, TRUE_CONST);
sym_set_flag(temp, KNOWN);
sym_set_flag(temp, NOT_NULL);
return temp;
}
_Py_UOpsSymType*
_Py_uop_sym_new_null(_Py_UOpsAbstractInterpContext *ctx)
{
_Py_UOpsSymType *null_sym = _Py_uop_sym_new_unknown(ctx);
if (null_sym == NULL) {
return NULL;
}
_Py_uop_sym_set_null(null_sym);
return null_sym;
}
bool
_Py_uop_sym_matches_type(_Py_UOpsSymType *sym, PyTypeObject *typ)
{
assert(typ == NULL || PyType_Check(typ));
if (!sym_has_flag(sym, KNOWN)) {
return false;
}
return sym->typ == typ;
}
// 0 on success, -1 on error.
_Py_UOpsAbstractFrame *
_Py_uop_ctx_frame_new(
_Py_UOpsAbstractInterpContext *ctx,
PyCodeObject *co,
_Py_UOpsSymType **localsplus_start,
int n_locals_already_filled,
int curr_stackentries
)
{
assert(ctx->curr_frame_depth < MAX_ABSTRACT_FRAME_DEPTH);
_Py_UOpsAbstractFrame *frame = &ctx->frames[ctx->curr_frame_depth];
frame->stack_len = co->co_stacksize;
frame->locals_len = co->co_nlocalsplus;
frame->locals = localsplus_start;
frame->stack = frame->locals + co->co_nlocalsplus;
frame->stack_pointer = frame->stack + curr_stackentries;
ctx->n_consumed = localsplus_start + (co->co_nlocalsplus + co->co_stacksize);
if (ctx->n_consumed >= ctx->limit) {
return NULL;
}
// 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);
if (local == NULL) {
return NULL;
}
frame->locals[i] = local;
}
// Initialize the stack as well
for (int i = 0; i < curr_stackentries; i++) {
_Py_UOpsSymType *stackvar = _Py_uop_sym_new_unknown(ctx);
if (stackvar == NULL) {
return NULL;
}
frame->stack[i] = stackvar;
}
return frame;
}
void
_Py_uop_abstractcontext_fini(_Py_UOpsAbstractInterpContext *ctx)
{
if (ctx == NULL) {
return;
}
ctx->curr_frame_depth = 0;
int tys = ctx->t_arena.ty_curr_number;
for (int i = 0; i < tys; i++) {
Py_CLEAR(ctx->t_arena.arena[i].const_val);
}
}
int
_Py_uop_abstractcontext_init(
_Py_UOpsAbstractInterpContext *ctx
)
{
ctx->limit = ctx->locals_and_stack + MAX_ABSTRACT_INTERP_SIZE;
ctx->n_consumed = ctx->locals_and_stack;
#ifdef Py_DEBUG // Aids debugging a little. There should never be NULL in the abstract interpreter.
for (int i = 0 ; i < MAX_ABSTRACT_INTERP_SIZE; i++) {
ctx->locals_and_stack[i] = NULL;
}
#endif
// Setup the arena for sym expressions.
ctx->t_arena.ty_curr_number = 0;
ctx->t_arena.ty_max_number = TY_ARENA_SIZE;
// Frame setup
ctx->curr_frame_depth = 0;
return 0;
}
int
_Py_uop_ctx_frame_pop(
_Py_UOpsAbstractInterpContext *ctx
)
{
_Py_UOpsAbstractFrame *frame = ctx->frame;
ctx->n_consumed = frame->locals;
ctx->curr_frame_depth--;
assert(ctx->curr_frame_depth >= 1);
ctx->frame = &ctx->frames[ctx->curr_frame_depth - 1];
return 0;
}
#define TEST_PREDICATE(PRED, MSG) \
do { \
if (!(PRED)) { \
PyErr_SetString( \
PyExc_AssertionError, \
(MSG)); \
goto fail; \
} \
} while (0)
/*
static _Py_UOpsSymType *
make_bottom(_Py_UOpsAbstractInterpContext *ctx)
{
_Py_UOpsSymType *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_uop_abstractcontext_init(ctx);
_Py_UOpsSymType *top = _Py_uop_sym_new_unknown(ctx);
if (top == NULL) {
return NULL;
}
TEST_PREDICATE(!_Py_uop_sym_is_null(top), "unknown is NULL");
TEST_PREDICATE(!_Py_uop_sym_is_not_null(top), "unknown is not 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_UOpsSymType *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");
_Py_uop_abstractcontext_fini(ctx);
Py_RETURN_NONE;
fail:
_Py_uop_abstractcontext_fini(ctx);
return NULL;
}

2
Tools/c-analyzer/cpython/ignored.tsv
View File

@ -740,6 +740,4 @@ Modules/expat/xmlrole.c - error -
## other
Modules/_io/_iomodule.c - _PyIO_Module -
Modules/_sqlite/module.c - _sqlite3module -
Python/optimizer_analysis.c - _Py_UOpsAbstractFrame_Type -
Python/optimizer_analysis.c - _Py_UOpsAbstractInterpContext_Type -
Modules/clinic/md5module.c.h _md5_md5 _keywords -

Can't render this file because it has a wrong number of fields in line 4.

6
Tools/cases_generator/optimizer_generator.py
View File

@ -87,14 +87,14 @@ def emit_default(out: CWriter, uop: Uop) -> None:
if var.name != "unused" and not var.peek:
if var.is_array():
out.emit(f"for (int _i = {var.size}; --_i >= 0;) {{\n")
out.emit(f"{var.name}[_i] = sym_new_unknown(ctx);\n")
out.emit(f"{var.name}[_i] = _Py_uop_sym_new_unknown(ctx);\n")
out.emit(f"if ({var.name}[_i] == NULL) goto out_of_space;\n")
out.emit("}\n")
elif var.name == "null":
out.emit(f"{var.name} = sym_new_null(ctx);\n")
out.emit(f"{var.name} = _Py_uop_sym_new_null(ctx);\n")
out.emit(f"if ({var.name} == NULL) goto out_of_space;\n")
else:
out.emit(f"{var.name} = sym_new_unknown(ctx);\n")
out.emit(f"{var.name} = _Py_uop_sym_new_unknown(ctx);\n")
out.emit(f"if ({var.name} == NULL) goto out_of_space;\n")