11 files changed, 153 insertions, 151 deletions
diff --git a/Help/command/target_precompile_headers.rst b/Help/command/target_precompile_headers.rst
index d283948..5ab3766 100644
--- a/Help/command/target_precompile_headers.rst
+++ b/Help/command/target_precompile_headers.rst
@@ -79,6 +79,17 @@ must be available for the compiler to find them.  Other header file names
 source directory (e.g. :variable:`CMAKE_CURRENT_SOURCE_DIR`) and will be
 included by absolute path.
 
+When specifying angle brackets inside a :manual:`generator expression
+<cmake-generator-expressions(7)>`, be sure to encode the closing ``>``
+as ``$<ANGLE-R>``.  For example:
+
+.. code-block:: cmake
+
+  target_precompile_headers(mylib PRIVATE
+    "$<$<COMPILE_LANGUAGE:C>:<stddef.h$<ANGLE-R>>"
+    "$<$<COMPILE_LANGUAGE:CXX>:<cstddef$<ANGLE-R>>"
+    )
+
 See Also
 ^^^^^^^^
 
diff --git a/Help/prop_sf/SKIP_UNITY_BUILD_INCLUSION.rst b/Help/prop_sf/SKIP_UNITY_BUILD_INCLUSION.rst
index 53f3970..6d1e60d 100644
--- a/Help/prop_sf/SKIP_UNITY_BUILD_INCLUSION.rst
+++ b/Help/prop_sf/SKIP_UNITY_BUILD_INCLUSION.rst
@@ -1,7 +1,11 @@
 SKIP_UNITY_BUILD_INCLUSION
 --------------------------
 
-Is this source file skipped by :prop_tgt:`UNITY_BUILD` feature.
+Setting this property to true ensures the source file will be skipped by
+unity builds when its associated target has its :prop_tgt:`UNITY_BUILD`
+property set to true.  The source file will instead be compiled on its own
+in the same way as it would with unity builds disabled.
 
-This property helps with "ODR (One definition rule)" problems
-that one would run into when using an :prop_tgt:`UNITY_BUILD`.
+This property helps with "ODR (One definition rule)" problems where combining
+a particular source file with others might lead to build errors or other
+unintended side effects.
diff --git a/Help/prop_tgt/UNITY_BUILD.rst b/Help/prop_tgt/UNITY_BUILD.rst
index fab4f15..479802e 100644
--- a/Help/prop_tgt/UNITY_BUILD.rst
+++ b/Help/prop_tgt/UNITY_BUILD.rst
@@ -1,60 +1,60 @@
 UNITY_BUILD
 -----------
 
-Should the target source files be processed into batches for
-faster compilation. This feature is known as "Unity build",
-or "Jumbo build".
-
-The ``C`` and ``CXX`` source files are grouped separately.
-
-This property is initialized by the value of the
-:variable:`CMAKE_UNITY_BUILD` variable if it is set when
-a target is created.
-
-.. note::
-
-  It's not recommended to directly set :prop_tgt:`UNITY_BUILD`
-  to ``ON``, but to instead set :variable:`CMAKE_UNITY_BUILD` from
-  the command line.  However, it IS recommended to set
-  :prop_tgt:`UNITY_BUILD` to ``OFF`` if you need to ensure that a
-  target doesn't get a unity build.
-
-The batch size can be specified by setting
-:prop_tgt:`UNITY_BUILD_BATCH_SIZE`.
-
-The batching of source files is done by adding new sources files
-which will ``#include`` the source files, and exclude them from
-building by setting :prop_sf:`HEADER_FILE_ONLY` to ``ON``.
+When this property is set to true, the target source files will be combined
+into batches for faster compilation.  This is done by creating a (set of)
+unity sources which ``#include`` the original sources, then compiling these
+unity sources instead of the originals.  This is known as a *Unity* or *Jumbo*
+build.  The :prop_tgt:`UNITY_BUILD_BATCH_SIZE` property controls the upper
+limit on how many sources can be combined per unity source file.
+
+Unity builds are not currently supported for all languages.  CMake version
+|release| supports combining ``C`` and ``CXX`` source files.  For targets that
+mix source files from more than one language, CMake will separate the languages
+such that each generated unity source file only contains sources for a single
+language.
+
+This property is initialized by the value of the :variable:`CMAKE_UNITY_BUILD`
+variable when a target is created.
 
 .. note::
 
