[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

27–31 ↗

(On Diff #59145)

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.

138 ↗

(On Diff #59145)

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.

147–148 ↗

(On Diff #59145)

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.

178 ↗

(On Diff #59145)

see above.

[tra]

cmake/modules/SingleMultiSource.cmake

27–31 ↗

(On Diff #59145)

OK.

138 ↗

(On Diff #59145)

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

147–148 ↗

(On Diff #59145)

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 ↗

(On Diff #60405)

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.

test-suite/trunk/Bitcode/simd_ops/CMakeLists.txt

 set_target_properties(simd_ops PROPERTIES LINKER_LANGUAGE CXX)
 
 foreach(sourcebc ${uosources})
   string(REGEX REPLACE ".[cp]+$" "" pathbc ${sourcebc})
   string(REGEX REPLACE ".*/" "" namebc ${pathbc})
   string(REPLACE "." "" namebc ${namebc})
   set(Source ${CMAKE_CURRENT_SOURCE_DIR}/${ARCH}_halide_runtime.bc ${CMAKE_CURRENT_SOURCE_DIR}/${ARCH}_tests/${namebc}.bc ${CMAKE_CURRENT_SOURCE_DIR}/${ARCH}_scalar_tests/scalar_${namebc}.bc)
   set(PROG simd_ops_${namebc})
-  llvm_multisource()
-  target_link_libraries(${PROG} simd_ops)
+  llvm_multisource(TARGET_VAR _target)
+  target_link_libraries(${_target} simd_ops)
 endforeach()
-
-

test-suite/trunk/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)

test-suite/trunk/SingleSource/Benchmarks/Shootout-C++/EH/CMakeLists.txt

 set(REQUIRES_EH_SUPPORT 1)
 list(APPEND LDFLAGS -lstdc++)
-llvm_singlesource()
+llvm_singlesource(PREFIX "shootout-cxx")

test-suite/trunk/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")

test-suite/trunk/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)

test-suite/trunk/SingleSource/Regression/C++/EH/CMakeLists.txt

 set(REQUIRES_EH_SUPPORT 1)
 list(APPEND LDFLAGS -lstdc++)
-llvm_singlesource()
+llvm_singlesource(PREFIX "regression-cxx")

test-suite/trunk/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")

test-suite/trunk/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")

test-suite/trunk/SingleSource/UnitTests/Vector/NEON/CMakeLists.txt

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

test-suite/trunk/SingleSource/UnitTests/Vector/SSE/CMakeLists.txt

 set(FP_TOLERANCE 0.016)
 list(APPEND LDFLAGS -lm)
 list(APPEND TARGET_FLAGS -msse2)
 list(APPEND LCCFLAGS -msse2)
-llvm_singlesource()
+llvm_singlesource(PREFIX "Vector")

test-suite/trunk/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] [TARGET_VAR 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] [TARGET_VAR Var] sources...)
+#   Main macro for test creation.
+#   name -- base name for the test target to create
+#   PREFIX p - executable name prefix
+#   TARGET_VAR VarName - set ${VarName} = new target name
+#   source.. -- list of files to compile.
+#
+# Following convenience macros provide shortcuts for common test cases:
+#
+# llvm_singlesource([PREFIX p] [TARGET_VAR Var] [sources...])
+#
+#   Invokes llvm_test_executable() for each c/c++ source file.  If
+#   'sources is emptyno sources are specified, creates test executables
+#   for all C/C++ files in current directory, except for those
+#   listed in PROGRAMS_TO_SKIP.
+#   Passes optional PREFIX parameter to llvm_test_executable().
+#   If optional TARGET_VAR is specified, the variable is set to
+#   list of all created targets.
+#
+# 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()

 
 macro (test_suite_add_build_dependencies executable)
   if (NOT TEST_SUITE_USE_PERF)
     add_dependencies(${executable} timeit-target)
   endif()
   add_dependencies(${executable} timeit-host fpcmp-host)
 endmacro()
 
-macro(test_suite_add_executable name mainsource)
+macro(llvm_test_executable name)
+  cmake_parse_arguments(_LTARG "" "PREFIX;TARGET_VAR" "" ${ARGN})
+  if (_LTARG_PREFIX)
+    set(executable "${_LTARG_PREFIX}-${name}")
+  else()
+    set(executable ${name})
+  endif()
+  unset("${_LTARG_TARGET_VAR}")
+  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} ${_LTARG_UNPARSED_ARGUMENTS})
+    if (_LTARG_TARGET_VAR)
+      set(${_LTARG_TARGET_VAR} ${executable})
+    endif()
     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)
if(${name_idx} EQUAL -1 AND ${exe_idx} EQUAL -1)
     endif()
     test_suite_add_build_dependencies(${executable})
   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(_LSARG "" "PREFIX;TARGET_VAR" "" ${ARGN})
+  unset(_llvm_singlesource_extra_args)
+  if (_LSARG_PREFIX)
+    list(APPEND _llvm_singlesource_extra_args PREFIX ${_LSARG_PREFIX})
+  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} TARGET_VAR _llvm_single_source_target
+      ${_llvm_singlesource_extra_args} ${source})
+    if (_LSARG_TARGET_VAR AND _llvm_single_source_target)
+      list(APPEND ${_LSARG_TARGET_VAR} ${_llvm_single_source_target})
+    endif()
   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)
+  cmake_parse_arguments(_LMARG "" "PREFIX;TARGET_VAR" "" ${ARGN})
   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}
+      PREFIX ${_LMARG_PREFIX}
+      TARGET_VAR _llvm_multisource_target)
+    if(_llvm_multisource_target)
+      target_include_directories(${_llvm_multisource_target}
+        PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
+    endif()
+    if (_LMARG_TARGET_VAR AND _llvm_multisource_target)
+      set(${_LMARG_TARGET_VAR} ${_llvm_multisource_target})
+    endif()
   endif()
 endmacro()