Nuitka-winsvc 2.2.3__cp311-cp311-win_amd64.whl → 2.3.2__cp311-cp311-win_amd64.whl

nuitka/build/static_src/HelpersConsole.c

@@ -0,0 +1,96 @@
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+// This file is included from another C file, help IDEs to still parse it on
+// its own.
+#ifdef __IDE_ONLY__
+#include "nuitka/prelude.h"
+#define _NUITKA_ATTACH_CONSOLE_WINDOW 1
+#endif
+
+#if defined(_WIN32) && defined(_NUITKA_ATTACH_CONSOLE_WINDOW)
+#include <io.h>
+
+// Attach to the parent console respecting redirection only, otherwise we cannot
+// even output traces.
+static bool needs_stdin_attaching, needs_stdout_attaching, needs_stderr_attaching;
+
+void inheritAttachedConsole(void) {
+    bool is_attachable = AttachConsole(ATTACH_PARENT_PROCESS);
+
+    needs_stdin_attaching = is_attachable && fileno(stdin) < 0;
+    needs_stdout_attaching = is_attachable && fileno(stdout) < 0;
+    needs_stderr_attaching = is_attachable && fileno(stderr) < 0;
+
+    if (needs_stdin_attaching) {
+        SECURITY_ATTRIBUTES security_attributes = {sizeof(SECURITY_ATTRIBUTES), NULL, TRUE};
+
+        FILE_HANDLE win_handle = CreateFileW(L"CONIN$", GENERIC_WRITE, FILE_SHARE_READ, &security_attributes,
+                                             CREATE_ALWAYS, FILE_FLAG_NO_BUFFERING, NULL);
+
+        FILE *new_handle = _wfreopen(L"CONIN$", L"rb", stdin);
+        assert(new_handle != NULL);
+        *stdin = *new_handle;
+
+        SetStdHandle(STD_INPUT_HANDLE, win_handle);
+    } else {
+        BOOL r = SetStdHandle(STD_INPUT_HANDLE, (HANDLE)_get_osfhandle(fileno(stdin)));
+        assert(r);
+    }
+
+    if (needs_stdout_attaching) {
+        SECURITY_ATTRIBUTES security_attributes = {sizeof(SECURITY_ATTRIBUTES), NULL, TRUE};
+
+        FILE_HANDLE win_handle = CreateFileW(L"CONOUT$", GENERIC_WRITE, FILE_SHARE_WRITE, &security_attributes,
+                                             CREATE_ALWAYS, FILE_FLAG_NO_BUFFERING, NULL);
+        assert(win_handle != INVALID_HANDLE_VALUE);
+
+        FILE *new_handle = _wfreopen(L"CONOUT$", L"wb", stdout);
+        assert(new_handle != NULL);
+        // Win32 doesn't allow line buffering.
+        setvbuf(new_handle, NULL, _IONBF, 0);
+        *stdout = *new_handle;
+
+        BOOL r = SetStdHandle(STD_OUTPUT_HANDLE, win_handle);
+        assert(r);
+    } else {
+        setvbuf(stdout, NULL, _IONBF, 0);
+        BOOL r = SetStdHandle(STD_OUTPUT_HANDLE, (HANDLE)_get_osfhandle(fileno(stdout)));
+        assert(r);
+    }
+
+    if (needs_stderr_attaching) {
+        SECURITY_ATTRIBUTES security_attributes = {sizeof(SECURITY_ATTRIBUTES), NULL, TRUE};
+
+        FILE_HANDLE win_handle = CreateFileW(L"CONOUT$", GENERIC_WRITE, FILE_SHARE_WRITE, &security_attributes,
+                                             CREATE_ALWAYS, FILE_FLAG_NO_BUFFERING, NULL);
+
+        FILE *new_handle = _wfreopen(L"CONOUT$", L"wb", stderr);
+        assert(new_handle != NULL);
+        // Win32 doesn't allow line buffering.
+        setvbuf(new_handle, NULL, _IONBF, 0);
+
+        *stderr = *new_handle;
+        SetStdHandle(STD_ERROR_HANDLE, win_handle);
+    } else {
+        setvbuf(stderr, NULL, _IONBF, 0);
+        BOOL r = SetStdHandle(STD_ERROR_HANDLE, (HANDLE)_get_osfhandle(fileno(stderr)));
+        assert(r);
+    }
+}
+
+#endif
+
+//     Part of "Nuitka", an optimizing Python compiler that is compatible and
+//     integrates with CPython, but also works on its own.
+//
+//     Licensed under the Apache License, Version 2.0 (the "License");
+//     you may not use this file except in compliance with the License.
+//     You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//     Unless required by applicable law or agreed to in writing, software
+//     distributed under the License is distributed on an "AS IS" BASIS,
+//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//     See the License for the specific language governing permissions and
+//     limitations under the License.

