Nuitka-winsvc 2.2.2__cp311-cp311-win_amd64.whl → 2.3__cp311-cp311-win_amd64.whl

nuitka/build/static_src/HelpersAllocator.c

@@ -8,8 +8,44 @@
 #include "nuitka/prelude.h"
 #endif
 
+void *(*python_obj_malloc)(void *ctx, size_t size) = NULL;
+void *(*python_mem_malloc)(void *ctx, size_t size) = NULL;
+void *(*python_mem_calloc)(void *ctx, size_t nelem, size_t elsize) = NULL;
+
+#if defined(Py_DEBUG)
+void *python_obj_ctx = NULL;
+void *python_mem_ctx = NULL;
+#endif
+
+void initNuitkaAllocators(void) {
+    // PyMem_SetupDebugHooks();
+
+    PyMemAllocatorEx allocators;
+
+    PyMem_GetAllocator(PYMEM_DOMAIN_OBJ, &allocators);
+
+#if defined(Py_DEBUG)
+    python_obj_ctx = allocators.ctx;
+#endif
+
+    python_obj_malloc = allocators.malloc;
+
+    PyMem_GetAllocator(PYMEM_DOMAIN_MEM, &allocators);
+
+#if defined(Py_DEBUG)
+    python_mem_ctx = allocators.ctx;
+#endif
+
+    python_mem_malloc = allocators.malloc;
+    python_mem_calloc = allocators.calloc;
+}
+
+#if PYTHON_VERSION >= 0x3b0
+
 typedef struct _gc_runtime_state GCState;
 
+#if PYTHON_VERSION < 0x3d0
+
 #define AS_GC(o) ((PyGC_Head *)(((char *)(o)) - sizeof(PyGC_Head)))
 #define FROM_GC(g) ((PyObject *)(((char *)(g)) + sizeof(PyGC_Head)))
 
@@ -596,8 +632,19 @@ static Py_ssize_t Nuitka_gc_collect_generations(PyThreadState *tstate) {
     return n;
 }
 
+#else
+
+static void Nuitka_Py_ScheduleGC(PyThreadState *tstate) {
+    if (!_Py_eval_breaker_bit_is_set(tstate, _PY_GC_SCHEDULED_BIT)) {
+        _Py_set_eval_breaker_bit(tstate, _PY_GC_SCHEDULED_BIT);
+    }
+}
+
+#endif
+
 // This is called during object creation and might trigger garbage collection
 void Nuitka_PyObject_GC_Link(PyObject *op) {
+#if PYTHON_VERSION < 0x3d0
     PyGC_Head *g = AS_GC(op);
 
     PyThreadState *tstate = _PyThreadState_GET();
@@ -614,8 +661,32 @@ void Nuitka_PyObject_GC_Link(PyObject *op) {
         Nuitka_gc_collect_generations(tstate);
         gcstate->collecting = 0;
     }
+#else
+    PyGC_Head *gc = _Py_AS_GC(op);
+
+    // gc must be correctly aligned
+    _PyObject_ASSERT(op, ((uintptr_t)gc & (sizeof(uintptr_t) - 1)) == 0);
+
+    // TODO: Have this passed.
+
+    PyThreadState *tstate = _PyThreadState_GET();
+    GCState *gcstate = &tstate->interp->gc;
+
+    gc->_gc_next = 0;
+    gc->_gc_prev = 0;
+
+    gcstate->young.count++;
+    gcstate->heap_size++;
+
+    if (gcstate->young.count > gcstate->young.threshold && gcstate->enabled && gcstate->young.threshold &&
+        !_Py_atomic_load_int_relaxed(&gcstate->collecting) && !_PyErr_Occurred(tstate)) {
+        Nuitka_Py_ScheduleGC(tstate);
+    }
+#endif
 }
 
+#endif
+
 //     Part of "Nuitka", an optimizing Python compiler that is compatible and
 //     integrates with CPython, but also works on its own.
 //

nuitka/build/static_src/HelpersAttributes.c

