On Windows, get the C compiler version if running _getcompiler fails

Author: vstinner

Lib/test/test_tools/test_getbuildinfo.py

@@ -1,5 +1,6 @@
 """Test Tools/build/generate_getbuildinfo.py."""
 
+import contextlib
 import locale
 import os
 import subprocess
@@ -22,6 +23,23 @@
 
 
 class TestGetBuildInfo(unittest.TestCase):
+    @contextlib.contextmanager
+    def check_log(self, log):
+        try:
+            with support.captured_stdout() as stdout:
+                yield
+        finally:
+            self.assertEqual(stdout.getvalue(),
+                             f'{SCRIPT_NAME}: {log}\n')
+
+    @contextlib.contextmanager
+    def check_exit_fail(self, errmsg):
+        with self.check_log(errmsg):
+            try:
+                yield
+            except SystemExit as exc:
+                self.assertEqual(exc.code, 1)
+
     def test_get_py_version(self):
         with os_helper.change_cwd(SRC_DIR):
             PY_VERSION = generate_getbuildinfo.get_py_version()
@@ -151,12 +169,63 @@ def check_unchanged(compiler):
         check_unchanged('MSC v.1951 64 bit (AMD64)')
         check_unchanged('MSC v.1951 32 bit (Intel)')
 
-        with support.captured_stdout() as stdout:
+        log = ("Truncate compiler string 'Clang 21.0.0 "
+               "(clang-2100.1.1.101)' to 'Clang 21.0.0'")
+        with self.check_log(log):
             compiler = get_compiler('Clang 21.0.0 (clang-2100.1.1.101)')
             self.assertEqual(compiler, '[Clang 21.0.0]')
-        self.assertEqual(stdout.getvalue(),
-            f"{SCRIPT_NAME}: Truncate compiler string 'Clang 21.0.0 "
-            "(clang-2100.1.1.101)' to 'Clang 21.0.0'\n")
+
+    def test_get_c_compiler_version_windows(self):
+        get_compiler_version = generate_getbuildinfo.get_c_compiler_version_windows
+        C_COMPILER = 'CL.EXE'
+
+        tests = []
+
+        # Test a full output
+        output = textwrap.dedent('''
+            Microsoft (R) C/C++ Optimizing Compiler Version 19.51.36260 for ARM64
+            Copyright (C) Microsoft Corporation.  All rights reserved.
+
+            usage: cl [ option... ] filename... [ /link linkoption... ]
+        ''').strip()
+        tests.append((output, 'MSC v.1951 64 bit (ARM64)'))
+
+        output = 'Microsoft (R) C/C++ Optimizing Compiler Version 19.51.36260 for x64'
+        tests.append((output, 'MSC v.1951 64 bit (AMD64)'))
+
+        output = 'Microsoft (R) C/C++ Optimizing Compiler Version 19.51.36260 for x86'
+        tests.append((output, 'MSC v.1951 32 bit (Intel)'))
+
+        output = 'Microsoft (R) C/C++ Optimizing Compiler Version 19.51.36260 for ARM'
+        tests.append((output, 'MSC v.1951 32 bit (ARM)'))
+
+        def check_version(output, expected):
+            with mock.patch.object(generate_getbuildinfo,
+                                   'run_command') as mock_run_command:
+                mock_run_command.return_value = output
+                version = get_compiler_version(C_COMPILER)
+            self.assertEqual(version, expected)
+            mock_run_command.assert_called_once_with([C_COMPILER],
+                                                     check=False, stderr=True)
+
+        for output, expected in tests:
+            with self.subTest(output=output, expected=expected):
+                check_version(output, expected)
+
+        def check_error(output, errmsg):
+            with mock.patch.object(generate_getbuildinfo,
+                                   'run_command') as mock_run_command:
+                mock_run_command.return_value = output
+                with self.check_exit_fail(errmsg):
+                    get_compiler_version(C_COMPILER)
+
+        output = 'xxx'
+        check_error(output, f'Unable to parse cl.exe version: {output!r}')
+
+        platform = 'PLATFORM'
+        output = ('Microsoft (R) C/C++ Optimizing Compiler '
+                  f'Version 19.51.36260 for {platform}')
+        check_error(output, f'Unknown cl.exe platform: {platform!r}')
 
     def test_functional(self):
         old_locale = locale.setlocale(locale.LC_ALL)
