Nuitka-winsvc 1.8.6__cp312-cp312-win_amd64.whl → 1.9.3__cp312-cp312-win_amd64.whl

nuitka/build/Backend.scons

@@ -102,7 +102,7 @@ from .SconsUtils import (
     writeSconsReport,
 )
 
-# spell-checker: ignore ccversion,ccflags,werror,cppdefines,cpppath
+# spell-checker: ignore ccversion,ccflags,werror,cppdefines,cpppath,linkflags,libpath
 
 # Set the arguments.
 setArguments(ARGUMENTS)
@@ -120,7 +120,7 @@ nuitka_src = getArgumentRequired("nuitka_src")
 static_src = os.path.join(source_dir, "static")
 
 # The name of executable or extension module that we produce.
-result_basepath = getArgumentRequired("result_name")
+result_base_path = getArgumentRequired("result_name")
 
 # The name of executable that we produce (in executable mode).
 result_exe = getArgumentDefaulted("result_exe", None)
@@ -178,10 +178,6 @@ lto_mode = getArgumentDefaulted("lto_mode", "auto")
 # PGO mode: Use profile guided optimization of C compiler if available.
 pgo_mode = getArgumentDefaulted("pgo_mode", "no")
 
-# Windows target mode: Compile for Windows. Used to be an option, but we
-# no longer cross compile this way.
-win_target = os.name == "nt"
-
 # Windows subsystem mode: Disable console for windows builds.
 disable_console = getArgumentBool("disable_console", False)
 
@@ -204,7 +200,7 @@ clang_mode = getArgumentBool("clang_mode", False)
 # Clang on Windows with no requirement to use MinGW64 or using MSYS2 MinGW flavor,
 # is changed to ClangCL from Visual Studio.
 clangcl_mode = False
-if win_target and not mingw_mode and clang_mode:
+if os.name == "nt" and not mingw_mode and clang_mode:
     clang_mode = False
     clangcl_mode = True
 
@@ -290,6 +286,9 @@ cpp_include_dirs = getArgumentList("cpp_include_dirs", "")
 link_dirs = getArgumentList("link_dirs", "")
 link_libraries = getArgumentList("link_libraries", "")
 
+# From statically compiled modules of the Python
+link_module_libs = getArgumentList("link_module_libs", "")
+
 # Allow automatic downloads for ccache, etc.
 assume_yes_for_downloads = getArgumentBool("assume_yes_for_downloads", False)
 
@@ -362,6 +361,7 @@ env.debug_mode = debug_mode
 env.unstripped_mode = unstripped_mode
 env.disable_console = disable_console
 env.source_dir = source_dir
+env.nuitka_src = nuitka_src
 env.low_memory = low_memory
 env.macos_min_version = macos_min_version
 env.macos_target_arch = macos_target_arch
@@ -377,8 +377,8 @@ env.gcc_mode = isGccName(env.the_cc_name) or clang_mode
 env.clang_mode = clang_mode
 
 # Only use MSVC if not already clear, we are using MinGW.
-env.msvc_mode = win_target and not env.gcc_mode
-env.mingw_mode = win_target and env.gcc_mode
+env.msvc_mode = os.name == "nt" and not env.gcc_mode
+env.mingw_mode = os.name == "nt" and env.gcc_mode
 env.clangcl_mode = clangcl_mode
 
 # Consider switching from gcc to its g++ compiler as a workaround that makes us work without C11.
@@ -395,7 +395,7 @@ if show_scons_mode:
     my_print("Scons: Compiler used", end=" ")
     my_print(getExecutablePath(env.the_compiler, env=env), end=" ")
 
-    if win_target and env.msvc_mode:
+    if os.name == "nt" and env.msvc_mode:
         my_print("(MSVC %s)" % getMsvcVersionString(env))
 
     my_print()
@@ -412,6 +412,7 @@ setupCCompiler(
     lto_mode=lto_mode,
     pgo_mode=pgo_mode,
     job_count=job_count,
+    onefile_compile=False,
 )
 
 
@@ -425,14 +426,14 @@ if env.gcc_mode and not env.clang_mode and env.gcc_version >= (8,):
                 "--file-prefix-map=%s=%s" % (os.path.normpath(source_dir), "."),
                 "--file-prefix-map=%s=%s"
                 % (
-                    os.path.normpath(os.path.join(source_dir, "static_src")),
-                    os.path.normpath(os.path.join(nuitka_src, "static_src")),
+                    os.path.normpath(os.path.join(env.source_dir, "static_src")),
+                    os.path.normpath(os.path.join(env.nuitka_src, "static_src")),
                 ),
             ]
         )
 
 if env.msvc_mode:
