Nuitka-winsvc 1.8__cp311-cp311-win_amd64.whl → 2.5.1__cp311-cp311-win_amd64.whl

nuitka/build/static_src/HelpersDeepcopy.c

@@ -1,20 +1,5 @@
-//     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-//
-//     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.
-//
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
 /**
  * This is responsible for deep copy and hashing of constants.
  */
@@ -41,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;
@@ -76,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)));
@@ -161,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);
@@ -376,10 +363,9 @@ Py_hash_t DEEP_HASH(PyThreadState *tstate, PyObject *value) {
     } else if (PyLong_Check(value)) {
         Py_hash_t result = DEEP_HASH_INIT(tstate, value);
 
-        PyObject *exception_type, *exception_value;
-        PyTracebackObject *exception_tb;
+        struct Nuitka_ExceptionPreservationItem saved_exception_state;
 
-        FETCH_ERROR_OCCURRED_UNTRACED(tstate, &exception_type, &exception_value, &exception_tb);
+        FETCH_ERROR_OCCURRED_STATE_UNTRACED(tstate, &saved_exception_state);
 
         // Use string to hash the long value, which relies on that to not
         // use the object address.
@@ -387,16 +373,15 @@ Py_hash_t DEEP_HASH(PyThreadState *tstate, PyObject *value) {
         result ^= DEEP_HASH(tstate, str);
         Py_DECREF(str);
 
-        RESTORE_ERROR_OCCURRED_UNTRACED(tstate, exception_type, exception_value, exception_tb);
+        RESTORE_ERROR_OCCURRED_STATE_UNTRACED(tstate, &saved_exception_state);
 
         return result;
     } else if (PyUnicode_Check(value)) {
         Py_hash_t result = DEEP_HASH(tstate, (PyObject *)Py_TYPE(value));
 
-        PyObject *exception_type, *exception_value;
-        PyTracebackObject *exception_tb;
+        struct Nuitka_ExceptionPreservationItem saved_exception_state;
 
-        FETCH_ERROR_OCCURRED_UNTRACED(tstate, &exception_type, &exception_value, &exception_tb);
+        FETCH_ERROR_OCCURRED_STATE_UNTRACED(tstate, &saved_exception_state);
 
 #if PYTHON_VERSION >= 0x300
         char const *s = (char const *)PyUnicode_DATA(value);
@@ -412,7 +397,7 @@ Py_hash_t DEEP_HASH(PyThreadState *tstate, PyObject *value) {
 
         Py_DECREF(str);
 #endif
-        RESTORE_ERROR_OCCURRED_UNTRACED(tstate, exception_type, exception_value, exception_tb);
+        RESTORE_ERROR_OCCURRED_STATE_UNTRACED(tstate, &saved_exception_state);
 
         return result;
     }
@@ -566,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':
@@ -592,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);
@@ -609,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);
@@ -631,3 +616,18 @@ PyObject *DEEP_COPY_TUPLE_GUIDED(PyThreadState *tstate, PyObject *value, char co
     assert(*guide == 0);
     return result;
 }
+
+//     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/HelpersDictionaries.c

@@ -1,20 +1,5 @@
-//     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-//
-//     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.
-//
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
 /* These helpers are used to work with dictionaries.
 
 */
@@ -200,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
@@ -207,14 +198,16 @@ static void SET_CURRENT_EXCEPTION_KEY_ERROR(PyThreadState *tstate, PyObject *key
      * welcome. The check is inexact, as the unwrapping one is too.
      */
     if (PyTuple_Check(key) || key == Py_None) {
-        PyObject *tuple = PyTuple_Pack(1, key);
+        PyObject *tuple = MAKE_TUPLE1(tstate, key);
 
         SET_CURRENT_EXCEPTION_TYPE0_VALUE1(tstate, PyExc_KeyError, tuple);
     } else {
         SET_CURRENT_EXCEPTION_TYPE0_VALUE0(tstate, PyExc_KeyError, key);
     }
 #else
-    return _MAKE_EXCEPTION_FROM_TYPE_ARG(PyExc_KeyError, key);
+    struct Nuitka_ExceptionPreservationItem exception_state = {Nuitka_CreateKeyError(tstate, key)};
+
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &exception_state);
 #endif
 }
 