-  Marking the original sources with :prop_sf:`HEADER_FILE_ONLY`
-  is considered an implementation detail that may change in the
-  future because it does not work well in combination with
-  the :variable:`CMAKE_EXPORT_COMPILE_COMMANDS` variable.
+  Projects should not directly set the ``UNITY_BUILD`` property or its
+  associated :variable:`CMAKE_UNITY_BUILD` variable to true.  Depending
+  on the capabilities of the build machine and compiler used, it might or
+  might not be appropriate to enable unity builds.  Therefore, this feature
+  should be under developer control, which would normally be through the
+  developer choosing whether or not to set the :variable:`CMAKE_UNITY_BUILD`
+  variable on the :manual:`cmake(1)` command line or some other equivalent
+  method.  However, it IS recommended to set the ``UNITY_BUILD`` target
+  property to false if it is known that enabling unity builds for the
+  target can lead to problems.
 
 ODR (One definition rule) errors
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Since multiple source files are included into one source file,
-it can lead to ODR errors. This section contains properties
-which help fixing these errors.
-
-The source files marked by :prop_sf:`SKIP_UNITY_BUILD_INCLUSION`
-will be skipped from unity build.
-
-The source files that have :prop_sf:`COMPILE_OPTIONS`,
-:prop_sf:`COMPILE_DEFINITIONS`, :prop_sf:`COMPILE_FLAGS`, or
-:prop_sf:`INCLUDE_DIRECTORIES` will also be skipped.
-
-With the :prop_tgt:`UNITY_BUILD_CODE_BEFORE_INCLUDE` and
-:prop_tgt:`UNITY_BUILD_CODE_AFTER_INCLUDE` one can specify code
-to be injected in the unity source file before and after every
-``#include`` statement.
-
-.. note::
-
-  The order of source files defined in the ``CMakeLists.txt`` will
-  be preserved into the generated unity source files. This can
-  be used to manually enforce a specific grouping based on the
-  :prop_tgt:`UNITY_BUILD_BATCH_SIZE` target property.
+When multiple source files are included into one source file, as is done
+for unity builds, it can potentially lead to ODR errors.  CMake provides
+a number of measures to help address such problems:
+
+* Any source file that has a non-empty :prop_sf:`COMPILE_OPTIONS`,
+  :prop_sf:`COMPILE_DEFINITIONS`, :prop_sf:`COMPILE_FLAGS`, or
+  :prop_sf:`INCLUDE_DIRECTORIES` source property will not be combined
+  into a unity source.
+
+* Projects can prevent an individual source file from being combined into
+  a unity source by setting its :prop_sf:`SKIP_UNITY_BUILD_INCLUSION`
+  source property to true.  This can be a more effective way to prevent
+  problems with specific files than disabling unity builds for an entire
+  target.
+
+* The :prop_tgt:`UNITY_BUILD_CODE_BEFORE_INCLUDE` and
+  :prop_tgt:`UNITY_BUILD_CODE_AFTER_INCLUDE` target properties can be used
+  to inject code into the unity source files before and after every
+  ``#include`` statement.
+
+* The order of source files added to the target via commands like
+  :command:`add_library`, :command:`add_executable` or
+  :command:`target_sources` will be preserved in the generated unity source
+  files.  This can be used to manually enforce a specific grouping based on
+  the :prop_tgt:`UNITY_BUILD_BATCH_SIZE` target property.
diff --git a/Help/prop_tgt/UNITY_BUILD_BATCH_SIZE.rst b/Help/prop_tgt/UNITY_BUILD_BATCH_SIZE.rst
index 84047f2..44ffe27 100644
--- a/Help/prop_tgt/UNITY_BUILD_BATCH_SIZE.rst
+++ b/Help/prop_tgt/UNITY_BUILD_BATCH_SIZE.rst
@@ -1,13 +1,23 @@
 UNITY_BUILD_BATCH_SIZE
 ----------------------
 
-Specifies how many source code files will be included into a
-:prop_tgt:`UNITY_BUILD` source file.
+Specifies the maximum number of source files that can be combined into any one
+unity source file when unity builds are enabled by the :prop_tgt:`UNITY_BUILD`
+target property.  The original source files will be distributed across as many
+unity source files as necessary to honor this limit.
 