@@ -975,7 +975,7 @@ static bool SET_ATTRIBUTE_GENERIC(PyThreadState *tstate, PyTypeObject *type, PyO
             dict = *dict_pointer;
 
             if (dict == NULL) {
-                dict = MAKE_DICT_EMPTY();
+                dict = MAKE_DICT_EMPTY(tstate);
                 *dict_pointer = dict;
             }
         }

nuitka/build/static_src/HelpersBuiltin.c

@@ -38,7 +38,7 @@ PyObject *CALL_BUILTIN_KW_ARGS(PyThreadState *tstate, PyObject *callable, PyObje
             CHECK_OBJECT(args[i]);
 
             if (kw_dict == NULL) {
-                kw_dict = MAKE_DICT_EMPTY();
+                kw_dict = MAKE_DICT_EMPTY(tstate);
             }
 
             NUITKA_MAY_BE_UNUSED int res = PyDict_SetItemString(kw_dict, arg_names[i], args[i]);
@@ -48,7 +48,7 @@ PyObject *CALL_BUILTIN_KW_ARGS(PyThreadState *tstate, PyObject *callable, PyObje
         i++;
     }
 
-    PyObject *args_tuple = MAKE_TUPLE(args, usable_args);
+    PyObject *args_tuple = MAKE_TUPLE(tstate, args, usable_args);
 
     PyObject *result = CALL_FUNCTION(tstate, callable, args_tuple, kw_dict);
     Py_XDECREF(kw_dict);
@@ -78,7 +78,7 @@ PyObject *COMPILE_CODE(PyThreadState *tstate, PyObject *source_code, PyObject *f
         return source_code;
     }
 
-    PyObject *pos_args = MAKE_TUPLE3(source_code, file_name, mode);
+    PyObject *pos_args = MAKE_TUPLE3(tstate, source_code, file_name, mode);
 
     PyObject *kw_values[] = {
         flags,
@@ -593,7 +593,7 @@ PyObject *BUILTIN_TYPE1(PyObject *arg) {
 }
 
 PyObject *BUILTIN_TYPE3(PyThreadState *tstate, PyObject *module_name, PyObject *name, PyObject *bases, PyObject *dict) {
-    PyObject *pos_args = MAKE_TUPLE3(name, bases, dict);
+    PyObject *pos_args = MAKE_TUPLE3(tstate, name, bases, dict);
 
     PyObject *result = PyType_Type.tp_new(&PyType_Type, pos_args, NULL);
 
@@ -673,7 +673,7 @@ PyObject *BUILTIN_SUPER0(PyThreadState *tstate, PyDictObject *module_dict, PyObj
 PyObject *BUILTIN_CALLABLE(PyObject *value) {
     int res = PyCallable_Check(value);
     PyObject *result = BOOL_FROM(res != 0);
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 

nuitka/build/static_src/HelpersBytes.c

@@ -65,10 +65,10 @@ PyObject *Nuitka_Bytes_FromStringAndSize(const char *data, Py_ssize_t size) {
 #endif
     }
 
-    op = (PyBytesObject *)PyObject_Malloc(PyBytesObject_SIZE + size);
+    op = (PyBytesObject *)NuitkaObject_Malloc(PyBytesObject_SIZE + size);
 
-    Py_SET_SIZE(op, size);
     Py_SET_TYPE(op, &PyBytes_Type);
+    Py_SET_SIZE(op, size);
 
     Nuitka_Py_NewReference((PyObject *)op);
 

nuitka/build/static_src/HelpersCalling.c

@@ -80,6 +80,7 @@ PyObject *callPythonFunction(PyObject *func, PyObject *const *args, int count) {
     return result;
 }
 
+#if PYTHON_VERSION < 0x380 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_UNCOMPILED_FUNCTION_CALL_OPT)
 static PyObject *callPythonFunctionNoArgs(PyObject *func) {
     PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
     PyObject *globals = PyFunction_GET_GLOBALS(func);
@@ -145,6 +146,8 @@ static PyObject *callPythonFunctionNoArgs(PyObject *func) {
 }
 #endif
 
+#endif
+
 PyObject *CALL_METHOD_WITH_POSARGS(PyThreadState *tstate, PyObject *source, PyObject *attr_name,
                                    PyObject *positional_args) {
     CHECK_OBJECT(source);