[build-script] Don't rebuild CMake

This patch updates the CMake-building mechanism to avoid
re-bootstrapping CMake if we already bootstrapped one that is new
enough.

I've made it so that all paths through the function return the path to a
CMake so we can use the result of the function as the cmake path without
having to check.

The function will choose one of the following ways of getting CMake in
order of preference:
 - One we already built
 - The system CMake
 - Bootstrapping one from scratch

It prefers one we built over checking the system CMake because, if we
have already built a CMake previously, it's a good indication that
there either was no system CMake installed, or it wasn't new enough. We
shouldn't waste time checking it again if a previous run detected that
it wasn't good enough.

The system CMake is preferable to building one from scratch if we don't
need to though, so we determine if the system CMake is sufficient.

Finally, if one that we built either doesn't exist, or isn't new enough,
and the system either doesn't have a CMake, or a new enough CMake, build
one. It is built into the location that we are checking for caching, so
the next time we run build-script, it should hit the first case and
choose the already-built CMake instead of building it again.

Author: etcwilde

utils/build-script

@@ -702,12 +702,9 @@ def main_normal():
     invocation = build_script_invocation.BuildScriptInvocation(toolchain, args)
 
     cmake = CMake(args=args, toolchain=toolchain)
-    # Check the CMake version is sufficient on Linux and build from source
-    # if not.
-    cmake_path = cmake.check_cmake_version(SWIFT_SOURCE_ROOT, SWIFT_BUILD_ROOT)
-    if cmake_path is not None:
-        toolchain.cmake = cmake_path
-        args.cmake = cmake_path
+    toolchain.cmake = cmake.get_cmake_path(source_root=SWIFT_SOURCE_ROOT,
+                                           build_root=SWIFT_BUILD_ROOT)
+    args.cmake = toolchain.cmake
 
     # Validate the arguments.
     validate_arguments(toolchain, args)

utils/swift_build_support/swift_build_support/cmake.py

@@ -282,28 +282,38 @@ def build_cmake(self, source_root, build_root):
         os.chdir(cwd)
         return os.path.join(cmake_build_dir, 'bin', 'cmake')
 
-    # For Linux and FreeBSD only, determine the version of the installed
-    # CMake compared to the source and build the source if necessary.
-    # Returns the path to the cmake binary.
-    def check_cmake_version(self, source_root, build_root):
-        if not platform.system() in ["Linux", "FreeBSD"]:
-            return
+    # Get the path to CMake to use for the build
+    # This function will not build CMake for Apple platforms.
+    # For other platforms, this builds CMake if a new enough version is not
+    # available.
+    def get_cmake_path(self, source_root, build_root):
+        if platform.system() == 'Darwin':
+            return self.toolchain.cmake
 
         cmake_source_dir = os.path.join(source_root, 'cmake')
-        # If the source is not checked out then don't attempt to build cmake.
         if not os.path.isdir(cmake_source_dir):
-            return
-
-        cmake_binary = 'cmake'
-        try:
-            if self.args.cmake is not None:
-                cmake_binary = self.args.cmake
-        except AttributeError:
-            cmake_binary = 'cmake'
-
-        installed_ver = self.installed_cmake_version(cmake_binary)
-        if installed_ver >= self.cmake_source_version(cmake_source_dir):
-            return
-        else:
-            # Build CMake from source and return the path to the executable.
-            return self.build_cmake(source_root, build_root)
+            return self.toolchain.cmake
+
+        cmake_required_version = self.cmake_source_version(cmake_source_dir)
+
+        # If we have already built a CMake, see if that is new enough. If it is,
+        # we don't need to build it again. This is a good indication that the
+        # system either doesn't have a CMake installed or it wasn't new enough
+        # so prefer our built CMake first.
+        cmake_built_path = os.path.join(build_root,
+                                        f'cmake-{self.args.host_target}',
+                                        'bin', 'cmake')
+        if os.path.isfile(cmake_built_path):
+            cmake_built_version = self.installed_cmake_version(cmake_built_path)
+            if cmake_built_version >= cmake_required_version:
+                return cmake_built_path
+
+        # If we already have a new enough CMake installed on the system, use it
+        if self.toolchain.cmake is not None:
+            cmake_installed_version = self.installed_cmake_version(self.toolchain.cmake)
+            if cmake_installed_version >= cmake_required_version:
+                return self.toolchain.cmake
+
+        # The pre-installed CMake isn't new enough. Build one from our sources
+        # and return the path to that.
+        return self.build_cmake(source_root, build_root)