diff --git a/Help/command/file.rst b/Help/command/file.rst
index db4d6fc..465e567 100644
--- a/Help/command/file.rst
+++ b/Help/command/file.rst
@@ -26,8 +26,8 @@
     file(`MAKE_DIRECTORY`_ [<dir>...])
     file({`COPY`_ | `INSTALL`_} <file>... DESTINATION <dir> [...])
     file(`SIZE`_ <filename> <out-var>)
-    file(`READ_SYMLINK`_ <filename> <out-var>)
-    file(`CREATE_LINK`_ <file> <new-file> [...])
+    file(`READ_SYMLINK`_ <linkname> <out-var>)
+    file(`CREATE_LINK`_ <original> <linkname> [...])
 
   `Path Conversion`_
     file(`RELATIVE_PATH`_ <out-var> <directory> <file>)
@@ -350,22 +350,22 @@
 
 .. code-block:: cmake
 
-  file(READ_SYMLINK <filename> <variable>)
+  file(READ_SYMLINK <linkname> <variable>)
 
-Read the symlink at ``<filename>`` and put the result in ``<variable>``.
-Requires that ``<filename>`` is a valid path pointing to a symlink. If
-``<filename>`` does not exist, or is not a symlink, an error is thrown.
+This subcommand queries the symlink ``<linkname>`` and stores the path it
+points to in the result ``<variable>``.  If ``<linkname>`` does not exist or
+is not a symlink, CMake issues a fatal error.
 
 Note that this command returns the raw symlink path and does not resolve
-relative symlinks. If you want to resolve the relative symlink yourself, you
-could do something like this:
+a relative path.  The following is an example of how to ensure that an
+absolute path is obtained:
 
 .. code-block:: cmake
 
-  set(filename "/path/to/foo.sym")
-  file(READ_SYMLINK "${filename}" result)
+  set(linkname "/path/to/foo.sym")
+  file(READ_SYMLINK "${linkname}" result)
   if(NOT IS_ABSOLUTE "${result}")
-    get_filename_component(dir "${filename}" DIRECTORY)
+    get_filename_component(dir "${linkname}" DIRECTORY)
     set(result "${dir}/${result}")
   endif()
 
@@ -373,23 +373,23 @@
 
 .. code-block:: cmake
 
