[CMake] Fix broken uses of `try_compile_only()` and improve the function.

[delcypher]

Summary

There were existing calls to try_compile_only() with arguments not
prefixed by SOURCE or FLAGS. These were silently being ignored.
It looks like the SOURCE and FLAGS arguments were first introduced
in r278454.

One implication of this is that for a builtins only build for Darwin
(see darwin_test_archs()) it would mean we weren't actually passing
-arch <arch> to the compiler). This would result in compiler-rt
claiming all supplied architectures could be targetted provided
the compiler could build for Clang's default architecture.

This patch fixes this in several ways.

• Fixes all incorrect calls to try_compile_only().
• Adds code to try_compile_only() to check for unhandled arguments and raises a fatal error if this occurs. This should stop any incorrect calls in the future.
• Improve the documentation on try_compile_only() which seemed completely wrong.

rdar://problem/48928526

[delcypher]

Fix missing unused arguments checks.

cmake/Modules/BuiltinTests.cmake

 include(CMakeCheckCompilerFlagCommonPatterns)
 
-# This function takes an OS and a list of architectures and identifies the
-# subset of the architectures list that the installed toolchain can target.
+# Test compiler can compile simple C/C++/Objective-C program without invoking
+# the linker.
+#
+# try_compile_only(
+#   OUTPUT_VAR
+#   [SOURCE source_text]
+#   [FLAGS flag_0 [ flag_1 ]]
+# )
+#
+# OUTPUT_VAR - The variable name to store the result. The result is a boolean
+#              `True` or `False`.
+#
+# SOURCE     - Optional. If specified use source the source text string
+#              specified. If not specified source code will be used that is C,
+#              C++, and Objective-C compatible.
+#
+# FLAGS      - Optional. If specified pass the one or more specified flags to
+#              the compiler.
+#
+# EXAMPLES:
+#
+# try_compile_only(HAS_F_NO_RTTI FLAGS "-fno-rtti")
+#
+# try_compile_only(HAS_CXX_AUTO_TYPE_DECL
+#   SOURCE "int foo(int x) { auto y = x + 1; return y;}"
+#   FLAGS "-x" "c++" "-std=c++11" "-Werror=c++11-extensions"
+# )
+#
 function(try_compile_only output)
+  # NOTE: `SOURCE` needs to be a multi-argument because source code
+  # often contains semicolons which happens to be CMake's list separator
+  # which confuses `cmake_parse_arguments()`.
   cmake_parse_arguments(ARG "" "" "SOURCE;FLAGS" ${ARGN})
   if(NOT ARG_SOURCE)
     set(ARG_SOURCE "int foo(int x, int y) { return x + y; }\n")
   endif()
   set(SIMPLE_C ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/src.c)
   file(WRITE ${SIMPLE_C} "${ARG_SOURCE}\n")
   string(REGEX MATCHALL "<[A-Za-z0-9_]*>" substitutions
          ${CMAKE_C_COMPILE_OBJECT})

cmake/Modules/CompilerRTDarwinUtils.cmake

if(${os} MATCHES "^(iossim|tvossim|watchossim)$")
     list(REMOVE_ITEM archs "x86_64h")
   endif()
 
   set(working_archs)
   foreach(arch ${archs})
    
     set(arch_linker_flags "-arch ${arch} ${os_linker_flags}")
     if(TEST_COMPILE_ONLY)
-      try_compile_only(CAN_TARGET_${os}_${arch} -v -arch ${arch} ${DARWIN_${os}_CFLAGS})
+      try_compile_only(CAN_TARGET_${os}_${arch} FLAGS -v -arch ${arch} ${DARWIN_${os}_CFLAGS})
     else()
       set(SAVED_CMAKE_EXE_LINKER_FLAGS ${CMAKE_EXE_LINKER_FLAGS})
       set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${arch_linker_flags}")
       try_compile(CAN_TARGET_${os}_${arch} ${CMAKE_BINARY_DIR} ${SIMPLE_C}
                   COMPILE_DEFINITIONS "-v -arch ${arch}" ${DARWIN_${os}_CFLAGS}
                   OUTPUT_VARIABLE TEST_OUTPUT)
       set(CMAKE_EXE_LINKER_FLAGS ${SAVED_CMAKE_EXE_LINKER_FLAGS})
     endif()

cmake/Modules/CompilerRTUtils.cmake

macro(test_target_arch arch def)
   foreach(arg ${ARGN})
     set(argstring "${argstring} ${arg}")
   endforeach()
   check_compile_definition("${def}" "${argstring}" HAS_${arch}_DEF)
   if(NOT DEFINED CAN_TARGET_${arch})
     if(NOT HAS_${arch}_DEF)
       set(CAN_TARGET_${arch} FALSE)
     elseif(TEST_COMPILE_ONLY)
-      try_compile_only(CAN_TARGET_${arch} ${TARGET_${arch}_CFLAGS})
+      try_compile_only(CAN_TARGET_${arch} FLAGS ${TARGET_${arch}_CFLAGS})
     else()
       set(FLAG_NO_EXCEPTIONS "")
       if(COMPILER_RT_HAS_FNO_EXCEPTIONS_FLAG)
         set(FLAG_NO_EXCEPTIONS " -fno-exceptions ")
       endif()
       set(SAVED_CMAKE_EXE_LINKER_FLAGS ${CMAKE_EXE_LINKER_FLAGS})
       set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${argstring}")
       try_compile(CAN_TARGET_${arch} ${CMAKE_BINARY_DIR} ${SIMPLE_SOURCE}