nuitka/build/static_src/HelpersConstantsBlob.c

@@ -113,7 +113,7 @@ static PyObject *our_list_richcompare(PyListObject *list1, PyListObject *list2,
         result = Py_False;
     }
 
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 
@@ -136,7 +136,7 @@ static PyObject *our_tuple_richcompare(PyTupleObject *tuple1, PyTupleObject *tup
         result = Py_False;
     }
 
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 
@@ -210,7 +210,7 @@ static PyObject *our_set_richcompare(PyObject *set1, PyObject *set2, int op) {
 #endif
     }
 
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 
@@ -226,7 +226,7 @@ static PyObject *our_float_richcompare(PyFloatObject *a, PyFloatObject *b, int o
         result = Py_False;
     }
 
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 
@@ -274,7 +274,7 @@ static PyObject *our_dict_richcompare(PyObject *a, PyObject *b, int op) {
         }
     }
 
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 
@@ -921,7 +921,7 @@ static unsigned char const *_unpackBlobConstants(PyThreadState *tstate, PyObject
             PyObject *items[3];
             data = _unpackBlobConstants(tstate, &items[0], data, 3);
 
-            PyObject *s = MAKE_SLICE_OBJECT3(items[0], items[1], items[2]);
+            PyObject *s = MAKE_SLICE_OBJECT3(tstate, items[0], items[1], items[2]);
 
             *output = s;
             is_object = true;
@@ -1146,8 +1146,12 @@ static unsigned char const *_unpackBlobConstants(PyThreadState *tstate, PyObject
         if (is_object == true) {
             CHECK_OBJECT(*output);
 
+#if PYTHON_VERSION < 0x3c0
             Py_INCREF(*output);
             Py_INCREF(*output);
+#else
+            Py_SET_REFCNT_IMMORTAL(*output);
+#endif
         }
 
         // PRINT_ITEM(*output);

nuitka/build/static_src/HelpersDeepcopy.c

@@ -26,7 +26,7 @@ PyObject *DEEP_COPY_LIST(PyThreadState *tstate, PyObject *value) {
     assert(PyList_CheckExact(value));
 
     Py_ssize_t n = PyList_GET_SIZE(value);
-    PyObject *result = MAKE_LIST_EMPTY(n);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, n);
 
     PyTypeObject *type = NULL;
     copy_func copy_function = NULL;
@@ -61,7 +61,7 @@ PyObject *DEEP_COPY_TUPLE(PyThreadState *tstate, PyObject *value) {
 
     Py_ssize_t n = PyTuple_GET_SIZE(value);
 
-    PyObject *result = MAKE_TUPLE_EMPTY_VAR(n);
+    PyObject *result = MAKE_TUPLE_EMPTY_VAR(tstate, n);
 
     for (Py_ssize_t i = 0; i < n; i++) {
         PyTuple_SET_ITEM(result, i, DEEP_COPY(tstate, PyTuple_GET_ITEM(value, i)));
@@ -146,8 +146,10 @@ static void _initDeepCopy(void) {
 
 #if PYTHON_VERSION >= 0x3a0
     {
+        PyThreadState *tstate = PyThreadState_GET();
+
         PyObject *args[2] = {(PyObject *)&PyFloat_Type, (PyObject *)&PyTuple_Type};
-        PyObject *args_tuple = MAKE_TUPLE(args, 2);
+        PyObject *args_tuple = MAKE_TUPLE(tstate, args, 2);
         PyObject *union_value = MAKE_UNION_TYPE(args_tuple);
 
         Nuitka_PyUnion_Type = Py_TYPE(union_value);
@@ -549,15 +551,15 @@ static PyObject *_DEEP_COPY_ELEMENT_GUIDED(PyThreadState *tstate, PyObject *valu
     case 'L':
         return _DEEP_COPY_LIST_GUIDED(tstate, value, guide);
     case 'l':
-        return LIST_COPY(value);
+        return LIST_COPY(tstate, value);
     case 'T':
         return _DEEP_COPY_TUPLE_GUIDED(tstate, value, guide);
     case 't':
-        return TUPLE_COPY(value);
+        return TUPLE_COPY(tstate, value);
     case 'D':
         return DEEP_COPY_DICT(tstate, value);
     case 'd':
-        return DICT_COPY(value);
+        return DICT_COPY(tstate, value);
     case 'S':
         return DEEP_COPY_SET(tstate, value);
     case 'B':
@@ -575,7 +577,7 @@ static PyObject *_DEEP_COPY_LIST_GUIDED(PyThreadState *tstate, PyObject *value,
 
     Py_ssize_t size = PyList_GET_SIZE(value);
 
-    PyObject *result = MAKE_LIST_EMPTY(size);
+    PyObject *result = MAKE_LIST_EMPTY(tstate, size);
 
     for (Py_ssize_t i = 0; i < size; i++) {
         PyObject *item = _DEEP_COPY_ELEMENT_GUIDED(tstate, PyList_GET_ITEM(value, i), guide);
@@ -592,7 +594,7 @@ static PyObject *_DEEP_COPY_TUPLE_GUIDED(PyThreadState *tstate, PyObject *value,
     Py_ssize_t size = PyTuple_GET_SIZE(value);
 
     // We cannot have size 0, so this is safe.
-    PyObject *result = MAKE_TUPLE_EMPTY(size);
+    PyObject *result = MAKE_TUPLE_EMPTY(tstate, size);
 
     for (Py_ssize_t i = 0; i < size; i++) {
         PyObject *item = _DEEP_COPY_ELEMENT_GUIDED(tstate, PyTuple_GET_ITEM(value, i), guide);

nuitka/build/static_src/HelpersDictionaries.c

@@ -185,6 +185,12 @@ PyObject *DICT_GET_ITEM1(PyThreadState *tstate, PyObject *dict, PyObject *key) {
 #endif
 }
 
+#if PYTHON_VERSION >= 0x3c0
+static PyObject *Nuitka_CreateKeyError(PyThreadState *tstate, PyObject *key) {
+    return (PyObject *)Nuitka_BaseExceptionSingleArg_new(tstate, (PyTypeObject *)PyExc_KeyError, key);
+}
+#endif
+
 static void SET_CURRENT_EXCEPTION_KEY_ERROR(PyThreadState *tstate, PyObject *key) {
 #if PYTHON_VERSION < 0x3c0
     /* Wrap all kinds of tuples, because normalization will later unwrap
@@ -199,9 +205,9 @@ static void SET_CURRENT_EXCEPTION_KEY_ERROR(PyThreadState *tstate, PyObject *key
         SET_CURRENT_EXCEPTION_TYPE0_VALUE0(tstate, PyExc_KeyError, key);
     }
 #else
-    PyObject *exception_value = MAKE_EXCEPTION_FROM_TYPE_ARG0(tstate, PyExc_KeyError, key);
+    struct Nuitka_ExceptionPreservationItem exception_state = {Nuitka_CreateKeyError(tstate, key)};
 
-    SET_CURRENT_EXCEPTION_TYPE0_VALUE1(tstate, PyExc_KeyError, exception_value);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &exception_state);
 #endif
 }
 
@@ -589,12 +595,12 @@ PyObject *DICT_ITEMS(PyObject *dict) {
      */
 retry:
     size = mp->ma_used;
-    result = MAKE_LIST_EMPTY(size);
+    result = MAKE_LIST_EMPTY(tstate, size);
     CHECK_OBJECT(result);
 
     for (Py_ssize_t i = 0; i < size; i++) {
         // Later populated.
-        PyObject *item = MAKE_TUPLE_EMPTY(2);
+        PyObject *item = MAKE_TUPLE_EMPTY(tstate, 2);
         CHECK_OBJECT(item);
 
         PyList_SET_ITEM(result, i, item);
@@ -643,7 +649,7 @@ PyObject *DICT_KEYS(PyObject *dict) {
      */
 retry:
     size = mp->ma_used;
-    result = MAKE_LIST_EMPTY(size);
+    result = MAKE_LIST_EMPTY(tstate, size);
     CHECK_OBJECT(result);
 
     if (unlikely(size != mp->ma_used)) {
@@ -688,7 +694,7 @@ PyObject *DICT_VALUES(PyObject *dict) {
      */
 retry:
     size = mp->ma_used;
-    result = MAKE_LIST_EMPTY(size);
+    result = MAKE_LIST_EMPTY(tstate, size);
     CHECK_OBJECT(result);
 
     if (unlikely(size != mp->ma_used)) {
@@ -1294,9 +1300,9 @@ PyObject *TO_DICT(PyThreadState *tstate, PyObject *seq_obj, PyObject *dict_obj)
 
         // Fast path for dictionaries.
         if (PyDict_CheckExact(seq_obj)) {
-            result = DICT_COPY(seq_obj);
+            result = DICT_COPY(tstate, seq_obj);
         } else {
-            result = MAKE_DICT_EMPTY();
+            result = MAKE_DICT_EMPTY(tstate);
 
             Py_INCREF(seq_obj);
 
@@ -1324,7 +1330,7 @@ PyObject *TO_DICT(PyThreadState *tstate, PyObject *seq_obj, PyObject *dict_obj)
             }
         }
     } else {
-        result = MAKE_DICT_EMPTY();
+        result = MAKE_DICT_EMPTY(tstate);
     }
 
     // TODO: Should specialize for dict_obj/seq_obj presence to save a bit of time
@@ -1343,14 +1349,14 @@ PyObject *TO_DICT(PyThreadState *tstate, PyObject *seq_obj, PyObject *dict_obj)
 }
 
 #if NUITKA_DICT_HAS_FREELIST
-PyObject *MAKE_DICT_EMPTY(void) {
+PyObject *MAKE_DICT_EMPTY(PyThreadState *tstate) {
     PyDictObject *empty_dict_mp = (PyDictObject *)const_dict_empty;
 
 #if PYTHON_VERSION < 0x3c0
     empty_dict_mp->ma_keys->dk_refcnt++;
 #endif
 
-    PyDictObject *result_mp = _Nuitka_AllocatePyDictObject();
+    PyDictObject *result_mp = _Nuitka_AllocatePyDictObject(tstate);
 
     result_mp->ma_keys = empty_dict_mp->ma_keys;
     result_mp->ma_values = empty_dict_mp->ma_values;

nuitka/build/static_src/HelpersDictionariesGenerated.c

@@ -33,12 +33,12 @@ static inline PyDictValues *_Nuitka_PyDict_new_values(Py_ssize_t size) {
     Py_ssize_t values_size = sizeof(PyObject *) * size;
 
 #if PYTHON_VERSION < 0x3b0
-    return (PyDictValues *)PyMem_MALLOC(values_size);
+    return (PyDictValues *)NuitkaMem_Malloc(values_size);
 #else
     // With Python3.11 or higher a prefix is allocated too.
     size_t prefix_size = _Py_SIZE_ROUND_UP(size + 2, sizeof(PyObject *));
     size_t n = prefix_size + values_size;
-    uint8_t *mem = (uint8_t *)PyMem_MALLOC(n);
+    uint8_t *mem = (uint8_t *)NuitkaMem_Malloc(n);
 
     assert(mem != NULL);
 
@@ -49,22 +49,26 @@ static inline PyDictValues *_Nuitka_PyDict_new_values(Py_ssize_t size) {
 #endif
 }
 
-#if NUITKA_DICT_HAS_FREELIST
-static struct _Py_dict_state *_Nuitka_Py_get_dict_state(void) {
-    PyInterpreterState *interp = _PyInterpreterState_GET();
-    return &interp->dict_state;
-}
-#endif
-
 #if PYTHON_VERSION >= 0x300
-static PyDictObject *_Nuitka_AllocatePyDictObject(void) {
+static PyDictObject *_Nuitka_AllocatePyDictObject(PyThreadState *tstate) {
     PyDictObject *result_mp;
 
 #if NUITKA_DICT_HAS_FREELIST
-    struct _Py_dict_state *state = _Nuitka_Py_get_dict_state();
+    // This is the CPython name, spell-checker: ignore numfree
+
+#if PYTHON_VERSION < 0x3d0
+    PyDictObject **items = tstate->interp->dict_state.free_list;
+    int *numfree = &tstate->interp->dict_state.numfree;
+#else
+    struct _Py_object_freelists *freelists = _Nuitka_object_freelists_GET(tstate);
+    struct _Py_dict_freelist *state = &freelists->dicts;
+    PyDictObject **items = state->items;
+    int *numfree = &state->numfree;
+#endif
 
-    if (state->numfree) {
-        result_mp = state->free_list[--state->numfree];
+    if (*numfree) {
+        (*numfree) -= 1;
+        result_mp = items[*numfree];
 
         Nuitka_Py_NewReference((PyObject *)result_mp);
 
@@ -80,6 +84,38 @@ static PyDictObject *_Nuitka_AllocatePyDictObject(void) {
 }
 #endif
 
+#if PYTHON_VERSION >= 0x360
+static PyDictKeysObject *_Nuitka_AllocatePyDictKeysObject(PyThreadState *tstate, Py_ssize_t keys_size) {
+    // CPython names, spell-checker: ignore numfree,dictkeys
+    PyDictKeysObject *dk;
+
+// TODO: Cannot always use cached objects. Need to also consider
+// "log2_size == PyDict_LOG_MINSIZE && unicode" as a criterion,
+// seems it can only be used for the smallest keys type.
+#if NUITKA_DICT_HAS_FREELIST && 0
+#if PYTHON_VERSION < 0x3d0
+    PyDictKeysObject **items = tstate->interp->dict_state.keys_free_list;
+    int *numfree = &tstate->interp->dict_state.keys_numfree;
+#else
+    struct _Py_object_freelists *freelists = _Nuitka_object_freelists_GET(tstate);
+    struct _Py_dictkeys_freelist *state = &freelists->dictkeys;
+    PyDictKeysObject **items = state->items;
+    int *numfree = &state->numfree;
+#endif
+
+    if (*numfree) {
+        (*numfree) -= 1;
+        dk = items[*numfree];
+    } else
+#endif
+    {
+        dk = (PyDictKeysObject *)NuitkaObject_Malloc(keys_size);
+    }
+
+    return dk;
+}
+#endif
+
 #if PYTHON_VERSION >= 0x360 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_DICT_OPT)
 static Py_ssize_t _Nuitka_Py_PyDict_KeysSize(PyDictKeysObject *keys) {
 #if PYTHON_VERSION < 0x360
@@ -98,7 +134,7 @@ static Py_ssize_t _Nuitka_Py_PyDict_KeysSize(PyDictKeysObject *keys) {
 }
 #endif
 
-PyObject *DICT_COPY(PyObject *dict_value) {
+PyObject *DICT_COPY(PyThreadState *tstate, PyObject *dict_value) {
 #if _NUITKA_EXPERIMENTAL_DISABLE_DICT_OPT
     CHECK_OBJECT(dict_value);
     assert(PyDict_CheckExact(dict_value));
@@ -111,7 +147,7 @@ PyObject *DICT_COPY(PyObject *dict_value) {
     assert(PyDict_CheckExact(dict_value));
 
     if (((PyDictObject *)dict_value)->ma_used == 0) {
-        result = MAKE_DICT_EMPTY();
+        result = MAKE_DICT_EMPTY(tstate);
     } else {
         PyDictObject *dict_mp = (PyDictObject *)dict_value;
 
@@ -136,7 +172,7 @@ PyObject *DICT_COPY(PyObject *dict_value) {
         /* Python 3 */
 #ifndef PY_NOGIL
         if (_PyDict_HasSplitTable(dict_mp)) {
-            PyDictObject *result_mp = _Nuitka_AllocatePyDictObject();
+            PyDictObject *result_mp = _Nuitka_AllocatePyDictObject(tstate);
             assert(result_mp != NULL);
             result = (PyObject *)result_mp;
 
@@ -184,14 +220,14 @@ PyObject *DICT_COPY(PyObject *dict_value) {
                 assert(dict_mp->ma_values == NULL);
                 assert(dict_mp->ma_keys->dk_refcnt == 1);
 
-                PyDictObject *result_mp = _Nuitka_AllocatePyDictObject();
+                PyDictObject *result_mp = _Nuitka_AllocatePyDictObject(tstate);
                 result = (PyObject *)result_mp;
 
                 result_mp->ma_values = NULL;
                 result_mp->ma_used = dict_mp->ma_used;
 
                 Py_ssize_t keys_size = _Nuitka_Py_PyDict_KeysSize(dict_mp->ma_keys);
-                result_mp->ma_keys = (PyDictKeysObject *)PyObject_MALLOC(keys_size);
+                result_mp->ma_keys = _Nuitka_AllocatePyDictKeysObject(tstate, keys_size);
                 assert(result_mp->ma_keys);
 
                 memcpy(result_mp->ma_keys, dict_mp->ma_keys, keys_size);
@@ -307,7 +343,7 @@ PyObject *DEEP_COPY_DICT(PyThreadState *tstate, PyObject *dict_value) {
     CHECK_OBJECT(dict_value);
     assert(PyDict_CheckExact(dict_value));
 
-    result = DICT_COPY(dict_value);
+    result = DICT_COPY(tstate, dict_value);
 
     Py_ssize_t pos = 0;
     PyObject *key, *value;
@@ -324,7 +360,7 @@ PyObject *DEEP_COPY_DICT(PyThreadState *tstate, PyObject *dict_value) {
     assert(PyDict_CheckExact(dict_value));
 
     if (((PyDictObject *)dict_value)->ma_used == 0) {
-        result = MAKE_DICT_EMPTY();
+        result = MAKE_DICT_EMPTY(tstate);
     } else {
         PyDictObject *dict_mp = (PyDictObject *)dict_value;
 
@@ -352,7 +388,7 @@ PyObject *DEEP_COPY_DICT(PyThreadState *tstate, PyObject *dict_value) {
         /* Python 3 */
 #ifndef PY_NOGIL
         if (_PyDict_HasSplitTable(dict_mp)) {
-            PyDictObject *result_mp = _Nuitka_AllocatePyDictObject();
+            PyDictObject *result_mp = _Nuitka_AllocatePyDictObject(tstate);
             assert(result_mp != NULL);
             result = (PyObject *)result_mp;
 
@@ -400,14 +436,14 @@ PyObject *DEEP_COPY_DICT(PyThreadState *tstate, PyObject *dict_value) {
                 assert(dict_mp->ma_values == NULL);
                 assert(dict_mp->ma_keys->dk_refcnt == 1);
 
-                PyDictObject *result_mp = _Nuitka_AllocatePyDictObject();
+                PyDictObject *result_mp = _Nuitka_AllocatePyDictObject(tstate);
                 result = (PyObject *)result_mp;
 
                 result_mp->ma_values = NULL;
                 result_mp->ma_used = dict_mp->ma_used;
 
                 Py_ssize_t keys_size = _Nuitka_Py_PyDict_KeysSize(dict_mp->ma_keys);
-                result_mp->ma_keys = (PyDictKeysObject *)PyObject_MALLOC(keys_size);
+                result_mp->ma_keys = _Nuitka_AllocatePyDictKeysObject(tstate, keys_size);
                 assert(result_mp->ma_keys);
 
                 memcpy(result_mp->ma_keys, dict_mp->ma_keys, keys_size);
@@ -528,7 +564,7 @@ PyObject *DEEP_COPY_DICT(PyThreadState *tstate, PyObject *dict_value) {
 }
 
 // Helper for function calls with star dict arguments. */
-static PyObject *COPY_DICT_KW(PyObject *dict_value) {
+static PyObject *COPY_DICT_KW(PyThreadState *tstate, PyObject *dict_value) {
     PyObject *result;
     bool had_kw_error = false;
 
@@ -536,7 +572,7 @@ static PyObject *COPY_DICT_KW(PyObject *dict_value) {
     CHECK_OBJECT(dict_value);
     assert(PyDict_CheckExact(dict_value));
 
-    result = DICT_COPY(dict_value);
+    result = DICT_COPY(tstate, dict_value);
 
     Py_ssize_t pos = 0;
     PyObject *key, *value;
@@ -551,7 +587,7 @@ static PyObject *COPY_DICT_KW(PyObject *dict_value) {
     assert(PyDict_CheckExact(dict_value));
 
     if (((PyDictObject *)dict_value)->ma_used == 0) {
-        result = MAKE_DICT_EMPTY();
+        result = MAKE_DICT_EMPTY(tstate);
     } else {
         PyDictObject *dict_mp = (PyDictObject *)dict_value;
 
@@ -579,7 +615,7 @@ static PyObject *COPY_DICT_KW(PyObject *dict_value) {
         /* Python 3 */
 #ifndef PY_NOGIL
         if (_PyDict_HasSplitTable(dict_mp)) {
-            PyDictObject *result_mp = _Nuitka_AllocatePyDictObject();
+            PyDictObject *result_mp = _Nuitka_AllocatePyDictObject(tstate);
             assert(result_mp != NULL);
             result = (PyObject *)result_mp;
 
@@ -651,14 +687,14 @@ static PyObject *COPY_DICT_KW(PyObject *dict_value) {
                 assert(dict_mp->ma_values == NULL);
                 assert(dict_mp->ma_keys->dk_refcnt == 1);
 
-                PyDictObject *result_mp = _Nuitka_AllocatePyDictObject();
+                PyDictObject *result_mp = _Nuitka_AllocatePyDictObject(tstate);
                 result = (PyObject *)result_mp;
 
                 result_mp->ma_values = NULL;
                 result_mp->ma_used = dict_mp->ma_used;
 
                 Py_ssize_t keys_size = _Nuitka_Py_PyDict_KeysSize(dict_mp->ma_keys);
-                result_mp->ma_keys = (PyDictKeysObject *)PyObject_MALLOC(keys_size);
+                result_mp->ma_keys = _Nuitka_AllocatePyDictKeysObject(tstate, keys_size);
                 assert(result_mp->ma_keys);
 
                 memcpy(result_mp->ma_keys, dict_mp->ma_keys, keys_size);