-  file(CREATE_LINK <file> <new-file>
+  file(CREATE_LINK <original> <linkname>
        [RESULT <result>] [COPY_ON_ERROR] [SYMBOLIC])
 
-Create a link to ``<file>`` at ``<new-file>``.
+Create a link ``<linkname>`` that points to ``<original>``.
+It will be a hard link by default, but providing the ``SYMBOLIC`` option
+results in a symbolic link instead.  Hard links require that ``original``
+exists and is a file, not a directory.  If ``<linkname>`` already exists,
+it will be overwritten.
 
-It is a hard link by default. This can be changed to symbolic links by
-using ``SYMBOLIC``.  The original file needs to exist for hard links.
-
-The ``<result>`` variable, if specified, gets the status of the operation.
-It is set to ``0`` in case of success. Otherwise, it contains the error
-generated. In case of failures, if ``RESULT`` is not specified, a fatal error
-is emitted.
+The ``<result>`` variable, if specified, receives the status of the operation.
+It is set to ``0`` upon success or an error message otherwise.  If ``RESULT``
+is not specified and the operation fails, a fatal error is emitted.
 
 Specifying ``COPY_ON_ERROR`` enables copying the file as a fallback if
-creating the link fails.
-
-Overwrites the ``<new-file>`` if it exists.
+creating the link fails.  It can be useful for handling situations such as
+``<original>`` and ``<linkname>`` being on different drives or mount points,
+which would make them unable to support a hard link.
 
 Path Conversion
 ^^^^^^^^^^^^^^^
diff --git a/Help/command/get_filename_component.rst b/Help/command/get_filename_component.rst
index f55499a..9bbf877 100644
--- a/Help/command/get_filename_component.rst
+++ b/Help/command/get_filename_component.rst
@@ -15,14 +15,13 @@
  NAME      = File name without directory
  EXT       = File name longest extension (.b.c from d/a.b.c)
  NAME_WE   = File name without directory or longest extension
- LAST_EXT  = File name last extention (.c from d/a.b.c)
+ LAST_EXT  = File name last extension (.c from d/a.b.c)
  NAME_WLE  = File name without directory or last extension
  PATH      = Legacy alias for DIRECTORY (use for CMake <= 2.8.11)
 
 Paths are returned with forward slashes and have no trailing slashes.
-The longest file extension is always considered.  If the optional
-``CACHE`` argument is specified, the result variable is added to the
-cache.
+If the optional ``CACHE`` argument is specified, the result variable is
+added to the cache.
 
 .. code-block:: cmake
 
diff --git a/Help/command/try_compile.rst b/Help/command/try_compile.rst
index 77f42a1..ca8fc77 100644
--- a/Help/command/try_compile.rst
+++ b/Help/command/try_compile.rst
@@ -12,12 +12,12 @@
 
 .. code-block:: cmake
 
-  try_compile(RESULT_VAR <bindir> <srcdir>
+  try_compile(<resultVar> <bindir> <srcdir>
               <projectName> [<targetName>] [CMAKE_FLAGS <flags>...]
               [OUTPUT_VARIABLE <var>])
 
 Try building a project.  The success or failure of the ``try_compile``,
-i.e. ``TRUE`` or ``FALSE`` respectively, is returned in ``RESULT_VAR``.
+i.e. ``TRUE`` or ``FALSE`` respectively, is returned in ``<resultVar>``.
 
 In this form, ``<srcdir>`` should contain a complete CMake project with a
 ``CMakeLists.txt`` file and all sources.  The ``<bindir>`` and ``<srcdir>``
@@ -30,7 +30,7 @@
 
 .. code-block:: cmake
 
-  try_compile(RESULT_VAR <bindir> <srcfile|SOURCES srcfile...>
+  try_compile(<resultVar> <bindir> <srcfile|SOURCES srcfile...>
               [CMAKE_FLAGS <flags>...]
               [COMPILE_DEFINITIONS <defs>...]
               [LINK_OPTIONS <options>...]
@@ -42,13 +42,19 @@
               [<LANG>_EXTENSIONS <bool>]
               )
 
-Try building an executable from one or more source files.  The success or
-failure of the ``try_compile``, i.e. ``TRUE`` or ``FALSE`` respectively, is
-returned in ``RESULT_VAR``.
+Try building an executable or static library from one or more source files
+(which one is determined by the :variable:`CMAKE_TRY_COMPILE_TARGET_TYPE`
+variable).  The success or failure of the ``try_compile``, i.e. ``TRUE`` or
+``FALSE`` respectively, is returned in ``<resultVar>``.
 
-In this form the user need only supply one or more source files that include a
-definition for ``main``.  CMake will create a ``CMakeLists.txt`` file to build
-the source(s) as an executable that looks something like this:
+In this form, one or more source files must be provided.  If
+:variable:`CMAKE_TRY_COMPILE_TARGET_TYPE` is unset or is set to ``EXECUTABLE``,
+the sources must include a definition for ``main`` and CMake will create a
+``CMakeLists.txt`` file to build the source(s) as an executable.
+If :variable:`CMAKE_TRY_COMPILE_TARGET_TYPE` is set to ``STATIC_LIBRARY``,
+a static library will be built instead and no definition for ``main`` is
+required.  For an executable, the generated ``CMakeLists.txt`` file would
+contain something like the following:
 
 .. code-block:: cmake
 
@@ -73,7 +79,7 @@
   in the generated test project.
 
 ``COPY_FILE <fileName>``
-  Copy the linked executable to the given ``<fileName>``.
+  Copy the built executable or static library to the given ``<fileName>``.
 
 ``COPY_FILE_ERROR <var>``
   Use after ``COPY_FILE`` to capture into variable ``<var>`` any error
@@ -88,12 +94,12 @@
   given to the ``CMAKE_FLAGS`` option will be ignored.
 
 ``LINK_OPTIONS <options>...``
-  Specify link step options to pass to :command:`target_link_options` or
-  to :prop_tgt:`STATIC_LIBRARY_OPTIONS` target property in the generated
-  project, depending of the :variable:`CMAKE_TRY_COMPILE_TARGET_TYPE` variable.
+  Specify link step options to pass to :command:`target_link_options` or to
+  set the :prop_tgt:`STATIC_LIBRARY_OPTIONS` target property in the generated
+  project, depending on the :variable:`CMAKE_TRY_COMPILE_TARGET_TYPE` variable.
 
 ``OUTPUT_VARIABLE <var>``
-  Store the output from the build process the given variable.
+  Store the output from the build process in the given variable.
 
 ``<LANG>_STANDARD <std>``
   Specify the :prop_tgt:`C_STANDARD`, :prop_tgt:`CXX_STANDARD`,
@@ -114,7 +120,7 @@
 ``try_compile`` operations reuse this single output directory.  If you use
 ``--debug-trycompile``, you can only debug one ``try_compile`` call at a time.
 The recommended procedure is to protect all ``try_compile`` calls in your
-project by ``if(NOT DEFINED RESULT_VAR)`` logic, configure with cmake
+project by ``if(NOT DEFINED <resultVar>)`` logic, configure with cmake
 all the way through once, then delete the cache entry associated with
 the try_compile call of interest, and then re-run cmake again with
 ``--debug-trycompile``.
@@ -139,8 +145,8 @@
 :module:`CheckPIESupported` module must be called before using the
 :command:`try_compile` command.
 
-The current settings of :policy:`CMP0065` and :policy:`CMP0083` are set in the
-generated project.
+The current settings of :policy:`CMP0065` and :policy:`CMP0083` are propagated
+through to the generated test project.
 
 Set the :variable:`CMAKE_TRY_COMPILE_CONFIGURATION` variable to choose
 a build configuration.
@@ -150,7 +156,9 @@
 
 Set the :variable:`CMAKE_TRY_COMPILE_PLATFORM_VARIABLES` variable to specify
 variables that must be propagated into the test project.  This variable is
-meant for use only in toolchain files.
+meant for use only in toolchain files and is only honored by the
+``try_compile()`` command for the source files form, not when given a whole
+project.
 
 If :policy:`CMP0067` is set to ``NEW``, or any of the ``<LANG>_STANDARD``,
 ``<LANG>_STANDARD_REQUIRED``, or ``<LANG>_EXTENSIONS`` options are used,
diff --git a/Help/command/try_run.rst b/Help/command/try_run.rst
index 137402f..d401ebe 100644
--- a/Help/command/try_run.rst
+++ b/Help/command/try_run.rst
@@ -12,8 +12,8 @@
 
 .. code-block:: cmake
 
-  try_run(RUN_RESULT_VAR COMPILE_RESULT_VAR
-          bindir srcfile [CMAKE_FLAGS <flags>...]
+  try_run(<runResultVar> <compileResultVar>
+          <bindir> <srcfile> [CMAKE_FLAGS <flags>...]
           [COMPILE_DEFINITIONS <defs>...]
           [LINK_OPTIONS <options>...]
           [LINK_LIBRARIES <libs>...]
@@ -23,9 +23,9 @@
           [ARGS <args>...])
 
 Try compiling a ``<srcfile>``.  Returns ``TRUE`` or ``FALSE`` for success
-or failure in ``COMPILE_RESULT_VAR``.  If the compile succeeded, runs the
-executable and returns its exit code in ``RUN_RESULT_VAR``.  If the
-executable was built, but failed to run, then ``RUN_RESULT_VAR`` will be
+or failure in ``<compileResultVar>``.  If the compile succeeded, runs the
+executable and returns its exit code in ``<runResultVar>``.  If the
+executable was built, but failed to run, then ``<runResultVar>`` will be
 set to ``FAILED_TO_RUN``.  See the :command:`try_compile` command for
 information on how the test project is constructed to build the source file.
 
@@ -85,10 +85,10 @@
 would have produced if it had been run on its actual target platform.
 These cache entries are:
 
-``<RUN_RESULT_VAR>``
+``<runResultVar>``
   Exit code if the executable were to be run on the target platform.
 
-``<RUN_RESULT_VAR>__TRYRUN_OUTPUT``
+``<runResultVar>__TRYRUN_OUTPUT``
   Output from stdout and stderr if the executable were to be run on
   the target platform.  This is created only if the
   ``RUN_OUTPUT_VARIABLE`` or ``OUTPUT_VARIABLE`` option was used.
diff --git a/Help/manual/cmake-modules.7.rst b/Help/manual/cmake-modules.7.rst
index 71a8b00..d9b939f 100644
--- a/Help/manual/cmake-modules.7.rst
+++ b/Help/manual/cmake-modules.7.rst
@@ -178,7 +178,6 @@
    /module/FindMPEG2
    /module/FindMPEG
    /module/FindMPI
-   /module/FindOctave
    /module/FindODBC
    /module/FindOpenACC
    /module/FindOpenAL
diff --git a/Help/manual/ctest.1.rst b/Help/manual/ctest.1.rst
index bcf75ac..d1bd69b 100644
--- a/Help/manual/ctest.1.rst
+++ b/Help/manual/ctest.1.rst
@@ -11,8 +11,9 @@
 .. parsed-literal::
 
  ctest [<options>]
- ctest <path-to-source> <path-to-build> --build-generator <generator>
-       [<options>...] [-- <build-options>...] [--test-command <test>]
+ ctest --build-and-test <path-to-source> <path-to-build>
+       --build-generator <generator> [<options>...]
+       [--build-options <opts>...] [--test-command <command> [<args>...]]
  ctest {-D <dashboard> | -M <model> -T <action> | -S <script> | -SP <script>}
        [-- <dashboard-options>...]
 
diff --git a/Help/module/FindOctave.rst b/Help/module/FindOctave.rst
deleted file mode 100644
index 2dbcec4..0000000
--- a/Help/module/FindOctave.rst
+++ /dev/null
@@ -1 +0,0 @@
-.. cmake-module:: ../../Modules/FindOctave.cmake
diff --git a/Help/policy/CMP0083.rst b/Help/policy/CMP0083.rst
index b26d6c8..32acf1f 100644
--- a/Help/policy/CMP0083.rst
+++ b/Help/policy/CMP0083.rst
@@ -23,9 +23,10 @@
 :prop_tgt:`POSITION_INDEPENDENT_CODE` target property for executables will be
 honored at link time.
 
-This policy was introduced in CMake version 3.14.  CMake version
-|release| warns when the policy is not set and uses ``OLD`` behavior.  Use
-the :command:`cmake_policy` command to set it to ``OLD`` or ``NEW`` explicitly.
+This policy was introduced in CMake version 3.14. Use the
+:command:`cmake_policy` command to set it to ``OLD`` or ``NEW`` explicitly.
+Unlike most policies, CMake version |release| does not warn when this policy is
+not set and simply uses ``OLD`` behavior.
 
 .. include:: DEPRECATED.txt
 
diff --git a/Help/prop_tgt/BUILD_RPATH_USE_ORIGIN.rst b/Help/prop_tgt/BUILD_RPATH_USE_ORIGIN.rst
index 511de7a..3378797 100644
--- a/Help/prop_tgt/BUILD_RPATH_USE_ORIGIN.rst
+++ b/Help/prop_tgt/BUILD_RPATH_USE_ORIGIN.rst
@@ -8,14 +8,14 @@
 
 On platforms that support runtime paths (``RPATH``) with the
 ``$ORIGIN`` token, setting this property to ``TRUE`` enables relative
-paths in the build ``RPATH`` for executables that point to shared
-libraries in the same build tree.
+paths in the build ``RPATH`` for executables and shared libraries that
+point to shared libraries in the same build tree.
 
-Normally the build ``RPATH`` of an executable contains absolute paths
-to the directory of shared libraries. Directories contained within the
-build tree can be made relative to enable relocatable builds and to
-help achieving reproducible builds by omitting the build directory
-from the build environment.
+Normally the build ``RPATH`` of a binary contains absolute paths
+to the directory of each shared library it links to.  The ``RPATH``
+entries for directories contained within the build tree can be made
+relative to enable relocatable builds and to help achieve reproducible
+builds by omitting the build directory from the build environment.
 
 This property has no effect on platforms that do not support the
 ``$ORIGIN`` token in ``RPATH``, or when the :variable:`CMAKE_SKIP_RPATH`
diff --git a/Help/prop_tgt/EXCLUDE_FROM_ALL.rst b/Help/prop_tgt/EXCLUDE_FROM_ALL.rst
index e7457e1..0eee297 100644
--- a/Help/prop_tgt/EXCLUDE_FROM_ALL.rst
+++ b/Help/prop_tgt/EXCLUDE_FROM_ALL.rst
@@ -6,8 +6,16 @@
 A property on a target that indicates if the target is excluded from
 the default build target.  If it is not, then with a Makefile for
 example typing make will cause this target to be built.  The same
-concept applies to the default build of other generators.  Installing
-a target with EXCLUDE_FROM_ALL set to true has undefined behavior.
+concept applies to the default build of other generators.
+
+With ``EXCLUDE_FROM_ALL`` set to false or not set at all, the target
+will be brought up to date as part of doing a ``make install`` or its
+equivalent for the CMake generator being used.  If a target has
+``EXCLUDE_FROM_ALL`` set to true, then any attempt to install that
+target has undefined behavior.  Note that such a target can still safely
+be listed in an :command:`install(TARGETS)` command as long as the install
+components the target belongs to are not part of the set of components
+that anything tries to install.
 
 This property is enabled by default for targets that are created in
 directories that have :prop_dir:`EXCLUDE_FROM_ALL` set to ``TRUE``.
diff --git a/Help/release/3.14.rst b/Help/release/3.14.rst
index 13d209f..5038a75 100644
--- a/Help/release/3.14.rst
+++ b/Help/release/3.14.rst
@@ -14,7 +14,7 @@
 ----------
 
 * The :generator:`Visual Studio 16 2019` generator was added.  This is
-  experimental and based on "Visual Studio 2019 Preview 2" because this
+  experimental and based on "Visual Studio 2019 Preview 4" because this
   version of VS has not been released.
 
   The VS 2019 generator differs from generators for earlier versions
@@ -166,13 +166,18 @@
   :command:`check_fortran_source_runs` command to check if a Fortran
   source snippet compiles and runs.
 
+* The :module:`CMakePackageConfigHelpers` module's
+  :command:`write_basic_package_version_file` command gained a new
+  ``ARCH_INDEPENDENT`` option for supporting architecture-independent
+  packages.
+
 * The :module:`ExternalProject` module :command:`ExternalProject_Add` command
   gained ``LOG_DIR`` and ``LOG_MERGED_STDOUTERR`` options to control logging.
 
 * The :module:`ExternalProject` module :command:`ExternalProject_Add` command
   gained ``LOG_PATCH`` to optionally log the patch step.
 
-* The :module:`ExternalProject` module's ``ExternalProject_Add`` command
+* The :module:`ExternalProject` module :command:`ExternalProject_Add` command
   learned to apply ``SOURCE_SUBDIR`` when ``BUILD_IN_SOURCE`` is also used.
   The ``BUILD_COMMAND`` is run in the given ``SOURCE_SUBDIR`` of the
   ``SOURCE_DIR``.
@@ -211,8 +216,6 @@
   mirror the new options to the ``mex`` command in MATLAB R2018a.
   The option ``MX_LIBRARY`` is no longer needed.
 
-* A :module:`FindOctave` module was added to find GNU octave.
-
 * The :module:`FindPostgreSQL` module now provides imported targets.
 
 * The :module:`FindPython`, :module:`FindPython2`, and :module:`FindPython3`
@@ -370,3 +373,7 @@
   :variable:`CPACK_DEBIAN_ARCHIVE_TYPE` variable, because ``dpkg`` has
   never supported the PAX tar format. The ``paxr`` value will be mapped
   to ``gnutar`` and a deprecation message emitted.
+
+* CMake no longer issues a warning if a target listed in an
+  :command:`install(TARGETS)` command has its :prop_tgt:`EXCLUDE_FROM_ALL`
+  property set to true.
diff --git a/Help/variable/CMAKE_LANG_IMPLICIT_INCLUDE_DIRECTORIES.rst b/Help/variable/CMAKE_LANG_IMPLICIT_INCLUDE_DIRECTORIES.rst
index cc80851..e361fd9 100644
--- a/Help/variable/CMAKE_LANG_IMPLICIT_INCLUDE_DIRECTORIES.rst
+++ b/Help/variable/CMAKE_LANG_IMPLICIT_INCLUDE_DIRECTORIES.rst
@@ -6,4 +6,9 @@
 CMake does not explicitly specify these directories on compiler
 command lines for language ``<LANG>``.  This prevents system include
 directories from being treated as user include directories on some
-compilers.
+compilers, which is important for ``C``, ``CXX``, and ``CUDA`` to
+avoid overriding standard library headers.
+
+This value is not used for ``Fortran`` because it has no standard
+library headers and some compilers do not search their implicit
+include directories for module ``.mod`` files.
diff --git a/Modules/CMakeDetermineASMCompiler.cmake b/Modules/CMakeDetermineASMCompiler.cmake
index dbc41c8..b8c8c5d 100644
--- a/Modules/CMakeDetermineASMCompiler.cmake
+++ b/Modules/CMakeDetermineASMCompiler.cmake
@@ -83,7 +83,7 @@
   set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_XL "XL C")
 
   list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS MSVC )
-  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_MSVC "/?")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_MSVC "-?")
   set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_MSVC "Microsoft")
 
   list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS TI )
