[test-suite] Simplified test executable name generation.

[tra]

Summary

This makes it possible to further customize build process for particular
target in the user's CMake files.

• Documented some of the variables controlling test generation.
• test_suite_add_executable has been renamed to llvm_test_executable()
• removed 'mainsource' parameter
• return generated executable names, if user needs them
• Set include paths for current build/source dirs for each test we generate.
  
  Note: previously iinclude path was set globally each time llvm_multisource() was invoked. It looked unintentional. Now it's set per executable and no longer applies to subdirectories. As far as I can tell, testsuite still builds. Please let me know if we do want/need to add include paths per directory on llvm_multisource() invocation.

[tra]

@MatzeB - ping.

[MatzeB]

cmake/modules/SingleMultiSource.cmake

45–49

Passing function results through global variable is ugly.
The cmake way to handle function results would be to have an additional (possibly optional) parameter that names the variable where we write the result to. That way you can at least see the connection at the call site.

129

This would have needed a PARENT_SCOPE flag to actually work. Though I still recommend against using well known variable names to pass the result along.

143–144

Why did you move this into llvm_test_executable()? It wasn't present for singlesource tests before. It also would have been a nice test to use the returned target name inside llvm_multisource() and apply target_include_directories() on that.

174

see above.

[tra]

cmake/modules/SingleMultiSource.cmake

45–49

OK.

129

llvm_*source() are macros, so is llvm_test_excutable therefore PARENT_SCOPE is not needed here.

143–144

I was trying to make default compilation flags identical for both llvm_*source() variants.
I can easily move it back to llvm_multisource, if you prefer.

[tra]

Addressed MatzeB@'s comments

llvm_test_executable tweaks:
now accepts TARGETS parameter with a name of variable to append names of generated targets.
Global llvm_target_prefix is gone. Instead llvm_test_executable now accept PREFIX
parameter to prepend to executable name if we need to avoid name clashes.

[MatzeB]

LGTM, with one more comment below:

cmake/modules/SingleMultiSource.cmake

202–204

Shouldn't this be like:

llvm_test_executable(${executable} ${sources} TARGETS ${target})
target_include_directories(${target} ...)

[tra]

Rebased on top of recent HEAD.

[tra]

Addressed MatzeB@'s comment.

Record target name right after we've created it.
Check whether we've created a target before using it to add include directories.

[tra]

• prefix local variables in macros.
• check whether we've created a target before using it.
• reset TARGET_VAR variable in llvm_test_executable, so end-user does not have to.
• return target info from llvm_multisource. It was previously clobbered.

@MatzeB - I'd appreciate if you could take another look.

[tra]

Use unique prefix for variables set by cmake_parse_arguments() so we don't clobber them by accident.
Updated Bitcode/simd_ops to use TARGET_VAR to figure out target name.

SingleSource/Benchmarks/Shootout-C++/CMakeLists.txt

-llvm_target_prefix("shootout-cxx")
 list(APPEND CXXFLAGS -Wno-deprecated)
 list(APPEND CPPFLAGS -Wno-deprecated)
 set(FP_TOLERANCE 0.00000001)
 if(ARCH STREQUAL "XCore")
   if(NOT DEFINED SMALL_PROBLEM_SIZE)
     set(XCORE_TARGET_NEEDS_MEMORY 256)
     set(RUNTIMELIMIT 10800)
   endif()
 endif()
 if(TEST_SUITE_BENCHMARKING_ONLY)
   list(APPEND PROGRAMS_TO_SKIP hello reversefile spellcheck sumcol wc wordfreq)
 endif()
 list(APPEND LDFLAGS -lstdc++ -lm)
 if(TARGET_OS STREQUAL "Darwin")
   # Necessary for ackermann on iOS
   list(APPEND LDFLAGS -Xlinker -stack_size -Xlinker 0x800000)
 endif()
-llvm_singlesource()
+llvm_singlesource(PREFIX "shootout-cxx")
 
 llvm_add_subdirectories(EH)

SingleSource/Benchmarks/Shootout/CMakeLists.txt

-llvm_target_prefix("shootout")
 list(APPEND LDFLAGS -lm)
 if(ARCH STREQUAL "XCore")
   set(XCORE_TARGET_NEEDS_MEMORY 256)
 endif()
 if(TEST_SUITE_BENCHMARKING_ONLY)
   list(APPEND PROGRAMS_TO_SKIP hello)
 endif()
-llvm_singlesource()
+llvm_singlesource(PREFIX "shootout")

SingleSource/Regression/C++/CMakeLists.txt

-llvm_target_prefix("regression-cxx")
 list(APPEND LDFLAGS -lstdc++)
-llvm_singlesource()
+llvm_singlesource(PREFIX "regression-cxx")
 
 llvm_add_subdirectories(EH)

SingleSource/Regression/C/CMakeLists.txt