@@ -581,6 +574,15 @@ int DICT_HAS_ITEM(PyThreadState *tstate, PyObject *dict, PyObject *key) {
 
         return 0;
     }
+
+#if PYTHON_VERSION < 0x370 || PYTHON_VERSION >= 0x3b0
+    assert(value_addr != NULL);
+    PyObject *result = *value_addr;
+#endif
+
+    if (unlikely(result == NULL)) {
+        return 0;
+    }
 #endif
     return 1;
 #endif
@@ -602,12 +604,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);
@@ -656,7 +658,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)) {
@@ -701,7 +703,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)) {
@@ -749,7 +751,8 @@ typedef struct {
 #endif
 
 // Generic helper for various dictionary iterations, to be inlined.
-static inline PyObject *_MAKE_DICT_ITERATOR(PyDictObject *dict, PyTypeObject *type, bool is_iteritems) {
+static inline PyObject *_MAKE_DICT_ITERATOR(PyThreadState *tstate, PyDictObject *dict, PyTypeObject *type,
+                                            bool is_iteritems) {
     CHECK_OBJECT((PyObject *)dict);
     assert(PyDict_CheckExact((PyObject *)dict));
 
@@ -763,7 +766,7 @@ static inline PyObject *_MAKE_DICT_ITERATOR(PyDictObject *dict, PyTypeObject *ty
     di->len = dict->ma_used;
     if (is_iteritems) {
         // TODO: Have this as faster variants, we do these sometimes.
-        di->di_result = PyTuple_Pack(2, Py_None, Py_None);
+        di->di_result = MAKE_TUPLE2(tstate, Py_None, Py_None);
         CHECK_OBJECT(di->di_result);
     } else {
         di->di_result = NULL;
@@ -783,58 +786,54 @@ static inline PyObject *_MAKE_DICT_ITERATOR(PyDictObject *dict, PyTypeObject *ty
 #endif
 }
 
-PyObject *DICT_ITERITEMS(PyObject *dict) {
+PyObject *DICT_ITERITEMS(PyThreadState *tstate, PyObject *dict) {
 #if PYTHON_VERSION < 0x270
     static PyTypeObject *dictiteritems_type = NULL;
 
     if (unlikely(dictiteritems_type == NULL)) {
-        PyThreadState *tstate = PyThreadState_GET();
         dictiteritems_type =
             Py_TYPE(CALL_FUNCTION_NO_ARGS(tstate, PyObject_GetAttrString(const_dict_empty, "iteritems")));
     }
 
-    return _MAKE_DICT_ITERATOR((PyDictObject *)dict, dictiteritems_type, true);
+    return _MAKE_DICT_ITERATOR(tstate, (PyDictObject *)dict, dictiteritems_type, true);
 #elif PYTHON_VERSION < 0x300
-    return _MAKE_DICT_ITERATOR((PyDictObject *)dict, &PyDictIterItem_Type, true);
+    return _MAKE_DICT_ITERATOR(tstate, (PyDictObject *)dict, &PyDictIterItem_Type, true);
 #else
-    return _MAKE_DICT_ITERATOR((PyDictObject *)dict, &PyDictItems_Type, true);
+    return _MAKE_DICT_ITERATOR(tstate, (PyDictObject *)dict, &PyDictItems_Type, true);
 #endif
 }
 
-PyObject *DICT_ITERKEYS(PyObject *dict) {
+PyObject *DICT_ITERKEYS(PyThreadState *tstate, PyObject *dict) {
 #if PYTHON_VERSION < 0x270
     static PyTypeObject *dictiterkeys_type = NULL;
 
     if (unlikely(dictiterkeys_type == NULL)) {
-        PyThreadState *tstate = PyThreadState_GET();
         dictiterkeys_type =
             Py_TYPE(CALL_FUNCTION_NO_ARGS(tstate, PyObject_GetAttrString(const_dict_empty, "iterkeys")));
     }
 
-    return _MAKE_DICT_ITERATOR((PyDictObject *)dict, dictiterkeys_type, false);
+    return _MAKE_DICT_ITERATOR(tstate, (PyDictObject *)dict, dictiterkeys_type, false);
 #elif PYTHON_VERSION < 0x300
-    return _MAKE_DICT_ITERATOR((PyDictObject *)dict, &PyDictIterKey_Type, false);
+    return _MAKE_DICT_ITERATOR(tstate, (PyDictObject *)dict, &PyDictIterKey_Type, false);
 #else
-    return _MAKE_DICT_ITERATOR((PyDictObject *)dict, &PyDictKeys_Type, false);
+    return _MAKE_DICT_ITERATOR(tstate, (PyDictObject *)dict, &PyDictKeys_Type, false);
 #endif
 }
 
-PyObject *DICT_ITERVALUES(PyObject *dict) {
+PyObject *DICT_ITERVALUES(PyThreadState *tstate, PyObject *dict) {
 #if PYTHON_VERSION < 0x270
     static PyTypeObject *dictitervalues_type = NULL;
 
     if (unlikely(dictitervalues_type == NULL)) {
-        PyThreadState *tstate = PyThreadState_GET();
-
         dictitervalues_type =
             Py_TYPE(CALL_FUNCTION_NO_ARGS(tstate, PyObject_GetAttrString(const_dict_empty, "itervalues")));
     }
 
-    return _MAKE_DICT_ITERATOR((PyDictObject *)dict, dictitervalues_type, false);
+    return _MAKE_DICT_ITERATOR(tstate, (PyDictObject *)dict, dictitervalues_type, false);
 #elif PYTHON_VERSION < 0x300
-    return _MAKE_DICT_ITERATOR((PyDictObject *)dict, &PyDictIterValue_Type, false);
+    return _MAKE_DICT_ITERATOR(tstate, (PyDictObject *)dict, &PyDictIterValue_Type, false);
 #else
-    return _MAKE_DICT_ITERATOR((PyDictObject *)dict, &PyDictValues_Type, false);
+    return _MAKE_DICT_ITERATOR(tstate, (PyDictObject *)dict, &PyDictValues_Type, false);
 #endif
 }
 
@@ -897,6 +896,111 @@ PyObject *DICT_VIEWITEMS(PyObject *dict) {
 #endif
 }
 
+#if PYTHON_VERSION >= 0x300
+static PyDictObject *_Nuitka_AllocatePyDictObject(PyThreadState *tstate) {
+    PyDictObject *result_mp;
+
+#if NUITKA_DICT_HAS_FREELIST
+    // 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 (*numfree) {
+        (*numfree) -= 1;
+        result_mp = items[*numfree];
+
+        Nuitka_Py_NewReference((PyObject *)result_mp);
+
+        assert(PyDict_CheckExact((PyObject *)result_mp));
+        assert(result_mp != NULL);
+    } else
+#endif
+    {
+        result_mp = (PyDictObject *)Nuitka_GC_New(&PyDict_Type);
+    }
+
+    return result_mp;
+}
+#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
+    {
+#if PYTHON_VERSION < 0x3d0
+        dk = (PyDictKeysObject *)NuitkaObject_Malloc(keys_size);
+#else
+        dk = (PyDictKeysObject *)NuitkaMem_Malloc(keys_size);
+#endif
+    }
+
+    return dk;
+}
+#endif
+
+#if PYTHON_VERSION >= 0x360 && !defined(_NUITKA_EXPERIMENTAL_DISABLE_DICT_OPT)
+
+// Usable fraction of keys.
+#define DK_USABLE_FRACTION(n) (((n) << 1) / 3)
+
+static Py_ssize_t _Nuitka_Py_PyDict_KeysSize(PyDictKeysObject *keys) {
+#if PYTHON_VERSION < 0x360
+    return sizeof(PyDictKeysObject) + (DK_SIZE(keys) - 1) * sizeof(PyDictKeyEntry);
+#elif PYTHON_VERSION < 0x370
+    return (sizeof(PyDictKeysObject) - Py_MEMBER_SIZE(PyDictKeysObject, dk_indices) + DK_IXSIZE(keys) * DK_SIZE(keys) +
+            DK_USABLE_FRACTION(DK_SIZE(keys)) * sizeof(PyDictKeyEntry));
+#elif PYTHON_VERSION < 0x3b0
+    return (sizeof(PyDictKeysObject) + DK_IXSIZE(keys) * DK_SIZE(keys) +
+            DK_USABLE_FRACTION(DK_SIZE(keys)) * sizeof(PyDictKeyEntry));
+#else
+    size_t entry_size = keys->dk_kind == DICT_KEYS_GENERAL ? sizeof(PyDictKeyEntry) : sizeof(PyDictUnicodeEntry);
+    return (sizeof(PyDictKeysObject) + ((size_t)1 << keys->dk_log2_index_bytes) +
+            DK_USABLE_FRACTION(DK_SIZE(keys)) * entry_size);
+#endif
+}
+#endif
+
+#if PYTHON_VERSION < 0x3b0
+typedef PyObject *PyDictValues;
+#endif
+
+#if PYTHON_VERSION < 0x360
+#define DK_ENTRIES_SIZE(keys) (keys->dk_size)
+#elif PYTHON_VERSION < 0x3b0
+#define DK_ENTRIES_SIZE(keys) DK_USABLE_FRACTION(DK_SIZE(keys))
+#else
+#define DK_ENTRIES_SIZE(keys) (keys->dk_nentries)
+#endif
+
 #include "HelpersDictionariesGenerated.c"
 
 void DICT_CLEAR(PyObject *dict) {
@@ -1000,9 +1104,9 @@ static Py_ssize_t Nuitka_Py_unicodekeys_lookup_generic(PyDictObject *mp, PyDictK
     NUITKA_CANNOT_GET_HERE("Nuitka_Py_unicodekeys_lookup_generic failed");
 }
 
-// TODO: Make use of this one in Nuitka_PyDictLookupStr
-static Py_ssize_t Nuitka_Py_unicodekeys_lookup_unicode(PyDictKeysObject *dk, PyObject *key, Py_hash_t hash) {
+Py_ssize_t Nuitka_Py_unicodekeys_lookup_unicode(PyDictKeysObject *dk, PyObject *key, Py_hash_t hash) {
     assert(PyUnicode_CheckExact(key));
+    assert(dk->dk_kind != DICT_KEYS_GENERAL);
 
     PyDictUnicodeEntry *ep0 = DK_UNICODE_ENTRIES(dk);
 
@@ -1093,7 +1197,6 @@ static Py_ssize_t Nuitka_Py_dictkeys_generic_lookup(PyDictObject *mp, PyDictKeys
         perturb >>= PERTURB_SHIFT;
         i = mask & (i * 5 + perturb + 1);
     }
-    Py_UNREACHABLE();
 }
 
 Py_ssize_t Nuitka_PyDictLookup(PyDictObject *mp, PyObject *key, Py_hash_t hash, PyObject ***value_addr) {
@@ -1144,11 +1247,25 @@ restart:
     return ix;
 }
 
-// TODO: Take advantage of string key knowledge directly.
 Py_ssize_t Nuitka_PyDictLookupStr(PyDictObject *mp, PyObject *key, Py_hash_t hash, PyObject ***value_addr) {
     assert(PyUnicode_CheckExact(key));
 
-    return Nuitka_PyDictLookup(mp, key, hash, value_addr);
+    PyDictKeysObject *dk = mp->ma_keys;
+    assert(dk->dk_kind != DICT_KEYS_GENERAL);
+
+    Py_ssize_t ix = Nuitka_Py_unicodekeys_lookup_unicode(dk, key, hash);
+
+    if (ix >= 0) {
+        if (dk->dk_kind == DICT_KEYS_SPLIT) {
+            *value_addr = &mp->ma_values->values[ix];
+        } else {
+            *value_addr = &DK_UNICODE_ENTRIES(dk)[ix].me_value;
+        }
+    } else {
+        *value_addr = NULL;
+    }
+
+    return ix;
 }
 
 #endif
@@ -1156,8 +1273,8 @@ Py_ssize_t Nuitka_PyDictLookupStr(PyDictObject *mp, PyObject *key, Py_hash_t has
 bool Nuitka_DictNext(PyObject *dict, Py_ssize_t *pos, PyObject **key_ptr, PyObject **value_ptr) {
     CHECK_OBJECT(dict);
     assert(PyDict_CheckExact(dict));
-    assert(key_ptr);
-    assert(value_ptr);
+    assert(key_ptr != NULL);
+    assert(value_ptr != NULL);
 
 #if PYTHON_VERSION < 0x300
     Py_ssize_t i = *pos;
@@ -1180,6 +1297,39 @@ bool Nuitka_DictNext(PyObject *dict, Py_ssize_t *pos, PyObject **key_ptr, PyObje
 
     return true;
 
+#elif PYTHON_VERSION < 0x360
+    PyDictObject *mp = (PyDictObject *)dict;
+    PyObject **dict_value_ptr;
+    Py_ssize_t offset;
+
+    Py_ssize_t i = *pos;
+    assert(i >= 0);
+
+    if (mp->ma_values) {
+        dict_value_ptr = &mp->ma_values[i];
+        offset = sizeof(PyObject *);
+    } else {
+        dict_value_ptr = &mp->ma_keys->dk_entries[i].me_value;
+        offset = sizeof(PyDictKeyEntry);
+    }
+
+    Py_ssize_t mask = DK_MASK(mp->ma_keys);
+
+    while ((i <= mask) && (*dict_value_ptr == NULL)) {
+        dict_value_ptr = (PyObject **)(((char *)dict_value_ptr) + offset);
+        i++;
+    }
+
+    if (i > mask) {
+        return false;
+    }
+
+    *key_ptr = mp->ma_keys->dk_entries[i].me_key;
+    *value_ptr = *dict_value_ptr;
+    *pos = i + 1;
+
+    return true;
+
 #elif PYTHON_VERSION < 0x3b0
     PyDictObject *mp = (PyDictObject *)dict;
     PyDictKeyEntry *entry;
@@ -1188,7 +1338,6 @@ bool Nuitka_DictNext(PyObject *dict, Py_ssize_t *pos, PyObject **key_ptr, PyObje
     Py_ssize_t i = *pos;
     assert(i >= 0);
 
-#ifndef PY_NOGIL
     if (mp->ma_values) {
         if (i >= mp->ma_used) {
             return false;
@@ -1198,15 +1347,9 @@ bool Nuitka_DictNext(PyObject *dict, Py_ssize_t *pos, PyObject **key_ptr, PyObje
         value = DK_VALUE(mp, i);
 
         assert(value != NULL);
-#else
-    if (false) {
-#endif
     } else {
-#if PYTHON_VERSION < 0x360
-        Py_ssize_t n = mp->ma_keys->dk_size;
-#else
         Py_ssize_t n = mp->ma_keys->dk_nentries;
-#endif
+
         if (i >= n) {
             return false;
         }
@@ -1307,9 +1450,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);
 
@@ -1337,7 +1480,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
@@ -1355,20 +1498,31 @@ PyObject *TO_DICT(PyThreadState *tstate, PyObject *seq_obj, PyObject *dict_obj)
     return result;
 }
 
+#if _NUITKA_MAINTAIN_DICT_VERSION_TAG
+uint64_t nuitka_dict_version_tag_counter = ((uint64_t)1) << 32;
+#endif
+
 #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;
     result_mp->ma_used = 0;
+#if PYTHON_VERSION >= 0x3c0
+    result_mp->ma_version_tag = DICT_NEXT_VERSION(_PyInterpreterState_GET());
+#elif PYTHON_VERSION >= 0x360
+    result_mp->ma_version_tag = 1;
+#endif
 
-    // Key reference needs to be counted.
-#ifdef Py_REF_DEBUG
+    // Key reference needs to be counted on older Python
+#if defined(Py_REF_DEBUG) && PYTHON_VERSION < 0x3c0
     _Py_RefTotal++;
 #endif
 
@@ -1444,3 +1598,18 @@ PyObject *MAKE_DICT_X_CSTR(char const **keys, PyObject **values, Py_ssize_t size
 
     return result;
 }
+
+//     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.