@@ -179,9 +248,8 @@ def test_functional(self):
         with support.swap_attr(sys, 'argv', argv):
             with os_helper.EnvironmentVarGuard() as env:
                 env['SOURCE_DATE_EPOCH'] = str(1791419852)
-                with support.captured_stdout() as stdout:
+                with self.check_log(f'{filename} updated'):
                     generate_getbuildinfo.main()
-                self.assertEqual(stdout.getvalue(), f'{SCRIPT_NAME}: {filename} updated\n')
 
         with open(filename) as fp:
             output = fp.read()

PCbuild/_freeze_module.vcxproj

@@ -466,7 +466,10 @@
     <Message Text="Updated files: @(_UpdatedGetPath->'%(Filename)%(Extension)',', ')"
              Condition="'@(_UpdatedGetPath)' != ''" Importance="high" />
   </Target>
-  <Target Name="_GetBuildInfoHeader" BeforeTargets="PrepareForBuild"
+  <!-- Use AfterTargets to get ClCompilerPath variable -->
+  <Target Name="_GetBuildInfoHeader"
+          BeforeTargets="PrepareForBuild"
+          AfterTargets="ClCompile"
           Inputs="Tools\build\generate_getbuildinfo.py"
           Outputs="Modules\getbuildinfo.h"
           DependsOnTargets="FindPythonForBuild">
@@ -480,7 +483,7 @@
     </PropertyGroup>
 
     <Message Text="Run generate_getbuildinfo.py" Importance="high" />
-    <Exec Command='$(PythonForBuild) Tools\build\generate_getbuildinfo.py --platform=win32 --git-program="$(_GIT)" --getcompiler-program="$(GetCompilerExe)" --free-threading=$(FreeThreading)'
+    <Exec Command='$(PythonForBuild) Tools\build\generate_getbuildinfo.py --platform=win32 --git-program="$(_GIT)" --c-compiler="$(ClCompilerPath)" --getcompiler-program="$(GetCompilerExe)" --free-threading=$(FreeThreading)'
           WorkingDirectory="$(PySourcePath)" />
   </Target>
   <Target Name="_RebuildFrozen" AfterTargets="AfterBuild" Condition="$(Configuration) != 'PGUpdate'">

PCbuild/_getcompiler.vcxproj

@@ -112,4 +112,13 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>
+
+  <Target Name="_DebugGetCompiler" AfterTargets="ClCompile" BeforeTargets="PrepareForBuild">
+    <Message Text="MSBuildToolsPath: $(MSBuildToolsPath)" Importance="high" />
+    <Message Text="CLToolExe: $(CLToolExe)" Importance="high" />
+    <Message Text="CLToolPath: $(CLToolPath)" Importance="high" />
+    <Message Text="ClCompilerPath: $(ClCompilerPath)" Importance="high" />
+    <Message Text="VCINSTALLDIR: %VCINSTALLDIR%" Importance="high" />
+  </Target>
+
 </Project>

Tools/build/generate_getbuildinfo.py

@@ -36,6 +36,15 @@ def create_makefile_regex(name):
     r'([0-9]+\.[0-9a-z.+]+)'             # version
 )
 
+# Parse 'Microsoft (R) C/C++ Optimizing Compiler Version 19.51.36260 for ARM64'
+CL_VERSION_REGEX = re.compile(r'Compiler Version ([0-9]+).([0-9]+).[0-9]+ for (.*)')
+CL_VERSION_SUFFIX = {
+    'x86': "32 bit (Intel)",
+    'x64': "64 bit (AMD64)",
+    'ARM': "32 bit (ARM)",
+    'ARM64': "64 bit (ARM64)",
+}
+
 
 def log(msg):
     print(f"{SCRIPT_NAME}: {msg}")