-llvm_target_prefix("regression-c")
 if(ARCH STREQUAL "x86")
   if(DEFINED USE_REFERENCE_OUTPUT)
     set(EXEC_XFAILS casts)
   endif()
 endif()
 list(APPEND LDFLAGS -lm)
-llvm_singlesource()
+llvm_singlesource(PREFIX "regression-c")

SingleSource/UnitTests/Vector/CMakeLists.txt

-llvm_target_prefix("Vector")
 if(ARCH STREQUAL "PowerPC")
   llvm_add_subdirectories(Altivec)
 endif()
 if(ARCH STREQUAL "x86")
   llvm_add_subdirectories(SSE)
 endif()
 if(NOT "${CC_UNDER_TEST_TARGET_IS_THUMBV7}" STREQUAL "")
   llvm_add_subdirectories(NEON)
 endif()
 if(ARCH STREQUAL "AArch64")
   llvm_add_subdirectories(NEON AArch64)
 endif()
 if(NOT DEFINED CC_UNDER_TEST_IS_CLANG)
   set(PROGRAMS_TO_SKIP constpool)
 endif()
 if(ARCH STREQUAL "XCore")
   if(NOT DEFINED SMALL_PROBLEM_SIZE)
     set(RUNTIMELIMIT 7200)
   endif()
 endif()
-llvm_singlesource()
+llvm_singlesource(PREFIX "Vector")

SingleSource/UnitTests/Vector/NEON/CMakeLists.txt

-llvm_target_prefix("Vector-NEON")
 list(APPEND CFLAGS -std=c99)
-llvm_singlesource()
+llvm_singlesource(PREFIX "Vector-NEON")

cmake/modules/SingleMultiSource.cmake

 ##===- SingleMultiSource.cmake --------------------------------------------===##
 #
 # Defines helpers to add executables and tests. The entry points to this
 # file are:
-#   `llvm_singlesource()` and
+#   `llvm_test_executable(executable [PREFIX p] [TARGETS VarName] sources...)`,
+#   `llvm_singlesource([PREFIX p] [TARGETS VarName])`, and
 #   `llvm_multisource()`
 #
-# Each is a macro that uses the environment it was called in to determine
-# what to build and how, and generates a test file that can be given to LIT.
-# The test file is generated at configure time.
+# llvm_test_executable(name [PREFIX p] [TARGETS Var] sources...)
+#   Main macro for test creation.
+#   name -- base name for the test target to create
+#   PREFIX p - executable name prefix
+#   TARGETS VarName - append target name to ${VarName}
+#   source.. -- list of files to compile.
+#
+# Following convenience macros provide shortcuts for common test cases:
+#
+# llvm_singlesource([PREFIX p] [TARGETS Var] [sources...])
+#
+#   Invokes llvm_test_executable() for each c/c++ source file.  If
+#   sources is empty, creates test executables for all C/C++ files in
+#   current directory, except for those listed in PROGRAMS_TO_SKIP.
+#   Passes optional PREFIX and TARGETS parameters through to
+#   llvm_test_executable().
+#
+# llvm_multisource(executable)
+#   Invokes llvm_test_executable(executable [sources...])
+#
+# Variables that control target generation:
+#   PROGRAMS_TO_SKIP - list of base names of executalbes to skip.
 #
 ##===----------------------------------------------------------------------===##
 
 include(TestFile)
 
 
-# Set unique target prefix within caller's scope.
-function(llvm_target_prefix prefix)
-  if(prefix)
-    set(TARGET_PREFIX "${prefix}-" PARENT_SCOPE)
-  else()
-    set(TARGET_PREFIX "" PARENT_SCOPE)
-  endif()
-endfunction()
-
-# Given a source file name after which a test should be named, create a unique
-# name for the test. Usually this is just the source file with the suffix
-# stripped, and ${TARGET_PREFIX} prepended.
-function(get_unique_exe_name new_name main_src)
-  string(REGEX REPLACE ".[cp]+$" "" path ${main_src})
-  get_filename_component(name ${path} NAME )
-
-  set(${new_name} "${TARGET_PREFIX}${name}" PARENT_SCOPE)
-endfunction()
+# Sets Var to ${name} with directory and shortest extension removed.
+macro(basename Var name)
+  # strip directory name
+  get_filename_component(_filename ${name} NAME)
+  # remove shortest extension.
+  string(REGEX REPLACE "\\.[^.]*$" "" ${Var} ${_filename})
+endmacro()
 
 # Add flags to a cmake target property.
 macro(append_target_flags propertyname target)
   if(NOT "${ARGN}" STREQUAL "")
     get_target_property(old_flags ${target} ${propertyname})
     if(${old_flags} STREQUAL "old_flags-NOTFOUND")
       set(old_flags)
     endif()
     # Transform ${ARGN} which is a cmake list into a series of commandline
     # arguments. This requires some shell quoting (the approach here isn't
     # perfect)
     string(REPLACE " " "\\ " quoted "${ARGN}")
     string(REPLACE "\"" "\\\"" quoted "${quoted}")
     string(REPLACE ";" " " quoted "${quoted}")
