Nuitka
The Python compiler
Loading...
Searching...
No Matches
CompiledFrameType.c
1// Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
2
3#ifdef __IDE_ONLY__
4#include "nuitka/freelists.h"
5#include "nuitka/prelude.h"
6#include <structmember.h>
7#endif
8
9// For reporting about reference counts per type.
10#if _DEBUG_REFCOUNTS
11int count_active_Nuitka_Frame_Type = 0;
12int count_allocated_Nuitka_Frame_Type = 0;
13int count_released_Nuitka_Frame_Type = 0;
14#endif
15
16// For reporting about frame cache usage
17#if _DEBUG_REFCOUNTS
18int count_active_frame_cache_instances = 0;
19int count_allocated_frame_cache_instances = 0;
20int count_released_frame_cache_instances = 0;
21int count_hit_frame_cache_instances = 0;
22#endif
23
24#if PYTHON_VERSION < 0x3b0
25static PyMemberDef Nuitka_Frame_members[] = {
26 {(char *)"f_back", T_OBJECT, offsetof(PyFrameObject, f_back), READONLY | RESTRICTED},
27 {(char *)"f_code", T_OBJECT, offsetof(PyFrameObject, f_code), READONLY | RESTRICTED},
28 {(char *)"f_builtins", T_OBJECT, offsetof(PyFrameObject, f_builtins), READONLY | RESTRICTED},
29 {(char *)"f_globals", T_OBJECT, offsetof(PyFrameObject, f_globals), READONLY | RESTRICTED},
30 {(char *)"f_lasti", T_INT, offsetof(PyFrameObject, f_lasti), READONLY | RESTRICTED},
31 {NULL}};
32
33#else
34#define Nuitka_Frame_members 0
35#endif
36
37#if PYTHON_VERSION < 0x300
38
39static PyObject *_Nuitka_Frame_get_exc_traceback(PyObject *self, void *data) {
40 assert(Nuitka_Frame_CheckExact(self));
41 CHECK_OBJECT(self);
42 assert(_PyObject_GC_IS_TRACKED(self));
43
44 struct Nuitka_FrameObject *frame = (struct Nuitka_FrameObject *)self;
45 PyObject *result = frame->m_frame.f_exc_traceback;
46
47 if (result == NULL) {
48 result = Py_None;
49 }
50
51 Py_INCREF(result);
52 return result;
53}
54
55static int _Nuitka_Frame_set_exc_traceback(PyObject *self, PyObject *traceback, void *data) {
56 assert(Nuitka_Frame_CheckExact(self));
57 CHECK_OBJECT(self);
58 assert(_PyObject_GC_IS_TRACKED(self));
59
60 struct Nuitka_FrameObject *frame = (struct Nuitka_FrameObject *)self;
61 Py_XDECREF(frame->m_frame.f_exc_traceback);
62
63 if (traceback == Py_None) {
64 traceback = NULL;
65 }
66
67 frame->m_frame.f_exc_traceback = traceback;
68 Py_XINCREF(traceback);
69
70 return 0;
71}
72
73static PyObject *_Nuitka_Frame_get_exc_type(PyObject *self, void *data) {
74 assert(Nuitka_Frame_CheckExact(self));
75 CHECK_OBJECT(self);
76 assert(_PyObject_GC_IS_TRACKED(self));
77
78 PyObject *result;
79 struct Nuitka_FrameObject *frame = (struct Nuitka_FrameObject *)self;
80
81 if (frame->m_frame.f_exc_type != NULL) {
82 result = frame->m_frame.f_exc_type;
83 } else {
84 result = Py_None;
85 }
86
87 Py_INCREF(result);
88 return result;
89}
90
91static int _Nuitka_Frame_set_exc_type(PyObject *self, PyObject *exception_type, void *data) {
92 assert(Nuitka_Frame_CheckExact(self));
93 CHECK_OBJECT(self);
94 assert(_PyObject_GC_IS_TRACKED(self));
95
96 struct Nuitka_FrameObject *frame = (struct Nuitka_FrameObject *)self;
97 PyObject *old = frame->m_frame.f_exc_type;
98
99 if (exception_type == Py_None) {
100 exception_type = NULL;
101 }
102
103 frame->m_frame.f_exc_type = exception_type;
104 Py_XINCREF(frame->m_frame.f_exc_type);
105
106 Py_XDECREF(old);
107
108 return 0;
109}
110
111static PyObject *_Nuitka_Frame_get_exc_value(PyObject *self, void *data) {
112 assert(Nuitka_Frame_CheckExact(self));
113 CHECK_OBJECT(self);
114 assert(_PyObject_GC_IS_TRACKED(self));
115
116 PyObject *result;
117 struct Nuitka_FrameObject *frame = (struct Nuitka_FrameObject *)self;
118
119 if (frame->m_frame.f_exc_value != NULL) {
120 result = frame->m_frame.f_exc_value;
121 } else {
122 result = Py_None;
123 }
124
125 Py_INCREF(result);
126 return result;
127}
128
129static int _Nuitka_Frame_set_exc_value(PyObject *self, PyObject *exception_value, void *data) {
130 assert(Nuitka_Frame_CheckExact(self));
131 CHECK_OBJECT(self);
132 assert(_PyObject_GC_IS_TRACKED(self));
133
134 struct Nuitka_FrameObject *frame = (struct Nuitka_FrameObject *)self;
135 PyObject *old = frame->m_frame.f_exc_value;
136
137 if (exception_value == Py_None) {
138 exception_value = NULL;
139 }
140
141 frame->m_frame.f_exc_value = exception_value;
142 Py_XINCREF(exception_value);
143 Py_XDECREF(old);
144
145 return 0;
146}
147
148static PyObject *_Nuitka_Frame_get_restricted(PyObject *self, void *data) {
149 assert(Nuitka_Frame_CheckExact(self));
150 CHECK_OBJECT(self);
151 assert(_PyObject_GC_IS_TRACKED(self));
152
153 Py_INCREF_IMMORTAL(Py_False);
154 return Py_False;
155}
156
157#endif
158
159static PyObject *_Nuitka_Frame_get_locals(PyObject *self, void *data) {
160 assert(Nuitka_Frame_CheckExact(self));
161 CHECK_OBJECT(self);
162 assert(_PyObject_GC_IS_TRACKED(self));
163
164 NUITKA_MAY_BE_UNUSED PyThreadState *tstate = PyThreadState_GET();
165
166 struct Nuitka_FrameObject *nuitka_frame = (struct Nuitka_FrameObject *)self;
167 if (nuitka_frame->m_type_description == NULL) {
168#if PYTHON_VERSION < 0x3b0
169 PyFrameObject *locals_owner = &nuitka_frame->m_frame;
170#else
171 _PyInterpreterFrame *locals_owner = &nuitka_frame->m_interpreter_frame;
172#endif
173
174 if (locals_owner->f_locals == NULL) {
175 locals_owner->f_locals = MAKE_DICT_EMPTY(tstate);
176 }
177
178 Py_INCREF(locals_owner->f_locals);
179 return locals_owner->f_locals;
180 } else {
181 PyObject *result = MAKE_DICT_EMPTY(tstate);
182 PyObject **var_names = Nuitka_GetCodeVarNames(Nuitka_GetFrameCodeObject(nuitka_frame));
183
184 char const *w = nuitka_frame->m_type_description;
185 char const *t = nuitka_frame->m_locals_storage;
186
187 while (*w != 0) {
188 switch (*w) {
189 case NUITKA_TYPE_DESCRIPTION_OBJECT:
190 case NUITKA_TYPE_DESCRIPTION_OBJECT_PTR: {
191 PyObject *value = *(PyObject **)t;
192 CHECK_OBJECT_X(value);
193
194 if (value != NULL) {
195 DICT_SET_ITEM(result, *var_names, value);
196 }
197
198 t += sizeof(PyObject *);
199
200 break;
201 }
202 case NUITKA_TYPE_DESCRIPTION_CELL: {
203 struct Nuitka_CellObject *value = *(struct Nuitka_CellObject **)t;
204 assert(Nuitka_Cell_Check((PyObject *)value));
205 CHECK_OBJECT(value);
206
207 if (value->ob_ref != NULL) {
208 DICT_SET_ITEM(result, *var_names, value->ob_ref);
209 }
210
211 t += sizeof(struct Nuitka_CellObject *);
212
213 break;
214 }
215 case NUITKA_TYPE_DESCRIPTION_NULL: {
216 break;
217 }
218 case NUITKA_TYPE_DESCRIPTION_BOOL: {
219 int value = *(int *)t;
220 t += sizeof(int);
221 switch ((nuitka_bool)value) {
222 case NUITKA_BOOL_TRUE: {
223 DICT_SET_ITEM(result, *var_names, Py_True);
224 break;
225 }
226 case NUITKA_BOOL_FALSE: {
227 DICT_SET_ITEM(result, *var_names, Py_False);
228 break;
229 }
230 default:
231 break;
232 }
233 break;
234 }
235 default:
236 assert(false);
237 }
238
239 w += 1;
240 var_names += 1;
241 }
242
243 return result;
244 }
245}
246
247static PyObject *_Nuitka_Frame_get_lineno(PyObject *self, void *data) {
248 assert(Nuitka_Frame_CheckExact(self));
249 CHECK_OBJECT(self);
250 assert(_PyObject_GC_IS_TRACKED(self));
251
252 struct Nuitka_FrameObject *frame = (struct Nuitka_FrameObject *)self;
253 return Nuitka_PyInt_FromLong(frame->m_frame.f_lineno);
254}
255
256static PyObject *_Nuitka_Frame_get_trace(PyObject *self, void *data) {
257 assert(Nuitka_Frame_CheckExact(self));
258 CHECK_OBJECT(self);
259 assert(_PyObject_GC_IS_TRACKED(self));
260
261 struct Nuitka_FrameObject *frame = (struct Nuitka_FrameObject *)self;
262 PyObject *result = frame->m_frame.f_trace;
263 Py_INCREF(result);
264 return result;
265}
266
267static int _Nuitka_Frame_set_trace(PyObject *self, PyObject *value, void *data) {
268 assert(Nuitka_Frame_CheckExact(self));
269 CHECK_OBJECT(self);
270 assert(_PyObject_GC_IS_TRACKED(self));
271#if !defined(_NUITKA_DEPLOYMENT_MODE) && !defined(_NUITKA_NO_DEPLOYMENT_FRAME_USELESS_SET_TRACE)
272 if (value == Py_None) {
273 return 0;
274 } else {
275 PyThreadState *tstate = PyThreadState_GET();
276
277 SET_CURRENT_EXCEPTION_TYPE0_STR(
278 tstate, PyExc_RuntimeError,
279 "f_trace is not writable in Nuitka, ignore with '--no-deployment-flag=frame-useless-set-trace'");
280 return -1;
281 }
282#else
283 return 0;
284#endif
285}
286
287#if PYTHON_VERSION >= 0x370
288static PyObject *_Nuitka_Frame_get_trace_lines(PyObject *self, void *data) {
289 assert(Nuitka_Frame_CheckExact(self));
290 CHECK_OBJECT(self);
291 assert(_PyObject_GC_IS_TRACKED(self));
292
293 PyObject *result = Py_False;
294 Py_INCREF_IMMORTAL(result);
295 return result;
296}
297
298static int _Nuitka_Frame_set_trace_lines(PyObject *self, PyObject *value, void *data) {
299 assert(Nuitka_Frame_CheckExact(self));
300 CHECK_OBJECT(self);
301 assert(_PyObject_GC_IS_TRACKED(self));
302
303 PyThreadState *tstate = PyThreadState_GET();
304
305 SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_RuntimeError, "f_trace_lines is not writable in Nuitka");
306 return -1;
307}
308
309static PyObject *_Nuitka_Frame_get_trace_opcodes(PyObject *self, void *data) {
310 assert(Nuitka_Frame_CheckExact(self));
311 CHECK_OBJECT(self);
312 assert(_PyObject_GC_IS_TRACKED(self));
313
314 PyObject *result = Py_False;
315 Py_INCREF_IMMORTAL(result);
316 return result;
317}
318
319static int _Nuitka_Frame_set_trace_opcodes(PyObject *self, PyObject *value, void *data) {
320 assert(Nuitka_Frame_CheckExact(self));
321 CHECK_OBJECT(self);
322 assert(_PyObject_GC_IS_TRACKED(self));
323
324 PyThreadState *tstate = PyThreadState_GET();
325
326 SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_RuntimeError, "f_trace_opcodes is not writable in Nuitka");
327 return -1;
328}
329#endif
330
331static PyGetSetDef Nuitka_Frame_tp_getset[] = {
332 {(char *)"f_locals", _Nuitka_Frame_get_locals, NULL, NULL},
333 {(char *)"f_lineno", _Nuitka_Frame_get_lineno, NULL, NULL},
334 {(char *)"f_trace", _Nuitka_Frame_get_trace, _Nuitka_Frame_set_trace, NULL},
335#if PYTHON_VERSION < 0x300
336 {(char *)"f_restricted", _Nuitka_Frame_get_restricted, NULL, NULL},
337 {(char *)"f_exc_traceback", _Nuitka_Frame_get_exc_traceback, _Nuitka_Frame_set_exc_traceback, NULL},
338 {(char *)"f_exc_type", _Nuitka_Frame_get_exc_type, _Nuitka_Frame_set_exc_type, NULL},
339 {(char *)"f_exc_value", _Nuitka_Frame_get_exc_value, _Nuitka_Frame_set_exc_value, NULL},
340#endif
341#if PYTHON_VERSION >= 0x370
342 {(char *)"f_trace_lines", _Nuitka_Frame_get_trace_lines, _Nuitka_Frame_set_trace_lines, NULL},
343 {(char *)"f_trace_opcodes", _Nuitka_Frame_get_trace_opcodes, _Nuitka_Frame_set_trace_opcodes, NULL},
344#endif
345 {NULL}};
346
347// tp_repr slot, decide how a function shall be output
348static PyObject *Nuitka_Frame_tp_repr(struct Nuitka_FrameObject *nuitka_frame) {
349 assert(Nuitka_Frame_CheckExact((PyObject *)nuitka_frame));
350 CHECK_OBJECT((PyObject *)nuitka_frame);
351 assert(_PyObject_GC_IS_TRACKED(nuitka_frame));
352
353#if PYTHON_VERSION >= 0x370
354 PyCodeObject *code_object = Nuitka_GetFrameCodeObject(nuitka_frame);
355 return Nuitka_String_FromFormat("<compiled_frame at %p, file %R, line %d, code %S>", nuitka_frame,
356 code_object->co_filename, Nuitka_GetFrameLineNumber(nuitka_frame),
357 code_object->co_name);
358#elif _DEBUG_FRAME || _DEBUG_REFRAME || _DEBUG_EXCEPTIONS
359 PyCodeObject *code_object = Nuitka_GetFrameCodeObject(nuitka_frame);
360 return Nuitka_String_FromFormat("<compiled_frame object for %s at %p>",
361 Nuitka_String_AsString(code_object->co_name), nuitka_frame);
362#else
363 return Nuitka_String_FromFormat("<compiled_frame object at %p>", nuitka_frame);
364#endif
365}
366
367static void Nuitka_Frame_tp_clear(struct Nuitka_FrameObject *frame) {
368 if (frame->m_type_description) {
369 char const *w = frame->m_type_description;
370 char const *t = frame->m_locals_storage;
371
372 while (*w != 0) {
373 switch (*w) {
374 case NUITKA_TYPE_DESCRIPTION_OBJECT:
375 case NUITKA_TYPE_DESCRIPTION_OBJECT_PTR:
376 case NUITKA_TYPE_DESCRIPTION_NILONG: {
377 PyObject *value = *(PyObject **)t;
378 CHECK_OBJECT_X(value);
379
380 Py_XDECREF(value);
381
382 t += sizeof(PyObject *);
383
384 break;
385 }
386 case NUITKA_TYPE_DESCRIPTION_CELL: {
387 struct Nuitka_CellObject *value = *(struct Nuitka_CellObject **)t;
388 assert(Nuitka_Cell_Check((PyObject *)value));
389 CHECK_OBJECT(value);
390
391 Py_DECREF(value);
392
393 t += sizeof(struct Nuitka_CellObject *);
394
395 break;
396 }
397 case NUITKA_TYPE_DESCRIPTION_NULL: {
398 break;
399 }
400 case NUITKA_TYPE_DESCRIPTION_BOOL: {
401 t += sizeof(int);
402
403 break;
404 }
405 default:
406 assert(false);
407 }
408
409 w += 1;
410 }
411
412 frame->m_type_description = NULL;
413 }
414}
415
416// Freelist setup
417#define MAX_FRAME_FREE_LIST_COUNT 100
418static struct Nuitka_FrameObject *free_list_frames = NULL;
419static int free_list_frames_count = 0;
420
421static void Nuitka_Frame_tp_dealloc(struct Nuitka_FrameObject *nuitka_frame) {
422#if _DEBUG_REFCOUNTS
423 count_active_Nuitka_Frame_Type -= 1;
424 count_released_Nuitka_Frame_Type += 1;
425#endif
426
427#ifndef __NUITKA_NO_ASSERT__
428 // Save the current exception, if any, we must to not corrupt it.
429 PyThreadState *tstate = PyThreadState_GET();
430
431 struct Nuitka_ExceptionPreservationItem saved_exception_state1;
432 FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state1);
433 RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state1);
434#endif
435
436 Nuitka_GC_UnTrack(nuitka_frame);
437
438 PyFrameObject *frame = &nuitka_frame->m_frame;
439#if PYTHON_VERSION < 0x3b0
440 PyFrameObject *locals_owner = frame;
441#else
442 _PyInterpreterFrame *locals_owner = &nuitka_frame->m_interpreter_frame;
443#endif
444
445 assert(Nuitka_GC_IS_TRACKED_X((PyObject *)frame->f_back));
446 Py_XDECREF(frame->f_back);
447 Py_DECREF(locals_owner->f_builtins);
448 Py_DECREF(locals_owner->f_globals);
449 Py_XDECREF(locals_owner->f_locals);
450
451#if PYTHON_VERSION < 0x370
452 Py_XDECREF(frame->f_exc_type);
453 Py_XDECREF(frame->f_exc_value);
454 Py_XDECREF(frame->f_exc_traceback);
455#endif
456
457 Nuitka_Frame_tp_clear(nuitka_frame);
458
459 if (Py_REFCNT(nuitka_frame) > 0) {
460 Py_SET_REFCNT(nuitka_frame, Py_REFCNT(nuitka_frame) - 1);
461 if (Py_REFCNT(nuitka_frame) >= 1) {
462 // TODO: Allow this in debug mode, for now we would like to reproduce it.
463 assert(false);
464 return;
465 }
466 }
467
468#if PYTHON_VERSION >= 0x3b0
469 // Restore from backup, see header comment for the field "m_ob_size" to get
470 // it.
471 Py_SET_SIZE(nuitka_frame, nuitka_frame->m_ob_size);
472#endif
473
474 releaseToFreeList(free_list_frames, nuitka_frame, MAX_FRAME_FREE_LIST_COUNT);
475
476#ifndef __NUITKA_NO_ASSERT__
477 struct Nuitka_ExceptionPreservationItem saved_exception_state2;
478 FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state2);
479 RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state2);
480
481 ASSERT_SAME_EXCEPTION_STATE(&saved_exception_state1, &saved_exception_state2);
482#endif
483}
484
485static int Nuitka_Frame_tp_traverse(struct Nuitka_FrameObject *frame, visitproc visit, void *arg) {
486 assert(Nuitka_Frame_CheckExact((PyObject *)frame));
487 CHECK_OBJECT((PyObject *)frame);
488 assert(_PyObject_GC_IS_TRACKED(frame));
489
490 Py_VISIT(frame->m_frame.f_back);
491
492#if PYTHON_VERSION < 0x3b0
493 PyFrameObject *locals_owner = &frame->m_frame;
494#else
495 _PyInterpreterFrame *locals_owner = &frame->m_interpreter_frame;
496#endif
497
498 Py_VISIT(locals_owner->f_builtins);
499 Py_VISIT(locals_owner->f_globals);
500 // Py_VISIT(locals_owner->f_locals);
501
502#if PYTHON_VERSION < 0x370
503 Py_VISIT(frame->m_frame.f_exc_type);
504 Py_VISIT(frame->m_frame.f_exc_value);
505 Py_VISIT(frame->m_frame.f_exc_traceback);
506#endif
507
508 // Traverse attached locals too.
509 char const *w = frame->m_type_description;
510 char const *t = frame->m_locals_storage;
511
512 while (w != NULL && *w != 0) {
513 switch (*w) {
514 case NUITKA_TYPE_DESCRIPTION_OBJECT:
515 case NUITKA_TYPE_DESCRIPTION_OBJECT_PTR: {
516 PyObject *value = *(PyObject **)t;
517 CHECK_OBJECT_X(value);
518
519 Py_VISIT(value);
520 t += sizeof(PyObject *);
521
522 break;
523 }
524 case NUITKA_TYPE_DESCRIPTION_CELL: {
525 struct Nuitka_CellObject *value = *(struct Nuitka_CellObject **)t;
526 assert(Nuitka_Cell_Check((PyObject *)value));
527 CHECK_OBJECT(value);
528
529 Py_VISIT(value);
530
531 t += sizeof(struct Nuitka_CellObject *);
532
533 break;
534 }
535 case NUITKA_TYPE_DESCRIPTION_NULL: {
536 break;
537 }
538 case NUITKA_TYPE_DESCRIPTION_BOOL: {
539 t += sizeof(int);
540
541 break;
542 }
543 default:
544 NUITKA_CANNOT_GET_HERE("invalid type description");
545 assert(false);
546 }
547
548 w += 1;
549 }
550
551 return 0;
552}
553
554#if PYTHON_VERSION >= 0x300
555
556static PyObject *Nuitka_GetFrameGenerator(struct Nuitka_FrameObject *nuitka_frame) {
557#if PYTHON_VERSION < 0x3b0
558 return nuitka_frame->m_frame.f_gen;
559#else
560 return nuitka_frame->m_generator;
561#endif
562}
563
564static PyObject *Nuitka_Frame_clear(struct Nuitka_FrameObject *frame, PyObject *unused) {
565 assert(Nuitka_Frame_CheckExact((PyObject *)frame));
566 CHECK_OBJECT((PyObject *)frame);
567 assert(_PyObject_GC_IS_TRACKED(frame));
568
569 PyThreadState *tstate = PyThreadState_GET();
570
571 if (Nuitka_Frame_IsExecuting(frame)) {
572 SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_RuntimeError, "cannot clear an executing frame");
573
574 return NULL;
575 }
576
577#if PYTHON_VERSION >= 0x3b0
578 if (frame->m_frame_state == FRAME_COMPLETED) {
579 Nuitka_Frame_tp_clear(frame);
580
581 Py_RETURN_NONE;
582 }
583
584 if (frame->m_frame_state == FRAME_EXECUTING) {
585 SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_RuntimeError, "cannot clear an executing frame");
586 return NULL;
587 }
588#endif
589
590#if PYTHON_VERSION >= 0x300
591 // For frames that are closed, we also need to close the generator.
592 PyObject *f_gen = Nuitka_GetFrameGenerator(frame);
593 if (f_gen != NULL) {
594 CHECK_OBJECT(f_gen);
595
596 Py_INCREF(frame);
597
598 bool close_exception;
599
600 if (Nuitka_Generator_Check(f_gen)) {
601 struct Nuitka_GeneratorObject *generator = (struct Nuitka_GeneratorObject *)f_gen;
602 Nuitka_SetFrameGenerator(frame, NULL);
603
604 close_exception = !_Nuitka_Generator_close(tstate, generator);
605 }
606#if PYTHON_VERSION >= 0x350
607 else if (Nuitka_Coroutine_Check(f_gen)) {
608 struct Nuitka_CoroutineObject *coroutine = (struct Nuitka_CoroutineObject *)f_gen;
609 Nuitka_SetFrameGenerator(frame, NULL);
610
611 close_exception = !_Nuitka_Coroutine_close(tstate, coroutine);
612 }
613#endif
614#if PYTHON_VERSION >= 0x360
615 else if (Nuitka_Asyncgen_Check(f_gen)) {
616 struct Nuitka_AsyncgenObject *asyncgen = (struct Nuitka_AsyncgenObject *)f_gen;
617 Nuitka_SetFrameGenerator(frame, NULL);
618
619 close_exception = !_Nuitka_Asyncgen_close(tstate, asyncgen);
620 }
621#endif
622 else {
623 // Compiled frames should only have our types, so this ought to not happen.
624 assert(false);
625
626 Nuitka_SetFrameGenerator(frame, NULL);
627
628 close_exception = false;
629 }
630
631 if (unlikely(close_exception)) {
632 PyErr_WriteUnraisable(f_gen);
633 }
634
635 Py_DECREF(frame);
636 }
637#endif
638
639 Nuitka_Frame_tp_clear(frame);
640
641 Py_RETURN_NONE;
642}
643
644#endif
645
646static inline Py_ssize_t Nuitka_Frame_GetSize(struct Nuitka_FrameObject *frame) {
647 assert(Nuitka_Frame_CheckExact((PyObject *)frame));
648 CHECK_OBJECT((PyObject *)frame);
649 assert(_PyObject_GC_IS_TRACKED(frame));
650
651#if PYTHON_VERSION < 0x3b0
652 return Py_SIZE(frame);
653#else
654 return frame->m_ob_size;
655#endif
656}
657
658static PyObject *Nuitka_Frame_sizeof(struct Nuitka_FrameObject *frame, PyObject *unused) {
659 assert(Nuitka_Frame_CheckExact((PyObject *)frame));
660 CHECK_OBJECT((PyObject *)frame);
661 assert(_PyObject_GC_IS_TRACKED(frame));
662
663 return PyInt_FromSsize_t(sizeof(struct Nuitka_FrameObject) + Py_SIZE(frame));
664}
665
666static PyMethodDef Nuitka_Frame_methods[] = {
667#if PYTHON_VERSION >= 0x300
668 {"clear", (PyCFunction)Nuitka_Frame_clear, METH_NOARGS, "F.clear(): clear most references held by the frame"},
669#endif
670 {"__sizeof__", (PyCFunction)Nuitka_Frame_sizeof, METH_NOARGS, "F.__sizeof__() -> size of F in memory, in bytes"},
671 {NULL, NULL}};
672
673PyTypeObject Nuitka_Frame_Type = {
674 PyVarObject_HEAD_INIT(NULL, 0) "compiled_frame",
675 sizeof(struct Nuitka_FrameObject),
676 1,
677 (destructor)Nuitka_Frame_tp_dealloc, // tp_dealloc
678 0, // tp_print
679 0, // tp_getattr
680 0, // tp_setattr
681 0, // tp_compare
682 (reprfunc)Nuitka_Frame_tp_repr, // tp_repr
683 0, // tp_as_number
684 0, // tp_as_sequence
685 0, // tp_as_mapping
686 0, // tp_hash
687 0, // tp_call
688 0, // tp_str
689 0, // tp_getattro (PyObject_GenericGetAttr)
690 0, // tp_setattro (PyObject_GenericSetAttr)
691 0, // tp_as_buffer
692 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, // tp_flags
693 0, // tp_doc
694 (traverseproc)Nuitka_Frame_tp_traverse, // tp_traverse
695 (inquiry)Nuitka_Frame_tp_clear, // tp_clear
696 0, // tp_richcompare
697 0, // tp_weaklistoffset
698 0, // tp_iter
699 0, // tp_iternext
700 Nuitka_Frame_methods, // tp_methods
701 Nuitka_Frame_members, // tp_members
702 Nuitka_Frame_tp_getset, // tp_getset
703 0, // tp_base
704 0, // tp_dict
705};
706
707void _initCompiledFrameType(void) {
708 assert(Nuitka_Frame_Type.tp_doc != PyFrame_Type.tp_doc || PyFrame_Type.tp_doc == NULL);
709 assert(Nuitka_Frame_Type.tp_traverse != PyFrame_Type.tp_traverse);
710 assert(Nuitka_Frame_Type.tp_clear != PyFrame_Type.tp_clear || PyFrame_Type.tp_clear == NULL);
711 assert(Nuitka_Frame_Type.tp_richcompare != PyFrame_Type.tp_richcompare || PyFrame_Type.tp_richcompare == NULL);
712 assert(Nuitka_Frame_Type.tp_weaklistoffset != PyFrame_Type.tp_weaklistoffset ||
713 PyFrame_Type.tp_weaklistoffset == 0);
714 assert(Nuitka_Frame_Type.tp_iter != PyFrame_Type.tp_iter || PyFrame_Type.tp_iter == NULL);
715 assert(Nuitka_Frame_Type.tp_iternext != PyFrame_Type.tp_iternext || PyFrame_Type.tp_iternext == NULL);
716 assert(Nuitka_Frame_Type.tp_methods != PyFrame_Type.tp_methods);
717 assert(Nuitka_Frame_Type.tp_members != PyFrame_Type.tp_members);
718 assert(Nuitka_Frame_Type.tp_getset != PyFrame_Type.tp_getset);
719
720 assert(Nuitka_Frame_Type.tp_descr_get != PyFrame_Type.tp_descr_get || PyFrame_Type.tp_descr_get == NULL);
721
722 assert(Nuitka_Frame_Type.tp_descr_set != PyFrame_Type.tp_descr_set || PyFrame_Type.tp_descr_set == NULL);
723 assert(Nuitka_Frame_Type.tp_dictoffset != PyFrame_Type.tp_dictoffset || PyFrame_Type.tp_dictoffset == 0);
724 // TODO: These get changed and into the same thing, not sure what to compare against, project something
725 // assert(Nuitka_Frame_Type.tp_dict != PyFrame_Type.tp_dict);
726 // assert(Nuitka_Frame_Type.tp_init != PyFrame_Type.tp_init || PyFrame_Type.tp_init == NULL);
727 // assert(Nuitka_Frame_Type.tp_alloc != PyFrame_Type.tp_alloc || PyFrame_Type.tp_alloc == NULL);
728 // assert(Nuitka_Frame_Type.tp_new != PyFrame_Type.tp_new || PyFrame_Type.tp_new == NULL);
729 // assert(Nuitka_Frame_Type.tp_free != PyFrame_Type.tp_free || PyFrame_Type.tp_free == NULL);
730 // assert(Nuitka_Frame_Type.tp_weaklist != PyFrame_Type.tp_weaklist);
731 assert(Nuitka_Frame_Type.tp_bases != PyFrame_Type.tp_bases);
732 assert(Nuitka_Frame_Type.tp_mro != PyFrame_Type.tp_mro);
733 assert(Nuitka_Frame_Type.tp_cache != PyFrame_Type.tp_cache || PyFrame_Type.tp_cache == NULL);
734 assert(Nuitka_Frame_Type.tp_subclasses != PyFrame_Type.tp_subclasses || PyFrame_Type.tp_cache == NULL);
735 assert(Nuitka_Frame_Type.tp_del != PyFrame_Type.tp_del || PyFrame_Type.tp_del == NULL);
736#if PYTHON_VERSION >= 0x300
737 assert(Nuitka_Frame_Type.tp_finalize != PyFrame_Type.tp_finalize || PyFrame_Type.tp_finalize == NULL);
738#endif
739 Nuitka_PyType_Ready(&Nuitka_Frame_Type, &PyFrame_Type, true, true, false, false, false);
740
741 // These are to be used interchangeably. Make sure that's true.
742 assert(offsetof(struct Nuitka_FrameObject, m_frame) == 0);
743}
744
745static struct Nuitka_FrameObject *_MAKE_COMPILED_FRAME(PyCodeObject *code, PyObject *module, PyObject *f_locals,
746 Py_ssize_t locals_size) {
747 CHECK_CODE_OBJECT(code);
748 CHECK_OBJECT(module);
749
750#if _DEBUG_REFCOUNTS
751 count_active_Nuitka_Frame_Type += 1;
752 count_allocated_Nuitka_Frame_Type += 1;
753#endif
754
755 PyObject *globals = ((PyModuleObject *)module)->md_dict;
756 CHECK_OBJECT(globals);
757
758 assert(PyDict_Check(globals));
759
760 struct Nuitka_FrameObject *result;
761
762 // Macro to assign result memory from GC or free list.
763 allocateFromFreeList(free_list_frames, struct Nuitka_FrameObject, Nuitka_Frame_Type, locals_size);
764
765 result->m_type_description = NULL;
766
767 PyFrameObject *frame = &result->m_frame;
768 // Globals and locals are stored differently before Python 3.11
769#if PYTHON_VERSION < 0x3b0
770 PyFrameObject *locals_owner = frame;
771#else
772 _PyInterpreterFrame *locals_owner = &result->m_interpreter_frame;
773#endif
774
775#if PYTHON_VERSION < 0x3d0
776 locals_owner->f_code = code;
777#elif PYTHON_VERSION < 0x3e0
778 locals_owner->f_executable = (PyObject *)code;
779#else
780 // TODO: Why is our code object not immortal?
781 locals_owner->f_executable = _PyStackRef_FromPyObjectNew((PyObject *)code);
782#endif
783
784 frame->f_trace = Py_None;
785
786#if PYTHON_VERSION < 0x370
787 frame->f_exc_type = NULL;
788 frame->f_exc_value = NULL;
789 frame->f_exc_traceback = NULL;
790#else
791 frame->f_trace_lines = 0;
792 frame->f_trace_opcodes = 0;
793#endif
794
795#if PYTHON_VERSION >= 0x3b0
796 result->m_ob_size = Py_SIZE(result);
797#endif
798 frame->f_back = NULL;
799
800 Py_INCREF(dict_builtin);
801 locals_owner->f_builtins = (PyObject *)dict_builtin;
802
803 Py_INCREF(globals);
804 locals_owner->f_globals = globals;
805
806 // Note: Reference taking happens in calling function.
807 CHECK_OBJECT_X(f_locals);
808 locals_owner->f_locals = f_locals;
809
810#if PYTHON_VERSION < 0x300
811 frame->f_tstate = PyThreadState_GET();
812#endif
813
814#if PYTHON_VERSION < 0x3b0
815 frame->f_lasti = -1;
816 frame->f_iblock = 0; // spell-checker: ignore iblock
817#endif
818
819 frame->f_lineno = code->co_firstlineno;
820
821#if PYTHON_VERSION >= 0x300
822 Nuitka_SetFrameGenerator(result, NULL);
823
824 Nuitka_Frame_MarkAsNotExecuting(result);
825#endif
826
827#if PYTHON_VERSION >= 0x3b0
828 result->m_interpreter_frame.frame_obj = &result->m_frame;
829 result->m_interpreter_frame.owner = FRAME_OWNED_BY_GENERATOR;
830#if PYTHON_VERSION >= 0x3e0
831 result->m_interpreter_frame.f_funcobj = PyStackRef_NULL; // spell-checker: ignore funcobj
832#elif PYTHON_VERSION >= 0x3c0
833 result->m_interpreter_frame.f_funcobj = NULL; // spell-checker: ignore funcobj
834#else
835 result->m_interpreter_frame.f_func = NULL;
836#endif
837#if PYTHON_VERSION < 0x3d0
838 result->m_interpreter_frame.prev_instr = _PyCode_CODE(code);
839#else
840 result->m_interpreter_frame.instr_ptr = _PyCode_CODE(code);
841#endif
842 result->m_frame.f_frame = &result->m_interpreter_frame;
843
844 assert(!_PyFrame_IsIncomplete(&result->m_interpreter_frame));
845#endif
846
847 Nuitka_GC_Track(result);
848 return result;
849}
850
851struct Nuitka_FrameObject *MAKE_MODULE_FRAME(PyCodeObject *code, PyObject *module) {
852 PyObject *f_locals = ((PyModuleObject *)module)->md_dict;
853 Py_INCREF(f_locals);
854
855 return _MAKE_COMPILED_FRAME(code, module, f_locals, 0);
856}
857
858struct Nuitka_FrameObject *MAKE_FUNCTION_FRAME(PyThreadState *tstate, PyCodeObject *code, PyObject *module,
859 Py_ssize_t locals_size) {
860 PyObject *f_locals;
861
862 if (likely((code->co_flags & CO_OPTIMIZED) == CO_OPTIMIZED)) {
863 f_locals = NULL;
864 } else {
865 PyObject *kw_pairs[2] = {const_str_plain___module__, MODULE_NAME0(tstate, module)};
866 f_locals = MAKE_DICT(kw_pairs, 1);
867 }
868
869 return _MAKE_COMPILED_FRAME(code, module, f_locals, locals_size);
870}
871
872struct Nuitka_FrameObject *MAKE_CLASS_FRAME(PyThreadState *tstate, PyCodeObject *code, PyObject *module,
873 PyObject *f_locals, Py_ssize_t locals_size) {
874 // The frame template sets f_locals on usage itself, need not create it that way.
875 if (f_locals == NULL) {
876 PyObject *kw_pairs[2] = {const_str_plain___module__, MODULE_NAME0(tstate, module)};
877 f_locals = MAKE_DICT(kw_pairs, 1);
878 } else {
879 Py_INCREF(f_locals);
880 }
881
882 return _MAKE_COMPILED_FRAME(code, module, f_locals, locals_size);
883}
884
885// This is the backend of MAKE_CODE_OBJECT macro.
886PyCodeObject *makeCodeObject(PyObject *filename, int line, int flags, PyObject *function_name,
887#if PYTHON_VERSION >= 0x3b0
888 PyObject *function_qualname,
889#endif
890 PyObject *arg_names, PyObject *free_vars, int arg_count
891#if PYTHON_VERSION >= 0x300
892 ,
893 int kw_only_count
894#endif
895#if PYTHON_VERSION >= 0x380
896 ,
897 int pos_only_count
898#endif
899) {
900
901 if (filename == Py_None) {
902 filename = const_str_empty;
903 }
904
905 // TODO: We don't do that anymore once new-code-objects
906 // is the default, then we don't need to pass it, since
907 // we create them incomplete anyway.
908 CHECK_OBJECT(filename);
909 assert(Nuitka_StringOrUnicode_CheckExact(filename));
910
911 CHECK_OBJECT(function_name);
912 assert(Nuitka_String_CheckExact(function_name));
913
914#if PYTHON_VERSION >= 0x3b0
915 if (function_qualname) {
916 CHECK_OBJECT(function_qualname);
917 PyUnicode_CheckExact(function_qualname);
918 }
919#endif
920
921#if PYTHON_VERSION >= 0x300
922 assert(kw_only_count >= 0);
923#endif
924#if PYTHON_VERSION >= 0x380
925 assert(pos_only_count >= 0);
926#endif
927 assert(flags >= 0);
928 assert(arg_count >= 0);
929
930// TODO: On macOS with zig, libpython asserts against values failing, but only if
931// debug mode is not on, these check without using the disabled assert.
932#if 0
933 if (pos_only_count < 0) abort();
934 if (kw_only_count < 0) abort();
935 if (flags < 0) abort();
936 if (arg_count < 0) abort();
937#endif
938
939#if PYTHON_VERSION < 0x300
940 PyObject *filename_str = NULL;
941
942 // TODO: Memory leak of filename, it might be intended transferred to the
943 // code object by using code.
944 if (PyUnicode_CheckExact(filename)) {
945 filename_str = PyUnicode_AsUTF8String(filename);
946 filename = filename_str;
947 } else {
948 filename_str = filename;
949 Py_INCREF(filename);
950 }
951#endif
952
953 if (arg_names == NULL || arg_names == Py_None) {
954 arg_names = const_tuple_empty;
955 }
956 CHECK_OBJECT(arg_names);
957 assert(PyTuple_Check(arg_names));
958
959 if (free_vars == NULL || free_vars == Py_None) {
960 free_vars = const_tuple_empty;
961 }
962 CHECK_OBJECT(free_vars);
963 assert(PyTuple_Check(free_vars));
964
965 // The PyCode_New has funny code that interns, mutating the tuple that owns
966 // it. Really serious non-immutable shit. We have triggered that changes
967 // behind our back in the past.
968#ifndef __NUITKA_NO_ASSERT__
969 // TODO: Reactivate once code object creation becomes un-streaming driven
970 // and we can pass the extra args with no worries.
971
972 // Py_hash_t hash = DEEP_HASH(arg_names);
973#endif
974
975 // spell-checker: ignore lnotab
976#if PYTHON_VERSION < 0x300
977 PyObject *code = const_str_empty;
978 PyObject *lnotab = const_str_empty;
979 PyObject *consts = const_tuple_empty;
980 PyObject *names = const_tuple_empty;
981 int stacksize = 0;
982#elif PYTHON_VERSION < 0x3b0
983 PyObject *code = const_bytes_empty;
984 PyObject *lnotab = const_bytes_empty;
985 PyObject *consts = const_tuple_empty;
986 PyObject *names = const_tuple_empty;
987 int stacksize = 0;
988#else
989 // Our code object needs to be recognizable, and Python doesn't store the
990 // length anymore, so we need a non-empty one.
991 static PyObject *empty_code = NULL;
992 static PyObject *lnotab = NULL;
993 static PyObject *consts = NULL;
994 static PyObject *names = NULL;
995 // TODO: Seems removable.
996 static PyObject *exception_table = NULL;
997 static int stacksize = 0;
998
999 if (empty_code == NULL) {
1000 // Only needed once here.
1001 PyThreadState *tstate = PyThreadState_GET();
1002
1003 PyObject *empty_code_module_object = Py_CompileString(
1004 "def empty(): raise RuntimeError('Compiled function bytecode used')", "<exec>", Py_file_input);
1005 NUITKA_MAY_BE_UNUSED PyObject *module =
1006 PyImport_ExecCodeModule("nuitka_empty_function", empty_code_module_object);
1007 CHECK_OBJECT(module);
1008
1009 PyObject *empty_function = PyObject_GetAttrString(module, "empty");
1010 CHECK_OBJECT(empty_function);
1011 PyObject *empty_code_object = PyObject_GetAttrString(empty_function, "__code__");
1012 CHECK_OBJECT(empty_code_object);
1013
1014 NUITKA_MAY_BE_UNUSED bool bool_res = Nuitka_DelModuleString(tstate, "nuitka_empty_function");
1015 assert(bool_res != false);
1016
1017 empty_code = PyObject_GetAttrString(empty_code_object, "co_code");
1018 CHECK_OBJECT(empty_code);
1019#if PYTHON_VERSION >= 0x3c0
1020 lnotab = ((PyCodeObject *)empty_code_object)->co_linetable; // spell-checker: ignore linetable
1021#else
1022 lnotab = PyObject_GetAttrString(empty_code_object, "co_lnotab");
1023 CHECK_OBJECT(lnotab);
1024#endif
1025 consts = PyObject_GetAttrString(empty_code_object, "co_consts");
1026 CHECK_OBJECT(consts);
1027 names = PyObject_GetAttrString(empty_code_object, "co_names");
1028 CHECK_OBJECT(names);
1029 exception_table = PyObject_GetAttrString(empty_code_object, "co_exceptiontable");
1030 CHECK_OBJECT(exception_table);
1031
1032 stacksize = (int)PyLong_AsLong(PyObject_GetAttrString(empty_code_object, "co_stacksize"));
1033 }
1034
1035 PyObject *code = empty_code;
1036 CHECK_OBJECT(empty_code);
1037 assert(PyBytes_Check(code));
1038 CHECK_OBJECT(lnotab);
1039 assert(PyBytes_Check(lnotab));
1040 CHECK_OBJECT(consts);
1041 assert(PyTuple_Check(consts));
1042 CHECK_OBJECT(names);
1043 assert(PyTuple_Check(names));
1044 CHECK_OBJECT(exception_table);
1045 assert(PyBytes_Check(exception_table));
1046 assert(stacksize >= 0);
1047#endif
1048
1049 // For Python 3.11 this value is checked, even if not used.
1050#if PYTHON_VERSION >= 0x3b0
1051 int nlocals = (int)PyTuple_GET_SIZE(arg_names);
1052#else
1053 int nlocals = 0;
1054#endif
1055
1056 // Not using PyCode_NewEmpty, it doesn't given us much beyond this
1057 // and is not available for Python2.
1058
1059#if PYTHON_VERSION >= 0x380
1060 PyCodeObject *result = PyCode_NewWithPosOnlyArgs(arg_count, // arg_count
1061#else
1062 PyCodeObject *result = PyCode_New(arg_count, // arg_count
1063#endif
1064
1065#if PYTHON_VERSION >= 0x300
1066#if PYTHON_VERSION >= 0x380
1067 pos_only_count, // pos-only count
1068#endif
1069 kw_only_count, // kw-only count
1070#endif
1071 nlocals, // nlocals
1072 stacksize, // stacksize
1073 flags, // flags
1074 code, // code (bytecode)
1075 consts, // consts (we are not going to be compatible)
1076 names, // names (we are not going to be compatible)
1077 arg_names, // var_names (we are not going to be compatible)
1078 free_vars, // free_vars
1079 const_tuple_empty, // cell_vars (we are not going to be compatible)
1080 filename, // filename
1081 function_name, // name
1082#if PYTHON_VERSION >= 0x3b0
1083 function_qualname, // qualname
1084#endif
1085 line, // first_lineno (offset of the code object)
1086 lnotab // lnotab (table to translate code object)
1087#if PYTHON_VERSION >= 0x3b0
1088 ,
1089 exception_table // exception_table
1090#endif
1091 );
1092
1093 // assert(DEEP_HASH(tstate, arg_names) == hash);
1094
1095#if PYTHON_VERSION < 0x300
1096 Py_DECREF(filename_str);
1097#endif
1098
1099 if (result == NULL) {
1100 PyErr_PrintEx(0);
1101 NUITKA_CANNOT_GET_HERE("Failed to create code object");
1102 }
1103
1104 return result;
1105}
1106
1107PyCodeObject *USE_CODE_OBJECT(PyThreadState *tstate, PyObject *code_object, PyObject *module_filename_obj) {
1108 assert(PyCode_Check(code_object));
1109 CHECK_OBJECT(module_filename_obj);
1110
1111 PyCodeObject *co = (PyCodeObject *)code_object;
1112 PyObject *old = co->co_filename;
1113
1114 if (old == const_str_empty) {
1115 // Set the filename, ignore the loss of a reference to empty string,
1116 // that's our singleton and immortal at least practically.
1117 co->co_filename = Py_NewRef(module_filename_obj);
1118
1119#if PYTHON_VERSION >= 0x3b0
1120 // Also, make sure the qualname is completed from the partial
1121 // name.
1122 if (co->co_qualname != co->co_name) {
1123 PyObject *w = UNICODE_CONCAT(tstate, co->co_qualname, const_str_dot);
1124 co->co_qualname = UNICODE_CONCAT(tstate, w, co->co_name);
1125 Py_DECREF(w);
1126 }
1127#endif
1128 }
1129
1130 return co;
1131}
1132
1133void Nuitka_Frame_AttachLocals(struct Nuitka_FrameObject *frame_object, char const *type_description, ...) {
1134 assert(Nuitka_Frame_CheckExact((PyObject *)frame_object));
1135 CHECK_OBJECT((PyObject *)frame_object);
1136 assert(_PyObject_GC_IS_TRACKED(frame_object));
1137 assertFrameObject(frame_object);
1138
1139#if _DEBUG_FRAME
1140 PRINT_FORMAT("Attaching to frame 0x%lx %s\n", frame_object,
1141 Nuitka_String_AsString(PyObject_Repr((PyObject *)Nuitka_Frame_GetCodeObject(&frame_object->m_frame))));
1142#endif
1143
1144 assert(frame_object->m_type_description == NULL);
1145
1146 // TODO: Do not call this if there is nothing to do. Instead make all the
1147 // places handle NULL pointer and recognize that there is nothing to do.
1148 // assert(type_description != NULL && assert(strlen(type_description)>0));
1149 if (type_description == NULL) {
1150 type_description = "";
1151 }
1152
1153 frame_object->m_type_description = type_description;
1154
1155 char const *w = type_description;
1156 char *t = frame_object->m_locals_storage;
1157
1158 va_list(ap);
1159 va_start(ap, type_description);
1160
1161 while (*w != 0) {
1162 switch (*w) {
1163 case NUITKA_TYPE_DESCRIPTION_OBJECT: {
1164 PyObject *value = va_arg(ap, PyObject *);
1165 memcpy(t, &value, sizeof(PyObject *));
1166 Py_XINCREF(value);
1167 t += sizeof(PyObject *);
1168
1169 break;
1170 }
1171 case NUITKA_TYPE_DESCRIPTION_OBJECT_PTR: {
1172 /* Note: We store the pointed object only, so this is only
1173 a shortcut for the calling side. */
1174 PyObject **value = va_arg(ap, PyObject **);
1175 CHECK_OBJECT_X(*value);
1176
1177 memcpy(t, value, sizeof(PyObject *));
1178
1179 Py_XINCREF(*value);
1180 t += sizeof(PyObject *);
1181
1182 break;
1183 }
1184 case NUITKA_TYPE_DESCRIPTION_CELL: {
1185 struct Nuitka_CellObject *value = va_arg(ap, struct Nuitka_CellObject *);
1186 assert(Nuitka_Cell_Check((PyObject *)value));
1187 CHECK_OBJECT(value);
1188 CHECK_OBJECT_X(value->ob_ref);
1189
1190 memcpy(t, &value, sizeof(struct Nuitka_CellObject *));
1191 // TODO: Reference count must become wrong here, should
1192 // be forced to one probably, or we should simply not
1193 // store cells, but their values. Take a ref off "value"
1194 // is probably not needed.
1195 // Py_SET_REFCNT((struct Nuitka_CellObject *)t, 1);
1196 Py_INCREF(value);
1197
1198 t += sizeof(struct Nuitka_CellObject *);
1199
1200 break;
1201 }
1202 case NUITKA_TYPE_DESCRIPTION_NULL: {
1203 NUITKA_MAY_BE_UNUSED void *value = va_arg(ap, struct Nuitka_CellObject *);
1204
1205 break;
1206 }
1207 case NUITKA_TYPE_DESCRIPTION_BOOL: {
1208 int value = va_arg(ap, int);
1209 memcpy(t, &value, sizeof(int));
1210
1211 t += sizeof(value);
1212
1213 break;
1214 }
1215 case NUITKA_TYPE_DESCRIPTION_NILONG: {
1216 nuitka_ilong value = va_arg(ap, nuitka_ilong);
1217 ENFORCE_NILONG_OBJECT_VALUE(&value);
1218
1219 CHECK_OBJECT(value.python_value);
1220 memcpy(t, &value.python_value, sizeof(PyObject *));
1221 Py_XINCREF(value.python_value);
1222 t += sizeof(PyObject *);
1223
1224 break;
1225 }
1226 default:
1227 NUITKA_CANNOT_GET_HERE("invalid type description");
1228 assert(false);
1229 }
1230
1231 w += 1;
1232 }
1233
1234 va_end(ap);
1235
1236 assert(t - frame_object->m_locals_storage <= Nuitka_Frame_GetSize(frame_object));
1237}
1238
1239// Make a dump of the active frame stack. For debugging purposes only.
1240#if _DEBUG_FRAME
1241void dumpFrameStack(void) {
1242 PyThreadState *tstate = PyThreadState_GET();
1243
1244 struct Nuitka_ExceptionPreservationItem saved_exception_state;
1245 FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
1246
1247 int total = 0;
1248
1249#if PYTHON_VERSION < 0x3b0
1250 PyFrameObject *current = PyThreadState_GET()->frame;
1251 while (current != NULL) {
1252 total++;
1253 current = current->f_back;
1254 }
1255
1256 current = tstate->frame;
1257#else
1258 _PyCFrame *current = tstate->cframe;
1259 while (current != NULL) {
1260 total++;
1261 current = current->previous;
1262 }
1263
1264 current = tstate->cframe;
1265#endif
1266
1267 PRINT_STRING(">--------->\n");
1268
1269 while (current) {
1270#if PYTHON_VERSION < 0x3b0
1271 PyObject *current_repr = PyObject_Str((PyObject *)current);
1272 PyObject *code_repr = PyObject_Str((PyObject *)current->f_code);
1273#else
1274 PyObject *current_repr = NULL;
1275 if (current->current_frame->frame_obj != NULL) {
1276 current_repr = PyObject_Str((PyObject *)current->current_frame->frame_obj);
1277 } else {
1278 current_repr = const_str_empty;
1279 Py_INCREF(const_str_empty);
1280 }
1281 PyObject *code_repr = PyObject_Str((PyObject *)Nuitka_InterpreterFrame_GetCodeObject(current->current_frame));
1282#endif
1283
1284 PRINT_FORMAT("Frame stack %d: %s %d %s\n", total--, Nuitka_String_AsString(current_repr), Py_REFCNT(current),
1285 Nuitka_String_AsString(code_repr));
1286
1287 Py_DECREF(current_repr);
1288 Py_DECREF(code_repr);
1289
1290#if PYTHON_VERSION < 0x3b0
1291 current = current->f_back;
1292#else
1293 current = current->previous;
1294#endif
1295 }
1296
1297 PRINT_STRING(">---------<\n");
1298
1299 RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state);
1300}
1301
1302static void PRINT_UNCOMPILED_FRAME(char const *prefix, PyFrameObject *frame) {
1303 PRINT_STRING(prefix);
1304 PRINT_STRING(" ");
1305
1306 if (frame) {
1307 PyObject *frame_str = PyObject_Str((PyObject *)frame);
1308 PRINT_ITEM(frame_str);
1309 Py_DECREF(frame_str);
1310
1311 PyObject *code_object_str = PyObject_Repr((PyObject *)Nuitka_Frame_GetCodeObject(frame));
1312 PRINT_ITEM(code_object_str);
1313 Py_DECREF(code_object_str);
1314
1315 PRINT_REFCOUNT((PyObject *)frame);
1316 } else {
1317 PRINT_STRING("<NULL> no frame");
1318 }
1319
1320 PRINT_NEW_LINE();
1321}
1322
1323void PRINT_COMPILED_FRAME(char const *prefix, struct Nuitka_FrameObject *frame) {
1324 return PRINT_UNCOMPILED_FRAME(prefix, &frame->m_frame);
1325}
1326
1327void PRINT_INTERPRETER_FRAME(char const *prefix, Nuitka_ThreadStateFrameType *frame) {
1328#if PYTHON_VERSION < 0x3b0
1329 PRINT_UNCOMPILED_FRAME(prefix, frame);
1330#else
1331 PRINT_STRING(prefix);
1332 PRINT_STRING(" ");
1333
1334 if (frame) {
1335 PRINT_FORMAT("0x%lx ", frame);
1336
1337 PyObject *code_object_str = PyObject_Repr((PyObject *)Nuitka_InterpreterFrame_GetCodeObject(frame));
1338 PRINT_ITEM(code_object_str);
1339 Py_DECREF(code_object_str);
1340 } else {
1341 PRINT_STRING("<NULL> no frame");
1342 }
1343
1344 PRINT_NEW_LINE();
1345#endif
1346}
1347
1348void PRINT_TOP_FRAME(char const *prefix) {
1349 PyThreadState *tstate = PyThreadState_GET();
1350
1351#if PYTHON_VERSION < 0x3b0
1352 PRINT_UNCOMPILED_FRAME(prefix, tstate->frame);
1353#else
1354 PRINT_INTERPRETER_FRAME(prefix, CURRENT_TSTATE_INTERPRETER_FRAME(tstate));
1355#endif
1356}
1357
1358#endif
1359
1360// Part of "Nuitka", an optimizing Python compiler that is compatible and
1361// integrates with CPython, but also works on its own.
1362//
1363// Licensed under the Apache License, Version 2.0 (the "License");
1364// you may not use this file except in compliance with the License.
1365// You may obtain a copy of the License at
1366//
1367// http://www.apache.org/licenses/LICENSE-2.0
1368//
1369// Unless required by applicable law or agreed to in writing, software
1370// distributed under the License is distributed on an "AS IS" BASIS,
1371// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1372// See the License for the specific language governing permissions and
1373// limitations under the License.
Nuitka_CellObject
Definition compiled_cell.h:14
Nuitka_ExceptionPreservationItem
Definition exceptions.h:712
Nuitka_FrameObject
Definition compiled_frame.h:117
Nuitka_GeneratorObject
Definition compiled_generator.h:41
PyModuleObject
Definition helpers.h:10
nuitka_ilong
Definition ints.h:27