[test-suite, CUDA] Make sure we use the thrust library from test external dir.

[tra]

Summary

CUDA SDK comes with its own copy of thrust in its includes. In order to
guarantee that our thrust tests pick up the headers from the right place,
we need to ensure that thrust include paths precede any explicit CUDA
include paths.

test-suite/trunk/External/CUDA/CMakeLists.txt

if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${Name}.reference_output)
     set(NO_REFERENCE_OUTPUT 1)
     set(REFERENCE_OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/${Name}.reference_output)
     llvm_test_traditional(${_executable})
   else()
     # otherwise just run the executable.
     llvm_test_run()
   endif()
   llvm_test_executable(${_executable} ${_sources})
+  target_compile_options(${_executable} PUBLIC ${VariantCPPFLAGS})
   if(VariantLibs)
     target_link_libraries(${_executable} ${VariantLibs})
   endif()
   add_dependencies(cuda-tests-simple-${VariantSuffix} ${_executable})
   # Local tests are presumed to be fast.
   list(APPEND CUDA_SIMPLE_TEST_TARGETS ${_executable}.test)
 endmacro()
 

 endmacro()
 
 macro(create_one_thrust_test TestSource)
   thrust_make_test_name(_TestName ${TestSourcePath})
   set(_executable thrust-${_TestName}-${VariantSuffix})
   llvm_test_run(--verbose ${_ExtraThrustTestArgs})
   llvm_test_executable(${_executable} ${TestSource})
   target_link_libraries(${_executable} ${VariantLibs})
-  target_compile_options(${_executable} PUBLIC ${THRUST_CPPFLAGS})
+  target_compile_options(${_executable} BEFORE PUBLIC ${THRUST_CPPFLAGS})
+  target_compile_options(${_executable} PUBLIC ${VariantCPPFLAGS})
   list(APPEND THRUST_VARIANT_TESTS ${_executable})
 endmacro()
 
 function(create_thrust_tests VariantSuffix)
   set(_ThrustMainTarget cuda-tests-thrust-${VariantSuffix})
   if(LARGE_PROBLEM_SIZE)
     set(_ExtraThrustTestArgs "--sizes=large")
   endif()
   if(THRUST_SPLIT_TESTS)
     # test framework is common for all tests, so we build it once as a
     # library.
     add_library(ThrustTestFrameworkLib-${VariantSuffix} STATIC ${ThrustTestFramework})
-    append_compile_flags(ThrustTestFrameworkLib-${VariantSuffix} ${CPPFLAGS} ${THRUST_CPPFLAGS})
+    target_compile_options(ThrustTestFrameworkLib-${VariantSuffix} BEFORE PRIVATE ${THRUST_CPPFLAGS})
+    target_compile_options(ThrustTestFrameworkLib-${VariantSuffix} PRIVATE ${VariantCPPFLAGS})
     add_dependencies(ThrustTestFrameworkLib-${VariantSuffix} timeit-host fpcmp-host)
     list(APPEND VariantLibs ThrustTestFrameworkLib-${VariantSuffix})
 
     # Create individual test executable per test source file. This
     # stresses cmake -- it consumes tons of memory and takes forever
     # to finish.
     foreach(TestSourcePath IN LISTS ThrustAllTestSources)
       create_one_thrust_test(${TestSourcePath})
     endforeach()
     # Create target to build all thrust tests for this variant
     add_custom_target(${_ThrustMainTarget} DEPENDS ${THRUST_VARIANT_TESTS}
       COMMENT "Build CUDA test variant ${VariantSuffix}")
   else()
     # Single monolitic test executable. Alas this stresses linker
     # during debug build. Final executable may end up being too large
     # to link.
     # We can create one test script per thrust test, but running
     # thrust tests in parallel is bottlenecked by GPU and startup
     # overhead, so it's actually way slower than running all tests
     # sequentially.
     llvm_test_run(--verbose ${_ExtraThrustTestArgs})
+    # CUDA SDK comes with its own version of thrust in its include directory.
+    # In order to use the thrust library we want, its include path must precede
+    # that of the CUDA SDK include path.
     llvm_test_executable(${_ThrustMainTarget} ${ThrustTestFramework} ${ThrustAllTestSources})
-    target_compile_options(${_ThrustMainTarget} PUBLIC ${THRUST_CPPFLAGS})
+    target_compile_options(${_ThrustMainTarget} BEFORE PUBLIC ${THRUST_CPPFLAGS})
+    target_compile_options(${_executable} PUBLIC ${VariantCPPFLAGS})
     target_link_libraries(${_ThrustMainTarget} ${VariantLibs})
   endif()
   add_dependencies(cuda-tests-${VariantSuffix} cuda-tests-thrust-${VariantSuffix})
   add_dependencies(cuda-tests-thrust ${_ThrustMainTarget})
 endfunction()
 
 # Create set of tests for a given {CUDA,C++ standard,C++ library} tuple.
 function(create_cuda_test_variant Std VariantSuffix)
   message(STATUS "Creating CUDA test variant ${VariantSuffix}")
   add_custom_target(cuda-tests-${VariantSuffix}
     COMMENT "Build CUDA test variant ${VariantSuffix}")
 
   set(VariantLibs ${_Cuda_Libs} ${_Stdlib_Libs})
-  list(APPEND CPPFLAGS ${_Cuda_CPPFLAGS} ${_Std_CPPFLAGS} ${_Stdlib_CPPFLAGS})
+  set(VariantCPPFLAGS ${_Cuda_CPPFLAGS} ${_Std_CPPFLAGS} ${_Stdlib_CPPFLAGS})
   list(APPEND LDFLAGS ${_Cuda_LDFLAGS} ${_Std_LDFLAGS} ${_Stdlib_LDFLAGS})
 
   # Create a separate test target for simple tests that can be built/tested quickly.
   add_custom_target(cuda-tests-simple-${VariantSuffix}
     COMMENT "Build Simple CUDA tests for ${VariantSuffix}")
   create_local_cuda_tests(${VariantSuffix})
   add_dependencies(cuda-tests-simple cuda-tests-simple-${VariantSuffix})