@@ -110,6 +110,10 @@
   set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_ADSP "-version")
   set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_ADSP "Analog Devices")
 
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS QCC)
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_QCC "-V")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_QCC "gcc_nto")
+
   include(CMakeDetermineCompilerId)
   set(userflags)
   CMAKE_DETERMINE_COMPILER_ID_VENDOR(ASM${ASM_DIALECT} "${userflags}")
diff --git a/Modules/CMakeDetermineCompilerABI.cmake b/Modules/CMakeDetermineCompilerABI.cmake
index fd1d5fb..e0d2449 100644
--- a/Modules/CMakeDetermineCompilerABI.cmake
+++ b/Modules/CMakeDetermineCompilerABI.cmake
@@ -96,6 +96,12 @@
         file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
           "Parsed ${lang} implicit include dir info from above output: rv=${rv}\n${log}\n\n")
         if("${rv}" STREQUAL "done")
+          # Entries that we have been told to explicitly pass as standard include
+          # directories will not be implicitly added by the compiler.
+          if(CMAKE_${lang}_STANDARD_INCLUDE_DIRECTORIES)
+            list(REMOVE_ITEM implicit_incdirs ${CMAKE_${lang}_STANDARD_INCLUDE_DIRECTORIES})
+          endif()
+
           # We parsed implicit include directories, so override the default initializer.
           set(_CMAKE_${lang}_IMPLICIT_INCLUDE_DIRECTORIES_INIT "${implicit_incdirs}")
         endif()
diff --git a/Modules/CMakeDetermineCompilerId.cmake b/Modules/CMakeDetermineCompilerId.cmake
index 83ce392..59dab6d 100644
--- a/Modules/CMakeDetermineCompilerId.cmake
+++ b/Modules/CMakeDetermineCompilerId.cmake
@@ -181,7 +181,10 @@
     set(vs_version ${CMAKE_MATCH_1})
     set(id_platform ${CMAKE_VS_PLATFORM_NAME})
     set(id_lang "${lang}")
-    if(CMAKE_VS_PLATFORM_TOOLSET MATCHES "v[0-9]+_clang_.*")
+    set(id_PostBuildEvent_Command "")
+    if(CMAKE_VS_PLATFORM_TOOLSET MATCHES "^[Ll][Ll][Vv][Mm]$")
+      set(id_cl_var "ClangClExecutable")
+    elseif(CMAKE_VS_PLATFORM_TOOLSET MATCHES "v[0-9]+_clang_.*")
       set(id_cl clang.exe)
     else()
       set(id_cl cl.exe)
@@ -268,7 +271,11 @@
     set(id_dir ${CMAKE_${lang}_COMPILER_ID_DIR})
     set(id_src "${src}")
     set(id_compile "ClCompile")
-    set(id_PostBuildEvent_Command "for %%i in (${id_cl}) do %40echo CMAKE_${lang}_COMPILER=%%~$PATH:i")
+    if(id_cl_var)
+      set(id_PostBuildEvent_Command "echo CMAKE_${lang}_COMPILER=$(${id_cl_var})")
+    else()
+      set(id_PostBuildEvent_Command "for %%i in (${id_cl}) do %40echo CMAKE_${lang}_COMPILER=%%~$PATH:i")
+    endif()
     set(id_Import_props "")
     set(id_Import_targets "")
     set(id_ItemDefinitionGroup_entry "")
@@ -824,7 +831,7 @@
   endif()
 
   # Test whether an MSVC-like command-line option works.
-  execute_process(COMMAND "${CMAKE_${lang}_COMPILER}" /?
+  execute_process(COMMAND "${CMAKE_${lang}_COMPILER}" -?
     RESULT_VARIABLE _clang_result
     OUTPUT_VARIABLE _clang_stdout
     ERROR_VARIABLE _clang_stderr)
diff --git a/Modules/CMakeDetermineVSServicePack.cmake b/Modules/CMakeDetermineVSServicePack.cmake
index 9edc309..a3c4d9c 100644
--- a/Modules/CMakeDetermineVSServicePack.cmake
+++ b/Modules/CMakeDetermineVSServicePack.cmake
@@ -79,7 +79,7 @@
 function(_DetermineVSServicePack_FastCheckVersionWithCompiler _SUCCESS_VAR  _VERSION_VAR)
     if(EXISTS ${CMAKE_CXX_COMPILER})
       execute_process(
-          COMMAND ${CMAKE_CXX_COMPILER} /?
+          COMMAND ${CMAKE_CXX_COMPILER} -?
           ERROR_VARIABLE _output
           OUTPUT_QUIET
         )
diff --git a/Modules/CheckCXXSourceRuns.cmake b/Modules/CheckCXXSourceRuns.cmake
index 7db976b..5e3f195 100644
--- a/Modules/CheckCXXSourceRuns.cmake
+++ b/Modules/CheckCXXSourceRuns.cmake
@@ -103,7 +103,8 @@
       CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_FUNCTION_DEFINITIONS}
       -DCMAKE_SKIP_RPATH:BOOL=${CMAKE_SKIP_RPATH}
       "${CHECK_CXX_SOURCE_COMPILES_ADD_INCLUDES}"
-      COMPILE_OUTPUT_VARIABLE OUTPUT)
+      COMPILE_OUTPUT_VARIABLE OUTPUT
+      RUN_OUTPUT_VARIABLE RUN_OUTPUT)
 
     # if it did not compile make the return value fail code of 1
     if(NOT ${VAR}_COMPILED)
@@ -118,6 +119,8 @@
       file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
         "Performing C++ SOURCE FILE Test ${VAR} succeeded with the following output:\n"
         "${OUTPUT}\n"
+        "...and run output:\n"
+        "${RUN_OUTPUT}\n"
         "Return value: ${${VAR}}\n"
         "Source file was:\n${SOURCE}\n")
     else()
@@ -133,6 +136,8 @@
       file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
         "Performing C++ SOURCE FILE Test ${VAR} failed with the following output:\n"
         "${OUTPUT}\n"
+        "...and run output:\n"
+        "${RUN_OUTPUT}\n"
         "Return value: ${${VAR}_EXITCODE}\n"
         "Source file was:\n${SOURCE}\n")
     endif()
diff --git a/Modules/CheckFortranSourceRuns.cmake b/Modules/CheckFortranSourceRuns.cmake
index 13fdb0b..a80c13d 100644
--- a/Modules/CheckFortranSourceRuns.cmake
+++ b/Modules/CheckFortranSourceRuns.cmake
@@ -133,7 +133,8 @@
       CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_FUNCTION_DEFINITIONS}
       -DCMAKE_SKIP_RPATH:BOOL=${CMAKE_SKIP_RPATH}
       "${CHECK_Fortran_SOURCE_COMPILES_ADD_INCLUDES}"
-      COMPILE_OUTPUT_VARIABLE OUTPUT)
+      COMPILE_OUTPUT_VARIABLE OUTPUT
+      RUN_OUTPUT_VARIABLE RUN_OUTPUT)
 
     # if it did not compile make the return value fail code of 1
     if(NOT ${VAR}_COMPILED)
@@ -148,6 +149,8 @@
       file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
         "Performing Fortran SOURCE FILE Test ${VAR} succeeded with the following output:\n"
         "${OUTPUT}\n"
+        "...and run output:\n"
+        "${RUN_OUTPUT}\n"
         "Return value: ${${VAR}}\n"
         "Source file was:\n${SOURCE}\n")
     else()
@@ -163,6 +166,8 @@
       file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
         "Performing Fortran SOURCE FILE Test ${VAR} failed with the following output:\n"
         "${OUTPUT}\n"
+        "...and run output:\n"
+        "${RUN_OUTPUT}\n"
         "Return value: ${${VAR}_EXITCODE}\n"
         "Source file was:\n${SOURCE}\n")
     endif()
diff --git a/Modules/Compiler/QCC-ASM.cmake b/Modules/Compiler/QCC-ASM.cmake
new file mode 100644
index 0000000..9a9935b
--- /dev/null
+++ b/Modules/Compiler/QCC-ASM.cmake
@@ -0,0 +1,2 @@
+include(Compiler/QCC)
+__compiler_qcc(ASM)
diff --git a/Modules/ExternalProject.cmake b/Modules/ExternalProject.cmake
index c5d6b45..22e0523 100644
--- a/Modules/ExternalProject.cmake
+++ b/Modules/ExternalProject.cmake
@@ -550,7 +550,8 @@
       When enabled, the output of the test step is logged to files.
 
     ``LOG_MERGED_STDOUTERR <bool>``
