tc_build: tools: Check for multicall binary in find_host_cc()

There are two minor problems with find_host_cc() when using a multicall
binary setup.

The first is calling .resolve() on a multicall binary, which breaks the
multicall setup because the symlink is how the multicall binary works in
the first place. Avoid calling .resolve() in the case of multicall
binaries.

The second is clang-<ver> is not present in a multicall setup, so a
versioned binary from elsewhere in PATH can be chosen before a multicall
binary because plain clang is checked after the versioned binaries.
Check if the first clang in PATH is a multicall binary and use it if so.
Otherwise, fallback to looking at versioned binaries first then the
unversioned clang so that newer versions of clang, such as those from
apt.llvm.org, are chosen first.

While in the area, use an else branch for the for loop that looks for
compilers, saving a couple lines and a cc check.

Signed-off-by: Nathan Chancellor <nathan@kernel.org>

Author: nathanchance

tc_build/tools.py

@@ -28,6 +28,9 @@ def __init__(self):
         self.merge_fdata = None
         self.perf2bolt = None
 
+    def cc_is_multicall(self, cc):
+        return Path(cc).resolve().name == 'llvm'
+
     def find_host_ar(self):
         # GNU ar is the default, no need for llvm-ar if using GCC
         if not self.cc_is_clang:
@@ -40,16 +43,26 @@ def find_host_ar(self):
 
     def find_host_cc(self):
         # resolve() is called here and below to get /usr/lib/llvm-#/bin/... for
-        # versioned LLVM binaries on Debian and Ubuntu.
+        # versioned LLVM binaries on Debian and Ubuntu. We do not want to
+        # resolve a multicall binary though, as the symlink is how it works
+        # properly.
         if (cc := self.from_env('CC')):
-            return cc.resolve()
+            return cc if self.cc_is_multicall(cc) else cc.resolve()
+
+        # As a special case, see if the first clang command in PATH is a
+        # multicall binary, as there will be no clang-<ver> binary or symlink,
+        # so the versioned binary logic below may result in a clang-<ver>
+        # binary from PATH "overriding" the clang symlink to llvm. We generally
+        # want clang-<ver> to override clang though because clang-<ver> may be
+        # newer than a plain clang binary (such as when using apt.llvm.org).
+        if (clang := shutil.which('clang')) and self.cc_is_multicall(clang):
+            return Path(clang)
 
         possible_c_compilers = [*self.generate_versioned_binaries(), 'clang', 'gcc']
         for compiler in possible_c_compilers:
             if (cc := shutil.which(compiler)):
                 break
-
-        if not cc:
+        else:
             raise RuntimeError('Neither clang nor gcc could be found on your system?')
 
         return Path(cc).resolve()  # resolve() for Debian/Ubuntu variants