-If the property is not set, CMake will use the value provided
-by :variable:`CMAKE_UNITY_BUILD_BATCH_SIZE`.
+The initial value for this property is taken from the
+:variable:`CMAKE_UNITY_BUILD_BATCH_SIZE` variable when the target is created.
+If that variable has not been set, the initial value will be 8.
 
-By setting it to value `0` the generated unity source file will
-contain all the source files that would otherwise be split
-into multiple batches. It is not recommended to do so, since it
-would affect performance.
+The batch size needs to be selected carefully.  If set too high, the size of
+the combined source files could result in the compiler using excessive memory
+or hitting other similar limits.  In extreme cases, this can even result in
+build failure.  On the other hand, if the batch size is too low, there will be
+little gain in build performance.
+
+Although strongly discouraged, the batch size may be set to a value of 0 to
+combine all the sources for the target into a single unity file, regardless of
+how many sources are involved.  This runs the risk of creating an excessively
+large unity source file and negatively impacting the build performance, so
+a value of 0 is not generally recommended.
diff --git a/Help/prop_tgt/UNITY_BUILD_CODE_AFTER_INCLUDE.rst b/Help/prop_tgt/UNITY_BUILD_CODE_AFTER_INCLUDE.rst
index 7795289..7231b61 100644
--- a/Help/prop_tgt/UNITY_BUILD_CODE_AFTER_INCLUDE.rst
+++ b/Help/prop_tgt/UNITY_BUILD_CODE_AFTER_INCLUDE.rst
@@ -2,7 +2,18 @@ UNITY_BUILD_CODE_AFTER_INCLUDE
 ------------------------------
 
 Code snippet which is included verbatim by the :prop_tgt:`UNITY_BUILD`
-feature just after the `#include` statement of the targeted source
-files.
+feature just after every ``#include`` statement in the generated unity
+source files.  For example:
 
-This could be something like `#undef NOMINMAX`.
+.. code-block:: cmake
+
+  set(after [[
+  #if defined(NOMINMAX)
+  #undef NOMINMAX
+  #endif
+  ]])
+  set_target_properties(myTarget PROPERTIES
+    UNITY_BUILD_CODE_AFTER_INCLUDE "${after}"
+  )
+
+See also :prop_tgt:`UNITY_BUILD_CODE_BEFORE_INCLUDE`.
diff --git a/Help/prop_tgt/UNITY_BUILD_CODE_BEFORE_INCLUDE.rst b/Help/prop_tgt/UNITY_BUILD_CODE_BEFORE_INCLUDE.rst
index f335463..7ed6fa1 100644
--- a/Help/prop_tgt/UNITY_BUILD_CODE_BEFORE_INCLUDE.rst
+++ b/Help/prop_tgt/UNITY_BUILD_CODE_BEFORE_INCLUDE.rst
@@ -2,7 +2,18 @@ UNITY_BUILD_CODE_BEFORE_INCLUDE
 -------------------------------
 
 Code snippet which is included verbatim by the :prop_tgt:`UNITY_BUILD`
-feature just before the `#include` statement of the targeted source
-files.
+feature just before every ``#include`` statement in the generated unity
+source files.  For example:
 
-This could be something like `#define NOMINMAX`.
+.. code-block:: cmake
+
+  set(before [[
+  #if !defined(NOMINMAX)
+  #define NOMINMAX
+  #endif
+  ]])
+  set_target_properties(myTarget PROPERTIES
+    UNITY_BUILD_CODE_BEFORE_INCLUDE "${before}"
+  )
+
+See also :prop_tgt:`UNITY_BUILD_CODE_AFTER_INCLUDE`.
diff --git a/Help/variable/CMAKE_UNITY_BUILD.rst b/Help/variable/CMAKE_UNITY_BUILD.rst
index bbcfd68..a86cd67 100644
--- a/Help/variable/CMAKE_UNITY_BUILD.rst
+++ b/Help/variable/CMAKE_UNITY_BUILD.rst
@@ -1,11 +1,19 @@
 CMAKE_UNITY_BUILD
 -----------------
 
