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

nuitka/build/static_src/HelpersConstantsBlob.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
+
 /** Providing access to the constants binary blob.
  *
  * There are multiple ways, the constants binary is accessed, and its
@@ -128,7 +113,7 @@ static PyObject *our_list_richcompare(PyListObject *list1, PyListObject *list2,
         result = Py_False;
     }
 
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 
@@ -151,7 +136,7 @@ static PyObject *our_tuple_richcompare(PyTupleObject *tuple1, PyTupleObject *tup
         result = Py_False;
     }
 
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 
@@ -196,8 +181,10 @@ static PyObject *our_set_richcompare(PyObject *set1, PyObject *set2, int op) {
         // Same sized set, simply check if values are identical. Other reductions should
         // make it identical, or else this won't have the effect intended.
         while (_PySet_Next(set1, &pos1, &key1)) {
-            int res = _PySet_Next(set2, &pos2, &key2);
-            assert(res != 0);
+            {
+                NUITKA_MAY_BE_UNUSED int res = _PySet_Next(set2, &pos2, &key2);
+                assert(res != 0);
+            }
 
             if (key1 != key2) {
                 result = Py_False;
@@ -210,8 +197,10 @@ static PyObject *our_set_richcompare(PyObject *set1, PyObject *set2, int op) {
         // Same sized dictionary, simply check if values are identical. Other reductions should
         // make it identical, or else this won't have the effect intended.
         while (_PySet_NextEntry(set1, &pos1, &key1, &unused1)) {
-            int res = _PySet_NextEntry(set2, &pos2, &key2, &unused2);
-            assert(res != 0);
+            {
+                NUITKA_MAY_BE_UNUSED int res = _PySet_NextEntry(set2, &pos2, &key2, &unused2);
+                assert(res != 0);
+            }
 
             if (key1 != key2) {
                 result = Py_False;
@@ -221,7 +210,7 @@ static PyObject *our_set_richcompare(PyObject *set1, PyObject *set2, int op) {
 #endif
     }
 
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 
@@ -237,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;
 }
 
@@ -273,8 +262,10 @@ static PyObject *our_dict_richcompare(PyObject *a, PyObject *b, int op) {
         // Other reductions should make it identical, or else this won't have the
         // effect intended.
         while (Nuitka_DictNext(a, &pos1, &key1, &value1)) {
-            int res = Nuitka_DictNext(b, &pos2, &key2, &value2);
-            assert(res != 0);
+            {
+                NUITKA_MAY_BE_UNUSED int res = Nuitka_DictNext(b, &pos2, &key2, &value2);
+                assert(res != 0);
+            }
 
             if (key1 != key2 || value1 != value2) {
                 result = Py_False;
@@ -283,7 +274,7 @@ static PyObject *our_dict_richcompare(PyObject *a, PyObject *b, int op) {
         }
     }
 
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 
@@ -404,8 +395,8 @@ static int unpackValueInt(unsigned char const **data) {
     return size;
 }
 
-static long unpackValueLong(unsigned char const **data) {
-    long size;
+static double unpackValueFloat(unsigned char const **data) {
+    double size;
 
     memcpy(&size, *data, sizeof(size));
     *data += sizeof(size);
@@ -413,38 +404,32 @@ static long unpackValueLong(unsigned char const **data) {
     return size;
 }
 
-static long long unpackValueLongLong(unsigned char const **data) {
-    long long size;
-
-    memcpy(&size, *data, sizeof(size));
-    *data += sizeof(size);
+static unsigned char const *_unpackValueCString(unsigned char const *data) {
+    while (*(data++) != 0) {
+    }
 
-    return size;
+    return data;
 }
 
-static unsigned long long unpackValueUnsignedLongLong(unsigned char const **data) {
-    unsigned long long size;
-
-    memcpy(&size, *data, sizeof(size));
-    *data += sizeof(size);
+// Decoding Variable-length quantity values
+static uint64_t _unpackVariableLength(unsigned char const **data) {
+    uint64_t result = 0;
+    uint64_t factor = 1;
 
-    return size;
-}
+    while (1) {
+        unsigned char value = **data;
+        *data += 1;
 
-static double unpackValueFloat(unsigned char const **data) {
-    double size;
-
-    memcpy(&size, *data, sizeof(size));
-    *data += sizeof(size);
+        result += (value & 127) * factor;
 
-    return size;
-}
+        if (value < 128) {
+            break;
+        }
 
-static unsigned char const *_unpackValueCString(unsigned char const *data) {
-    while (*(data++) != 0) {
+        factor <<= 7;
     }
 
-    return data;
+    return result;
 }
 
 static PyObject *_unpackAnonValue(unsigned char anon_index) {
@@ -498,658 +483,678 @@ PyObject *_unpackSpecialValue(unsigned char special_index) {
 }
 
 static unsigned char const *_unpackBlobConstants(PyThreadState *tstate, PyObject **output, unsigned char const *data,
-                                                 int count) {
+                                                 int count);
 
-    for (int _i = 0; _i < count; _i++) {
-        // Make sure we discover failures to assign.
-        *output = NULL;
-        bool is_object;
+static unsigned char const *_unpackBlobConstant(PyThreadState *tstate, PyObject **output, unsigned char const *data) {
+
+    // Make sure we discover failures to assign.
+    *output = NULL;
+    bool is_object;
 
-        char c = *((char const *)data++);
+    char c = *((char const *)data++);
 #ifdef _NUITKA_EXPERIMENTAL_DEBUG_CONSTANTS
-        unsigned char const *data_old = data;
-        printf("Type %c for %d of %d:\n", c, _i, count);
+    unsigned char const *data_old = data;
+    printf("Type %c for %d of %d:\n", c, _i, count);
 #endif
-        switch (c) {
+    switch (c) {
 
-        case 'p': {
-            assert(_i > 0);
+    case 'p': {
+        *output = *(output - 1);
+        is_object = true;
 
-            *output = *(output - 1);
-            is_object = true;
+        break;
+    }
+    case 'T': {
+        int size = (int)_unpackVariableLength(&data);
 
-            break;
+        PyObject *t = PyTuple_New(size);
+
+        if (size > 0) {
+            data = _unpackBlobConstants(tstate, &PyTuple_GET_ITEM(t, 0), data, size);
         }
-        case 'T': {
-            // TODO: Use fixed sizes
-            // uint32_t size = unpackSizeUint32(&data);
-            int size = unpackValueInt(&data);
 
-            PyObject *t = PyTuple_New(size);
+        insertToDictCacheForcedHash(tuple_cache, &t, (hashfunc)our_tuple_hash, (richcmpfunc)our_tuple_richcompare);
 
-            if (size > 0) {
-                data = _unpackBlobConstants(tstate, &PyTuple_GET_ITEM(t, 0), data, size);
-            }
+        *output = t;
+        is_object = true;
 
-            insertToDictCacheForcedHash(tuple_cache, &t, (hashfunc)our_tuple_hash, (richcmpfunc)our_tuple_richcompare);
+        break;
+    }
+    case 'L': {
+        int size = (int)_unpackVariableLength(&data);
 
-            *output = t;
-            is_object = true;
+        PyObject *l = PyList_New(size);
 
-            break;
+        if (size > 0) {
+            data = _unpackBlobConstants(tstate, &PyList_GET_ITEM(l, 0), data, size);
         }
-        case 'L': {
-            // TODO: Use fixed sizes
-            // uint32_t size = unpackSizeUint32(&data);
-            int size = unpackValueInt(&data);
 
-            PyObject *l = PyList_New(size);
+        insertToDictCacheForcedHash(list_cache, &l, (hashfunc)our_list_hash, (richcmpfunc)our_list_richcompare);
 
-            if (size > 0) {
-                data = _unpackBlobConstants(tstate, &PyList_GET_ITEM(l, 0), data, size);
-            }
-
-            insertToDictCacheForcedHash(list_cache, &l, (hashfunc)our_list_hash, (richcmpfunc)our_list_richcompare);
+        *output = l;
+        is_object = true;
 
-            *output = l;
-            is_object = true;
-
-            break;
-        }
-        case 'D': {
-            // TODO: Use flexible sizes with bias towards small values.
-            // uint32_t size = unpackSizeUint32(&data);
-            int size = unpackValueInt(&data);
+        break;
+    }
+    case 'D': {
+        int size = (int)_unpackVariableLength(&data);
 
-            PyObject *d = _PyDict_NewPresized(size);
+        PyObject *d = _PyDict_NewPresized(size);
 
-            if (size > 0) {
-                NUITKA_DYNAMIC_ARRAY_DECL(keys, PyObject *, size);
-                NUITKA_DYNAMIC_ARRAY_DECL(values, PyObject *, size);
+        if (size > 0) {
+            NUITKA_DYNAMIC_ARRAY_DECL(keys, PyObject *, size);
+            NUITKA_DYNAMIC_ARRAY_DECL(values, PyObject *, size);
 
-                data = _unpackBlobConstants(tstate, &keys[0], data, size);
-                data = _unpackBlobConstants(tstate, &values[0], data, size);
+            data = _unpackBlobConstants(tstate, &keys[0], data, size);
+            data = _unpackBlobConstants(tstate, &values[0], data, size);
 
-                for (int i = 0; i < size; i++) {
-                    PyDict_SetItem(d, keys[i], values[i]);
-                }
+            for (int i = 0; i < size; i++) {
+                PyDict_SetItem(d, keys[i], values[i]);
             }
+        }
 
-            insertToDictCacheForcedHash(dict_cache, &d, (hashfunc)our_dict_hash, (richcmpfunc)our_dict_richcompare);
+        insertToDictCacheForcedHash(dict_cache, &d, (hashfunc)our_dict_hash, (richcmpfunc)our_dict_richcompare);
 
-            *output = d;
-            is_object = true;
+        *output = d;
+        is_object = true;
 
-            break;
-        }
-        case 'P':
-        case 'S': {
-            // TODO: Use fixed sizes
-            // uint32_t size = unpackSizeUint32(&data);
-            int size = unpackValueInt(&data);
-
-            PyObject *s;
+        break;
+    }
+    case 'P':
+    case 'S': {
+        int size = (int)_unpackVariableLength(&data);
+
+        PyObject *s;
+
+        if (c == 'S') {
+            s = PySet_New(NULL);
+        } else {
+            if (size == 0) {
+                // Get at the frozenset singleton of CPython and use it too. Some things
+                // rely on it being a singleton across the board.
+                static PyObject *empty_frozenset = NULL;
+
+                if (empty_frozenset == NULL) {
+                    empty_frozenset = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, (PyObject *)&PyFrozenSet_Type,
+                                                                    Nuitka_Bytes_FromStringAndSize("", 0));
+                }
 
-            if (c == 'S') {
-                s = PySet_New(NULL);
+                s = empty_frozenset;
             } else {
-                if (size == 0) {
-                    // Get at the frozenset singleton of CPython and use it too. Some things
-                    // rely on it being a singleton across the board.
-                    static PyObject *empty_frozenset = NULL;
-
-                    if (empty_frozenset == NULL) {
-                        empty_frozenset = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, (PyObject *)&PyFrozenSet_Type,
-                                                                        Nuitka_Bytes_FromStringAndSize("", 0));
-                    }
-
-                    s = empty_frozenset;
-                } else {
-                    s = PyFrozenSet_New(NULL);
-                }
+                s = PyFrozenSet_New(NULL);
             }
+        }
 
-            if (size > 0) {
-                NUITKA_DYNAMIC_ARRAY_DECL(values, PyObject *, size);
+        if (size > 0) {
+            NUITKA_DYNAMIC_ARRAY_DECL(values, PyObject *, size);
 
-                data = _unpackBlobConstants(tstate, &values[0], data, size);
+            data = _unpackBlobConstants(tstate, &values[0], data, size);
 
-                for (int i = 0; i < size; i++) {
-                    PySet_Add(s, values[i]);
-                }
+            for (int i = 0; i < size; i++) {
+                PySet_Add(s, values[i]);
             }
+        }
 
-            // sets are cached globally too.
-            if (c == 'S') {
-                insertToDictCacheForcedHash(set_cache, &s, (hashfunc)our_set_hash, (richcmpfunc)our_set_richcompare);
-            } else {
-                insertToDictCacheForcedHash(frozenset_cache, &s, (hashfunc)our_set_hash,
-                                            (richcmpfunc)our_set_richcompare);
-            }
+        // sets are cached globally too.
+        if (c == 'S') {
+            insertToDictCacheForcedHash(set_cache, &s, (hashfunc)our_set_hash, (richcmpfunc)our_set_richcompare);
+        } else {
+            insertToDictCacheForcedHash(frozenset_cache, &s, (hashfunc)our_set_hash, (richcmpfunc)our_set_richcompare);
+        }
 
-            *output = s;
-            is_object = true;
+        *output = s;
+        is_object = true;
 
-            break;
-        }
+        break;
+    }
 #if PYTHON_VERSION < 0x300
-        case 'i': {
-            // TODO: Use fixed sizes for small values, e.g. byte sized.
-            long value = unpackValueLong(&data);
+    case 'I':
+    case 'i': {
+        long value = (long)_unpackVariableLength(&data);
+        if (c == 'I') {
+            value = -value;
+        }
 
-            PyObject *i = PyInt_FromLong(value);
+        PyObject *i = PyInt_FromLong(value);
 
-            insertToDictCache(int_cache, &i);
+        insertToDictCache(int_cache, &i);
 
-            *output = i;
-            is_object = true;
+        *output = i;
+        is_object = true;
 
-            break;
-        }
+        break;
+    }
 #endif
-        case 'l': {
-            // TODO: Use fixed sizes for small values, e.g. byte, word sized.
-            long value = unpackValueLong(&data);
+    case 'l':
+    case 'q': {
+        // Positive/negative integer value with abs value < 2**31
+        uint64_t value = _unpackVariableLength(&data);
 
-            PyObject *l = Nuitka_LongFromCLong(value);
+        PyObject *l = Nuitka_LongFromCLong((c == 'l') ? ((long)value) : (-(long)value));
+        assert(l != NULL);
 
-            // Avoid the long cache, won't do anything useful for small ints
+        // Avoid the long cache, won't do anything useful for small ints
 #if PYTHON_VERSION >= 0x300
-            if (value < NUITKA_STATIC_SMALLINT_VALUE_MIN || value >= NUITKA_STATIC_SMALLINT_VALUE_MAX)
+        if (value < NUITKA_STATIC_SMALLINT_VALUE_MIN || value >= NUITKA_STATIC_SMALLINT_VALUE_MAX)
 #endif
-            {
-                insertToDictCache(long_cache, &l);
-            }
-
-            *output = l;
-            is_object = true;
-
-            break;
-        }
-        case 'q': {
-            long long value = unpackValueLongLong(&data);
-
-            PyObject *l = PyLong_FromLongLong(value);
-
+        {
             insertToDictCache(long_cache, &l);
+        }
 
-            *output = l;
-            is_object = true;
+        *output = l;
+        is_object = true;
 
-            break;
-        }
-        case 'g': {
-            PyObject *result = PyLong_FromLong(0);
+        break;
+    }
+    case 'G':
+    case 'g': {
+        PyObject *result = PyLong_FromLong(0);
 
-            unsigned char sign = *data++;
-            int size = unpackValueInt(&data);
+        int size = (int)_unpackVariableLength(&data);
 
-            PyObject *shift = PyLong_FromLong(8 * sizeof(unsigned long long));
+        PyObject *shift = PyLong_FromLong(31);
 
-            for (int i = 0; i < size; i++) {
-                result = PyNumber_InPlaceLshift(result, shift);
+        for (int i = 0; i < size; i++) {
+            result = PyNumber_InPlaceLshift(result, shift);
 
-                unsigned long long value = unpackValueUnsignedLongLong(&data);
-                PyObject *part = PyLong_FromUnsignedLongLong(value);
-                result = PyNumber_InPlaceAdd(result, part);
-                Py_DECREF(part);
-            }
+            uint64_t value = _unpackVariableLength(&data);
+            PyObject *part = Nuitka_LongFromCLong((long)value);
+            assert(part != NULL);
+            result = PyNumber_InPlaceAdd(result, part);
+            Py_DECREF(part);
+        }
 
-            Py_DECREF(shift);
+        Py_DECREF(shift);
 
-            if (sign == '-') {
-                // TODO: There is a negate function
-                PyObject *neg = PyLong_FromLong(-1);
-                result = PyNumber_InPlaceMultiply(result, neg);
-                Py_DECREF(neg);
-            }
+        if (c == 'G') {
+            Nuitka_LongSetSignNegative(result);
+        }
 
-            insertToDictCache(long_cache, &result);
+        insertToDictCache(long_cache, &result);
 
-            *output = result;
-            is_object = true;
+        *output = result;
+        is_object = true;
 
-            break;
-        }
-        case 'f': {
-            double value = unpackValueFloat(&data);
+        break;
+    }
+    case 'f': {
+        double value = unpackValueFloat(&data);
 
-            PyObject *f = PyFloat_FromDouble(value);
+        PyObject *f = PyFloat_FromDouble(value);
 
-            // Floats are cached globally too.
-            insertToDictCacheForcedHash(float_cache, &f, NULL, (richcmpfunc)our_float_richcompare);
+        // Floats are cached globally too.
+        insertToDictCacheForcedHash(float_cache, &f, NULL, (richcmpfunc)our_float_richcompare);
 
-            *output = f;
-            is_object = true;
+        *output = f;
+        is_object = true;
 
-            break;
-        }
-        case 'j': {
-            double real = unpackValueFloat(&data);
-            double imag = unpackValueFloat(&data);
+        break;
+    }
+    case 'j': {
+        double real = unpackValueFloat(&data);
+        double imag = unpackValueFloat(&data);
 
-            *output = PyComplex_FromDoubles(real, imag);
-            is_object = true;
+        *output = PyComplex_FromDoubles(real, imag);
+        is_object = true;
 
-            break;
-        }
-        case 'J': {
-            PyObject *parts[2];
+        break;
+    }
+    case 'J': {
+        PyObject *parts[2];
 
-            // Complex via float is done for ones that are 0, nan, float.
-            data = _unpackBlobConstants(tstate, &parts[0], data, 2);
+        // Complex via float is done for ones that are 0, nan, float.
+        data = _unpackBlobConstants(tstate, &parts[0], data, 2);
 
-            *output = BUILTIN_COMPLEX2(tstate, parts[0], parts[1]);
-            is_object = true;
+        *output = BUILTIN_COMPLEX2(tstate, parts[0], parts[1]);
+        is_object = true;
 
-            break;
-        }
+        break;
+    }
 #if PYTHON_VERSION < 0x300
-        case 'a':
-        case 'c': {
-            // Python2 str, potentially attribute, zero terminated.
-            size_t size = strlen((const char *)data);
+    case 'a':
+    case 'c': {
+        // Python2 str, potentially attribute, zero terminated.
+        size_t size = strlen((const char *)data);
 
-            PyObject *s = PyString_FromStringAndSize((const char *)data, size);
-            CHECK_OBJECT(s);
+        PyObject *s = PyString_FromStringAndSize((const char *)data, size);
+        CHECK_OBJECT(s);
 
-            data += size + 1;
+        data += size + 1;
 
-            if (c == 'a') {
-                PyString_InternInPlace(&s);
-            }
+        if (c == 'a') {
+            PyString_InternInPlace(&s);
+        }
 
-            *output = s;
-            is_object = true;
+        *output = s;
+        is_object = true;
 
-            break;
-        }
+        break;
+    }
 #else
-        case 'c': {
-            // Python3 bytes, zero terminated.
-            size_t size = strlen((const char *)data);
+    case 'c': {
+        // Python3 bytes, zero terminated.
+        size_t size = strlen((const char *)data);
 
-            PyObject *b = Nuitka_Bytes_FromStringAndSize((const char *)data, size);
-            CHECK_OBJECT(b);
+        PyObject *b = Nuitka_Bytes_FromStringAndSize((const char *)data, size);
+        CHECK_OBJECT(b);
 
-            data += size + 1;
+        data += size + 1;
 
-            // Empty bytes value is here as well.
-            if (size > 1) {
-                insertToDictCache(bytes_cache, &b);
-            }
+        // Empty bytes value is here as well.
+        if (size > 1) {
+            insertToDictCache(bytes_cache, &b);
+        }
 
-            *output = b;
-            is_object = true;
+        *output = b;
+        is_object = true;
 
-            break;
-        }
+        break;
+    }
 #endif
-        case 'd': {
-            // Python2 str length 1 str, potentially attribute, or Python3 single byte
+    case 'd': {
+        // Python2 str length 1 str, potentially attribute, or Python3 single byte
 
 #if PYTHON_VERSION < 0x300
-            PyObject *s = PyString_FromStringAndSize((const char *)data, 1);
-            data += 1;
-            *output = s;
+        PyObject *s = PyString_FromStringAndSize((const char *)data, 1);
+        data += 1;
+        *output = s;
 #else
-            PyObject *b = Nuitka_Bytes_FromStringAndSize((const char *)data, 1);
-            data += 1;
-            *output = b;
+        PyObject *b = Nuitka_Bytes_FromStringAndSize((const char *)data, 1);
+        data += 1;
+        *output = b;
 #endif
 
-            is_object = true;
+        is_object = true;
 
-            break;
-        }
-        case 'w': {
-            // Python2 unicode, Python3 str length 1, potentially attribute in Python3
+        break;
+    }
+    case 'w': {
+        // Python2 unicode, Python3 str length 1, potentially attribute in Python3
 
-            PyObject *u = PyUnicode_FromStringAndSize((const char *)data, 1);
-            data += 1;
+        PyObject *u = PyUnicode_FromStringAndSize((const char *)data, 1);
+        data += 1;
 
 #if PYTHON_VERSION >= 0x300
-            PyUnicode_InternInPlace(&u);
+        PyUnicode_InternInPlace(&u);
 #else
-            insertToDictCache(unicode_cache, &u);
+        insertToDictCache(unicode_cache, &u);
 #endif
 
-            *output = u;
-            is_object = true;
+        *output = u;
+        is_object = true;
 
-            break;
-        }
-        case 'b': {
-            // Python2 str or Python3 bytes, length indicated.
-            int size = unpackValueInt(&data);
-            assert(size > 1);
+        break;
+    }
+    case 'b': {
+        // Python2 str or Python3 bytes, length indicated.
+        int size = (int)_unpackVariableLength(&data);
+        assert(size > 1);
 
-            PyObject *b = Nuitka_Bytes_FromStringAndSize((const char *)data, size);
-            CHECK_OBJECT(b);
+        PyObject *b = Nuitka_Bytes_FromStringAndSize((const char *)data, size);
+        CHECK_OBJECT(b);
 
-            data += size;
+        data += size;
 
 #if PYTHON_VERSION >= 0x300
-            insertToDictCache(bytes_cache, &b);
+        insertToDictCache(bytes_cache, &b);
 #endif
 
-            *output = b;
-            is_object = true;
+        *output = b;
+        is_object = true;
 
-            break;
-        }
+        break;
+    }
 
-        case 'B': {
-            // TODO: Use fixed sizes for small, e.g. character values, and length vs. 0
-            // termination.
-            int size = unpackValueInt(&data);
+    case 'B': {
+        int size = (int)_unpackVariableLength(&data);
 
-            PyObject *b = PyByteArray_FromStringAndSize((const char *)data, size);
-            data += size;
+        PyObject *b = PyByteArray_FromStringAndSize((const char *)data, size);
+        data += size;
 
-            *output = b;
-            is_object = true;
+        *output = b;
+        is_object = true;
 
-            break;
-        }
+        break;
+    }
 #if PYTHON_VERSION >= 0x300
-        case 'a': // Python3 attributes
+    case 'a': // Python3 attributes
 #endif
-        case 'u': { // Python2 unicode, Python3 str, zero terminated.
-            size_t size = strlen((const char *)data);
+    case 'u': { // Python2 unicode, Python3 str, zero terminated.
+        size_t size = strlen((const char *)data);
 #if PYTHON_VERSION < 0x300
-            PyObject *u = PyUnicode_FromStringAndSize((const char *)data, size);
+        PyObject *u = PyUnicode_FromStringAndSize((const char *)data, size);
 #else
-            PyObject *u = PyUnicode_DecodeUTF8((const char *)data, size, "surrogatepass");
+        PyObject *u = PyUnicode_DecodeUTF8((const char *)data, size, "surrogatepass");
 #endif
-            data += size + 1;
+        data += size + 1;
 
 #if PYTHON_VERSION >= 0x300
-            if (c == 'a') {
-                PyUnicode_InternInPlace(&u);
-            }
+        if (c == 'a') {
+            PyUnicode_InternInPlace(&u);
+        }
 #else
-            insertToDictCache(unicode_cache, &u);
+        insertToDictCache(unicode_cache, &u);
 #endif
 
-            *output = u;
-            is_object = true;
+        *output = u;
+        is_object = true;
 
-            break;
-        }
-        case 'v': {
-            int size = unpackValueInt(&data);
+        break;
+    }
+    case 'v': {
+        int size = (int)_unpackVariableLength(&data);
 
 #if PYTHON_VERSION < 0x300
-            PyObject *u = PyUnicode_FromStringAndSize((const char *)data, size);
+        PyObject *u = PyUnicode_FromStringAndSize((const char *)data, size);
 #else
-            PyObject *u = PyUnicode_DecodeUTF8((const char *)data, size, "surrogatepass");
+        PyObject *u = PyUnicode_DecodeUTF8((const char *)data, size, "surrogatepass");
 #endif
-            data += size;
+        data += size;
 
 #if PYTHON_VERSION < 0x300
-            insertToDictCache(unicode_cache, &u);
+        insertToDictCache(unicode_cache, &u);
 #endif
 
-            *output = u;
-            is_object = true;
+        *output = u;
+        is_object = true;
 
-            break;
-        }
-        case 'n': {
-            *output = Py_None;
-            is_object = true;
+        break;
+    }
+    case 'n': {
+        *output = Py_None;
+        is_object = true;
 
-            break;
-        }
-        case 't': {
-            *output = Py_True;
-            is_object = true;
+        break;
+    }
+    case 't': {
+        *output = Py_True;
+        is_object = true;
 
-            break;
-        }
-        case 'F': {
-            *output = Py_False;
-            is_object = true;
+        break;
+    }
+    case 'F': {
+        *output = Py_False;
+        is_object = true;
 
-            break;
-        }
-        case ':': {
-            // Slice object
-            PyObject *items[3];
-            data = _unpackBlobConstants(tstate, &items[0], data, 3);
+        break;
+    }
+    case ':': {
+        // Slice object
+        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;
+        *output = s;
+        is_object = true;
 
-            break;
-        }
-        case ';': {
-            // (x)range objects
+        break;
+    }
+    case ';': {
+        // (x)range objects
+        PyObject *items[3];
+        data = _unpackBlobConstants(tstate, &items[0], data, 3);
 #if PYTHON_VERSION < 0x300
-            long start = unpackValueLong(&data);
-            long stop = unpackValueLong(&data);
-            long step = unpackValueLong(&data);
+        assert(PyInt_CheckExact(items[0]));
+        assert(PyInt_CheckExact(items[1]));
+        assert(PyInt_CheckExact(items[2]));
 
-            PyObject *s = MAKE_XRANGE(tstate, start, stop, step);
-#else
-            PyObject *items[3];
-            data = _unpackBlobConstants(tstate, &items[0], data, 3);
+        long start = PyInt_AS_LONG(items[0]);
+        long stop = PyInt_AS_LONG(items[1]);
+        long step = PyInt_AS_LONG(items[2]);
 
-            PyObject *s = BUILTIN_XRANGE3(tstate, items[0], items[1], items[2]);
+        PyObject *s = MAKE_XRANGE(tstate, start, stop, step);
+#else
+        PyObject *s = BUILTIN_XRANGE3(tstate, items[0], items[1], items[2]);
 #endif
-            *output = s;
-            is_object = true;
+        *output = s;
+        is_object = true;
 
-            break;
-        }
-        case 'M': {
-            // Anonymous builtin by table index value.
-            unsigned char anon_index = *data++;
-
-            *output = _unpackAnonValue(anon_index);
-            is_object = true;
+        break;
+    }
+    case 'M': {
+        // Anonymous builtin by table index value.
+        unsigned char anon_index = *data++;
 
-            break;
-        }
-        case 'Q': {
-            // Anonymous builtin by table index value.
-            unsigned char special_index = *data++;
+        *output = _unpackAnonValue(anon_index);
+        is_object = true;
 
-            *output = _unpackSpecialValue(special_index);
-            is_object = true;
+        break;
+    }
+    case 'Q': {
+        // Anonymous builtin by table index value.
+        unsigned char special_index = *data++;
 
-            break;
-        }
-        case 'O': {
-            // Builtin by name. TODO: Define number table shared by C and Python
-            // serialization to avoid using strings here.
-            char const *builtin_name = (char const *)data;
-            data = _unpackValueCString(data);
+        *output = _unpackSpecialValue(special_index);
+        is_object = true;
 
-            *output = PyObject_GetAttrString((PyObject *)builtin_module, builtin_name);
-            is_object = true;
+        break;
+    }
+    case 'O': {
+        // Builtin by name. TODO: Define number table shared by C and Python
+        // serialization to avoid using strings here.
+        char const *builtin_name = (char const *)data;
+        data = _unpackValueCString(data);
 
-            break;
-        }
-        case 'E': {
-            // Builtin exception by name. TODO: Define number table shared by C and Python
-            // serialization to avoid using strings here.
-            char const *builtin_exception_name = (char const *)data;
-            data = _unpackValueCString(data);
+        *output = PyObject_GetAttrString((PyObject *)builtin_module, builtin_name);
+        is_object = true;
 
-            *output = PyObject_GetAttrString((PyObject *)builtin_module, builtin_exception_name);
-            is_object = true;
+        break;
+    }
+    case 'E': {
+        // Builtin exception by name. TODO: Define number table shared by C and Python
+        // serialization to avoid using strings here.
+        char const *builtin_exception_name = (char const *)data;
+        data = _unpackValueCString(data);
 
-            break;
-        }
-        case 'Z': {
-            unsigned char v = *data++;
+        *output = PyObject_GetAttrString((PyObject *)builtin_module, builtin_exception_name);
+        is_object = true;
 
-            PyObject *z = NULL;
+        break;
+    }
+    case 'Z': {
+        unsigned char v = *data++;
 
-            switch (v) {
-            case 0: {
-                static PyObject *_const_float_0_0 = NULL;
+        PyObject *z = NULL;
 
-                if (_const_float_0_0 == NULL) {
-                    _const_float_0_0 = PyFloat_FromDouble(0.0);
-                }
-                z = _const_float_0_0;
+        switch (v) {
+        case 0: {
+            static PyObject *_const_float_0_0 = NULL;
 
-                break;
+            if (_const_float_0_0 == NULL) {
+                _const_float_0_0 = PyFloat_FromDouble(0.0);
             }
-            case 1: {
-                static PyObject *_const_float_minus_0_0 = NULL;
+            z = _const_float_0_0;
 
-                if (_const_float_minus_0_0 == NULL) {
-                    _const_float_minus_0_0 = PyFloat_FromDouble(0.0);
+            break;
+        }
+        case 1: {
+            static PyObject *_const_float_minus_0_0 = NULL;
 
-                    // Older Python3 has variable signs from C, so be explicit about it.
-                    PyFloat_SET_DOUBLE(_const_float_minus_0_0,
-                                       copysign(PyFloat_AS_DOUBLE(_const_float_minus_0_0), -1.0));
-                }
-                z = _const_float_minus_0_0;
+            if (_const_float_minus_0_0 == NULL) {
+                _const_float_minus_0_0 = PyFloat_FromDouble(0.0);
 
-                break;
+                // Older Python3 has variable signs from C, so be explicit about it.
+                PyFloat_SET_DOUBLE(_const_float_minus_0_0, copysign(PyFloat_AS_DOUBLE(_const_float_minus_0_0), -1.0));
             }
+            z = _const_float_minus_0_0;
 
-            case 2: {
-                static PyObject *_const_float_plus_nan = NULL;
+            break;
+        }
 
-                if (_const_float_plus_nan == NULL) {
-                    _const_float_plus_nan = PyFloat_FromDouble(Py_NAN);
+        case 2: {
+            static PyObject *_const_float_plus_nan = NULL;
 
-                    // Older Python3 has variable signs for NaN from C, so be explicit about it.
-                    PyFloat_SET_DOUBLE(_const_float_plus_nan, copysign(PyFloat_AS_DOUBLE(_const_float_plus_nan), 1.0));
-                }
-                z = _const_float_plus_nan;
+            if (_const_float_plus_nan == NULL) {
+                _const_float_plus_nan = PyFloat_FromDouble(Py_NAN);
 
-                break;
+                // Older Python3 has variable signs for NaN from C, so be explicit about it.
+                PyFloat_SET_DOUBLE(_const_float_plus_nan, copysign(PyFloat_AS_DOUBLE(_const_float_plus_nan), 1.0));
             }
-            case 3: {
-                static PyObject *_const_float_minus_nan = NULL;
+            z = _const_float_plus_nan;
 
-                if (_const_float_minus_nan == NULL) {
-                    _const_float_minus_nan = PyFloat_FromDouble(Py_NAN);
+            break;
+        }
+        case 3: {
+            static PyObject *_const_float_minus_nan = NULL;
 
-                    // Older Python3 has variable signs for NaN from C, so be explicit about it.
-                    PyFloat_SET_DOUBLE(_const_float_minus_nan,
-                                       copysign(PyFloat_AS_DOUBLE(_const_float_minus_nan), -1.0));
-                }
-                z = _const_float_minus_nan;
+            if (_const_float_minus_nan == NULL) {
+                _const_float_minus_nan = PyFloat_FromDouble(Py_NAN);
 
-                break;
+                // Older Python3 has variable signs for NaN from C, so be explicit about it.
+                PyFloat_SET_DOUBLE(_const_float_minus_nan, copysign(PyFloat_AS_DOUBLE(_const_float_minus_nan), -1.0));
             }
-            case 4: {
-                static PyObject *_const_float_plus_inf = NULL;
+            z = _const_float_minus_nan;
 
-                if (_const_float_plus_inf == NULL) {
-                    _const_float_plus_inf = PyFloat_FromDouble(Py_HUGE_VAL);
+            break;
+        }
+        case 4: {
+            static PyObject *_const_float_plus_inf = NULL;
 
-                    // Older Python3 has variable signs from C, so be explicit about it.
-                    PyFloat_SET_DOUBLE(_const_float_plus_inf, copysign(PyFloat_AS_DOUBLE(_const_float_plus_inf), 1.0));
-                }
-                z = _const_float_plus_inf;
+            if (_const_float_plus_inf == NULL) {
+                _const_float_plus_inf = PyFloat_FromDouble(Py_HUGE_VAL);
 
-                break;
+                // Older Python3 has variable signs from C, so be explicit about it.
+                PyFloat_SET_DOUBLE(_const_float_plus_inf, copysign(PyFloat_AS_DOUBLE(_const_float_plus_inf), 1.0));
             }
-            case 5: {
-                static PyObject *_const_float_minus_inf = NULL;
+            z = _const_float_plus_inf;
 
-                if (_const_float_minus_inf == NULL) {
-                    _const_float_minus_inf = PyFloat_FromDouble(Py_HUGE_VAL);
+            break;
+        }
+        case 5: {
+            static PyObject *_const_float_minus_inf = NULL;
 
-                    // Older Python3 has variable signs from C, so be explicit about it.
-                    PyFloat_SET_DOUBLE(_const_float_minus_inf,
-                                       copysign(PyFloat_AS_DOUBLE(_const_float_minus_inf), -1.0));
-                }
-                z = _const_float_minus_inf;
+            if (_const_float_minus_inf == NULL) {
+                _const_float_minus_inf = PyFloat_FromDouble(Py_HUGE_VAL);
 
-                break;
+                // Older Python3 has variable signs from C, so be explicit about it.
+                PyFloat_SET_DOUBLE(_const_float_minus_inf, copysign(PyFloat_AS_DOUBLE(_const_float_minus_inf), -1.0));
             }
-            default: {
-                PRINT_FORMAT("Missing decoding for %d\n", (int)c);
-                NUITKA_CANNOT_GET_HERE("Corrupt constants blob");
-            }
-            }
-
-            // Floats are cached globally too.
-            insertToDictCacheForcedHash(float_cache, &z, NULL, (richcmpfunc)our_float_richcompare);
-
-            *output = z;
-            is_object = true;
+            z = _const_float_minus_inf;
 
             break;
         }
-        case 'X': {
-            // Blob data pointer, user knowns size.
-            int size = unpackValueInt(&data);
+        default: {
+            PRINT_FORMAT("Missing decoding for %d\n", (int)c);
+            NUITKA_CANNOT_GET_HERE("Corrupt constants blob");
+        }
+        }
 
-            *output = (PyObject *)data;
-            is_object = false;
+        // Floats are cached globally too.
+        insertToDictCacheForcedHash(float_cache, &z, NULL, (richcmpfunc)our_float_richcompare);
 
-            data += size;
+        *output = z;
+        is_object = true;
 
-            break;
-        }
+        break;
+    }
+    case 'X': {
+        // Blob data pointer, user knowns size.
+        uint64_t size = _unpackVariableLength(&data);
+
+        *output = (PyObject *)data;
+        is_object = false;
+
+        data += size;
+
+        break;
+    }
 #if PYTHON_VERSION >= 0x390
-        case 'G': {
-            // GenericAlias object
-            PyObject *items[2];
-            data = _unpackBlobConstants(tstate, &items[0], data, 2);
+    case 'A': {
+        // GenericAlias object
+        PyObject *items[2];
+        data = _unpackBlobConstants(tstate, &items[0], data, 2);
 
-            PyObject *g = Py_GenericAlias(items[0], items[1]);
+        PyObject *g = Py_GenericAlias(items[0], items[1]);
 
-            // TODO: Maybe deduplicate.
-            *output = g;
+        // TODO: Maybe deduplicate.
+        *output = g;
 
-            is_object = true;
-            break;
-        }
+        is_object = true;
+        break;
+    }
 #endif
 #if PYTHON_VERSION >= 0x3a0
-        case 'H': {
-            // UnionType object
-            PyObject *args;
-            data = _unpackBlobConstants(tstate, &args, data, 1);
+    case 'H': {
+        // UnionType object
+        PyObject *args;
+        data = _unpackBlobConstants(tstate, &args, data, 1);
 
-            PyObject *union_type = MAKE_UNION_TYPE(args);
+        PyObject *union_type = MAKE_UNION_TYPE(args);
 
-            // TODO: Maybe deduplicate.
-            *output = union_type;
+        // TODO: Maybe deduplicate.
+        *output = union_type;
 
-            is_object = true;
-            break;
-        }
+        is_object = true;
+        break;
+    }
 #endif
-        case '.': {
-            PRINT_FORMAT("Missing values %d\n", count - _i);
-            NUITKA_CANNOT_GET_HERE("Corrupt constants blob");
-        }
-        default:
-            PRINT_FORMAT("Missing decoding for %d\n", (int)c);
-            NUITKA_CANNOT_GET_HERE("Corrupt constants blob");
-        }
+    case 'C': {
+        // Code object, without the filename, we let the module do that, depending on
+        // the source mode.
+        int line = unpackValueInt(&data);
+        int flags = unpackValueInt(&data);
+
+        PyObject *function_name;
+        data = _unpackBlobConstant(tstate, &function_name, data);
+        // TODO: Version specific if we have this
+#if PYTHON_VERSION >= 0x3b0
+        PyObject *function_qualname;
+        data = _unpackBlobConstant(tstate, &function_qualname, data);
+#endif
+        PyObject *arg_names;
+        data = _unpackBlobConstant(tstate, &arg_names, data);
+        PyObject *free_vars;
+        data = _unpackBlobConstant(tstate, &free_vars, data);
+        int arg_count = unpackValueInt(&data);
+
+#if PYTHON_VERSION >= 0x300
+        int kw_only_count = unpackValueInt(&data);
+#if PYTHON_VERSION >= 0x380
+        int pos_only_count = unpackValueInt(&data);
+#endif
+#endif
+        // Filename will be supplied later during usage.
+        *output = (PyObject *)MAKE_CODE_OBJECT(Py_None, line, flags, function_name, function_qualname, arg_names,
+                                               free_vars, arg_count, kw_only_count, pos_only_count);
+
+        is_object = true;
+        break;
+    }
+    case '.': {
+        PRINT_STRING("Missing blob values\n");
+        NUITKA_CANNOT_GET_HERE("Corrupt constants blob");
+    }
+    default:
+        PRINT_FORMAT("Missing decoding for %d\n", (int)c);
+        NUITKA_CANNOT_GET_HERE("Corrupt constants blob");
+    }
 
 #ifdef _NUITKA_EXPERIMENTAL_DEBUG_CONSTANTS
-        printf("Size for %c was %d\n", c, data - data_old);
+    printf("Size for %c was %d\n", c, data - data_old);
 #endif
 
-        // Discourage in-place operations from modifying these. These
-        // might be put into containers, therefore take 2 refs to be
-        // accounting for the container too.
-        if (is_object == true) {
-            CHECK_OBJECT(*output);
+    // Discourage in-place operations from modifying these. These
+    // might be put into containers, therefore take 2 refs to be
+    // accounting for the container too.
+    if (is_object == true) {
+        CHECK_OBJECT(*output);
 
-            Py_INCREF(*output);
-            Py_INCREF(*output);
-        }
+#if PYTHON_VERSION < 0x3c0
+        Py_INCREF(*output);
+        Py_INCREF(*output);
+#else
+        Py_SET_REFCNT_IMMORTAL(*output);
+#endif
+    }
 
-        // PRINT_ITEM(*output);
-        // PRINT_NEW_LINE();
+    return data;
+}
+
+static unsigned char const *_unpackBlobConstants(PyThreadState *tstate, PyObject **output, unsigned char const *data,
+                                                 int count) {
+    for (int _i = 0; _i < count; _i++) {
+        data = _unpackBlobConstant(tstate, output, data);
 
         output += 1;
     }
@@ -1214,11 +1219,11 @@ unsigned char *findMacOSBinarySection(void) {
 #endif
 
 void loadConstantsBlob(PyThreadState *tstate, PyObject **output, char const *name) {
-    assert(PyThreadState_GET() == tstate);
-
     static bool init_done = false;
 
     if (init_done == false) {
+        NUITKA_PRINT_TIMING("loadConstantsBlob(): One time init.");
+
 #ifdef _NUITKA_EXPERIMENTAL_DEBUG_CONSTANTS
         printf("loadConstantsBlob '%s' one time init\n", name);
 #endif
@@ -1242,9 +1247,10 @@ void loadConstantsBlob(PyThreadState *tstate, PyObject **output, char const *nam
 
         assert(constant_bin);
 #endif
-
+        NUITKA_PRINT_TIMING("loadConstantsBlob(): Found blob, decoding now.");
         DECODE(constant_bin);
 
+        NUITKA_PRINT_TIMING("loadConstantsBlob(): CRC32 that blob for correctness.");
         uint32_t hash = unpackValueUint32(&constant_bin);
         uint32_t size = unpackValueUint32(&constant_bin);
 
@@ -1261,6 +1267,8 @@ void loadConstantsBlob(PyThreadState *tstate, PyObject **output, char const *nam
         printf("Checked CRC32 to match hash %u size %u\n", hash, size);
 #endif
 
+        NUITKA_PRINT_TIMING("loadConstantsBlob(): One time init complete.");
+
         init_done = true;
     }
 
@@ -1297,3 +1305,18 @@ void loadConstantsBlob(PyThreadState *tstate, PyObject **output, char const *nam
 
     unpackBlobConstants(tstate, output, w);
 }
+
+//     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.