-      When enabled, the output the step is not split by stdout and stderr.
+      When enabled, stdout and stderr will be merged for any step whose
+      output is being logged to files.
 
     ``LOG_OUTPUT_ON_FAILURE <bool>``
       This option only has an effect if at least one of the other ``LOG_<step>``
@@ -1643,7 +1644,6 @@
     set(stamp_default "${base}/Stamp/${name}")
     set(install_default "${base}/Install/${name}")
   endif()
-  set(log_default "${stamp_default}")
   get_property(build_in_source TARGET ${name} PROPERTY _EP_BUILD_IN_SOURCE)
   if(build_in_source)
     get_property(have_binary_dir TARGET ${name} PROPERTY _EP_BINARY_DIR SET)
@@ -1653,7 +1653,9 @@
     endif()
   endif()
   set(top "${CMAKE_CURRENT_BINARY_DIR}")
-  set(places stamp download source binary install tmp log)
+
+  # Apply defaults and convert to absolute paths.
+  set(places stamp download source binary install tmp)
   foreach(var ${places})
     string(TOUPPER "${var}" VAR)
     get_property(${var}_dir TARGET ${name} PROPERTY _EP_${VAR}_DIR)
@@ -1665,6 +1667,17 @@
     endif()
     set_property(TARGET ${name} PROPERTY _EP_${VAR}_DIR "${${var}_dir}")
   endforeach()
+
+  # Special case for default log directory based on stamp directory.
+  get_property(log_dir TARGET ${name} PROPERTY _EP_LOG_DIR)
+  if(NOT log_dir)
+    get_property(log_dir TARGET ${name} PROPERTY _EP_STAMP_DIR)
+  endif()
+  if(NOT IS_ABSOLUTE "${log_dir}")
+    get_filename_component(log_dir "${top}/${log_dir}" ABSOLUTE)
+  endif()
+  set_property(TARGET ${name} PROPERTY _EP_LOG_DIR "${log_dir}")
+
   get_property(source_subdir TARGET ${name} PROPERTY _EP_SOURCE_SUBDIR)
   if(NOT source_subdir)
     set_property(TARGET ${name} PROPERTY _EP_SOURCE_SUBDIR "")
diff --git a/Modules/FindBoost.cmake b/Modules/FindBoost.cmake
index 8c112d4..7882c4b 100644
--- a/Modules/FindBoost.cmake
+++ b/Modules/FindBoost.cmake
@@ -1807,10 +1807,12 @@
     foreach(compiler IN LISTS _boost_COMPILER)
       list(APPEND _boost_RELEASE_NAMES
         ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_RELEASE_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION}
+        ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_RELEASE_ABI_TAG}${_boost_ARCHITECTURE_TAG}
         ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_RELEASE_ABI_TAG} )
     endforeach()
     list(APPEND _boost_RELEASE_NAMES
       ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_RELEASE_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION}
+      ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_RELEASE_ABI_TAG}${_boost_ARCHITECTURE_TAG}
       ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_RELEASE_ABI_TAG}
       ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}
       ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component} )
@@ -1819,10 +1821,12 @@
       foreach(compiler IN LISTS _boost_COMPILER)
         list(APPEND _boost_RELEASE_NAMES
           ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_RELEASE_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION}
+          ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_RELEASE_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG}
           ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_RELEASE_STATIC_ABI_TAG} )
       endforeach()
       list(APPEND _boost_RELEASE_NAMES
         ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_RELEASE_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION}
+        ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_RELEASE_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG}
         ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_RELEASE_STATIC_ABI_TAG} )
     endif()
   endforeach()
@@ -1860,10 +1864,12 @@
     foreach(compiler IN LISTS _boost_COMPILER)
       list(APPEND _boost_DEBUG_NAMES
         ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION}
+        ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG}${_boost_ARCHITECTURE_TAG}
         ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG} )
     endforeach()
     list(APPEND _boost_DEBUG_NAMES
       ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION}
+      ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG}${_boost_ARCHITECTURE_TAG}
       ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG}
       ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}
       ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component} )
@@ -1872,10 +1878,12 @@
       foreach(compiler IN LISTS _boost_COMPILER)
         list(APPEND _boost_DEBUG_NAMES
           ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_DEBUG_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION}
+          ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_DEBUG_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG}
           ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_DEBUG_STATIC_ABI_TAG} )
       endforeach()
       list(APPEND _boost_DEBUG_NAMES
         ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_DEBUG_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION}
+        ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_DEBUG_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG}
         ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_DEBUG_STATIC_ABI_TAG} )
     endif()
   endforeach()