-Initializes the :prop_tgt:`UNITY_BUILD` target property on targets
-as they are created.  Set to ``ON`` to batch compilation of multiple
-sources within each target.  This feature is known as "Unity build",
-or "Jumbo build".  By default this variable is not set and so does
-not enable unity builds on targets.
+This variable is used to initialize the :prop_tgt:`UNITY_BUILD`
+property of targets when they are created.  Setting it to true
+enables batch compilation of multiple sources within each target.
+This feature is known as a *Unity* or *Jumbo* build.
+
+Projects should not set this variable, it is intended as a developer
+control to be set on the :manual:`cmake(1)` command line or other
+equivalent methods.  The developer must have the ability to enable or
+disable unity builds according to the capabilities of their own machine
+and compiler.
+
+By default, this variable is not set, which will result in unity builds
+being disabled.
 
 .. note::
   This option currently does not work well in combination with
diff --git a/Help/variable/CMAKE_UNITY_BUILD_BATCH_SIZE.rst b/Help/variable/CMAKE_UNITY_BUILD_BATCH_SIZE.rst
index 3ab2344..7988d4b 100644
--- a/Help/variable/CMAKE_UNITY_BUILD_BATCH_SIZE.rst
+++ b/Help/variable/CMAKE_UNITY_BUILD_BATCH_SIZE.rst
@@ -1,6 +1,7 @@
 CMAKE_UNITY_BUILD_BATCH_SIZE
 ----------------------------
 
-Default value for :prop_tgt:`UNITY_BUILD_BATCH_SIZE` of targets.
-
-By default ``CMAKE_UNITY_BUILD_BATCH_SIZE`` is set to ``8``.
+This variable is used to initialize the :prop_tgt:`UNITY_BUILD_BATCH_SIZE`
+property of targets when they are created.  It specifies the default upper
+limit on the number of source files that may be combined in any one unity
+source file when unity builds are enabled for a target.
diff --git a/Modules/CMakeFindBinUtils.cmake b/Modules/CMakeFindBinUtils.cmake
index 69ace5a..c23e447 100644
--- a/Modules/CMakeFindBinUtils.cmake
+++ b/Modules/CMakeFindBinUtils.cmake
@@ -57,44 +57,6 @@ endfunction()
 __resolve_tool_path(CMAKE_LINKER "${_CMAKE_TOOLCHAIN_LOCATION}" "Default Linker")
 __resolve_tool_path(CMAKE_MT     "${_CMAKE_TOOLCHAIN_LOCATION}" "Default Manifest Tool")
 
-function(__get_compiler_component CMAKE_TOOL NAME)
-  get_property(_CMAKE_TOOL_CACHED CACHE ${CMAKE_TOOL} PROPERTY TYPE)
-  # If CMAKE_TOOL is present in the CMake Cache, return
-  if(_CMAKE_TOOL_CACHED)
-    return()
-  endif()
-
-  cmake_parse_arguments(_COMPILER_COMP_ARGS "" "DOC" "HINTS;NAMES" ${ARGN})
-
-  set(_LOCATION_FROM_COMPILER )
-  set(_NAME_FROM_COMPILER )
-
-  if (NOT DEFINED ${CMAKE_TOOL})
-    if("x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_ID}" STREQUAL "xGNU" OR
-       "x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_ID}" STREQUAL "xClang")
-      execute_process(
-        COMMAND ${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER} -print-prog-name=${NAME}
-        RESULT_VARIABLE _CMAKE_TOOL_PROG_NAME_RESULT
-        OUTPUT_VARIABLE _CMAKE_TOOL_PROG_NAME_OUTPUT
-        OUTPUT_STRIP_TRAILING_WHITESPACE
-      )
-      if (_CMAKE_TOOL_PROG_NAME_RESULT STREQUAL "0" AND IS_ABSOLUTE "${_CMAKE_TOOL_PROG_NAME_OUTPUT}")
-        get_filename_component(_LOCATION_FROM_COMPILER "${_CMAKE_TOOL_PROG_NAME_OUTPUT}" DIRECTORY)
-        get_filename_component(_NAME_FROM_COMPILER "${_CMAKE_TOOL_PROG_NAME_OUTPUT}" NAME)
-      endif()
-    endif()
-  endif()
-
-  if (NOT _COMPILER_COMP_ARGS_DOC)
-    set(_COMPILER_COMP_ARGS_DOC "Path to ${NAME} program")
-  endif()
-  find_program(${CMAKE_TOOL}
-    NAMES ${_NAME_FROM_COMPILER} ${_COMPILER_COMP_ARGS_NAMES}
-    HINTS ${_LOCATION_FROM_COMPILER} ${_COMPILER_COMP_ARGS_HINTS}
-    DOC "${_COMPILER_COMP_ARGS_DOC}"
-  )
-endfunction()
-
 set(_CMAKE_TOOL_VARS "")
 
 # if it's the MS C/CXX compiler, search for link