@@ -127,16 +136,23 @@ def parse_args():
     parser.add_argument('--git-tag', type=str)
     parser.add_argument('--git-branch', type=str)
     parser.add_argument('--getcompiler-program', type=str)
+    parser.add_argument('--c-compiler', type=str)
     parser.add_argument('--compiler', type=str)
     parser.add_argument('--free-threading', type=int)
     return parser.parse_args()
 
 
-def run_command(cmd, *, check=True):
+def run_command(cmd, *, check=True, stderr=False):
     cmd_str = shlex.join(cmd)
     log(f"+ {cmd_str}")
+    kwargs = {}
+    if stderr:
+        kwargs['stderr'] = subprocess.STDOUT
     try:
-        proc = subprocess.run(cmd, stdout=subprocess.PIPE, text=True)
+        proc = subprocess.run(cmd,
+                              stdout=subprocess.PIPE,
+                              text=True,
+                              **kwargs)
     except OSError as exc:
         error = f'with: {exc!r}'
     else:
@@ -157,7 +173,45 @@ def run_command(cmd, *, check=True):
     return proc.stdout.rstrip()
 
 
-def _get_compiler(getcompiler=None):
+def get_c_compiler_version_windows(c_compiler):
+    cmd = [c_compiler]
+    output = run_command(cmd, check=False, stderr=True)
+    if not output:
+        return None
+
+    # Get the first line
+    line = output.splitlines()[0]
+    match = CL_VERSION_REGEX.search(line)
+    if not match:
+        exit_error(f"Unable to parse cl.exe version: {output!r}")
+
+    major = match.group(1)
+    minor = match.group(2)
+    platform = match.group(3)
+    suffix = CL_VERSION_SUFFIX.get(platform)
+    if not suffix:
+        exit_error(f"Unknown cl.exe platform: {platform!r}")
+
+    return f"MSC v.{major}{minor} {suffix}"
+
+
+def get_c_compiler_version_unix(c_compiler=None):
+    CC = get_makefile_cc()
+    if not CC:
+        exit_error(f"ERROR: Unable to locate CC in Makefile")
+
+    cmd = shlex.split(CC)
+    cmd = [*cmd, '--version']
+
+    output = run_command(cmd, check=False)
+    if output:
+        # Get the first line
+        return output.splitlines()[0]
+
+    return None
+
+
+def _get_compiler(getcompiler=None, c_compiler=None):
     # Run _getcompiler program
     if not getcompiler:
         getcompiler = os.path.join('Programs', '_getcompiler')
@@ -174,21 +228,13 @@ def _get_compiler(getcompiler=None):
     if compiler:
         return compiler
 
+    # Running _getcompiler failed, get the C compiler version
     if MS_WINDOWS:
+        if c_compiler:
+            return get_c_compiler_version_windows(c_compiler)
         return None
-
-    # Running _getcompiler failed, run the compiler with --version
-    CC = get_makefile_cc()
-    if not CC:
-        exit_error(f"ERROR: Unable to locate CC in Makefile")
-
-    cmd = shlex.split(CC)
-    output = run_command([*cmd, '--version'], check=False)
-    if output:
-        # Get the first line
-        return output.splitlines()[0]
-
-    return None
+    else:
+        return get_c_compiler_version_unix()
 
 
 def compact_compiler(compiler):
@@ -215,9 +261,9 @@ def compact_compiler(compiler):
     return compiler
 
 
-def get_compiler(compiler, getcompiler_program=None):
+def get_compiler(compiler, getcompiler=None, c_compiler=None):
     if not compiler:
-        compiler = _get_compiler(getcompiler_program)
+        compiler = _get_compiler(getcompiler, c_compiler)
     if not compiler:
         # Default compiler name when everything else failed
         # (see Programs/_getcompiler.c)
@@ -263,7 +309,7 @@ def main():
     if not platform:
         platform = "unknown"
 
-    compiler = get_compiler(args.compiler, args.getcompiler_program)
+    compiler = get_compiler(args.compiler, args.getcompiler_program, args.c_compiler)
 
     build_info, git_id = get_build_info(git_tag, git_branch, git_version)