diff --git a/Modules/FindOctave.cmake b/Modules/FindOctave.cmake
deleted file mode 100644
index 8110ff1..0000000
--- a/Modules/FindOctave.cmake
+++ /dev/null
@@ -1,179 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#[=======================================================================[.rst:
-FindOctave
-----------
-
-Finds GNU Octave interpreter, libraries and compilers.
-
-Imported targets
-^^^^^^^^^^^^^^^^
-
-This module defines the following :prop_tgt:`IMPORTED` targets:
-
-``Octave::Interpreter``
-  Octave interpreter (the main program)
-``Octave::Octave``
-  include directories and the octave library
-``Octave::Octinterp``
-  include directories and the octinterp library including the dependency on
-  Octave::Octave
-
-If no ``COMPONENTS`` are specified, ``Interpreter`` is assumed.
-
-Result Variables
-^^^^^^^^^^^^^^^^
-
-``Octave_FOUND``
-  Octave interpreter and/or libraries were found
-``Octave_<component>_FOUND``
-  Octave <component> specified was found
-
-``Octave_EXECUTABLE``
-  Octave interpreter
-``Octave_INCLUDE_DIRS``
-  include path for mex.h
-``Octave_LIBRARIES``
-  octinterp, octave libraries
-
-
-Cache variables
-^^^^^^^^^^^^^^^
-
-The following cache variables may also be set:
-
-``Octave_INTERP_LIBRARY``
-  path to the library octinterp
-``Octave_OCTAVE_LIBRARY``
-  path to the liboctave library
-
-#]=======================================================================]
-
-cmake_policy(VERSION 3.3)
-
-unset(Octave_REQUIRED_VARS)
-unset(Octave_Development_FOUND)
-unset(Octave_Interpreter_FOUND)
-set(CMAKE_INSTALL_DEFAULT_COMPONENT_NAME Interpreter)
-
-if(Development IN_LIST Octave_FIND_COMPONENTS)
-  find_program(Octave_CONFIG_EXECUTABLE
-               NAMES octave-config)
-
-  if(Octave_CONFIG_EXECUTABLE)
-
-    execute_process(COMMAND ${Octave_CONFIG_EXECUTABLE} -p BINDIR
-                    OUTPUT_VARIABLE Octave_BINARY_DIR
-                    ERROR_QUIET
-                    OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-    execute_process(COMMAND ${Octave_CONFIG_EXECUTABLE} -p OCTINCLUDEDIR
-                    OUTPUT_VARIABLE Octave_INCLUDE_DIR
-                    ERROR_QUIET
-                    OUTPUT_STRIP_TRAILING_WHITESPACE)
-    list(APPEND Octave_REQUIRED_VARS ${Octave_INCLUDE_DIR})
-
-    execute_process(COMMAND ${Octave_CONFIG_EXECUTABLE} -p OCTLIBDIR
-                    OUTPUT_VARIABLE Octave_LIB1
-                    ERROR_QUIET
-                    OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-    execute_process(COMMAND ${Octave_CONFIG_EXECUTABLE} -p LIBDIR
-                    OUTPUT_VARIABLE Octave_LIB2
-                    ERROR_QUIET
-                    OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-    find_library(Octave_INTERP_LIBRARY
-               NAMES octinterp
-               PATHS ${Octave_LIB1} ${Octave_LIB2}
-               NO_DEFAULT_PATH
-              )
-    find_library(Octave_OCTAVE_LIBRARY
-                 NAMES octave
-                 PATHS ${Octave_LIB1} ${Octave_LIB2}
-                 NO_DEFAULT_PATH
-                )
-    list(APPEND Octave_REQUIRED_VARS ${Octave_OCTAVE_LIBRARY} ${Octave_INTERP_LIBRARY})
-
-    if(Octave_REQUIRED_VARS)
-      set(Octave_Development_FOUND true)
-    endif()
-  endif(Octave_CONFIG_EXECUTABLE)
-endif()
-
-if(Interpreter IN_LIST Octave_FIND_COMPONENTS)
-
-  find_program(Octave_EXECUTABLE
-               NAMES octave)
-
-  list(APPEND Octave_REQUIRED_VARS ${Octave_EXECUTABLE})
-
-endif()
-
-if(Octave_EXECUTABLE)
-  execute_process(COMMAND ${Octave_EXECUTABLE} -v
-                  OUTPUT_VARIABLE Octave_VERSION
-                  ERROR_QUIET
-                  OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-
-  string(REGEX REPLACE "GNU Octave, version ([0-9]+)\\.[0-9]+\\.[0-9]+.*" "\\1" Octave_VERSION_MAJOR ${Octave_VERSION})
-  string(REGEX REPLACE "GNU Octave, version [0-9]+\\.([0-9]+)\\.[0-9]+.*" "\\1" Octave_VERSION_MINOR ${Octave_VERSION})
-  string(REGEX REPLACE "GNU Octave, version [0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" Octave_VERSION_PATCH ${Octave_VERSION})
-
-  set(Octave_VERSION ${Octave_VERSION_MAJOR}.${Octave_VERSION_MINOR}.${Octave_VERSION_PATCH})
-
-  set(Octave_Interpreter_FOUND true)
-
-endif(Octave_EXECUTABLE)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Octave
-  REQUIRED_VARS Octave_REQUIRED_VARS
-  VERSION_VAR Octave_VERSION
-  HANDLE_COMPONENTS)
-
-
-if(Octave_Development_FOUND)
-  set(Octave_LIBRARIES ${Octave_INTERP_LIBRARY} ${Octave_OCTAVE_LIBRARY})
-  set(Octave_INCLUDE_DIRS ${Octave_INCLUDE_DIR})
-
-  if(NOT TARGET Octave::Octave)
-    add_library(Octave::Octave UNKNOWN IMPORTED)
-    set_target_properties(Octave::Octave PROPERTIES
-                          IMPORTED_LOCATION ${Octave_OCTAVE_LIBRARY}
-                          INTERFACE_INCLUDE_DIRECTORIES ${Octave_INCLUDE_DIR}
-                         )
-  endif()
-
-  if(NOT TARGET Octave::Octinterp)
-    add_library(Octave::Octinterp UNKNOWN IMPORTED)
-    set_target_properties(Octave::Octinterp PROPERTIES
-                          IMPORTED_LOCATION ${Octave_INTERP_LIBRARY}
-                          INTERFACE_INCLUDE_DIRECTORIES ${Octave_INCLUDE_DIR})
-    target_link_libraries(Octave::Octinterp INTERFACE
-                          Octave::Octave)
-  endif()
-
-endif()
-
-
-if(Octave_Interpreter_FOUND)
-  if(NOT TARGET Octave::Interpreter)
-    add_executable(Octave::Interpreter IMPORTED)
-    set_target_properties(Octave::Interpreter PROPERTIES
-                          IMPORTED_LOCATION ${Octave_EXECUTABLE}
-                          VERSION ${Octave_VERSION})
-  endif()
-endif()
-
-mark_as_advanced(
-  Octave_CONFIG_EXECUTABLE
-  Octave_INTERP_LIBRARY
-  Octave_OCTAVE_LIBRARY
-  Octave_INCLUDE_DIR
-  Octave_VERSION_MAJOR
-  Octave_VERSION_MINOR
-  Octave_VERSION_PATCH
-)
diff --git a/Modules/FindThreads.cmake b/Modules/FindThreads.cmake
index 5d894c8..919392a 100644
--- a/Modules/FindThreads.cmake
+++ b/Modules/FindThreads.cmake
@@ -118,16 +118,8 @@
   set(CMAKE_HAVE_THREADS_LIBRARY)
   if(NOT THREADS_HAVE_PTHREAD_ARG)
     # Check if pthread functions are in normal C library.
-    # If the pthread functions already exist in C library, we could just use
-    # them instead of linking to the additional pthread library. We could
-    # try to check any pthread symbol name, but here is an exception. If we
-    # use clang asan build, we will find the pthread_create() symbol in the
-    # libc(libasan). However, it doesn't have the full pthread implementation.
-    # So, we can't assume that we have the pthread implementation in libc
-    # using the pthread_create() checking here. Then, we turn to check the
-    # pthread_kill() symbol instead.
-    CHECK_SYMBOL_EXISTS(pthread_kill pthread.h CMAKE_HAVE_LIBC_PTHREAD_KILL)
-    if(CMAKE_HAVE_LIBC_PTHREAD_KILL)
+    CHECK_SYMBOL_EXISTS(pthread_create pthread.h CMAKE_HAVE_LIBC_CREATE)
+    if(CMAKE_HAVE_LIBC_CREATE)
       set(CMAKE_THREAD_LIBS_INIT "")
       set(CMAKE_HAVE_THREADS_LIBRARY 1)
       set(Threads_FOUND TRUE)
@@ -152,7 +144,7 @@
   _check_pthreads_flag()
 endif()
 
-if(CMAKE_THREAD_LIBS_INIT OR CMAKE_HAVE_LIBC_PTHREAD_KILL)
+if(CMAKE_THREAD_LIBS_INIT OR CMAKE_HAVE_LIBC_CREATE)
   set(CMAKE_USE_PTHREADS_INIT 1)
   set(Threads_FOUND TRUE)
 endif()
diff --git a/Modules/Platform/UnixPaths.cmake b/Modules/Platform/UnixPaths.cmake
index 46c24bb..97f744d 100644
--- a/Modules/Platform/UnixPaths.cmake
+++ b/Modules/Platform/UnixPaths.cmake
@@ -63,21 +63,29 @@
   /lib /lib32 /lib64 /usr/lib /usr/lib32 /usr/lib64
   )
 
+if(CMAKE_SYSROOT_COMPILE)
+  set(_cmake_sysroot_compile "${CMAKE_SYSROOT_COMPILE}")
+else()
+  set(_cmake_sysroot_compile "${CMAKE_SYSROOT}")
+endif()
+
 # Default per-language values.  These may be later replaced after
 # parsing the implicit directory information from compiler output.
 set(_CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES_INIT
   ${CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES}
-  /usr/include
+  "${_cmake_sysroot_compile}/usr/include"
   )
 set(_CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES_INIT
   ${CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES}
-  /usr/include
+  "${_cmake_sysroot_compile}/usr/include"
   )
 set(_CMAKE_CUDA_IMPLICIT_INCLUDE_DIRECTORIES_INIT
   ${CMAKE_CUDA_IMPLICIT_INCLUDE_DIRECTORIES}
-  /usr/include
+  "${_cmake_sysroot_compile}/usr/include"
   )
 
+unset(_cmake_sysroot_compile)
+
 # Enable use of lib32 and lib64 search path variants by default.
 set_property(GLOBAL PROPERTY FIND_LIBRARY_USE_LIB32_PATHS TRUE)
 set_property(GLOBAL PROPERTY FIND_LIBRARY_USE_LIB64_PATHS TRUE)
diff --git a/Source/Checks/cm_cxx14_check.cpp b/Source/Checks/cm_cxx14_check.cpp
index 9369ba2..fff36c9 100644
--- a/Source/Checks/cm_cxx14_check.cpp
+++ b/Source/Checks/cm_cxx14_check.cpp
@@ -1,8 +1,15 @@
 #include <cstdio>
+#include <iterator>
 #include <memory>
 
 int main()
 {
+  int a[] = { 0, 1, 2 };
+  auto ai = std::cbegin(a);
+
+  int b[] = { 2, 1, 0 };
+  auto bi = std::cend(b);
+
   std::unique_ptr<int> u(new int(0));
-  return *u;
+  return *u + *ai + *(bi - 1);
 }
diff --git a/Source/Checks/cm_cxx17_check.cpp b/Source/Checks/cm_cxx17_check.cpp
index 4e89184..9ea52c4 100644
--- a/Source/Checks/cm_cxx17_check.cpp
+++ b/Source/Checks/cm_cxx17_check.cpp
@@ -1,9 +1,18 @@
 #include <cstdio>
+#include <iterator>
 #include <memory>
 #include <unordered_map>
 
 int main()
 {
+  int a[] = { 0, 1, 2 };
+  auto ai = std::cbegin(a);
+
+  int b[] = { 2, 1, 0 };
+  auto bi = std::cend(b);
+
+  auto ci = std::size(a);
+
   std::unique_ptr<int> u(new int(0));
-  return *u;
+  return *u + *ai + *(bi - 1) + (3 - static_cast<int>(ci));
 }
diff --git a/Source/cmGeneratorTarget.cxx b/Source/cmGeneratorTarget.cxx
index 78040c3..25349d4 100644
--- a/Source/cmGeneratorTarget.cxx
+++ b/Source/cmGeneratorTarget.cxx
@@ -510,21 +510,10 @@
     return nullptr;
   }
 
-  switch (this->GetPolicyStatusCMP0083()) {
-    case cmPolicies::WARN: {
-      std::ostringstream e;
-      e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0083);
-      this->LocalGenerator->IssueMessage(MessageType::AUTHOR_WARNING, e.str());
-      CM_FALLTHROUGH;
-    }
-    case cmPolicies::OLD:
-      return nullptr;
-    default:
-      // nothing to do
-      break;
-  }
-
-  return PICValue.c_str();
+  auto status = this->GetPolicyStatusCMP0083();
+  return (status != cmPolicies::WARN && status != cmPolicies::OLD)
+    ? PICValue.c_str()
+    : nullptr;
 }
 
 bool cmGeneratorTarget::IsIPOEnabled(std::string const& lang,
diff --git a/Source/cmGlobalVisualStudio14Generator.cxx b/Source/cmGlobalVisualStudio14Generator.cxx
index a0a9558..2025867 100644
--- a/Source/cmGlobalVisualStudio14Generator.cxx
+++ b/Source/cmGlobalVisualStudio14Generator.cxx
@@ -158,14 +158,22 @@
                                                          bool required)
 {
   // Find the default version of the Windows 10 SDK.
-  this->WindowsTargetPlatformVersion = this->GetWindows10SDKVersion();
-  if (required && this->WindowsTargetPlatformVersion.empty()) {
+  std::string const version = this->GetWindows10SDKVersion();
+  if (required && version.empty()) {
     std::ostringstream e;
     e << "Could not find an appropriate version of the Windows 10 SDK"
       << " installed on this machine";
     mf->IssueMessage(MessageType::FATAL_ERROR, e.str());
     return false;
   }
+  this->SetWindowsTargetPlatformVersion(version, mf);
+  return true;
+}
+
+void cmGlobalVisualStudio14Generator::SetWindowsTargetPlatformVersion(
+  std::string const& version, cmMakefile* mf)
+{
+  this->WindowsTargetPlatformVersion = version;
   if (!cmSystemTools::VersionCompareEqual(this->WindowsTargetPlatformVersion,
                                           this->SystemVersion)) {
     std::ostringstream e;
@@ -175,7 +183,6 @@
   }
   mf->AddDefinition("CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION",
                     this->WindowsTargetPlatformVersion.c_str());
-  return true;
 }
 
 bool cmGlobalVisualStudio14Generator::SelectWindowsStoreToolset(
diff --git a/Source/cmGlobalVisualStudio14Generator.h b/Source/cmGlobalVisualStudio14Generator.h
index 32008b0..6e12d3e 100644
--- a/Source/cmGlobalVisualStudio14Generator.h
+++ b/Source/cmGlobalVisualStudio14Generator.h
@@ -40,6 +40,9 @@
 
   virtual bool SelectWindows10SDK(cmMakefile* mf, bool required);
 
+  void SetWindowsTargetPlatformVersion(std::string const& version,
+                                       cmMakefile* mf);
+
   // Used to verify that the Desktop toolset for the current generator is
   // installed on the machine.
   bool IsWindowsDesktopToolsetInstalled() const override;
diff --git a/Source/cmGlobalVisualStudioVersionedGenerator.cxx b/Source/cmGlobalVisualStudioVersionedGenerator.cxx
index 913fc4a..2f9eb3f 100644
--- a/Source/cmGlobalVisualStudioVersionedGenerator.cxx
+++ b/Source/cmGlobalVisualStudioVersionedGenerator.cxx
@@ -401,6 +401,12 @@
   // If the Win 8.1 SDK is installed then we can select a SDK matching
   // the target Windows version.
   if (this->IsWin81SDKInstalled()) {
+    // VS 2019 does not default to 8.1 so specify it explicitly when needed.
+    if (this->Version >= cmGlobalVisualStudioGenerator::VS16 &&
+        !cmSystemTools::VersionCompareGreater(this->SystemVersion, "8.1")) {
+      this->SetWindowsTargetPlatformVersion("8.1", mf);
+      return true;
+    }
     return cmGlobalVisualStudio14Generator::InitializeWindows(mf);
   }
   // Otherwise we must choose a Win 10 SDK even if we are not targeting
diff --git a/Source/cmIncludeExternalMSProjectCommand.cxx b/Source/cmIncludeExternalMSProjectCommand.cxx
index b224d09..93134ad 100644
--- a/Source/cmIncludeExternalMSProjectCommand.cxx
+++ b/Source/cmIncludeExternalMSProjectCommand.cxx
@@ -85,10 +85,12 @@
     // Create a target instance for this utility.
     cmTarget* target = this->Makefile->AddNewTarget(cmStateEnums::UTILITY,
                                                     utility_name.c_str());
+    if (this->Makefile->GetPropertyAsBool("EXCLUDE_FROM_ALL")) {
+      target->SetProperty("EXCLUDE_FROM_ALL", "TRUE");
+    }
 
     target->SetProperty("GENERATOR_FILE_NAME", utility_name.c_str());
     target->SetProperty("EXTERNAL_MSPROJECT", path.c_str());
-    target->SetProperty("EXCLUDE_FROM_ALL", "FALSE");
 
     if (!customType.empty())
       target->SetProperty("VS_PROJECT_TYPE", customType.c_str());
diff --git a/Source/cmInstallTargetGenerator.cxx b/Source/cmInstallTargetGenerator.cxx
index 59701a1..9d3a6bb 100644
--- a/Source/cmInstallTargetGenerator.cxx
+++ b/Source/cmInstallTargetGenerator.cxx
@@ -41,22 +41,6 @@
 
 cmInstallTargetGenerator::~cmInstallTargetGenerator() = default;
 
-void cmInstallTargetGenerator::GenerateScript(std::ostream& os)
-{
-  // Warn if installing an exclude-from-all target.
-  if (this->Target->GetPropertyAsBool("EXCLUDE_FROM_ALL")) {
-    std::ostringstream msg;
-    msg << "WARNING: Target \"" << this->Target->GetName()
-        << "\" has EXCLUDE_FROM_ALL set and will not be built by default "
-        << "but an install rule has been provided for it.  CMake does "
-        << "not define behavior for this case.";
-    cmSystemTools::Message(msg.str(), "Warning");
-  }
-
-  // Perform the main install script generation.
-  this->cmInstallGenerator::GenerateScript(os);
-}
-
 void cmInstallTargetGenerator::GenerateScriptForConfig(
   std::ostream& os, const std::string& config, Indent indent)
 {
diff --git a/Source/cmInstallTargetGenerator.h b/Source/cmInstallTargetGenerator.h
index 715b4ae..6df5b1a 100644
--- a/Source/cmInstallTargetGenerator.h
+++ b/Source/cmInstallTargetGenerator.h
@@ -69,7 +69,6 @@
   cmListFileBacktrace const& GetBacktrace() const { return this->Backtrace; }
 
 protected:
-  void GenerateScript(std::ostream& os) override;
   void GenerateScriptForConfig(std::ostream& os, const std::string& config,
                                Indent indent) override;
   void GenerateScriptForConfigObjectLibrary(std::ostream& os,
diff --git a/Source/cmLinkLineDeviceComputer.cxx b/Source/cmLinkLineDeviceComputer.cxx
index a403dc9..211d03b 100644
--- a/Source/cmLinkLineDeviceComputer.cxx
+++ b/Source/cmLinkLineDeviceComputer.cxx
@@ -34,6 +34,7 @@
   // * '-lpthread' => pass-along
   // * '-pthread' => drop
   // * '-a' => drop
+  // * '-framework Name' (as one string) => drop
   return (!cmHasLiteralPrefix(item, "-") || //
           cmHasLiteralPrefix(item, "-l") || //
           cmHasLiteralPrefix(item, "-L") || //
@@ -54,7 +55,13 @@
   typedef cmComputeLinkInformation::ItemVector ItemVector;
   ItemVector const& items = cli.GetItems();
   std::string config = cli.GetConfig();
+  bool skipItemAfterFramework = false;
   for (auto const& item : items) {
+    if (skipItemAfterFramework) {
+      skipItemAfterFramework = false;
+      continue;
+    }
+
     if (item.Target) {
       bool skip = false;
       switch (item.Target->GetType()) {
@@ -84,6 +91,11 @@
         out += this->ConvertToOutputFormat(
           this->ConvertToLinkReference(item.Value));
       }
+    } else if (item.Value == "-framework") {
+      // This is the first part of '-framework Name' where the framework
+      // name is specified as a following item.  Ignore both.
+      skipItemAfterFramework = true;
+      continue;
     } else if (cmLinkItemValidForDevice(item.Value)) {
       out += item.Value;
     }
diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index 8090e00..7e56818 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -920,6 +920,20 @@
     return result;
   }
 
+  // Standard include directories to be added unconditionally at the end.
+  // These are intended to simulate additional implicit include directories.
+  std::vector<std::string> userStandardDirs;
+  {
+    std::string key = "CMAKE_";
+    key += lang;
+    key += "_STANDARD_INCLUDE_DIRECTORIES";
+    std::string const value = this->Makefile->GetSafeDefinition(key);
+    cmSystemTools::ExpandListArgument(value, userStandardDirs);
+    for (std::string& usd : userStandardDirs) {
+      cmSystemTools::ConvertToUnixSlashes(usd);
+    }
+  }
+
   // Implicit include directories
   std::vector<std::string> implicitDirs;
   std::set<std::string> implicitSet;
@@ -928,24 +942,27 @@
     return (implicitSet.find(dir) == implicitSet.end());
   };
   {
-    std::string rootPath;
-    if (const char* sysrootCompile =
-          this->Makefile->GetDefinition("CMAKE_SYSROOT_COMPILE")) {
-      rootPath = sysrootCompile;
-    } else {
-      rootPath = this->Makefile->GetSafeDefinition("CMAKE_SYSROOT");
-    }
-    cmSystemTools::ConvertToUnixSlashes(rootPath);
-
     // Raw list of implicit include directories
-    std::vector<std::string> impDirVec;
+    // Start with "standard" directories that we unconditionally add below.
+    std::vector<std::string> impDirVec = userStandardDirs;
 
     // Load implicit include directories for this language.
-    std::string key = "CMAKE_";
-    key += lang;
-    key += "_IMPLICIT_INCLUDE_DIRECTORIES";
-    if (const char* value = this->Makefile->GetDefinition(key)) {
-      cmSystemTools::ExpandListArgument(value, impDirVec);
+    // We ignore this for Fortran because:
+    // * There are no standard library headers to avoid overriding.
+    // * Compilers like gfortran do not search their own implicit include
+    //   directories for modules ('.mod' files).
+    if (lang != "Fortran") {
+      std::string key = "CMAKE_";
+      key += lang;
+      key += "_IMPLICIT_INCLUDE_DIRECTORIES";
+      if (const char* value = this->Makefile->GetDefinition(key)) {
+        size_t const impDirVecOldSize = impDirVec.size();
+        cmSystemTools::ExpandListArgument(value, impDirVec);
+        // FIXME: Use cmRange with 'advance()' when it supports non-const.
+        for (size_t i = impDirVecOldSize; i < impDirVec.size(); ++i) {
+          cmSystemTools::ConvertToUnixSlashes(impDirVec[i]);
+        }
+      }
     }
 
     // The Platform/UnixPaths module used to hard-code /usr/include for C, CXX,
@@ -965,13 +982,8 @@
     }
 
     for (std::string const& i : impDirVec) {
-      std::string imd = i;
-      cmSystemTools::ConvertToUnixSlashes(imd);
-      if (!rootPath.empty() && !cmHasPrefix(imd, rootPath)) {
-        imd = rootPath + imd;
-      }
-      if (implicitSet.insert(imd).second) {
-        implicitDirs.emplace_back(std::move(imd));
+      if (implicitSet.insert(i).second) {
+        implicitDirs.emplace_back(i);
       }
     }
   }
@@ -1010,23 +1022,10 @@
   MoveSystemIncludesToEnd(result, config, lang, target);
 
   // Append standard include directories for this language.
-  {
-    std::vector<std::string> userStandardDirs;
-    {
-      std::string key = "CMAKE_";
-      key += lang;
-      key += "_STANDARD_INCLUDE_DIRECTORIES";
-      std::string const value = this->Makefile->GetSafeDefinition(key);
-      cmSystemTools::ExpandListArgument(value, userStandardDirs);
-    }
-    userDirs.reserve(userDirs.size() + userStandardDirs.size());
-    for (std::string& usd : userStandardDirs) {
-      cmSystemTools::ConvertToUnixSlashes(usd);
-      if (notImplicit(usd)) {
-        emitDir(usd);
-      }
-      userDirs.emplace_back(std::move(usd));
-    }
+  userDirs.reserve(userDirs.size() + userStandardDirs.size());
+  for (std::string& usd : userStandardDirs) {
+    emitDir(usd);
+    userDirs.emplace_back(std::move(usd));
   }
 
   // Append compiler implicit include directories
diff --git a/Source/cmQtAutoGenGlobalInitializer.cxx b/Source/cmQtAutoGenGlobalInitializer.cxx
index 95a297c..3ad91ee 100644
--- a/Source/cmQtAutoGenGlobalInitializer.cxx
+++ b/Source/cmQtAutoGenGlobalInitializer.cxx
@@ -6,10 +6,12 @@
 
 #include "cmAlgorithms.h"
 #include "cmCustomCommandLines.h"
+#include "cmDuration.h"
 #include "cmGeneratorTarget.h"
 #include "cmLocalGenerator.h"
 #include "cmMakefile.h"
 #include "cmMessageType.h"
+#include "cmProcessOutput.h"
 #include "cmState.h"
 #include "cmStateTypes.h"
 #include "cmSystemTools.h"
@@ -183,6 +185,68 @@
   }
 }
 
+bool cmQtAutoGenGlobalInitializer::GetExecutableTestOutput(
+  std::string const& generator, std::string const& executable,
+  std::string& error, std::string* output)
+{
+  // Check if we have cached output
+  {
+    auto it = this->ExecutableTestOutputs_.find(executable);
+    if (it != this->ExecutableTestOutputs_.end()) {
+      // Return output on demand
+      if (output != nullptr) {
+        *output = it->second;
+      }
+      return true;
+    }
+  }
+
+  // Check if the executable exists
+  if (!cmSystemTools::FileExists(executable, true)) {
+    error = "The \"";
+    error += generator;
+    error += "\" executable ";
+    error += cmQtAutoGen::Quoted(executable);
+    error += " does not exist.";
+    return false;
+  }
+
+  // Test the executable
+  std::string stdOut;
+  {
+    std::string stdErr;
+    std::vector<std::string> command;
+    command.push_back(executable);
+    command.emplace_back("-h");
+    int retVal = 0;
+    const bool runResult = cmSystemTools::RunSingleCommand(
+      command, &stdOut, &stdErr, &retVal, nullptr, cmSystemTools::OUTPUT_NONE,
+      cmDuration::zero(), cmProcessOutput::Auto);
+    if (!runResult) {
+      error = "Test run of \"";
+      error += generator;
+      error += "\" executable ";
+      error += cmQtAutoGen::Quoted(executable) + " failed.\n";
+      error += cmQtAutoGen::QuotedCommand(command);
+      error += "\n";
+      error += stdOut;
+      error += "\n";
+      error += stdErr;
+      return false;
+    }
+  }
+
+  // Return executable output on demand
+  if (output != nullptr) {
+    *output = stdOut;
+  }
+
+  // Register executable and output
+  this->ExecutableTestOutputs_.emplace(executable, std::move(stdOut));
+
+  return true;
+}
+
 bool cmQtAutoGenGlobalInitializer::generate()
 {
   return (InitializeCustomTargets() && SetupCustomTargets());
diff --git a/Source/cmQtAutoGenGlobalInitializer.h b/Source/cmQtAutoGenGlobalInitializer.h
index 9e6bac0..74184a0 100644
--- a/Source/cmQtAutoGenGlobalInitializer.h
+++ b/Source/cmQtAutoGenGlobalInitializer.h
@@ -8,6 +8,7 @@
 #include <map>
 #include <memory> // IWYU pragma: keep
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 class cmLocalGenerator;
@@ -38,10 +39,15 @@
   void AddToGlobalAutoRcc(cmLocalGenerator* localGen,
                           std::string const& targetName);
 
+  bool GetExecutableTestOutput(std::string const& generator,
+                               std::string const& executable,
+                               std::string& error, std::string* output);
+
 private:
   std::vector<std::unique_ptr<cmQtAutoGenInitializer>> Initializers_;
   std::map<cmLocalGenerator*, std::string> GlobalAutoGenTargets_;
   std::map<cmLocalGenerator*, std::string> GlobalAutoRccTargets_;
+  std::unordered_map<std::string, std::string> ExecutableTestOutputs_;
 };
 
 #endif
diff --git a/Source/cmQtAutoGenInitializer.cxx b/Source/cmQtAutoGenInitializer.cxx
index a96d574..614a88b 100644
--- a/Source/cmQtAutoGenInitializer.cxx
+++ b/Source/cmQtAutoGenInitializer.cxx
@@ -1439,18 +1439,18 @@
   return res;
 }
 
-std::pair<bool, std::string> GetQtExecutable(
-  const cmQtAutoGen::IntegerVersion& qtVersion, cmGeneratorTarget* target,
+std::pair<bool, std::string> cmQtAutoGenInitializer::GetQtExecutable(
   const std::string& executable, bool ignoreMissingTarget, std::string* output)
 {
   const std::string upperExecutable = cmSystemTools::UpperCase(executable);
-  std::string result =
-    target->Target->GetSafeProperty("AUTO" + upperExecutable + "_EXECUTABLE");
+  std::string result = this->Target->Target->GetSafeProperty(
+    "AUTO" + upperExecutable + "_EXECUTABLE");
   if (!result.empty()) {
-    cmListFileBacktrace lfbt = target->Target->GetMakefile()->GetBacktrace();
+    cmListFileBacktrace lfbt =
+      this->Target->Target->GetMakefile()->GetBacktrace();
     cmGeneratorExpression ge(lfbt);
     std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(result);
-    result = cge->Evaluate(target->GetLocalGenerator(), "");
+    result = cge->Evaluate(this->Target->GetLocalGenerator(), "");
 
     return std::make_pair(true, result);
   }
@@ -1460,12 +1460,12 @@
   // Find executable
   {
     const std::string targetName =
-      GetQtExecutableTargetName(qtVersion, executable);
+      GetQtExecutableTargetName(this->QtVersion, executable);
     if (targetName.empty()) {
       err = "The AUTO" + upperExecutable + " feature ";
       err += "supports only Qt 4, Qt 5 and Qt 6.";
     } else {
-      cmLocalGenerator* localGen = target->GetLocalGenerator();
+      cmLocalGenerator* localGen = this->Target->GetLocalGenerator();
       cmGeneratorTarget* tgt = localGen->FindGeneratorTargetToUse(targetName);
       if (tgt != nullptr) {
         if (tgt->IsImported()) {
@@ -1485,36 +1485,14 @@
 
   // Test executable
   if (err.empty()) {
-    if (cmSystemTools::FileExists(result, true)) {
-      std::vector<std::string> command;
-      command.push_back(result);
-      command.emplace_back("-h");
-      std::string stdOut;
-      std::string stdErr;
-      int retVal = 0;
-      const bool runResult = cmSystemTools::RunSingleCommand(
-        command, &stdOut, &stdErr, &retVal, nullptr,
-        cmSystemTools::OUTPUT_NONE, cmDuration::zero(), cmProcessOutput::Auto);
-      if (!runResult) {
-        err = "Test of \"" + executable + "\" binary ";
-        err += cmQtAutoGen::Quoted(result) + " failed: ";
-        err += cmQtAutoGen::QuotedCommand(command);
-      } else {
-        if (output != nullptr) {
-          *output = stdOut;
-        }
-      }
-    } else {
-      err = "The \"" + executable + "\" binary ";
-      err += cmQtAutoGen::Quoted(result);
-      err += " does not exist";
-    }
+    this->GlobalInitializer->GetExecutableTestOutput(executable, result, err,
+                                                     output);
   }
 
   // Print error
   if (!err.empty()) {
     std::string msg = "AutoGen (";
-    msg += target->GetName();
+    msg += this->Target->GetName();
     msg += "): ";
     msg += err;
     cmSystemTools::Error(msg);
@@ -1526,16 +1504,14 @@
 
 bool cmQtAutoGenInitializer::GetMocExecutable()
 {
-  const auto result =
-    GetQtExecutable(this->QtVersion, this->Target, "moc", false, nullptr);
+  const auto result = this->GetQtExecutable("moc", false, nullptr);
   this->Moc.Executable = result.second;
   return result.first;
 }
 
 bool cmQtAutoGenInitializer::GetUicExecutable()
 {
-  const auto result =
-    GetQtExecutable(this->QtVersion, this->Target, "uic", true, nullptr);
+  const auto result = this->GetQtExecutable("uic", true, nullptr);
   this->Uic.Executable = result.second;
   return result.first;
 }
@@ -1543,8 +1519,7 @@
 bool cmQtAutoGenInitializer::GetRccExecutable()
 {
   std::string stdOut;
-  const auto result =
-    GetQtExecutable(this->QtVersion, this->Target, "rcc", false, &stdOut);
+  const auto result = this->GetQtExecutable("rcc", false, &stdOut);
   this->Rcc.Executable = result.second;
   if (!result.first) {
     return false;
diff --git a/Source/cmQtAutoGenInitializer.h b/Source/cmQtAutoGenInitializer.h
index 10f0bf3..781dd15 100644
--- a/Source/cmQtAutoGenInitializer.h
+++ b/Source/cmQtAutoGenInitializer.h
@@ -110,6 +110,10 @@
                      std::vector<std::string>& files,
                      std::string& errorMessage);
 
+  std::pair<bool, std::string> GetQtExecutable(const std::string& executable,
+                                               bool ignoreMissingTarget,
+                                               std::string* output);
+
 private:
   cmQtAutoGenGlobalInitializer* GlobalInitializer;
   cmGeneratorTarget* Target;
diff --git a/Source/cmVSSetupHelper.cxx b/Source/cmVSSetupHelper.cxx
index 91a0e15..c78361e 100644
--- a/Source/cmVSSetupHelper.cxx
+++ b/Source/cmVSSetupHelper.cxx
@@ -190,14 +190,6 @@
     std::string const vcRoot = vsInstanceInfo.GetInstallLocation();
     std::string vcToolsVersionFile =
       vcRoot + "/VC/Auxiliary/Build/Microsoft.VCToolsVersion.default.txt";
-    if (!cmSystemTools::PathExists(vcToolsVersionFile)) {
-      // FIXME: VS 2019 Preview 2 installs the v142 toolset and does not
-      // provide the plain `Microsoft.VCToolsVersion.default.txt` that v141
-      // does.  This should be fixed in preview 3 and this workaround can
-      // be dropped.  Otherwise, we may need to switch to globbing.
-      vcToolsVersionFile = vcRoot +
-        "/VC/Auxiliary/Build/Microsoft.VCToolsVersion.v142.default.txt";
-    }
     std::string vcToolsVersion;
     cmsys::ifstream fin(vcToolsVersionFile.c_str());
     if (!fin || !cmSystemTools::GetLineFromStream(fin, vcToolsVersion)) {
diff --git a/Source/cmakemain.cxx b/Source/cmakemain.cxx
index 890b74e..a83f7dc 100644
--- a/Source/cmakemain.cxx
+++ b/Source/cmakemain.cxx
@@ -498,7 +498,7 @@
     return 1;
   }
 
-  cmake cm(cmake::RoleInternal, cmState::Unknown);
+  cmake cm(cmake::RoleInternal, cmState::Project);
   cmSystemTools::SetMessageCallback([&cm](const char* msg, const char* title) {
     cmakemainMessageCallback(msg, title, &cm);
   });
diff --git a/Tests/CMakeLists.txt b/Tests/CMakeLists.txt
index 6c888cc..431a492 100644
--- a/Tests/CMakeLists.txt
+++ b/Tests/CMakeLists.txt
@@ -1494,10 +1494,6 @@
     add_subdirectory(FindODBC)
   endif()
 
-  if(CMake_TEST_FindOctave)
-    add_subdirectory(FindOctave)
-  endif()
-
   if(CMake_TEST_FindOpenCL)
     add_subdirectory(FindOpenCL)
   endif()
diff --git a/Tests/FindOctave/CMakeLists.txt b/Tests/FindOctave/CMakeLists.txt
deleted file mode 100644
index 1acc966..0000000
--- a/Tests/FindOctave/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-add_test(NAME FindOctave.Test COMMAND
-  ${CMAKE_CTEST_COMMAND} -C $<CONFIGURATION>
-  --build-and-test
-  "${CMake_SOURCE_DIR}/Tests/FindOctave/Test"
-  "${CMake_BINARY_DIR}/Tests/FindOctave/Test"
-  ${build_generator_args}
-  --build-project TestFindOctave
-  --build-options ${build_options}
-  --test-command ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>
-  )
diff --git a/Tests/FindOctave/Test/CMakeLists.txt b/Tests/FindOctave/Test/CMakeLists.txt
deleted file mode 100644
index 73aa831..0000000
--- a/Tests/FindOctave/Test/CMakeLists.txt
+++ /dev/null
@@ -1,24 +0,0 @@
-cmake_minimum_required(VERSION 3.3)
-project(TestFindOctave CXX)
-enable_testing()
-
-find_package(Octave REQUIRED COMPONENTS Development Interpreter)
-
-add_definitions(-DCMAKE_EXPECTED_Octave_VERSION=${Octave_VERSION})
-
-add_executable(test_tgt main.cpp)
-target_link_libraries(test_tgt Octave::Octave)
-add_test(NAME test_tgt COMMAND test_tgt)
-
-add_executable(test_octinterp_tgt interp_main.cpp)
-target_link_libraries(test_octinterp_tgt Octave::Octinterp)
-add_test(NAME test_octinterp_tgt COMMAND test_octinterp_tgt)
-
-add_test(NAME test_tgt_exe
-         COMMAND Octave::Interpreter -q --eval "runtests('.')"
-         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-
-add_executable(test_var main.cpp)
-target_include_directories(test_var PRIVATE ${Octave_INCLUDE_DIRS})
-target_link_libraries(test_var PRIVATE ${Octave_LIBRARIES})
-add_test(NAME test_var COMMAND test_var)
diff --git a/Tests/FindOctave/Test/interp_main.cpp b/Tests/FindOctave/Test/interp_main.cpp
deleted file mode 100644
index 1efa187..0000000
--- a/Tests/FindOctave/Test/interp_main.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#include <iostream>
-#include <oct.h>
-#include <octave.h>
-#include <parse.h>
-#include <toplev.h>
-
-int main(void)
-{
-  string_vector argv(2);
-  argv(0) = "embedded";
-  argv(1) = "-q";
-
-  try {
-    octave_main(2, argv.c_str_vec(), 1);
-    octave_value_list in;
-    in(0) = 72.0;
-    const octave_value_list result = feval("sqrt", in);
-    std::cout << "result is " << result(0).scalar_value() << std::endl;
-    clean_up_and_exit(0);
-  } catch (const octave::exit_exception& ex) {
-    std::cerr << "Octave interpreter exited with status = " << ex.exit_status()
-              << std::endl;
-  } catch (const octave::execution_exception&) {
-    std::cerr << "error encountered in Octave evaluator!" << std::endl;
-  }
-}
diff --git a/Tests/FindOctave/Test/main.cpp b/Tests/FindOctave/Test/main.cpp
deleted file mode 100644
index 68270b1..0000000
--- a/Tests/FindOctave/Test/main.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <iostream>
-#include <oct.h>
-
-// http://www.dm.unibo.it/~achilles/calc/octave.html/Standalone-Programs.html
-int main(void)
-{
-  int n = 2;
-  Matrix a_matrix = Matrix(n, n);
-  for (octave_idx_type i = 0; i < n; i++) {
-    for (octave_idx_type j = 0; j < n; j++) {
-      a_matrix(i, j) = (i + 1) * 10 + (j + 1);
-    }
-  }
-
-  std::cout << a_matrix << std::endl;
-
-  return EXIT_SUCCESS;
-}
diff --git a/Tests/FindOctave/Test/testtrue.m b/Tests/FindOctave/Test/testtrue.m
deleted file mode 100644
index 0c28a9e..0000000
--- a/Tests/FindOctave/Test/testtrue.m
+++ /dev/null
@@ -1 +0,0 @@
-%!assert(true)
diff --git a/Tests/RunCMake/CMakeLists.txt b/Tests/RunCMake/CMakeLists.txt
index 1f3e5c3..f2b7ff1 100644
--- a/Tests/RunCMake/CMakeLists.txt
+++ b/Tests/RunCMake/CMakeLists.txt
@@ -284,11 +284,11 @@
   if(CMAKE_VERSION VERSION_LESS 3.9.20170907 AND "x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xMSVC")
     # Older CMake versions do not know about MSVC language standards.
     # Approximate our logic from MSVC-CXX.cmake.
-    if ((CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 19.0.24215.1 AND
+    if ((NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.0.24215.1 AND
          CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.10) OR
-       CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 19.10.25017)
+         NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.10.25017)
       set(CMAKE_CXX_STANDARD_DEFAULT 14)
-    elseif (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 16.0)
+    elseif (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 16.0)
       set(CMAKE_CXX_STANDARD_DEFAULT "")
     else()
       unset(CMAKE_CXX_STANDARD_DEFAULT)
diff --git a/Tests/RunCMake/CMakeRoleGlobalProperty/Project.cmake b/Tests/RunCMake/CMakeRoleGlobalProperty/Project.cmake
index c0b6a48..22cad2b 100644
--- a/Tests/RunCMake/CMakeRoleGlobalProperty/Project.cmake
+++ b/Tests/RunCMake/CMakeRoleGlobalProperty/Project.cmake
@@ -1,4 +1,8 @@
 get_property(role GLOBAL PROPERTY CMAKE_ROLE)
+
+file(WRITE "${CMAKE_BINARY_DIR}/test.cmake" "# a")
+include("${CMAKE_BINARY_DIR}/test.cmake")
+
 if(NOT role STREQUAL "PROJECT")
   message(SEND_ERROR "CMAKE_ROLE property is \"${role}\", should be \"PROJECT\"")
 endif()
diff --git a/Tests/RunCMake/CMakeRoleGlobalProperty/RunCMakeTest.cmake b/Tests/RunCMake/CMakeRoleGlobalProperty/RunCMakeTest.cmake
index 3cbd51d..7b29c28 100644
--- a/Tests/RunCMake/CMakeRoleGlobalProperty/RunCMakeTest.cmake
+++ b/Tests/RunCMake/CMakeRoleGlobalProperty/RunCMakeTest.cmake
@@ -2,6 +2,9 @@
 include(RunCTest)
 
 run_cmake(Project)
+file(WRITE "${RunCMake_BINARY_DIR}/Project-build/test.cmake" "# b")
+run_cmake_command(ProjectBuild "${CMAKE_COMMAND}" --build "${RunCMake_BINARY_DIR}/Project-build")
+
 run_cmake_command(Script "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_LIST_DIR}/Script.cmake")
 run_cmake_command(FindPackage "${CMAKE_COMMAND}" --find-package -DNAME=DummyPackage -DCOMPILER_ID=GNU -DLANGUAGE=CXX -DMODE=EXIST "-DCMAKE_MODULE_PATH=${CMAKE_CURRENT_LIST_DIR}")
 run_ctest(CTest)
diff --git a/Tests/RunCMake/install/TARGETS-OPTIONAL-stderr.txt b/Tests/RunCMake/install/TARGETS-OPTIONAL-stderr.txt
deleted file mode 100644
index 86e3ec0..0000000
--- a/Tests/RunCMake/install/TARGETS-OPTIONAL-stderr.txt
+++ /dev/null
@@ -1 +0,0 @@
-^WARNING: Target "notall" has EXCLUDE_FROM_ALL set and will not be built by default but an install rule has been provided for it\.  CMake does not define behavior for this case\.$