@@ -139,38 +101,28 @@ else()
     set(_CMAKE_ADDITIONAL_ADDR2LINE_NAMES "llvm-addr2line")
   endif()
 
-  __get_compiler_component(CMAKE_AR ar NAMES ${_CMAKE_TOOLCHAIN_PREFIX}ar${_CMAKE_TOOLCHAIN_SUFFIX} ${_CMAKE_ADDITIONAL_AR_NAMES}
-                                       HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
+  find_program(CMAKE_AR NAMES ${_CMAKE_TOOLCHAIN_PREFIX}ar${_CMAKE_TOOLCHAIN_SUFFIX} ${_CMAKE_ADDITIONAL_AR_NAMES} HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
 
-  __get_compiler_component(CMAKE_RANLIB ranlib NAMES ${_CMAKE_TOOLCHAIN_PREFIX}ranlib ${_CMAKE_ADDITIONAL_RANLIB_NAMES}
-                                               HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
+  find_program(CMAKE_RANLIB NAMES ${_CMAKE_TOOLCHAIN_PREFIX}ranlib ${_CMAKE_ADDITIONAL_RANLIB_NAMES} HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
   if(NOT CMAKE_RANLIB)
     set(CMAKE_RANLIB : CACHE INTERNAL "noop for ranlib")
   endif()
 
 
-  __get_compiler_component(CMAKE_STRIP strip NAMES ${_CMAKE_TOOLCHAIN_PREFIX}strip${_CMAKE_TOOLCHAIN_SUFFIX} ${_CMAKE_ADDITIONAL_STRIP_NAMES}
-                                             HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
-  __get_compiler_component(CMAKE_LINKER ld NAMES ${_CMAKE_TOOLCHAIN_PREFIX}ld ${_CMAKE_ADDITIONAL_LINKER_NAMES}
-                                           HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
-  __get_compiler_component(CMAKE_NM nm NAMES ${_CMAKE_TOOLCHAIN_PREFIX}nm ${_CMAKE_ADDITIONAL_NM_NAMES}
-                                       HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
-  __get_compiler_component(CMAKE_OBJDUMP objdump NAMES ${_CMAKE_TOOLCHAIN_PREFIX}objdump ${_CMAKE_ADDITIONAL_OBJDUMP_NAMES}
-                                       HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
-  __get_compiler_component(CMAKE_OBJCOPY objcopy NAMES ${_CMAKE_TOOLCHAIN_PREFIX}objcopy ${_CMAKE_ADDITIONAL_OBJCOPY_NAMES}
-                                       HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
-  __get_compiler_component(CMAKE_READELF readelf NAMES ${_CMAKE_TOOLCHAIN_PREFIX}readelf ${_CMAKE_ADDITIONAL_READELF_NAMES}
-                                       HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
-  __get_compiler_component(CMAKE_DLLTOOL dlltool NAMES ${_CMAKE_TOOLCHAIN_PREFIX}dlltool ${_CMAKE_ADDITIONAL_DLLTOOL_NAMES}
-                                       HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
-  __get_compiler_component(CMAKE_ADDR2LINE addr2line NAMES ${_CMAKE_TOOLCHAIN_PREFIX}addr2line ${_CMAKE_ADDITIONAL_ADDR2LINE_NAMES}
-                                       HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
+  find_program(CMAKE_STRIP NAMES ${_CMAKE_TOOLCHAIN_PREFIX}strip${_CMAKE_TOOLCHAIN_SUFFIX} ${_CMAKE_ADDITIONAL_STRIP_NAMES} HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
+  find_program(CMAKE_LINKER NAMES ${_CMAKE_TOOLCHAIN_PREFIX}ld ${_CMAKE_ADDITIONAL_LINKER_NAMES} HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
+  find_program(CMAKE_NM NAMES ${_CMAKE_TOOLCHAIN_PREFIX}nm ${_CMAKE_ADDITIONAL_NM_NAMES} HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
+  find_program(CMAKE_OBJDUMP NAMES ${_CMAKE_TOOLCHAIN_PREFIX}objdump ${_CMAKE_ADDITIONAL_OBJDUMP_NAMES} HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
+  find_program(CMAKE_OBJCOPY NAMES ${_CMAKE_TOOLCHAIN_PREFIX}objcopy ${_CMAKE_ADDITIONAL_OBJCOPY_NAMES} HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
+  find_program(CMAKE_READELF NAMES ${_CMAKE_TOOLCHAIN_PREFIX}readelf ${_CMAKE_ADDITIONAL_READELF_NAMES} HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
+  find_program(CMAKE_DLLTOOL NAMES ${_CMAKE_TOOLCHAIN_PREFIX}dlltool ${_CMAKE_ADDITIONAL_DLLTOOL_NAMES} HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
+  find_program(CMAKE_ADDR2LINE NAMES ${_CMAKE_TOOLCHAIN_PREFIX}addr2line ${_CMAKE_ADDITIONAL_ADDR2LINE_NAMES} HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
 
   list(APPEND _CMAKE_TOOL_VARS AR RANLIB STRIP LINKER NM OBJDUMP OBJCOPY READELF DLLTOOL ADDR2LINE)
 endif()
 
 if(CMAKE_PLATFORM_HAS_INSTALLNAME)
-  __get_compiler_component(CMAKE_INSTALL_NAME_TOOL install_name_tool NAMES ${_CMAKE_TOOLCHAIN_PREFIX}install_name_tool HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
+  find_program(CMAKE_INSTALL_NAME_TOOL NAMES ${_CMAKE_TOOLCHAIN_PREFIX}install_name_tool HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
 
   if(NOT CMAKE_INSTALL_NAME_TOOL)
     message(FATAL_ERROR "Could not find install_name_tool, please check your installation.")
diff --git a/Modules/CTestCoverageCollectGCOV.cmake b/Modules/CTestCoverageCollectGCOV.cmake
index 655827a..ff48cc2 100644
--- a/Modules/CTestCoverageCollectGCOV.cmake
+++ b/Modules/CTestCoverageCollectGCOV.cmake
@@ -20,7 +20,7 @@ This tarball also contains the following:
 After generating this tar file, it can be sent to CDash for display with the
 :command:`ctest_submit(CDASH_UPLOAD)` command.
 
-.. command:: cdash_coverage_collect_gcov
+.. command:: ctest_coverage_collect_gcov
 
   ::
 
diff --git a/Modules/Compiler/GNU-FindBinUtils.cmake b/Modules/Compiler/GNU-FindBinUtils.cmake
index a47b7ad..097fbf3 100644
--- a/Modules/Compiler/GNU-FindBinUtils.cmake
+++ b/Modules/Compiler/GNU-FindBinUtils.cmake
@@ -15,27 +15,21 @@ string(REGEX MATCH "^([0-9]+\\.[0-9]+)" __version_x_y
 get_filename_component(__gcc_hints "${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER}" DIRECTORY)
 
 # http://manpages.ubuntu.com/manpages/wily/en/man1/gcc-ar.1.html
-__get_compiler_component(
-    CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_AR gcc-ar
-    HINTS
-      ${__gcc_hints}
-    NAMES
-      "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ar-${__version_x_y}"
-      "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ar-${__version_x}"
-      "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ar"
+find_program(CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_AR NAMES
+    "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ar-${__version_x_y}"
+    "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ar-${__version_x}"
+    "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ar${_CMAKE_COMPILER_SUFFIX}"
+    HINTS ${__gcc_hints}
     DOC "A wrapper around 'ar' adding the appropriate '--plugin' option for the GCC compiler"
 )
 mark_as_advanced(CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_AR)
 
 # http://manpages.ubuntu.com/manpages/wily/en/man1/gcc-ranlib.1.html
-__get_compiler_component(
-    CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_RANLIB gcc-ranlib
-    HINTS
-      ${__gcc_hints}
-    NAMES
-      "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ranlib-${__version_x_y}"
-      "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ranlib-${__version_x}"
-      "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ranlib"
+find_program(CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_RANLIB NAMES
+    "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ranlib-${__version_x_y}"
+    "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ranlib-${__version_x}"
+    "${_CMAKE_TOOLCHAIN_PREFIX}gcc-ranlib${_CMAKE_COMPILER_SUFFIX}"
+    HINTS ${__gcc_hints}
     DOC "A wrapper around 'ranlib' adding the appropriate '--plugin' option for the GCC compiler"
 )
 mark_as_advanced(CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_RANLIB)