if(NOT DEFINED PROGRAM_IS_NONDETERMINISTIC)
     endif()
     if(REFERENCE_OUTPUT)
       llvm_test_verify("${DIFFPROG} %o ${REFERENCE_OUTPUT}")
     endif()
   endif()
   llvm_add_test(${testfile} ${executable})
 endfunction()
 
-macro(test_suite_add_executable name mainsource)
+macro(llvm_test_executable name)
+  cmake_parse_arguments(_ARG "" "PREFIX;TARGETS" "" ${ARGN})
+  if (_ARG_PREFIX)
+    set(executable "${_ARG_PREFIX}-${name}")
+  else()
+    set(executable ${name})
+  endif()
+  list(FIND PROGRAMS_TO_SKIP ${executable} exe_idx)
   list(FIND PROGRAMS_TO_SKIP ${name} name_idx)
   # Should we skip this?
-  if(${name_idx} EQUAL -1)
-    get_unique_exe_name(executable ${mainsource})
-    add_executable(${executable} ${ARGN})
+  if(${name_idx} EQUAL -1 AND ${exe_idx} EQUAL -1)
+    add_executable(${executable} ${_ARG_UNPARSED_ARGUMENTS})
     append_compile_flags(${executable} ${CFLAGS})
     append_compile_flags(${executable} ${CPPFLAGS})
     append_compile_flags(${executable} ${CXXFLAGS})
     # Note that we cannot use target_link_libraries() here because that one
     # only interprets inputs starting with '-' as flags.
     append_link_flags(${executable} ${LDFLAGS})
     set(executable_path ${CMAKE_CURRENT_BINARY_DIR}/${executable})
     if (TEST_SUITE_PROFILE_USE)
       append_compile_flags(${executable} -fprofile-instr-use=${executable_path}.profdata)
       append_link_flags(${executable} -fprofile-instr-use=${executable_path}.profdata)
     endif()
 
     set_property(GLOBAL APPEND PROPERTY TEST_SUITE_TARGETS ${executable})
 
     # Fall back to old style involving RUN_OPTIONS and STDIN_FILENAME if
     # llvm_test_run() was not called yet.
     if(NOT TESTSCRIPT)
       llvm_test_traditional(${executable_path}.test ${executable_path} ${name})
     else()
       llvm_add_test(${executable_path}.test ${executable_path})
     endif()
     if (NOT TEST_SUITE_USE_PERF)
       add_dependencies(${executable} timeit-target)
     endif()
     add_dependencies(${executable} timeit-host fpcmp-host)
+    if (_ARG_TARGETS)
+      list(APPEND ${_ARG_TARGETS} ${executable})
+    endif()
   endif()
 endmacro()
 
 # Configure the current directory as a SingleSource subdirectory - i.e. every
 # file in *.{c,cpp,cc} is treated as its own test.
 macro(llvm_singlesource)
+  cmake_parse_arguments(_ARG "" "PREFIX;TARGETS" "" ${ARGN})
+  set(_extra_args)
+  if (_ARG_PREFIX)
+    list(APPEND _extra_args PREFIX ${_ARG_PREFIX})
+  endif()
+  if (_ARG_TARGETS)
+    list(APPEND _extra_args TARGETS ${_ARG_TARGETS})
+  endif()
   file(GLOB sources *.c *.cpp *.cc)
   foreach(source ${sources})
-    # Find the pure name of the test
-    string(REGEX REPLACE ".[cp]+$" "" path ${source})
-    string(REGEX REPLACE ".*/" "" name ${path})
-
-    test_suite_add_executable(${name} ${source} ${source})
+    basename(name ${source})
+    llvm_test_executable(${name} ${_extra_args} ${source})
   endforeach()
 endmacro()
 
 # Configure the current directory as a MultiSource subdirectory - i.e. there is
 # one test and it consists of all sources in the directory (or a curated list,
 # if Source is defined).
 macro(llvm_multisource)
   if(DEFINED Source)
     set(sources ${Source})
   else()
     file(GLOB sources *.c *.cpp *.cc)
   endif()
   list(LENGTH sources sources_len)
 
   if(sources_len GREATER 0 AND DEFINED PROG)
-    include_directories(${CMAKE_CURRENT_SOURCE_DIR})
-    include_directories(${CMAKE_CURRENT_BINARY_DIR})
-    test_suite_add_executable(${PROG} "${PROG}.c" ${sources})
+    set(executable ${PROG})
+    llvm_test_executable(${executable} ${sources})
+    target_include_directories(${executable} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+    target_include_directories(${executable} PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
   endif()
 endmacro()