-    # With Clang on Windows, there is also an linker to use.
+    # With Clang on Windows, there is also an linker to use. spell-checker: ignore bigobj
     env.Append(
         CCFLAGS=[
             "/EHsc",  # No C++ exception handling code.
@@ -447,7 +448,7 @@ if env.msvc_mode:
 
     if module_mode:
         # Make sure we handle import library on our own and put it into the
-        # build directory.
+        # build directory, spell-checker: ignore IMPLIB
 
         no_import_lib = True
         env.Append(
@@ -463,10 +464,17 @@ if env.debug_mode:
     if env.gcc_mode:
         # Allow gcc/clang to point out all kinds of inconsistency to us by
         # raising an error.
+
+        if "allow-c-warnings" not in env.experimental_flags:
+            env.Append(
+                CCFLAGS=[
+                    "-Wall",
+                    "-Werror",
+                ]
+            )
+
         env.Append(
             CCFLAGS=[
-                "-Wall",
-                "-Werror",
                 # Unfortunately Py_INCREF(Py_False) triggers aliasing warnings,
                 # which are unfounded, so disable them.
                 "-Wno-error=strict-aliasing",
@@ -571,7 +579,7 @@ if env.gcc_mode and env.debian_python:
 
 
 def _detectPythonHeaderPath():
-    if win_target:
+    if os.name == "nt":
         # On Windows, the CPython installation layout is relatively fixed, but on MSYS2
         # compiled for mingw64, it's more standard.
 
@@ -611,7 +619,7 @@ def _detectPythonHeaderPath():
         if os.path.exists(os.path.join(candidate, "Python.h")):
             return candidate
 
-    if win_target:
+    if os.name == "nt":
         scons_logger.sysexit(
             """Error, you seem to be using the unsupported embeddable CPython distribution."""
         )
@@ -645,10 +653,10 @@ if env.nuitka_python:
 if env.static_libpython:
     env.Append(CPPDEFINES=["_NUITKA_STATIC_LIBPYTHON"])
 
-if env.static_libpython and (not win_target or env.nuitka_python):
+if env.static_libpython and (not os.name == "nt" or env.nuitka_python):
     env.Append(CPPDEFINES=["_NUITKA_USE_UNEXPOSED_API"])
 
-if win_target:
+if os.name == "nt":
     if env.nuitka_python:
         env.Append(
             LINKFLAGS=[
@@ -709,16 +717,19 @@ elif not module_mode:
     python_lib_path = os.path.join(python_prefix_external, "lib")
     env.Append(LIBPATH=[python_lib_path])
 
+    # Any module libs that are for self-compiled Python to be static.
+    env.Append(_LIBFLAGS=["-l" + lib_desc for lib_desc in link_module_libs])
+
     if env.nuitka_python:
         link_data = loadJsonFromFilename(
             os.path.join(python_prefix_external, "link.json")
         )
         for lib in link_data["libraries"]:
             # Need to prevent Scons from stripping .a from the passed in libs.
-            if os.path.isfile(lib):
-                env.Append(_LIBFLAGS=[lib])
-            elif lib.startswith(":") and lib.endswith(".a"):
+            if lib.startswith(":") and lib.endswith(".a"):
                 env.Append(_LIBFLAGS=["-l" + lib])
+            elif os.path.isfile(lib):
+                env.Append(_LIBFLAGS=[lib])
             else:
                 env.Append(LIBS=[lib])
         env.Append(LIBPATH=link_data["library_dirs"])
@@ -779,7 +790,7 @@ if isMacOS():
 
 # The static include files reside in Nuitka installation, which may be where
 # the "nuitka.build" package lives.
-nuitka_include = os.path.join(nuitka_src, "include")
+nuitka_include = os.path.join(env.nuitka_src, "include")
 
 if not os.path.exists(os.path.join(nuitka_include, "nuitka", "prelude.h")):
     scons_logger.sysexit(
@@ -789,10 +800,12 @@ if not os.path.exists(os.path.join(nuitka_include, "nuitka", "prelude.h")):
 
 # We have include files in the build directory and the static include directory
 # that is located inside Nuitka installation.
-env.Append(CPPPATH=[source_dir, nuitka_include, os.path.join(nuitka_src, "static_src")])
+env.Append(
+    CPPPATH=[source_dir, nuitka_include, os.path.join(env.nuitka_src, "static_src")]
+)
 
 # Set load libpython from binary directory default
-if env.gcc_mode and not isMacOS() and not win_target and not module_mode:
+if env.gcc_mode and not isMacOS() and not os.name == "nt" and not module_mode:
     if env.standalone_mode:
         rpath = "$$ORIGIN"
     else:
@@ -868,9 +881,8 @@ def discoverSourceFiles():
 
     result += [
         provideStaticSourceFile(
+            env=env,
             sub_path=filename,
-            nuitka_src=nuitka_src,
-            source_dir=source_dir,
             c11_mode=env.c11_mode,
         )
         for filename in static_src_filenames
@@ -883,11 +895,11 @@ source_files = discoverSourceFiles()
 
 if module_mode:
     # For Python modules, the standard shared library extension is not what
-    # gets used.
+    # gets used. spell-checker: ignore SHLIBSUFFIX
     env["SHLIBSUFFIX"] = module_suffix
 
     target = env.SharedLibrary(
-        result_basepath, source_files, no_import_lib=no_import_lib
+        result_base_path, source_files, no_import_lib=no_import_lib
     )
 else:
     target = env.Program(result_exe, source_files)
@@ -967,9 +979,7 @@ def createBuildDefinitionsFile():
             build_definitions["NUITKA_FORCED_STDERR_PATH"] = forced_stderr_path
 
     build_definitions["NUITKA_MAIN_MODULE_NAME"] = main_module_name
-
-    if main_module_name != "__main__":
-        build_definitions["NUITKA_MAIN_PACKAGE_MODE"] = 1
+    build_definitions["NUITKA_MAIN_IS_PACKAGE_BOOL"] = main_module_name != "__main__"
 
     createDefinitionsFile(source_dir, "build_definitions.h", build_definitions)
 
@@ -978,7 +988,7 @@ if forced_stderr_path and not forced_stdout_path:
     env.Append(CPPDEFINES=["NUITKA_STDERR_NOT_VISIBLE"])
 
 if file_reference_mode == "original":
-    env.Append(CPPDEFINES=["NUITKA_FILE_REFERENCE_ORIGINAL_MODE"])
+    env.Append(CPPDEFINES=["_NUITKA_FILE_REFERENCE_ORIGINAL_MODE"])
 
 
 createBuildDefinitionsFile()
@@ -1010,7 +1020,6 @@ env.Append(LIBS=link_libraries)
 # Work around windows bugs and use watchdogs to track progress of compilation.
 enableSpawnMonitoring(
     env=env,
-    win_target=win_target,
     module_mode=module_mode,
     source_files=source_files,
 )

nuitka/build/CCompilerVersion.scons

@@ -69,6 +69,7 @@ from .SconsUtils import (
     getArgumentBool,
     getArgumentDefaulted,
     getArgumentList,
+    getArgumentRequired,
     getExecutablePath,
     initScons,
     isClangName,
@@ -86,6 +87,8 @@ setArguments(ARGUMENTS)
 # Set up the basic stuff.
 initScons()
 
+nuitka_src = getArgumentRequired("nuitka_src")
+
 # Module mode: Create a Python extension module, create an executable otherwise.
 module_mode = getArgumentBool("module_mode", False)
 
@@ -99,10 +102,6 @@ experimental = getArgumentList("experimental", "")
 # good with the compiler in question.
 lto_mode = getArgumentDefaulted("lto_mode", "auto")
 
-# Windows target mode: Compile for Windows. Used to be an option, but we
-# no longer cross compile this way.
-win_target = os.name == "nt"
-
 # Windows subsystem mode: Disable console for windows builds.
 disable_console = getArgumentBool("disable_console", False)
 
@@ -122,7 +121,7 @@ clang_mode = getArgumentBool("clang_mode", False)
 # Clang on Windows with no requirement to use MinGW64 or using MSYS2 MinGW flavor,
 # is changed to ClangCL from Visual Studio.
 clangcl_mode = False
-if win_target and not mingw_mode and clang_mode:
+if os.name == "nt" and not mingw_mode and clang_mode:
     clang_mode = False
     clangcl_mode = True
 
@@ -163,7 +162,7 @@ if "CXX" in os.environ:
 
     cxx_dirname = os.path.dirname(os.environ["CXX"])
 
-    if win_target and isGccName(os.path.basename(os.environ["CXX"])):
+    if os.name == "nt" and isGccName(os.path.basename(os.environ["CXX"])):
         if show_scons_mode:
             my_print("Scons: Environment CXX seems to be a gcc, enable mingw_mode.")
         mingw_mode = True
@@ -221,6 +220,7 @@ env.the_cc_name = os.path.normcase(os.path.basename(env.the_compiler))
 env.debug_mode = debug_mode
 env.unstripped_mode = unstripped_mode
 env.disable_console = disable_console
+env.nuitka_src = nuitka_src
 env.low_memory = False
 env.macos_min_version = macos_min_version
 env.macos_target_arch = macos_target_arch
@@ -236,8 +236,8 @@ env.gcc_mode = isGccName(env.the_cc_name) or clang_mode
 env.clang_mode = clang_mode
 
 # Only use MSVC if not already clear, we are using MinGW.
-env.msvc_mode = win_target and not env.gcc_mode
-env.mingw_mode = win_target and env.gcc_mode
+env.msvc_mode = os.name == "nt" and not env.gcc_mode
+env.mingw_mode = os.name == "nt" and env.gcc_mode
 env.clangcl_mode = clangcl_mode
 
 # Consider switching from gcc to its g++ compiler as a workaround that makes us work without C11.
@@ -253,12 +253,13 @@ env.the_compiler = getExecutablePath(env.the_compiler, env=env)
 # Report the C compiler used.
 reportCCompiler(env, "Version", my_print)
 
-# Set up C compiler settings.
+# Set up C compiler settings, we would use that mode mode outputs.
 setupCCompiler(
     env=env,
     lto_mode=lto_mode,
     pgo_mode="no",  # TODO: Have this here too, decompression might benefit.
     job_count=job_count,
+    onefile_compile=False,
 )
 
 # TODO: Report modes.

nuitka/build/Onefile.scons

@@ -141,10 +141,6 @@ trace_mode = getArgumentBool("trace_mode", False)
 # good with the compiler in question.
 lto_mode = getArgumentDefaulted("lto_mode", "auto")
 
-# Windows target mode: Compile for Windows. Used to be an option, but we
-# no longer cross compile this way.
-win_target = os.name == "nt"
-
 # Windows subsystem mode: Disable console for windows builds.
 disable_console = getArgumentBool("disable_console", False)
 
@@ -164,7 +160,7 @@ clang_mode = getArgumentBool("clang_mode", False)
 # Clang on Windows with no requirement to use MinGW64 or using MSYS2 MinGW flavor,
 # is changed to ClangCL from Visual Studio.
 clangcl_mode = False
-if clang_mode and win_target and not mingw_mode:
+if clang_mode and os.name == "nt" and not mingw_mode:
     clang_mode = False
     clangcl_mode = True
 
@@ -223,7 +219,7 @@ if "CXX" in os.environ:
 
     cxx_dirname = os.path.dirname(os.environ["CXX"])
 
-    if win_target and isGccName(os.path.basename(os.environ["CXX"])):
+    if os.name == "nt" and isGccName(os.path.basename(os.environ["CXX"])):
         if show_scons_mode:
             my_print("Scons: Environment CXX seems to be a gcc, enable mingw_mode.")
         mingw_mode = True
@@ -283,6 +279,7 @@ env.debug_mode = debug_mode
 env.unstripped_mode = unstripped_mode
 env.disable_console = disable_console
 env.source_dir = source_dir
+env.nuitka_src = nuitka_src
 env.low_memory = False  # Never a concern in this case.
 env.macos_min_version = macos_min_version
 env.macos_target_arch = macos_target_arch
@@ -298,8 +295,8 @@ env.gcc_mode = isGccName(env.the_cc_name) or clang_mode
 env.clang_mode = clang_mode
 
 # Only use MSVC if not already clear, we are using MinGW.
-env.msvc_mode = win_target and not env.gcc_mode
-env.mingw_mode = win_target and env.gcc_mode
+env.msvc_mode = os.name == "nt" and not env.gcc_mode
+env.mingw_mode = os.name == "nt" and env.gcc_mode
 env.clangcl_mode = clangcl_mode
 
 # Consider switching from gcc to its g++ compiler as a workaround that makes us work without C11.
@@ -314,7 +311,7 @@ if show_scons_mode:
     my_print("Scons: Compiler used", end=" ")
     my_print(getExecutablePath(env.the_compiler, env=env), end=" ")
 
-    if win_target and env.msvc_mode:
+    if os.name == "nt" and env.msvc_mode:
         my_print("(MSVC %s)" % getMsvcVersionString(env))
 
     my_print()
@@ -332,6 +329,7 @@ setupCCompiler(
     lto_mode=lto_mode,
     pgo_mode="no",  # TODO: Have this here too, decompression might benefit.
     job_count=job_count,
+    onefile_compile=True,
 )
 
 # Avoid them as appearing to be different files. TODO: Find out which
@@ -373,14 +371,6 @@ if debug_mode:
             CCFLAGS=[
                 "-Wall",
                 "-Werror",
-                # Unfortunately Py_INCREF(Py_False) triggers aliasing warnings,
-                # which are unfounded, so disable them.
-                "-Wno-error=strict-aliasing",
-                "-Wno-strict-aliasing",
-                # At least for self-compiled Python3.2, and MinGW this happens
-                # and has little use anyway.
-                "-Wno-error=format",
-                "-Wno-format",
             ]
         )
 
@@ -427,8 +417,8 @@ env.Append(
     CPPPATH=[
         source_dir,
         nuitka_include,
-        os.path.join(nuitka_src, "static_src"),
-        os.path.join(nuitka_src, "inline_copy", "zstd"),
+        os.path.join(env.nuitka_src, "static_src"),
+        os.path.join(env.nuitka_src, "inline_copy", "zstd"),
     ],
 )
 
@@ -437,8 +427,6 @@ if env.msvc_mode:
     env.Append(CCFLAGS=["/MT"])  # Multithreaded, static version of C run time.
 
 if isMacOS():
-    env.Append(CPPDEFINES=["_NUITKA_PAYLOAD_FROM_MACOS_SECTION"])
-
     addConstantBlobFile(
         env=env,
         blob_filename=os.path.join(source_dir, "__payload.bin"),
@@ -463,9 +451,8 @@ def discoverSourceFiles():
     # Main onefile bootstrap program
     result.append(
         provideStaticSourceFile(
+            env=env,
             sub_path="OnefileBootstrap.c",
-            nuitka_src=nuitka_src,
-            source_dir=source_dir,
             c11_mode=env.c11_mode,
         )
     )
@@ -473,9 +460,8 @@ def discoverSourceFiles():
     if onefile_splash_screen:
         result.append(
             provideStaticSourceFile(
+                env=env,
                 sub_path="OnefileSplashScreen.cpp",
-                nuitka_src=nuitka_src,
-                source_dir=source_dir,
                 c11_mode=False,
             )
         )
@@ -510,7 +496,6 @@ env.Append(LIBS=link_libraries)
 # Work around windows bugs and use watchdogs to track progress of compilation.
 enableSpawnMonitoring(
     env=env,
-    win_target=win_target,
     module_mode=module_mode,
     source_files=source_files,
 )

nuitka/build/SconsCaching.py

@@ -106,6 +106,7 @@ def _injectCcache(env, cc_path, python_prefix, assume_yes_for_downloads):
             if isWin32Windows():
                 url = "https://github.com/ccache/ccache/releases/download/v4.6/ccache-4.6-windows-32.zip"
                 ccache_binary = getCachedDownload(
+                    name="ccache",
                     url=url,
                     is_arch_specific=False,
                     specificity=url.rsplit("/", 2)[1],
@@ -121,6 +122,7 @@ def _injectCcache(env, cc_path, python_prefix, assume_yes_for_downloads):
                     url = "https://nuitka.net/ccache/v4.2.1/ccache-4.2.1.zip"
 
                     ccache_binary = getCachedDownload(
+                        name="ccache",
                         url=url,
                         is_arch_specific=False,
                         specificity=url.rsplit("/", 2)[1],

nuitka/build/SconsCompilerSettings.py

@@ -52,11 +52,11 @@ from .SconsUtils import (
     setEnvironmentVariable,
 )
 
-# spell-checker: ignore CPPDEFINES,CPPPATH,CXXVERSION,CCFLAGS,LINKFLAGS,CXXFLAGS
+# spell-checker: ignore LIBPATH,CPPDEFINES,CPPPATH,CXXVERSION,CCFLAGS,LINKFLAGS,CXXFLAGS
 # spell-checker: ignore -flto,-fpartial-inlining,-freorder-functions,-defsym,-fprofile
 # spell-checker: ignore -fwrapv,-Wunused,fcompare,-ftrack,-fvisibility,-municode,
 # spell-checker: ignore -feliminate,noexecstack,implib
-# spell-checker: ignore LTCG,GENPROFILE,USEPROFILE,
+# spell-checker: ignore LTCG,GENPROFILE,USEPROFILE,CGTHREADS
 
 
 def _detectWindowsSDK(env):
@@ -161,6 +161,9 @@ def _enableLtoSettings(
     elif env.nuitka_python:
         lto_mode = True
         reason = "known to be supported (Nuitka-Python)"
+    elif env.fedora_python:
+        lto_mode = True
+        reason = "known to be supported (Fedora Python)"
     elif (
         env.debian_python
         and env.gcc_mode
@@ -210,26 +213,31 @@ version for lto mode (>= 4.6). Disabled."""
         reason = "gcc 4.6 is doesn't have good enough LTO support"
 
     if env.gcc_mode and lto_mode:
-        env.Append(CCFLAGS=["-flto"])
-
         if env.clang_mode:
+            env.Append(CCFLAGS=["-flto"])
             env.Append(LINKFLAGS=["-flto"])
         else:
+            env.Append(CCFLAGS=["-flto=%d" % job_count])
+            env.Append(LINKFLAGS=["-flto=%d" % job_count])
+
             env.Append(CCFLAGS=["-fuse-linker-plugin", "-fno-fat-lto-objects"])
             env.Append(LINKFLAGS=["-fuse-linker-plugin"])
 
-            env.Append(LINKFLAGS=["-flto=%d" % job_count])
-
             # Need to tell the linker these things are OK.
             env.Append(LINKFLAGS=["-fpartial-inlining", "-freorder-functions"])
 
+            if env.mingw_mode and "MAKE" not in os.environ:
+                setEnvironmentVariable(env, "MAKE", "mingw32-make.exe")
+
     # Tell compiler to use link time optimization for MSVC
     if env.msvc_mode and lto_mode:
         env.Append(CCFLAGS=["/GL"])
 
         if not env.clangcl_mode:
             env.Append(LINKFLAGS=["/LTCG"])
-            env.Append(LINKFLAGS=["/CGTHREADS:%d" % job_count])
+
+            if getMsvcVersion(env) >= (14, 3):
+                env.Append(LINKFLAGS=["/CGTHREADS:%d" % job_count])
 
     if orig_lto_mode == "auto":
         scons_details_logger.info(
@@ -491,6 +499,11 @@ unsigned char const *getConstantsBlobData(void) {
         # Indicate "linker" resource mode.
         env.Append(CPPDEFINES=["_NUITKA_CONSTANTS_FROM_LINKER"])
 
+        # For MinGW the symbol name to be used is more low level.
+        constant_bin_link_name = "constant_bin_data"
+        if env.mingw_mode:
+            constant_bin_link_name = "_" + constant_bin_link_name
+
         env.Append(
             LINKFLAGS=[
                 "-Wl,-b",
@@ -503,9 +516,9 @@ unsigned char const *getConstantsBlobData(void) {
                     mingw_mode=env.mingw_mode or isPosixWindows(),
                 ),
                 "-Wl,-defsym",
-                "-Wl,%sconstant_bin_data=_binary_%s___constants_bin_start"
+                "-Wl,%s=_binary_%s___constants_bin_start"
                 % (
-                    "_" if env.mingw_mode else "",
+                    constant_bin_link_name,
                     "".join(re.sub("[^a-zA-Z0-9_]", "_", c) for c in env.source_dir),
                 ),
             ]
@@ -573,7 +586,7 @@ def enableWindowsStackSize(env, target_arch):
         env.Append(LINKFLAGS=["-Wl,--stack,%d" % stack_size])
 
 
-def setupCCompiler(env, lto_mode, pgo_mode, job_count):
+def setupCCompiler(env, lto_mode, pgo_mode, job_count, onefile_compile):
     # This is driven by many branches on purpose and has a lot of things
     # to deal with for LTO checks and flags, pylint: disable=too-many-branches,too-many-statements
 
@@ -765,12 +778,12 @@ def setupCCompiler(env, lto_mode, pgo_mode, job_count):
         if env.disable_console:
             env.Append(CPPDEFINES=["_NUITKA_WINMAIN_ENTRY_POINT"])
 
-    # Avoid dependency on MinGW libraries.
+    # Avoid dependency on MinGW libraries, spell-checker: ignore libgcc
     if env.mingw_mode and not env.clang_mode:
         env.Append(LINKFLAGS=["-static-libgcc"])
 
     # MinGW64 for 64 bits needs this due to CPython bugs.
-    if env.mingw_mode and env.target_arch == "x86_64":
+    if env.mingw_mode and env.target_arch == "x86_64" and env.python_version < (3, 12):
         env.Append(CPPDEFINES=["MS_WIN64"])
 
     # For shell API usage to lookup app folders we need this. Note that on Windows ARM
@@ -783,6 +796,24 @@ def setupCCompiler(env, lto_mode, pgo_mode, job_count):
     if isFedoraBasedLinux():
         env.Append(CCFLAGS=["-fPIC"])
 
+    # We use zlib for crc32 functionality
+    zlib_inline_copy_dir = os.path.join(env.nuitka_src, "inline_copy", "zlib")
+    if os.path.exists(os.path.join(zlib_inline_copy_dir, "crc32.c")):
+        env.Append(
+            CPPPATH=[
+                zlib_inline_copy_dir,
+            ],
+        )
+    else:
+        # TODO: Should only happen for official Debian packages, and there we
+        # can use the zlib static linking maybe, but for onefile it's not easy
+        # to get it, so just use slow checksum for now.
+        if onefile_compile:
+            env.Append(CPPDEFINES=["_NUITKA_USE_OWN_CRC32"])
+        else:
+            env.Append(CPPDEFINES=["_NUITKA_USE_SYSTEM_CRC32"])
+            env.Append(LIBS="z")
+
 
 def _enablePgoSettings(env, pgo_mode):
     if pgo_mode == "no":
@@ -907,20 +938,29 @@ version (>= 5.3)."""
         )
 
     if env.gcc_version < (5,):
-        scons_logger.info("The provided gcc is too old, switching to its g++ instead.")
+        if env.python_version < (3, 11):
+            scons_logger.info(
+                "The provided gcc is too old, switching to its g++ instead.",
+                mnemonic="too-old-gcc",
+            )
 
-        # Switch to g++ from gcc then if possible, when C11 mode is false.
-        the_gpp_compiler = os.path.join(
-            os.path.dirname(env.the_compiler),
-            os.path.basename(env.the_compiler).replace("gcc", "g++"),
-        )
+            # Switch to g++ from gcc then if possible, when C11 mode is false.
+            the_gpp_compiler = os.path.join(
+                os.path.dirname(env.the_compiler),
+                os.path.basename(env.the_compiler).replace("gcc", "g++"),
+            )
 
-        if getExecutablePath(the_gpp_compiler, env=env):
-            env.the_compiler = the_gpp_compiler
-            env.the_cc_name = env.the_cc_name.replace("gcc", "g++")
+            if getExecutablePath(the_gpp_compiler, env=env):
+                env.the_compiler = the_gpp_compiler
+                env.the_cc_name = env.the_cc_name.replace("gcc", "g++")
+            else:
+                scons_logger.sysexit(
+                    "Error, your gcc is too old for C11 support, and no related g++ to workaround that is found."
+                )
         else:
             scons_logger.sysexit(
-                "Error, your gcc is too old for C11 support, and no related g++ to workaround that is found."
+                "Error, your gcc is too old for C11 support, install a newer one.",
+                mnemonic="too-old-gcc",
             )
 
 
@@ -929,6 +969,16 @@ def reportCCompiler(env, context, output_func):
 
     if env.the_cc_name == "cl":
         cc_output = "%s %s" % (env.the_cc_name, getMsvcVersionString(env))
+    elif isGccName(env.the_cc_name):
+        cc_output = "%s %s" % (
+            env.the_cc_name,
+            ".".join(str(d) for d in env.gcc_version),
+        )
+    elif isClangName(env.the_cc_name):
+        cc_output = "%s %s" % (
+            env.the_cc_name,
+            ".".join(str(d) for d in myDetectVersion(env, env.the_cc_name)),
+        )
     else:
         cc_output = env.the_cc_name
 

nuitka/build/SconsHacks.py

@@ -93,6 +93,7 @@ def _myDetectVersion(cc):
         command = (
             cc,
             "-dumpversion",
+            "-dumpfullversion",
         )
     else:
         command = (