Hello community, here is the log from the commit of package Vc for openSUSE:Factory checked in at 2015-10-08 08:25:28 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/Vc (Old) and /work/SRC/openSUSE:Factory/.Vc.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "Vc" Changes: -------- --- /work/SRC/openSUSE:Factory/Vc/Vc.changes 2015-09-13 09:45:27.000000000 +0200 +++ /work/SRC/openSUSE:Factory/.Vc.new/Vc.changes 2015-10-08 08:25:30.000000000 +0200 @@ -1,0 +2,15 @@ +Tue Oct 6 17:57:11 UTC 2015 - [email protected] + +- Update to 0.7.5: + * compilation warnings fixed + * detect Haswell and Broadwell CPUs (#6) + * bugfix: AVX::Mask::operator== returned incorrect answers on a + few masks + * more thorough mask testing + * detect and work around clang 3.6 bug with AVX codegen (#20) + * subscript workaround for GCC 5.1 and 5.2 (#9) + * merge vc_compile_for_all_implementations from master, making it + more robust + * fix isfinite usage with ICC (#8) + +------------------------------------------------------------------- Old: ---- Vc-0.7.4.tar.gz New: ---- Vc-0.7.5.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ Vc.spec ++++++ --- /var/tmp/diff_new_pack.yVbWlE/_old 2015-10-08 08:25:30.000000000 +0200 +++ /var/tmp/diff_new_pack.yVbWlE/_new 2015-10-08 08:25:30.000000000 +0200 @@ -18,13 +18,13 @@ Name: Vc -Version: 0.7.4 +Version: 0.7.5 Release: 0 Summary: Collection of SIMD Vector Classes License: LGPL-3.0+ and GPL-3.0+ Group: System/Libraries -Url: http://code.compeng.uni-frankfurt.de/projects/vc/ -Source0: http://code.compeng.uni-frankfurt.de/attachments/download/183/%{name}-%{version}.tar.gz +Url: https://github.com/VcDevel/Vc/ +Source0: https://github.com/VcDevel/Vc/releases/download/%{version}/%{name}-%{version}.tar.gz BuildRequires: cmake BuildRequires: doxygen BuildRequires: fdupes ++++++ Vc-0.7.4.tar.gz -> Vc-0.7.5.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/CMakeLists.txt new/Vc-0.7.5/CMakeLists.txt --- old/Vc-0.7.4/CMakeLists.txt 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/CMakeLists.txt 2015-08-26 15:22:18.000000000 +0200 @@ -128,11 +128,10 @@ set(libvc_compile_flags "-DVC_COMPILE_LIB") AddCompilerFlag("-fPIC" CXX_FLAGS libvc_compile_flags) - vc_compile_for_all_implementations(_objs src/trigonometric.cpp FLAGS ${libvc_compile_flags} + set(_srcs src/const.cpp src/cpuid.cpp src/support.cpp) + vc_compile_for_all_implementations(_srcs src/trigonometric.cpp FLAGS ${libvc_compile_flags} ONLY SSE2 SSE3 SSSE3 SSE4_1 AVX SSE+XOP+FMA4 AVX+XOP+FMA4 AVX+XOP+FMA AVX+FMA) - set(_srcs src/const.cpp src/cpuid.cpp src/support.cpp ${_objs}) - vc_compile_for_all_implementations(_objs src/avx_sorthelper.cpp FLAGS ${libvc_compile_flags} ONLY AVX) - set(_srcs ${_srcs} ${_objs}) + vc_compile_for_all_implementations(_srcs src/avx_sorthelper.cpp FLAGS ${libvc_compile_flags} ONLY AVX) add_library(Vc STATIC ${_srcs}) add_target_property(Vc COMPILE_FLAGS ${libvc_compile_flags}) add_target_property(Vc LABELS "other") @@ -250,7 +249,6 @@ include (CTest) configure_file(${CMAKE_SOURCE_DIR}/CTestCustom.cmake ${CMAKE_BINARY_DIR}/CTestCustom.cmake COPYONLY) if(BUILD_TESTING) - add_custom_target(build_tests VERBATIM) add_subdirectory(tests) endif(BUILD_TESTING) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/CTestConfig.cmake new/Vc-0.7.5/CTestConfig.cmake --- old/Vc-0.7.4/CTestConfig.cmake 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/CTestConfig.cmake 2015-08-26 15:22:18.000000000 +0200 @@ -1,9 +1,9 @@ set(CTEST_PROJECT_NAME "Vc") set(CTEST_NIGHTLY_START_TIME "00:00:00 CEST") -set(CTEST_DROP_METHOD "http") -set(CTEST_DROP_SITE "code.compeng.uni-frankfurt.de") -set(CTEST_DROP_LOCATION "/dashboard/submit.php?project=Vc-0.7") +set(CTEST_DROP_METHOD "https") +set(CTEST_DROP_SITE "cdash.gsi.de") +set(CTEST_DROP_LOCATION "/submit.php?project=Vc") set(CTEST_DROP_SITE_CDASH TRUE) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/CTestCustom.cmake new/Vc-0.7.5/CTestCustom.cmake --- old/Vc-0.7.4/CTestCustom.cmake 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/CTestCustom.cmake 2015-08-26 15:22:18.000000000 +0200 @@ -23,4 +23,4 @@ set(CTEST_CUSTOM_ERROR_EXCEPTION ${CTEST_CUSTOM_ERROR_EXCEPTION} "^make\\[[1-9]\\]: " "^collect2: ld returned . exit status" - "^make: \\*\\*\\* \\[all\\] Error ") + "^make: \\*\\*\\* \\[.*\\] Error ") diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/avx/debug.h new/Vc-0.7.5/avx/debug.h --- old/Vc-0.7.4/avx/debug.h 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/avx/debug.h 2015-08-26 15:22:18.000000000 +0200 @@ -45,7 +45,7 @@ private: template<typename T, typename V> static void printVector(V _x) { - enum { Size = sizeof(V) / sizeof(T) }; + enum JustSomeName__ { Size = sizeof(V) / sizeof(T) }; union { V v; T m[Size]; } x = { _x }; std::cerr << '[' << std::setprecision(24) << x.m[0]; for (int i = 1; i < Size; ++i) { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/avx/mask.h new/Vc-0.7.5/avx/mask.h --- old/Vc-0.7.4/avx/mask.h 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/avx/mask.h 2015-08-26 15:22:18.000000000 +0200 @@ -65,8 +65,8 @@ Vc_ALWAYS_INLINE_L Mask(const Mask<VectorSize * 2, 32u> &m) Vc_ALWAYS_INLINE_R; Vc_ALWAYS_INLINE_L Mask(const Mask<VectorSize / 2, 32u> &m) Vc_ALWAYS_INLINE_R; - Vc_ALWAYS_INLINE bool operator==(const Mask &rhs) const { return 0 != _mm256_testc_ps(k, rhs.k); } - Vc_ALWAYS_INLINE bool operator!=(const Mask &rhs) const { return 0 == _mm256_testc_ps(k, rhs.k); } + Vc_ALWAYS_INLINE bool operator==(const Mask &rhs) const { return _mm256_movemask_ps(k) == _mm256_movemask_ps(rhs.k); } + Vc_ALWAYS_INLINE bool operator!=(const Mask &rhs) const { return _mm256_movemask_ps(k) != _mm256_movemask_ps(rhs.k); } Vc_ALWAYS_INLINE Mask operator!() const { return _mm256_andnot_ps(data(), _mm256_setallone_ps()); } @@ -137,8 +137,8 @@ Vc_ALWAYS_INLINE Mask(const Mask<VectorSize / 2, 16u> *a) : k(avx_cast<m128>( _mm_packs_epi16(a[0].dataI(), a[1].dataI()))) {} - Vc_ALWAYS_INLINE bool operator==(const Mask &rhs) const { return 0 != _mm_testc_si128(dataI(), rhs.dataI()); } - Vc_ALWAYS_INLINE bool operator!=(const Mask &rhs) const { return 0 == _mm_testc_si128(dataI(), rhs.dataI()); } + Vc_ALWAYS_INLINE bool operator==(const Mask &rhs) const { return _mm_movemask_epi8(dataI()) == _mm_movemask_epi8(rhs.dataI()); } + Vc_ALWAYS_INLINE bool operator!=(const Mask &rhs) const { return _mm_movemask_epi8(dataI()) != _mm_movemask_epi8(rhs.dataI()); } Vc_ALWAYS_INLINE Mask operator!() const { return _mm_andnot_ps(data(), _mm_setallone_ps()); } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/avx/prefetches.tcc new/Vc-0.7.5/avx/prefetches.tcc --- old/Vc-0.7.4/avx/prefetches.tcc 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/avx/prefetches.tcc 2015-08-26 15:22:18.000000000 +0200 @@ -20,6 +20,12 @@ #ifndef VC_AVX_PREFETCHES_TCC #define VC_AVX_PREFETCHES_TCC +#ifdef __3dNOW__ +extern "C" { +#include <mm3dnow.h> +} +#endif + /*OUTER_NAMESPACE_BEGIN*/ namespace Vc { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/avx/shuffle.h new/Vc-0.7.5/avx/shuffle.h --- old/Vc-0.7.4/avx/shuffle.h 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/avx/shuffle.h 2015-08-26 15:22:18.000000000 +0200 @@ -114,7 +114,7 @@ static Vc_ALWAYS_INLINE m256i Vc_CONST blend(param256i x, param256i y) { return _mm256_castps_si256(blend<Dst0, Dst1, Dst2, Dst3, Dst4, Dst5, Dst6, Dst7>(_mm256_castsi256_ps(x), _mm256_castsi256_ps(y))); } - template<VecPos Dst> struct ScaleForBlend { enum { Value = Dst >= X4 ? Dst - X4 + Y0 : Dst }; }; + template<VecPos Dst> struct ScaleForBlend { enum JustSomeName__ { Value = Dst >= X4 ? Dst - X4 + Y0 : Dst }; }; template<VecPos Dst0, VecPos Dst1, VecPos Dst2, VecPos Dst3, VecPos Dst4, VecPos Dst5, VecPos Dst6, VecPos Dst7> static Vc_ALWAYS_INLINE m256 Vc_CONST permute(param256 x) { VC_STATIC_ASSERT(Dst0 >= X0 && Dst0 <= X7, Incorrect_Range); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/avx/types.h new/Vc-0.7.5/avx/types.h --- old/Vc-0.7.4/avx/types.h 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/avx/types.h 2015-08-26 15:22:18.000000000 +0200 @@ -77,8 +77,8 @@ template<> struct SseVectorType<m128i> { typedef m128i Type; }; template<> struct SseVectorType<m128d> { typedef m128d Type; }; - template<typename T> struct HasVectorDivisionHelper { enum { Value = 1 }; }; - //template<> struct HasVectorDivisionHelper<unsigned int> { enum { Value = 0 }; }; + template<typename T> struct HasVectorDivisionHelper { enum JustSomeName__ { Value = 1 }; }; + //template<> struct HasVectorDivisionHelper<unsigned int> { enum JustSomeName__ { Value = 0 }; }; template<typename T> struct VectorHelperSize; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/avx/vector.tcc new/Vc-0.7.5/avx/vector.tcc --- old/Vc-0.7.4/avx/vector.tcc 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/avx/vector.tcc 2015-08-26 15:22:18.000000000 +0200 @@ -568,6 +568,22 @@ OP_IMPL(double, ^, xor_) #undef OP_IMPL +// subscript operators {{{1 +#if defined(VC_GCC) && VC_GCC >= 0x50000 && VC_GCC <= 0x50200 +template <> Vc_ALWAYS_INLINE short_v::EntryType short_v::operator[](size_t index) const +{ + ALIGN(sizeof(d)) EntryType tmp[Size]; + store(&tmp[0]); + return tmp[index]; +} +template <> Vc_ALWAYS_INLINE ushort_v::EntryType ushort_v::operator[](size_t index) const +{ + ALIGN(sizeof(d)) EntryType tmp[Size]; + store(&tmp[0]); + return tmp[index]; +} +#endif + // operators {{{1 #include "../common/operators.h" // isNegative {{{1 @@ -1286,7 +1302,7 @@ }; template<typename VectorType, typename EntryType> struct VectorShift<16, 8, VectorType, EntryType> { - enum { + enum JustSomeName__ { EntryTypeSizeof = sizeof(EntryType) }; static Vc_INTRINSIC VectorType shifted(VC_ALIGNED_PARAMETER(VectorType) v, int amount) @@ -1319,7 +1335,7 @@ template<typename VectorType, typename EntryType> struct VectorRotate<32, 4, VectorType, EntryType> { typedef typename SseVectorType<VectorType>::Type SmallV; - enum { + enum JustSomeName__ { EntryTypeSizeof = sizeof(EntryType) }; static Vc_INTRINSIC VectorType rotated(VC_ALIGNED_PARAMETER(VectorType) v, int amount) @@ -1338,7 +1354,7 @@ template<typename VectorType, typename EntryType> struct VectorRotate<32, 8, VectorType, EntryType> { typedef typename SseVectorType<VectorType>::Type SmallV; - enum { + enum JustSomeName__ { EntryTypeSizeof = sizeof(EntryType) }; static Vc_INTRINSIC VectorType rotated(VC_ALIGNED_PARAMETER(VectorType) v, int amount) @@ -1360,7 +1376,7 @@ }; template<typename VectorType, typename EntryType> struct VectorRotate<16, 8, VectorType, EntryType> { - enum { + enum JustSomeName__ { EntryTypeSizeof = sizeof(EntryType) }; static Vc_INTRINSIC VectorType rotated(VC_ALIGNED_PARAMETER(VectorType) v, int amount) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/cmake/OptimizeForArchitecture.cmake new/Vc-0.7.5/cmake/OptimizeForArchitecture.cmake --- old/Vc-0.7.4/cmake/OptimizeForArchitecture.cmake 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/cmake/OptimizeForArchitecture.cmake 2015-08-26 15:22:18.000000000 +0200 @@ -1,5 +1,23 @@ +# Determine the host CPU feature set and determine the best set of compiler +# flags to enable all supported SIMD relevant features. Alternatively, the +# target CPU can be explicitly selected (for generating more generic binaries +# or for targeting a different system). +# Compilers provide e.g. the -march=native flag to achieve a similar result. +# This fails to address the need for building for a different microarchitecture +# than the current host. +# The script tries to deduce all settings from the model and family numbers of +# the CPU instead of reading the CPUID flags from e.g. /proc/cpuinfo. This makes +# the detection more independent from the CPUID code in the kernel (e.g. avx2 is +# not listed on older kernels). +# +# Usage: +# OptimizeForArchitecture() +# If either of Vc_SSE_INTRINSICS_BROKEN, Vc_AVX_INTRINSICS_BROKEN, +# Vc_AVX2_INTRINSICS_BROKEN is defined and set, the OptimizeForArchitecture +# macro will consequently disable the relevant features via compiler flags. + #============================================================================= -# Copyright 2010-2013 Matthias Kretz <[email protected]> +# Copyright 2010-2015 Matthias Kretz <[email protected]> # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are @@ -71,8 +89,14 @@ if(_vendor_id STREQUAL "GenuineIntel") if(_cpu_family EQUAL 6) # Any recent Intel CPU except NetBurst - if(_cpu_model EQUAL 62) + if(_cpu_model EQUAL 63) # e.g. Xeon E5 2660 v3 + set(TARGET_ARCHITECTURE "haswell") + elseif(_cpu_model EQUAL 62) set(TARGET_ARCHITECTURE "ivy-bridge") + elseif(_cpu_model EQUAL 61) + set(TARGET_ARCHITECTURE "broadwell") + elseif(_cpu_model EQUAL 60) + set(TARGET_ARCHITECTURE "haswell") elseif(_cpu_model EQUAL 58) set(TARGET_ARCHITECTURE "ivy-bridge") elseif(_cpu_model EQUAL 47) # Xeon E7 4860 @@ -142,7 +166,7 @@ endmacro() macro(OptimizeForArchitecture) - set(TARGET_ARCHITECTURE "auto" CACHE STRING "CPU architecture to optimize for. Using an incorrect setting here can result in crashes of the resulting binary because of invalid instructions used.\nSetting the value to \"auto\" will try to optimize for the architecture where cmake is called.\nOther supported values are: \"none\", \"generic\", \"core\", \"merom\" (65nm Core2), \"penryn\" (45nm Core2), \"nehalem\", \"westmere\", \"sandy-bridge\", \"ivy-bridge\", \"atom\", \"k8\", \"k8-sse3\", \"barcelona\", \"istanbul\", \"magny-cours\", \"bulldozer\", \"interlagos\", \"piledriver\", \"AMD 14h\", \"AMD 16h\".") + set(TARGET_ARCHITECTURE "auto" CACHE STRING "CPU architecture to optimize for. Using an incorrect setting here can result in crashes of the resulting binary because of invalid instructions used.\nSetting the value to \"auto\" will try to optimize for the architecture where cmake is called.\nOther supported values are: \"none\", \"generic\", \"core\", \"merom\" (65nm Core2), \"penryn\" (45nm Core2), \"nehalem\", \"westmere\", \"sandy-bridge\", \"ivy-bridge\", \"haswell\", \"broadwell\", \"atom\", \"k8\", \"k8-sse3\", \"barcelona\", \"istanbul\", \"magny-cours\", \"bulldozer\", \"interlagos\", \"piledriver\", \"AMD 14h\", \"AMD 16h\".") set(_force) if(NOT _last_target_arch STREQUAL "${TARGET_ARCHITECTURE}") message(STATUS "target changed from \"${_last_target_arch}\" to \"${TARGET_ARCHITECTURE}\"") @@ -188,6 +212,29 @@ list(APPEND _march_flag_list "corei7") list(APPEND _march_flag_list "core2") list(APPEND _available_vector_units_list "sse" "sse2" "sse3" "ssse3" "sse4.1" "sse4.2") + elseif(TARGET_ARCHITECTURE STREQUAL "broadwell") + list(APPEND _march_flag_list "broadwell") + list(APPEND _march_flag_list "haswell") + list(APPEND _march_flag_list "core-avx2") + list(APPEND _march_flag_list "ivybridge") + list(APPEND _march_flag_list "core-avx-i") + list(APPEND _march_flag_list "sandybridge") + list(APPEND _march_flag_list "corei7-avx") + list(APPEND _march_flag_list "westmere") + list(APPEND _march_flag_list "nehalem") + list(APPEND _march_flag_list "core2") + list(APPEND _available_vector_units_list "sse" "sse2" "sse3" "ssse3" "sse4.1" "sse4.2" "avx" "avx2" "rdrnd" "f16c" "fma" "bmi" "bmi2") + elseif(TARGET_ARCHITECTURE STREQUAL "haswell") + list(APPEND _march_flag_list "haswell") + list(APPEND _march_flag_list "core-avx2") + list(APPEND _march_flag_list "ivybridge") + list(APPEND _march_flag_list "core-avx-i") + list(APPEND _march_flag_list "sandybridge") + list(APPEND _march_flag_list "corei7-avx") + list(APPEND _march_flag_list "westmere") + list(APPEND _march_flag_list "nehalem") + list(APPEND _march_flag_list "core2") + list(APPEND _available_vector_units_list "sse" "sse2" "sse3" "ssse3" "sse4.1" "sse4.2" "avx" "avx2" "rdrnd" "f16c" "fma") elseif(TARGET_ARCHITECTURE STREQUAL "ivy-bridge") list(APPEND _march_flag_list "core-avx-i") list(APPEND _march_flag_list "corei7-avx") @@ -420,7 +467,7 @@ endif(_good) endforeach(_flag) foreach(_flag ${_enable_vector_unit_list}) - AddCompilerFlag("-m${_flag}" CXX_RESULT _result) + AddCompilerFlag("-m${_flag}" CXX_RESULT _result CXX_FLAGS Vc_ARCHITECTURE_FLAGS) if(_result) set(_header FALSE) if(_flag STREQUAL "sse3") diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/cmake/VcMacros.cmake new/Vc-0.7.5/cmake/VcMacros.cmake --- old/Vc-0.7.4/cmake/VcMacros.cmake 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/cmake/VcMacros.cmake 2015-08-26 15:22:18.000000000 +0200 @@ -364,6 +364,9 @@ elseif(Vc_CLANG_VERSION VERSION_EQUAL "3.2" AND NOT APPLE) # the LLVM assembler gets FMAs wrong (bug 15040) vc_add_compiler_flag(Vc_DEFINITIONS "-no-integrated-as") + elseif(Vc_CLANG_VERSION VERSION_GREATER "3.5.99" AND Vc_CLANG_VERSION VERSION_LESS 3.7.0) + UserWarning("Clang 3.6 has serious issues with AVX code generation, frequently losing 50% of the data. AVX is therefore disabled.\nPlease update to a more recent clang version.\n") + set(Vc_AVX_INTRINSICS_BROKEN true) endif() # disable these warnings because clang shows them for function overloads that were discarded via SFINAE @@ -398,59 +401,53 @@ endmacro() # helper macro for vc_compile_for_all_implementations -macro(_vc_compile_one_implementation _objs _impl) +macro(_vc_compile_one_implementation _srcs _impl) list(FIND _disabled_targets "${_impl}" _disabled_index) list(FIND _only_targets "${_impl}" _only_index) if(${_disabled_index} EQUAL -1 AND (NOT _only_targets OR ${_only_index} GREATER -1)) set(_extra_flags) set(_ok FALSE) - foreach(_flag ${ARGN}) - if(_flag STREQUAL "NO_FLAG") + foreach(_flags ${ARGN}) + if(_flags STREQUAL "NO_FLAG") set(_ok TRUE) break() endif() - string(REPLACE " " ";" _flag_list "${_flag}") - foreach(_flag ${_flag_list}) - AddCompilerFlag(${_flag} CXX_RESULT _ok) + string(REPLACE " " ";" _flag_list "${_flags}") + foreach(_f ${_flag_list}) + AddCompilerFlag(${_f} CXX_RESULT _ok) if(NOT _ok) break() endif() endforeach() if(_ok) - set(_extra_flags ${_flag_list}) + set(_extra_flags ${_flags}) break() endif() endforeach() - set(_outfile_flag -c -o) if(Vc_COMPILER_IS_MSVC) # MSVC for 64bit does not recognize /arch:SSE2 anymore. Therefore we set override _ok if _impl # says SSE if("${_impl}" MATCHES "SSE") set(_ok TRUE) endif() - set(_outfile_flag /c /Fo) endif() if(_ok) get_filename_component(_out "${_vc_compile_src}" NAME_WE) get_filename_component(_ext "${_vc_compile_src}" EXT) - if(Vc_COMPILER_IS_MSVC) - set(_out "${_out}_${_impl}${_ext}.obj") - else() - set(_out "${_out}_${_impl}${_ext}.o") - endif() - add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${_out} - COMMAND ${CMAKE_CXX_COMPILER} ${_flags} ${_extra_flags} - -DVC_IMPL=${_impl} - ${_outfile_flag}${_out} ${CMAKE_CURRENT_SOURCE_DIR}/${_vc_compile_src} - MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/${_vc_compile_src} - IMPLICIT_DEPENDS CXX ${CMAKE_CURRENT_SOURCE_DIR}/${_vc_compile_src} - COMMENT "Building CXX object ${_out}" - WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" - VERBATIM - ) - list(APPEND ${_objs} "${CMAKE_CURRENT_BINARY_DIR}/${_out}") + set(_out "${CMAKE_CURRENT_BINARY_DIR}/${_out}_${_impl}${_ext}") + add_custom_command(OUTPUT "${_out}" + COMMAND ${CMAKE_COMMAND} -E copy "${_vc_compile_src}" "${_out}" + MAIN_DEPENDENCY "${_vc_compile_src}" + COMMENT "Copy to ${_out}" + WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + VERBATIM) + set_source_files_properties( "${_out}" PROPERTIES + COMPILE_DEFINITIONS "VC_IMPL=${_impl}" + COMPILE_FLAGS "${_flags} ${_extra_flags}" + ) + list(APPEND ${_srcs} "${_out}") endif() endif() endmacro() @@ -461,19 +458,12 @@ # Example: # vc_compile_for_all_implementations(_objs src/trigonometric.cpp FLAGS -DCOMPILE_BLAH EXCLUDE Scalar) # add_executable(executable main.cpp ${_objs}) -macro(vc_compile_for_all_implementations _objs _src) - set(${_objs}) - - # remove all -march, -msse, etc. flags from the flags we want to pass +macro(vc_compile_for_all_implementations _srcs _src) + # remove all -march, -msse, etc. flags from the flags we want to pass. + # Vc_DEFINITIONS contains important flags, such as "-fabi-version=0" string(REPLACE "${Vc_ARCHITECTURE_FLAGS}" "" _flags "${Vc_DEFINITIONS}") string(REPLACE "-DVC_IMPL=[^ ]*" "" _flags "${_flags}") - # capture the -march= switch as -mtune; if there is none skip it - if(Vc_ARCHITECTURE_FLAGS MATCHES "-march=") - string(REGEX REPLACE "^.*-march=([^ ]*).*$" "-mtune=\\1" _tmp "${Vc_ARCHITECTURE_FLAGS}") - set(_flags "${_flags} ${_tmp}") - endif() - unset(_disabled_targets) unset(_only_targets) set(_state 0) @@ -495,49 +485,27 @@ endif() endforeach() - # make a semicolon separated list of all flags - string(TOUPPER "${CMAKE_BUILD_TYPE}" _tmp) - set(_tmp "CMAKE_CXX_FLAGS_${_tmp}") - string(REPLACE " " ";" _tmp "${CMAKE_CXX_FLAGS} ${${_tmp}} ${_flags}") - set(_flags) - foreach(item ${_tmp}) - if(item MATCHES "^[^']*'[^']*$") - if(_str) - list(APPEND _flags "${_str} ${item}") - unset(_str) - else() - set(_str "${item}") - endif() - else() - list(APPEND _flags "${item}") - endif() - endforeach() - get_directory_property(_inc INCLUDE_DIRECTORIES) - foreach(_i ${_inc}) - list(APPEND _flags "-I${_i}") - endforeach() - set(_vc_compile_src "${_src}") - _vc_compile_one_implementation(${_objs} Scalar NO_FLAG) + _vc_compile_one_implementation(${_srcs} Scalar NO_FLAG) if(NOT Vc_SSE_INTRINSICS_BROKEN) - _vc_compile_one_implementation(${_objs} SSE2 "-msse2" "-xSSE2" "/arch:SSE2") - _vc_compile_one_implementation(${_objs} SSE3 "-msse3" "-xSSE3" "/arch:SSE2") - _vc_compile_one_implementation(${_objs} SSSE3 "-mssse3" "-xSSSE3" "/arch:SSE2") - _vc_compile_one_implementation(${_objs} SSE4_1 "-msse4.1" "-xSSE4.1" "/arch:SSE2") - _vc_compile_one_implementation(${_objs} SSE4_2 "-msse4.2" "-xSSE4.2" "/arch:SSE2") - _vc_compile_one_implementation(${_objs} SSE3+SSE4a "-msse4a") + _vc_compile_one_implementation(${_srcs} SSE2 "-xSSE2" "-msse2" "/arch:SSE2") + _vc_compile_one_implementation(${_srcs} SSE3 "-xSSE3" "-msse3" "/arch:SSE2") + _vc_compile_one_implementation(${_srcs} SSSE3 "-xSSSE3" "-mssse3" "/arch:SSE2") + _vc_compile_one_implementation(${_srcs} SSE4_1 "-xSSE4.1" "-msse4.1" "/arch:SSE2") + _vc_compile_one_implementation(${_srcs} SSE4_2 "-xSSE4.2" "-msse4.2" "/arch:SSE2") + _vc_compile_one_implementation(${_srcs} SSE3+SSE4a "-msse4a") endif() if(NOT Vc_AVX_INTRINSICS_BROKEN) - _vc_compile_one_implementation(${_objs} AVX "-mavx" "-xAVX" "/arch:AVX") + _vc_compile_one_implementation(${_srcs} AVX "-xAVX" "-mavx" "/arch:AVX") if(NOT Vc_XOP_INTRINSICS_BROKEN) if(NOT Vc_FMA4_INTRINSICS_BROKEN) - _vc_compile_one_implementation(${_objs} SSE+XOP+FMA4 "-mxop -mfma4" "" "") - _vc_compile_one_implementation(${_objs} AVX+XOP+FMA4 "-mavx -mxop -mfma4" "" "") + _vc_compile_one_implementation(${_srcs} SSE+XOP+FMA4 "-mxop -mfma4" "" "") + _vc_compile_one_implementation(${_srcs} AVX+XOP+FMA4 "-mavx -mxop -mfma4" "" "") endif() - _vc_compile_one_implementation(${_objs} SSE+XOP+FMA "-mxop -mfma" "" "") - _vc_compile_one_implementation(${_objs} AVX+XOP+FMA "-mavx -mxop -mfma" "" "") + _vc_compile_one_implementation(${_srcs} SSE+XOP+FMA "-mxop -mfma" "" "") + _vc_compile_one_implementation(${_srcs} AVX+XOP+FMA "-mavx -mxop -mfma" "" "") endif() - _vc_compile_one_implementation(${_objs} AVX+FMA "-mavx -mfma" "" "") + _vc_compile_one_implementation(${_srcs} AVX+FMA "-mavx -mfma" "" "") endif() endmacro() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/common/deinterleave.h new/Vc-0.7.5/common/deinterleave.h --- old/Vc-0.7.4/common/deinterleave.h 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/common/deinterleave.h 2015-08-26 15:22:18.000000000 +0200 @@ -29,6 +29,8 @@ /** * \ingroup Vectors * + * \deprecated Turn to InterleavedMemoryWrapper for a more flexible and complete solution. + * * Loads two vectors of values from an interleaved array. * * \param a, b The vectors to load the values from memory into. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/common/fix_clang_emmintrin.h new/Vc-0.7.5/common/fix_clang_emmintrin.h --- old/Vc-0.7.4/common/fix_clang_emmintrin.h 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/common/fix_clang_emmintrin.h 2015-08-26 15:22:18.000000000 +0200 @@ -26,7 +26,7 @@ #include <Vc/global.h> -#ifdef VC_CLANG +#if defined VC_CLANG && VC_CLANG < 0x30400 #ifdef _mm_slli_si128 #undef _mm_slli_si128 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/common/logarithm.h new/Vc-0.7.5/common/logarithm.h --- old/Vc-0.7.4/common/logarithm.h 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/common/logarithm.h 2015-08-26 15:22:18.000000000 +0200 @@ -129,7 +129,7 @@ const V x4 = x2 * x2; // 5 → 9 const V x5 = x2 * x3; // 8 → 12 const V x6 = x3 * x3; // 9 → 13 - const V x7 = x4 * x3; // + const V x7 = x4 * x3; // const V x8 = x4 * x4; const V x9 = x5 * x4; const V x10 = x5 * x5; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/common/macros.h new/Vc-0.7.5/common/macros.h --- old/Vc-0.7.4/common/macros.h 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/common/macros.h 2015-08-26 15:22:18.000000000 +0200 @@ -181,22 +181,22 @@ #endif #define unrolled_loop16(_it_, _start_, _end_, _code_) \ -if (_start_ + 0 < _end_) { enum { _it_ = (_start_ + 0) < _end_ ? (_start_ + 0) : _start_ }; _code_ } \ -if (_start_ + 1 < _end_) { enum { _it_ = (_start_ + 1) < _end_ ? (_start_ + 1) : _start_ }; _code_ } \ -if (_start_ + 2 < _end_) { enum { _it_ = (_start_ + 2) < _end_ ? (_start_ + 2) : _start_ }; _code_ } \ -if (_start_ + 3 < _end_) { enum { _it_ = (_start_ + 3) < _end_ ? (_start_ + 3) : _start_ }; _code_ } \ -if (_start_ + 4 < _end_) { enum { _it_ = (_start_ + 4) < _end_ ? (_start_ + 4) : _start_ }; _code_ } \ -if (_start_ + 5 < _end_) { enum { _it_ = (_start_ + 5) < _end_ ? (_start_ + 5) : _start_ }; _code_ } \ -if (_start_ + 6 < _end_) { enum { _it_ = (_start_ + 6) < _end_ ? (_start_ + 6) : _start_ }; _code_ } \ -if (_start_ + 7 < _end_) { enum { _it_ = (_start_ + 7) < _end_ ? (_start_ + 7) : _start_ }; _code_ } \ -if (_start_ + 8 < _end_) { enum { _it_ = (_start_ + 8) < _end_ ? (_start_ + 8) : _start_ }; _code_ } \ -if (_start_ + 9 < _end_) { enum { _it_ = (_start_ + 9) < _end_ ? (_start_ + 9) : _start_ }; _code_ } \ -if (_start_ + 10 < _end_) { enum { _it_ = (_start_ + 10) < _end_ ? (_start_ + 10) : _start_ }; _code_ } \ -if (_start_ + 11 < _end_) { enum { _it_ = (_start_ + 11) < _end_ ? (_start_ + 11) : _start_ }; _code_ } \ -if (_start_ + 12 < _end_) { enum { _it_ = (_start_ + 12) < _end_ ? (_start_ + 12) : _start_ }; _code_ } \ -if (_start_ + 13 < _end_) { enum { _it_ = (_start_ + 13) < _end_ ? (_start_ + 13) : _start_ }; _code_ } \ -if (_start_ + 14 < _end_) { enum { _it_ = (_start_ + 14) < _end_ ? (_start_ + 14) : _start_ }; _code_ } \ -if (_start_ + 15 < _end_) { enum { _it_ = (_start_ + 15) < _end_ ? (_start_ + 15) : _start_ }; _code_ } \ +if (_start_ + 0 < _end_) { enum JustSomeName__ { _it_ = (_start_ + 0) < _end_ ? (_start_ + 0) : _start_ }; _code_ } \ +if (_start_ + 1 < _end_) { enum JustSomeName__ { _it_ = (_start_ + 1) < _end_ ? (_start_ + 1) : _start_ }; _code_ } \ +if (_start_ + 2 < _end_) { enum JustSomeName__ { _it_ = (_start_ + 2) < _end_ ? (_start_ + 2) : _start_ }; _code_ } \ +if (_start_ + 3 < _end_) { enum JustSomeName__ { _it_ = (_start_ + 3) < _end_ ? (_start_ + 3) : _start_ }; _code_ } \ +if (_start_ + 4 < _end_) { enum JustSomeName__ { _it_ = (_start_ + 4) < _end_ ? (_start_ + 4) : _start_ }; _code_ } \ +if (_start_ + 5 < _end_) { enum JustSomeName__ { _it_ = (_start_ + 5) < _end_ ? (_start_ + 5) : _start_ }; _code_ } \ +if (_start_ + 6 < _end_) { enum JustSomeName__ { _it_ = (_start_ + 6) < _end_ ? (_start_ + 6) : _start_ }; _code_ } \ +if (_start_ + 7 < _end_) { enum JustSomeName__ { _it_ = (_start_ + 7) < _end_ ? (_start_ + 7) : _start_ }; _code_ } \ +if (_start_ + 8 < _end_) { enum JustSomeName__ { _it_ = (_start_ + 8) < _end_ ? (_start_ + 8) : _start_ }; _code_ } \ +if (_start_ + 9 < _end_) { enum JustSomeName__ { _it_ = (_start_ + 9) < _end_ ? (_start_ + 9) : _start_ }; _code_ } \ +if (_start_ + 10 < _end_) { enum JustSomeName__ { _it_ = (_start_ + 10) < _end_ ? (_start_ + 10) : _start_ }; _code_ } \ +if (_start_ + 11 < _end_) { enum JustSomeName__ { _it_ = (_start_ + 11) < _end_ ? (_start_ + 11) : _start_ }; _code_ } \ +if (_start_ + 12 < _end_) { enum JustSomeName__ { _it_ = (_start_ + 12) < _end_ ? (_start_ + 12) : _start_ }; _code_ } \ +if (_start_ + 13 < _end_) { enum JustSomeName__ { _it_ = (_start_ + 13) < _end_ ? (_start_ + 13) : _start_ }; _code_ } \ +if (_start_ + 14 < _end_) { enum JustSomeName__ { _it_ = (_start_ + 14) < _end_ ? (_start_ + 14) : _start_ }; _code_ } \ +if (_start_ + 15 < _end_) { enum JustSomeName__ { _it_ = (_start_ + 15) < _end_ ? (_start_ + 15) : _start_ }; _code_ } \ do {} while ( false ) #define for_all_vector_entries(_it_, _code_) \ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/common/memory.h new/Vc-0.7.5/common/memory.h --- old/Vc-0.7.4/common/memory.h 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/common/memory.h 2015-08-26 15:22:18.000000000 +0200 @@ -133,10 +133,10 @@ #elif defined(VC_CLANG) __attribute__((aligned(__alignof(VectorAlignedBaseT<V>)))) #elif defined(VC_MSVC) - VectorAlignedBaseT<V> _force_alignment; + VectorAlignedBaseT<V> _force_alignment; // __declspec(align(#)) accepts only numbers not __alignof nor just VectorAlignment - // by putting VectorAlignedBaseT<V> here _force_alignment is aligned correctly. - // the downside is that there's a lot of padding before m_mem (32 Bytes with SSE) :( + // by putting VectorAlignedBaseT<V> here _force_alignment is aligned correctly. + // the downside is that there's a lot of padding before m_mem (32 Bytes with SSE) :( #endif EntryType m_mem[Size1][PaddedSize2]; public: @@ -271,10 +271,10 @@ #elif defined(VC_CLANG) __attribute__((aligned(__alignof(VectorAlignedBaseT<V>)))) #elif defined(VC_MSVC) - VectorAlignedBaseT<V> _force_alignment; + VectorAlignedBaseT<V> _force_alignment; // __declspec(align(#)) accepts only numbers not __alignof nor just VectorAlignment - // by putting VectorAlignedBaseT<V> here _force_alignment is aligned correctly. - // the downside is that there's a lot of padding before m_mem (32 Bytes with SSE) :( + // by putting VectorAlignedBaseT<V> here _force_alignment is aligned correctly. + // the downside is that there's a lot of padding before m_mem (32 Bytes with SSE) :( #endif EntryType m_mem[PaddedSize]; public: diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/common/operators.h new/Vc-0.7.5/common/operators.h --- old/Vc-0.7.4/common/operators.h 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/common/operators.h 2015-08-26 15:22:18.000000000 +0200 @@ -6,12 +6,12 @@ template<typename Cond, typename T> struct EnableIfNeitherIntegerNorVector : public EnableIf<!CanConvertToInt<Cond>::Value, T> {}; template<typename Cond, typename T> struct EnableIfNeitherIntegerNorVector<Vector<Cond>, T>; -template<typename T> struct IsVector { enum { Value = false }; }; -template<typename T> struct IsVector<Vector<T> > { enum { Value = true }; }; +template<typename T> struct IsVector { enum JustSomeName__ { Value = false }; }; +template<typename T> struct IsVector<Vector<T> > { enum JustSomeName__ { Value = true }; }; template<typename T0, typename T1, typename V0, typename V1> struct IsTypeCombinationOf { - enum { + enum JustSomeName__ { Value = IsVector<V0>::Value ? (IsVector<V1>::Value ? ( // Vec × Vec ( IsEqualType<T0, V0>::Value && HasImplicitCast<T1, V1>::Value && !HasImplicitCast<T1, int>::Value) || (HasImplicitCast<T0, V0>::Value && IsEqualType<T1, V1>::Value && !HasImplicitCast<T0, int>::Value) || @@ -32,7 +32,7 @@ template<typename T0, typename T1, typename V> struct IsVectorOperands { - enum { + enum JustSomeName__ { Value = (HasImplicitCast<T0, V>::Value && !HasImplicitCast<T0, int>::Value && !IsEqualType<T0, V>::Value && IsEqualType<T1, V>::Value) || (HasImplicitCast<T1, V>::Value && !HasImplicitCast<T1, int>::Value && !IsEqualType<T1, V>::Value && IsEqualType<T0, V>::Value) }; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/common/types.h new/Vc-0.7.5/common/types.h --- old/Vc-0.7.4/common/types.h 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/common/types.h 2015-08-26 15:22:18.000000000 +0200 @@ -74,42 +74,42 @@ template<bool Test, typename T = void> struct EnableIf { typedef T Value; }; template<typename T> struct EnableIf<false, T> {}; - template<typename T> struct IsSignedInteger { enum { Value = 0 }; }; - template<> struct IsSignedInteger<signed char> { enum { Value = 1 }; }; - template<> struct IsSignedInteger<short> { enum { Value = 1 }; }; - template<> struct IsSignedInteger<int> { enum { Value = 1 }; }; - template<> struct IsSignedInteger<long> { enum { Value = 1 }; }; - template<> struct IsSignedInteger<long long> { enum { Value = 1 }; }; - - template<typename T> struct IsUnsignedInteger { enum { Value = 0 }; }; - template<> struct IsUnsignedInteger<unsigned char> { enum { Value = 1 }; }; - template<> struct IsUnsignedInteger<unsigned short> { enum { Value = 1 }; }; - template<> struct IsUnsignedInteger<unsigned int> { enum { Value = 1 }; }; - template<> struct IsUnsignedInteger<unsigned long> { enum { Value = 1 }; }; - template<> struct IsUnsignedInteger<unsigned long long> { enum { Value = 1 }; }; - - template<typename T> struct IsInteger { enum { Value = IsSignedInteger<T>::Value | IsUnsignedInteger<T>::Value }; }; - - template<typename T> struct IsReal { enum { Value = 0 }; }; - template<> struct IsReal<float> { enum { Value = 1 }; }; - template<> struct IsReal<double> { enum { Value = 1 }; }; + template<typename T> struct IsSignedInteger { enum JustSomeName__ { Value = 0 }; }; + template<> struct IsSignedInteger<signed char> { enum JustSomeName__ { Value = 1 }; }; + template<> struct IsSignedInteger<short> { enum JustSomeName__ { Value = 1 }; }; + template<> struct IsSignedInteger<int> { enum JustSomeName__ { Value = 1 }; }; + template<> struct IsSignedInteger<long> { enum JustSomeName__ { Value = 1 }; }; + template<> struct IsSignedInteger<long long> { enum JustSomeName__ { Value = 1 }; }; + + template<typename T> struct IsUnsignedInteger { enum JustSomeName__ { Value = 0 }; }; + template<> struct IsUnsignedInteger<unsigned char> { enum JustSomeName__ { Value = 1 }; }; + template<> struct IsUnsignedInteger<unsigned short> { enum JustSomeName__ { Value = 1 }; }; + template<> struct IsUnsignedInteger<unsigned int> { enum JustSomeName__ { Value = 1 }; }; + template<> struct IsUnsignedInteger<unsigned long> { enum JustSomeName__ { Value = 1 }; }; + template<> struct IsUnsignedInteger<unsigned long long> { enum JustSomeName__ { Value = 1 }; }; + + template<typename T> struct IsInteger { enum JustSomeName__ { Value = IsSignedInteger<T>::Value | IsUnsignedInteger<T>::Value }; }; + + template<typename T> struct IsReal { enum JustSomeName__ { Value = 0 }; }; + template<> struct IsReal<float> { enum JustSomeName__ { Value = 1 }; }; + template<> struct IsReal<double> { enum JustSomeName__ { Value = 1 }; }; - template<typename T, typename U> struct IsEqualType { enum { Value = 0 }; }; - template<typename T> struct IsEqualType<T, T> { enum { Value = 1 }; }; + template<typename T, typename U> struct IsEqualType { enum JustSomeName__ { Value = 0 }; }; + template<typename T> struct IsEqualType<T, T> { enum JustSomeName__ { Value = 1 }; }; template<typename T, typename List0, typename List1 = void, typename List2 = void, typename List3 = void, typename List4 = void, typename List5 = void, typename List6 = void> - struct IsInTypelist { enum { Value = false }; }; - template<typename T, typename List1, typename List2, typename List3, typename List4, typename List5, typename List6> struct IsInTypelist<T, T, List1, List2, List3, List4, List5, List6> { enum { Value = true }; }; - template<typename T, typename List0, typename List2, typename List3, typename List4, typename List5, typename List6> struct IsInTypelist<T, List0, T, List2, List3, List4, List5, List6> { enum { Value = true }; }; - template<typename T, typename List0, typename List1, typename List3, typename List4, typename List5, typename List6> struct IsInTypelist<T, List0, List1, T, List3, List4, List5, List6> { enum { Value = true }; }; - template<typename T, typename List0, typename List1, typename List2, typename List4, typename List5, typename List6> struct IsInTypelist<T, List0, List1, List2, T, List4, List5, List6> { enum { Value = true }; }; - template<typename T, typename List0, typename List1, typename List2, typename List3, typename List5, typename List6> struct IsInTypelist<T, List0, List1, List2, List3, T, List5, List6> { enum { Value = true }; }; - template<typename T, typename List0, typename List1, typename List2, typename List3, typename List4, typename List6> struct IsInTypelist<T, List0, List1, List2, List3, List4, T, List6> { enum { Value = true }; }; - template<typename T, typename List0, typename List1, typename List2, typename List3, typename List4, typename List5> struct IsInTypelist<T, List0, List1, List2, List3, List4, List5, T> { enum { Value = true }; }; - - template<typename Arg0, typename Arg1, typename T0, typename T1> struct IsCombinationOf { enum { Value = false }; }; - template<typename Arg0, typename Arg1> struct IsCombinationOf<Arg0, Arg1, Arg0, Arg1> { enum { Value = true }; }; - template<typename Arg0, typename Arg1> struct IsCombinationOf<Arg0, Arg1, Arg1, Arg0> { enum { Value = true }; }; + struct IsInTypelist { enum JustSomeName__ { Value = false }; }; + template<typename T, typename List1, typename List2, typename List3, typename List4, typename List5, typename List6> struct IsInTypelist<T, T, List1, List2, List3, List4, List5, List6> { enum JustSomeName__ { Value = true }; }; + template<typename T, typename List0, typename List2, typename List3, typename List4, typename List5, typename List6> struct IsInTypelist<T, List0, T, List2, List3, List4, List5, List6> { enum JustSomeName__ { Value = true }; }; + template<typename T, typename List0, typename List1, typename List3, typename List4, typename List5, typename List6> struct IsInTypelist<T, List0, List1, T, List3, List4, List5, List6> { enum JustSomeName__ { Value = true }; }; + template<typename T, typename List0, typename List1, typename List2, typename List4, typename List5, typename List6> struct IsInTypelist<T, List0, List1, List2, T, List4, List5, List6> { enum JustSomeName__ { Value = true }; }; + template<typename T, typename List0, typename List1, typename List2, typename List3, typename List5, typename List6> struct IsInTypelist<T, List0, List1, List2, List3, T, List5, List6> { enum JustSomeName__ { Value = true }; }; + template<typename T, typename List0, typename List1, typename List2, typename List3, typename List4, typename List6> struct IsInTypelist<T, List0, List1, List2, List3, List4, T, List6> { enum JustSomeName__ { Value = true }; }; + template<typename T, typename List0, typename List1, typename List2, typename List3, typename List4, typename List5> struct IsInTypelist<T, List0, List1, List2, List3, List4, List5, T> { enum JustSomeName__ { Value = true }; }; + + template<typename Arg0, typename Arg1, typename T0, typename T1> struct IsCombinationOf { enum JustSomeName__ { Value = false }; }; + template<typename Arg0, typename Arg1> struct IsCombinationOf<Arg0, Arg1, Arg0, Arg1> { enum JustSomeName__ { Value = true }; }; + template<typename Arg0, typename Arg1> struct IsCombinationOf<Arg0, Arg1, Arg1, Arg0> { enum JustSomeName__ { Value = true }; }; namespace { @@ -129,7 +129,7 @@ static yes test( To) { return yes(); } #endif static no test(...) { return no(); } - enum { + enum JustSomeName__ { #ifdef VC_MSVC // I want to test whether implicit cast works. If it works MSVC thinks it should give a warning. Wrong. Shut up. #pragma warning(suppress : 4257 4267) @@ -140,8 +140,8 @@ #if defined(VC_GCC) && VC_GCC < 0x40300 // GCC 4.1 is very noisy because of the float->int and double->int type trait tests. We get // around this noise with a little specialization. - template<> struct HasImplicitCast<float , int> { enum { Value = true }; }; - template<> struct HasImplicitCast<double, int> { enum { Value = true }; }; + template<> struct HasImplicitCast<float , int> { enum JustSomeName__ { Value = true }; }; + template<> struct HasImplicitCast<double, int> { enum JustSomeName__ { Value = true }; }; #endif #ifdef VC_MSVC @@ -153,33 +153,33 @@ // // Because the HasImplicitCast specializations can only be implemented after the Vector class // was declared we have to write some nasty hacks. - template<typename T1, typename T2> struct HasImplicitCast<_Vector<T1>, T2> { enum { Value = false }; }; + template<typename T1, typename T2> struct HasImplicitCast<_Vector<T1>, T2> { enum JustSomeName__ { Value = false }; }; #if defined(VC_IMPL_Scalar) - template<unsigned int VS, typename T2> struct HasImplicitCast<Vc::Scalar::Mask<VS>, T2> { enum { Value = false }; }; - template<unsigned int VS> struct HasImplicitCast<Vc::Scalar::Mask<VS>, Vc::Scalar::Mask<VS> > { enum { Value = true }; }; + template<unsigned int VS, typename T2> struct HasImplicitCast<Vc::Scalar::Mask<VS>, T2> { enum JustSomeName__ { Value = false }; }; + template<unsigned int VS> struct HasImplicitCast<Vc::Scalar::Mask<VS>, Vc::Scalar::Mask<VS> > { enum JustSomeName__ { Value = true }; }; #elif defined(VC_IMPL_SSE) - template<unsigned int VS, typename T2> struct HasImplicitCast<Vc::SSE::Mask<VS>, T2> { enum { Value = false }; }; - template<unsigned int VS> struct HasImplicitCast<Vc::SSE::Mask<VS>, Vc::SSE::Mask<VS> > { enum { Value = true }; }; - template<typename T2> struct HasImplicitCast<Vc::SSE::Float8Mask, T2> { enum { Value = false }; }; - template<> struct HasImplicitCast<Vc::SSE::Float8Mask, Vc::SSE::Float8Mask> { enum { Value = true }; }; + template<unsigned int VS, typename T2> struct HasImplicitCast<Vc::SSE::Mask<VS>, T2> { enum JustSomeName__ { Value = false }; }; + template<unsigned int VS> struct HasImplicitCast<Vc::SSE::Mask<VS>, Vc::SSE::Mask<VS> > { enum JustSomeName__ { Value = true }; }; + template<typename T2> struct HasImplicitCast<Vc::SSE::Float8Mask, T2> { enum JustSomeName__ { Value = false }; }; + template<> struct HasImplicitCast<Vc::SSE::Float8Mask, Vc::SSE::Float8Mask> { enum JustSomeName__ { Value = true }; }; #elif defined(VC_IMPL_AVX) - template<unsigned int VectorSize, size_t RegisterWidth, typename T2> struct HasImplicitCast<Vc::AVX::Mask<VectorSize, RegisterWidth>, T2> { enum { Value = false }; }; - template<unsigned int VectorSize, size_t RegisterWidth> struct HasImplicitCast<Vc::AVX::Mask<VectorSize, RegisterWidth>, Vc::AVX::Mask<VectorSize, RegisterWidth> > { enum { Value = true }; }; + template<unsigned int VectorSize, size_t RegisterWidth, typename T2> struct HasImplicitCast<Vc::AVX::Mask<VectorSize, RegisterWidth>, T2> { enum JustSomeName__ { Value = false }; }; + template<unsigned int VectorSize, size_t RegisterWidth> struct HasImplicitCast<Vc::AVX::Mask<VectorSize, RegisterWidth>, Vc::AVX::Mask<VectorSize, RegisterWidth> > { enum JustSomeName__ { Value = true }; }; #endif - template<typename T> struct HasImplicitCast<_Vector<T>, _Vector<T> > { enum { Value = true }; }; - //template<> struct HasImplicitCast<_Vector< int>, _Vector< unsigned int>> { enum { Value = true }; }; - //template<> struct HasImplicitCast<_Vector< unsigned int>, _Vector< int>> { enum { Value = true }; }; - //template<> struct HasImplicitCast<_Vector< short>, _Vector<unsigned short>> { enum { Value = true }; }; - //template<> struct HasImplicitCast<_Vector<unsigned short>, _Vector< short>> { enum { Value = true }; }; - template<typename V, size_t Size1, size_t Size2, typename T2> struct HasImplicitCast<Vc::Memory<V, Size1, Size2>, T2> { enum { Value = false }; }; - template<typename V, size_t Size1, size_t Size2> struct HasImplicitCast<Vc::Memory<V, Size1, Size2>, Vc::Memory<V, Size1, Size2> > { enum { Value = true }; }; + template<typename T> struct HasImplicitCast<_Vector<T>, _Vector<T> > { enum JustSomeName__ { Value = true }; }; + //template<> struct HasImplicitCast<_Vector< int>, _Vector< unsigned int>> { enum JustSomeName__ { Value = true }; }; + //template<> struct HasImplicitCast<_Vector< unsigned int>, _Vector< int>> { enum JustSomeName__ { Value = true }; }; + //template<> struct HasImplicitCast<_Vector< short>, _Vector<unsigned short>> { enum JustSomeName__ { Value = true }; }; + //template<> struct HasImplicitCast<_Vector<unsigned short>, _Vector< short>> { enum JustSomeName__ { Value = true }; }; + template<typename V, size_t Size1, size_t Size2, typename T2> struct HasImplicitCast<Vc::Memory<V, Size1, Size2>, T2> { enum JustSomeName__ { Value = false }; }; + template<typename V, size_t Size1, size_t Size2> struct HasImplicitCast<Vc::Memory<V, Size1, Size2>, Vc::Memory<V, Size1, Size2> > { enum JustSomeName__ { Value = true }; }; #undef _Vector #endif template<typename T> struct CanConvertToInt : public HasImplicitCast<T, int> {}; - template<> struct CanConvertToInt<bool> { enum { Value = 0 }; }; - //template<> struct CanConvertToInt<float> { enum { Value = 0 }; }; - //template<> struct CanConvertToInt<double> { enum { Value = 0 }; }; + template<> struct CanConvertToInt<bool> { enum JustSomeName__ { Value = 0 }; }; + //template<> struct CanConvertToInt<float> { enum JustSomeName__ { Value = 0 }; }; + //template<> struct CanConvertToInt<double> { enum JustSomeName__ { Value = 0 }; }; enum TestEnum {}; VC_STATIC_ASSERT(CanConvertToInt<int>::Value == 1, CanConvertToInt_is_broken); @@ -202,8 +202,8 @@ VC_STATIC_ASSERT(HasImplicitCastTest3::Value == true, HasImplicitCast3_is_broken); VC_STATIC_ASSERT(HasImplicitCastTest4::Value == false, HasImplicitCast4_is_broken); - template<typename T> struct IsLikeInteger { enum { Value = !IsReal<T>::Value && CanConvertToInt<T>::Value }; }; - template<typename T> struct IsLikeSignedInteger { enum { Value = IsLikeInteger<T>::Value && !IsUnsignedInteger<T>::Value }; }; + template<typename T> struct IsLikeInteger { enum JustSomeName__ { Value = !IsReal<T>::Value && CanConvertToInt<T>::Value }; }; + template<typename T> struct IsLikeSignedInteger { enum JustSomeName__ { Value = IsLikeInteger<T>::Value && !IsUnsignedInteger<T>::Value }; }; } // anonymous namespace #ifndef VC_CHECK_ALIGNMENT diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/doc/Doxyfile new/Vc-0.7.5/doc/Doxyfile --- old/Vc-0.7.4/doc/Doxyfile 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/doc/Doxyfile 2015-08-26 15:22:18.000000000 +0200 @@ -34,7 +34,7 @@ # This could be handy for archiving the generated documentation or # if some version control system is used. -PROJECT_NUMBER = 0.7.4 +PROJECT_NUMBER = 0.7.5 # Using the PROJECT_BRIEF tag one can provide an optional one line description # for a project that appears at the top of each page and should give viewer diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/examples/finitediff/main.cpp new/Vc-0.7.5/examples/finitediff/main.cpp --- old/Vc-0.7.4/examples/finitediff/main.cpp 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/examples/finitediff/main.cpp 2015-08-26 15:22:18.000000000 +0200 @@ -39,7 +39,7 @@ #define USE_SCALAR_SINCOS -enum { +enum JustSomeName { N = 10240000, PrintStep = 1000000 }; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/examples/tsc.h new/Vc-0.7.5/examples/tsc.h --- old/Vc-0.7.4/examples/tsc.h 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/examples/tsc.h 2015-08-26 15:22:18.000000000 +0200 @@ -43,7 +43,7 @@ inline void TimeStampCounter::Start() { #ifdef _MSC_VER - unsigned int tmp; + unsigned int tmp; m_start.a = __rdtscp(&tmp); #else asm volatile("rdtscp" : "=a"(m_start.b[0]), "=d"(m_start.b[1]) :: "ecx" ); @@ -53,7 +53,7 @@ inline void TimeStampCounter::Stop() { #ifdef _MSC_VER - unsigned int tmp; + unsigned int tmp; m_end.a = __rdtscp(&tmp); #else asm volatile("rdtscp" : "=a"(m_end.b[0]), "=d"(m_end.b[1]) :: "ecx" ); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/include/Vc/global.h new/Vc-0.7.5/include/Vc/global.h --- old/Vc-0.7.4/include/Vc/global.h 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/include/Vc/global.h 2015-08-26 15:22:18.000000000 +0200 @@ -278,6 +278,21 @@ # define VC_IMPL_Scalar 1 #endif +#if defined(VC_CLANG) && VC_CLANG >= 0x30600 && VC_CLANG < 0x30700 +# if defined(VC_IMPL_AVX) +# warning "clang 3.6.x miscompiles AVX code, frequently losing 50% of the data. Vc will fall back to SSE4 instead." +# undef VC_IMPL_AVX +# define VC_IMPL_SSE4_2 1 +# define VC_IMPL_SSE4_1 1 +# define VC_IMPL_SSSE3 1 +# define VC_IMPL_SSE3 1 +# define VC_IMPL_SSE2 1 +# define VC_IMPL_SSE 1 +# endif +# undef VC_IMPL_FMA4 +# undef VC_IMPL_XOP +#endif + # if !defined(VC_IMPL_Scalar) && !defined(VC_IMPL_SSE) && !defined(VC_IMPL_AVX) # error "No suitable Vc implementation was selected! Probably VC_IMPL was set to an invalid value." # elif defined(VC_IMPL_SSE) && !defined(VC_IMPL_SSE2) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/include/Vc/version.h new/Vc-0.7.5/include/Vc/version.h --- old/Vc-0.7.4/include/Vc/version.h 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/include/Vc/version.h 2015-08-26 15:22:18.000000000 +0200 @@ -20,8 +20,8 @@ #ifndef VC_VERSION_H #define VC_VERSION_H -#define VC_VERSION_STRING "0.7.4" -#define VC_VERSION_NUMBER 0x000708 +#define VC_VERSION_STRING "0.7.5" +#define VC_VERSION_NUMBER 0x00070a #define VC_VERSION_CHECK(major, minor, patch) ((major << 16) | (minor << 8) | (patch << 1)) #define VC_LIBRARY_ABI_VERSION 3 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/scalar/math.h new/Vc-0.7.5/scalar/math.h --- old/Vc-0.7.4/scalar/math.h 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/scalar/math.h 2015-08-26 15:22:18.000000000 +0200 @@ -200,7 +200,7 @@ return typename Vector<T>::Mask( #ifdef _MSC_VER !!_finite(x.data()) -#elif defined(__INTEL_COMPILER) +#elif defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1500 ::isfinite(x.data()) #else std::isfinite(x.data()) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/sse/debug.h new/Vc-0.7.5/sse/debug.h --- old/Vc-0.7.4/sse/debug.h 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/sse/debug.h 2015-08-26 15:22:18.000000000 +0200 @@ -45,7 +45,7 @@ private: template<typename T, typename V> static void printVector(V _x) { - enum { Size = sizeof(V) / sizeof(T) }; + enum JustSomeName__ { Size = sizeof(V) / sizeof(T) }; union { V v; T m[Size]; } x = { _x }; std::cerr << '[' << std::setprecision(24) << x.m[0]; for (int i = 1; i < Size; ++i) { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/sse/mask.h new/Vc-0.7.5/sse/mask.h --- old/Vc-0.7.4/sse/mask.h 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/sse/mask.h 2015-08-26 15:22:18.000000000 +0200 @@ -451,7 +451,7 @@ Vc_ALWAYS_INLINE Vc_PURE int count() const { #ifdef VC_IMPL_POPCNT - return _mm_popcnt_u32(toInt()); + return _mm_popcnt_u32(toInt()); #else //X int tmp1 = _mm_movemask_ps(k[0]); //X int tmp2 = _mm_movemask_ps(k[1]); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/sse/vector.tcc new/Vc-0.7.5/sse/vector.tcc --- old/Vc-0.7.4/sse/vector.tcc 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/sse/vector.tcc 2015-08-26 15:22:18.000000000 +0200 @@ -1389,7 +1389,7 @@ // shifted / rotated {{{1 template<typename T> Vc_INTRINSIC Vc_PURE Vector<T> Vector<T>::shifted(int amount) const { - enum { + enum JustSomeName__ { EntryTypeSizeof = sizeof(EntryType) }; switch (amount) { @@ -1415,7 +1415,7 @@ } template<> Vc_INTRINSIC Vc_PURE sfloat_v sfloat_v::shifted(int amount) const { - enum { + enum JustSomeName__ { EntryTypeSizeof = sizeof(EntryType) }; switch (amount) { @@ -1439,7 +1439,7 @@ } template<typename T> Vc_INTRINSIC Vc_PURE Vector<T> Vector<T>::rotated(int amount) const { - enum { + enum JustSomeName__ { EntryTypeSizeof = sizeof(EntryType) }; const __m128i v = mm128_reinterpret_cast<__m128i>(d.v()); @@ -1460,7 +1460,7 @@ } template<> Vc_INTRINSIC Vc_PURE sfloat_v sfloat_v::rotated(int amount) const { - enum { + enum JustSomeName__ { EntryTypeSizeof = sizeof(EntryType) }; const __m128i v0 = sse_cast<__m128i>(d.v()[0]); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/sse/vectorhelper.tcc new/Vc-0.7.5/sse/vectorhelper.tcc --- old/Vc-0.7.4/sse/vectorhelper.tcc 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/sse/vectorhelper.tcc 2015-08-26 15:22:18.000000000 +0200 @@ -362,7 +362,7 @@ } template<> inline Vc_PURE M256 SortHelper<M256, 8>::sort(const M256 &_x) { - M256 x = _x; + M256 x = _x; typedef SortHelper<_M128, 4> H; _M128 a, b, l, h; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/test.cmake new/Vc-0.7.5/test.cmake --- old/Vc-0.7.4/test.cmake 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/test.cmake 2015-08-26 15:22:18.000000000 +0200 @@ -2,27 +2,53 @@ get_filename_component(CTEST_SOURCE_DIRECTORY "${CMAKE_CURRENT_LIST_FILE}" PATH) endif() +# Dashboard Model +################################################################################ set(dashboard_model "$ENV{dashboard_model}") if(NOT dashboard_model) set(dashboard_model "Experimental") endif() + +# Set build variables from environment variables +################################################################################ set(target_architecture "$ENV{target_architecture}") set(skip_tests "$ENV{skip_tests}") +# Set CMAKE_BUILD_TYPE from environment variable +################################################################################ set(build_type "$ENV{build_type}") if(NOT build_type) set(build_type "Release") endif() # better make sure we get english output (this is vital for the implicit_type_conversion_failures tests) +################################################################################ set(ENV{LANG} "en_US") +# determine the git branch we're testing +################################################################################ +file(READ "${CTEST_SOURCE_DIRECTORY}/.git/HEAD" git_branch) +string(STRIP "${git_branch}" git_branch) +# -> ref: refs/heads/foobar +string(REGEX REPLACE "^.*/" "" git_branch "${git_branch}") +# -> foobar + +# determine the (short) hostname of the build machine +################################################################################ +execute_process(COMMAND hostname -s RESULT_VARIABLE ok OUTPUT_VARIABLE CTEST_SITE ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE) +if(NOT ok EQUAL 0) + execute_process(COMMAND hostname OUTPUT_VARIABLE CTEST_SITE ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE) +endif() + +# collect system information for the "Build Name" (and build setup, e.g. -j) +################################################################################ find_program(UNAME uname) if(UNAME) execute_process(COMMAND ${UNAME} -s OUTPUT_VARIABLE arch OUTPUT_STRIP_TRAILING_WHITESPACE) string(TOLOWER "${arch}" arch) execute_process(COMMAND ${UNAME} -m OUTPUT_VARIABLE chip OUTPUT_STRIP_TRAILING_WHITESPACE) string(TOLOWER "${chip}" chip) + string(REPLACE "x86_64" "amd64" chip "${chip}") else() find_program(CMD cmd) if(CMD) @@ -42,7 +68,7 @@ reg query "HKLM\\HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0" /v Identifier OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE processorId) if("${processorId}" MATCHES "AMD64") - set(chip "x86_64") + set(chip "amd64") elseif("${processorId}" MATCHES "x86") set(chip "x86") else() @@ -50,131 +76,176 @@ endif() endif() -if("${arch}" MATCHES "[Ww]indows" OR "${arch}" MATCHES "win7") - find_program(CL cl) - execute_process(COMMAND ${CL} /nologo -EP "${CTEST_SOURCE_DIRECTORY}/cmake/msvc_version.c" OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE COMPILER_VERSION) - string(STRIP "${COMPILER_VERSION}" COMPILER_VERSION) - if("${CL}" MATCHES "amd64") - set(COMPILER_VERSION "${COMPILER_VERSION} x86 64bit") - elseif("${CL}" MATCHES "ia64") - set(COMPILER_VERSION "${COMPILER_VERSION} Itanium") - else() - set(COMPILER_VERSION "${COMPILER_VERSION} x86 32bit") - endif() - set(number_of_processors "$ENV{NUMBER_OF_PROCESSORS}") - if(NOT number_of_processors) +# determine a short description of the OS we're running on +################################################################################ +if(arch STREQUAL "linux") + execute_process(COMMAND lsb_release -d COMMAND cut -f2 OUTPUT_VARIABLE os_ident) + string(REGEX REPLACE "\\(.*\\)" "" os_ident "${os_ident}") # shorten the Distribution string, stripping everything in parens + string(REPLACE "Scientific Linux SL" "SL" os_ident "${os_ident}") + string(REPLACE " release" "" os_ident "${os_ident}") + string(REPLACE " GNU/Linux" "" os_ident "${os_ident}") + string(REPLACE "openSUSE" "Suse" os_ident "${os_ident}") + string(STRIP "${os_ident}" os_ident) +else() + set(os_ident "${arch}") + string(REPLACE "Windows" "Win" os_ident "${os_ident}") +endif() + +# Determine the processor count (number_of_processors) +################################################################################ +set(number_of_processors "$ENV{NUMBER_OF_PROCESSORS}") +if(NOT number_of_processors) + if("${arch}" MATCHES "[Ww]indows" OR "${arch}" MATCHES "win7" OR "${arch}" MATCHES "mingw") execute_process(COMMAND reg query "HKLM\\HARDWARE\\DESCRIPTION\\System\\CentralProcessor" OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE number_of_processors) string(REGEX REPLACE "[^0-9]+" "," number_of_processors "${number_of_processors}") string(REGEX REPLACE "^.*," "" number_of_processors "${number_of_processors}") math(EXPR number_of_processors "1 + ${number_of_processors}") + elseif("${arch}" STREQUAL "darwin") + execute_process(COMMAND sysctl -n hw.ncpu OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE number_of_processors) + else() + execute_process(COMMAND grep -c processor /proc/cpuinfo OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE number_of_processors) endif() -elseif(arch MATCHES "mingw") - find_program(CL cl) - find_program(GXX "g++") - if("$ENV{CXX}" MATCHES "g\\+\\+") - set(GXX "$ENV{CXX}") - endif() - if(GXX) - execute_process(COMMAND "${GXX}" --version OUTPUT_VARIABLE COMPILER_VERSION ERROR_VARIABLE COMPILER_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE) - string(REPLACE "\n" ";" COMPILER_VERSION "${COMPILER_VERSION}") - list(GET COMPILER_VERSION 0 COMPILER_VERSION) - elseif(CL) +endif() + +# Determine the compiler version string +################################################################################ +set(compiler) +macro(extract_msvc_compiler_info CL) + if(CL) execute_process(COMMAND ${CL} /nologo -EP "${CTEST_SOURCE_DIRECTORY}/cmake/msvc_version.c" OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE COMPILER_VERSION) string(STRIP "${COMPILER_VERSION}" COMPILER_VERSION) + if("${CL}" MATCHES "amd64") + set(COMPILER_VERSION "${COMPILER_VERSION} amd64") + elseif("${CL}" MATCHES "ia64") + set(COMPILER_VERSION "${COMPILER_VERSION} ia64") + else() + set(COMPILER_VERSION "${COMPILER_VERSION} x86") + endif() + set(compiler "MSVC") else() message(FATAL_ERROR "unknown compiler") endif() - execute_process(COMMAND reg query "HKLM\\HARDWARE\\DESCRIPTION\\System\\CentralProcessor" COMMAND grep -c CentralProcessor OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE number_of_processors) -else() - set(_cxx "$ENV{CXX}") - if(NOT _cxx) - set(_cxx "c++") - endif() - execute_process(COMMAND ${_cxx} --version OUTPUT_VARIABLE COMPILER_VERSION ERROR_VARIABLE COMPILER_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE) - string(REPLACE "\n" ";" COMPILER_VERSION "${COMPILER_VERSION}") +endmacro() +macro(extract_gnuc_compiler_info CXX) + execute_process(COMMAND "${CXX}" --version OUTPUT_VARIABLE COMPILER_VERSION_COMPLETE ERROR_VARIABLE COMPILER_VERSION_COMPLETE OUTPUT_STRIP_TRAILING_WHITESPACE) + string(REPLACE "\n" ";" COMPILER_VERSION "${COMPILER_VERSION_COMPLETE}") list(GET COMPILER_VERSION 0 COMPILER_VERSION) string(REPLACE "Open64 Compiler Suite: Version" "Open64" COMPILER_VERSION "${COMPILER_VERSION}") - if(arch STREQUAL "darwin") - execute_process(COMMAND sysctl -n hw.ncpu OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE number_of_processors) + string(REPLACE "icpc" "ICC" COMPILER_VERSION "${COMPILER_VERSION}") + string(REPLACE "gxx" "GCC" COMPILER_VERSION "${COMPILER_VERSION}") + string(REPLACE "g++" "GCC" COMPILER_VERSION "${COMPILER_VERSION}") + string(REPLACE ".exe" "" COMPILER_VERSION "${COMPILER_VERSION}") + string(REPLACE " version" "" COMPILER_VERSION "${COMPILER_VERSION}") + string(REGEX REPLACE " \\([^()]*\\)" "" COMPILER_VERSION "${COMPILER_VERSION}") + string(REGEX REPLACE " \\[.*\\]" "" COMPILER_VERSION "${COMPILER_VERSION}") + string(REGEX REPLACE "GCC-[0-9](\\.[0-9])?" "GCC" COMPILER_VERSION "${COMPILER_VERSION}") + string(STRIP "${COMPILER_VERSION}" COMPILER_VERSION) + if(COMPILER_VERSION_COMPLETE MATCHES "Free Software Foundation, Inc." AND NOT COMPILER_VERSION MATCHES "GCC") + # it's GCC but without "GCC" in the COMPILER_VERSION string - fix it up + string(REPLACE "cxx" "GCC" COMPILER_VERSION "${COMPILER_VERSION}") + string(REPLACE "c++" "GCC" COMPILER_VERSION "${COMPILER_VERSION}") + if(NOT COMPILER_VERSION MATCHES "GCC") + set(COMPILER_VERSION "GCC (${COMPILER_VERSION})") + endif() + endif() + if(COMPILER_VERSION MATCHES "clang") + set(compiler "clang") + elseif(COMPILER_VERSION MATCHES "ICC") + set(compiler "ICC") + elseif(COMPILER_VERSION MATCHES "Open64") + set(compiler "Open64") + elseif(COMPILER_VERSION MATCHES "GCC") + if(WIN32) + set(compiler "MinGW") + else() + set(compiler "GCC") + endif() + endif() +endmacro() +if("${arch}" MATCHES "[Ww]indows" OR "${arch}" MATCHES "win7") + find_program(CL cl) + extract_msvc_compiler_info(${CL}) +elseif(arch MATCHES "mingw") + if("$ENV{CXX}" MATCHES "g\\+\\+" OR "$ENV{CXX}" MATCHES "gxx") + set(GXX "$ENV{CXX}") else() - execute_process(COMMAND grep -c processor /proc/cpuinfo OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE number_of_processors) + find_program(GXX NAMES "g++" "gxx") endif() + if(GXX) + extract_gnuc_compiler_info("${GXX}") + else() + find_program(CL cl) + extract_msvc_compiler_info(${CL}) + endif() +else() + set(CXX "$ENV{CXX}") + if(NOT CXX) + unset(CXX) + find_program(CXX NAMES g++ clang++ icpc c++) + if(NOT CXX) + message(FATAL_ERROR "No C++ compiler found") + endif() + endif() + extract_gnuc_compiler_info("${CXX}") endif() -file(READ "${CTEST_SOURCE_DIRECTORY}/.git/HEAD" git_branch) -string(STRIP "${git_branch}" git_branch) -# -> ref: refs/heads/master -string(REGEX REPLACE "^.*/" "" git_branch "${git_branch}") -# -> master - -if(arch STREQUAL "linux") - execute_process(COMMAND lsb_release -d COMMAND cut -f2 OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE lsbRelease) - set(CTEST_BUILD_NAME "${lsbRelease}") +# Build the CTEST_BUILD_NAME string +################################################################################ +if(target_architecture) + set(tmp ${target_architecture}) else() - set(CTEST_BUILD_NAME "${arch}") + execute_process(COMMAND cmake -Darch=${arch} -P ${CTEST_SOURCE_DIRECTORY}/print_target_architecture.cmake OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE tmp ERROR_VARIABLE tmp) endif() -string(STRIP "${CTEST_BUILD_NAME} ${chip} ${COMPILER_VERSION} $ENV{CXXFLAGS}" CTEST_BUILD_NAME) -set(CTEST_BUILD_NAME "${CTEST_BUILD_NAME} ${build_type}") -if(target_architecture) - set(CTEST_BUILD_NAME "${CTEST_BUILD_NAME} ${target_architecture}") +if(build_type STREQUAL "Release") + set(build_type_short "Rel") +elseif(build_type STREQUAL "Debug") + set(build_type_short "Deb") +elseif(build_type STREQUAL "RelWithDebInfo") + set(build_type_short "RDI") +elseif(build_type STREQUAL "RelWithDebug") + set(build_type_short "RWD") +elseif(build_type STREQUAL "None") + set(build_type_short "Non") else() - execute_process(COMMAND cmake -Darch=${arch} -P ${CTEST_SOURCE_DIRECTORY}/print_target_architecture.cmake OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE auto_target_arch ERROR_VARIABLE auto_target_arch) - set(CTEST_BUILD_NAME "${CTEST_BUILD_NAME} ${auto_target_arch}") + set(build_type_short "${build_type}") endif() -string(REPLACE "/" "_" CTEST_BUILD_NAME "${git_branch}: ${CTEST_BUILD_NAME}") -string(REPLACE "+" "x" CTEST_BUILD_NAME "${CTEST_BUILD_NAME}") # CDash fails to escape '+' correctly in URIs -string(REGEX REPLACE "[][ ():]" "_" CTEST_BINARY_DIRECTORY "${CTEST_BUILD_NAME}") +string(STRIP "${git_branch} ${COMPILER_VERSION} $ENV{CXXFLAGS} ${build_type_short} ${tmp} ${chip} ${os_ident}" CTEST_BUILD_NAME) +string(REPLACE " " " " CTEST_BUILD_NAME "${CTEST_BUILD_NAME}") + +# work around CDash limitations: +string(REPLACE "/" "_" CTEST_BUILD_NAME "${CTEST_BUILD_NAME}") +string(REPLACE "+" "x" CTEST_BUILD_NAME "${CTEST_BUILD_NAME}") + +# Determine build directory +################################################################################ +string(REGEX REPLACE "[][ ():,]" "" CTEST_BINARY_DIRECTORY "${CTEST_BUILD_NAME}") set(CTEST_BINARY_DIRECTORY "${CTEST_SOURCE_DIRECTORY}/build-${dashboard_model}-${CTEST_BINARY_DIRECTORY}") -file(MAKE_DIRECTORY "${CTEST_BINARY_DIRECTORY}") -execute_process(COMMAND hostname -s RESULT_VARIABLE ok OUTPUT_VARIABLE CTEST_SITE ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE) -if(NOT ok EQUAL 0) - execute_process(COMMAND hostname OUTPUT_VARIABLE CTEST_SITE ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE) -endif() +# Give user feedback +################################################################################ +#message("src: ${CTEST_SOURCE_DIRECTORY}") +#message("obj: ${CTEST_BINARY_DIRECTORY}") +message("build name: ${CTEST_BUILD_NAME}") +message("site: ${CTEST_SITE}") +message("model: ${dashboard_model}") Set(CTEST_START_WITH_EMPTY_BINARY_DIRECTORY_ONCE TRUE) set(CTEST_NOTES_FILES "${CTEST_SOURCE_DIRECTORY}/.git/HEAD" "${CTEST_SOURCE_DIRECTORY}/.git/refs/heads/${git_branch}") -set(compiler) -if(COMPILER_VERSION MATCHES "clang") - set(compiler "clang") -elseif(COMPILER_VERSION MATCHES "g\\+\\+") - if(WIN32) - set(compiler "MinGW") - else() - set(compiler "GCC") - endif() -elseif(COMPILER_VERSION MATCHES "MSVC") - set(compiler "MSVC") -elseif(COMPILER_VERSION MATCHES "ICC") - set(compiler "ICC") -elseif(COMPILER_VERSION MATCHES "Open64") - set(compiler "Open64") -endif() -if(COMPILER_VERSION MATCHES "\\((experimental|prerelease)\\)" OR COMPILER_VERSION MATCHES "clang version 3.5") - set(compiler "experimental") -endif() - -include(${CTEST_SOURCE_DIRECTORY}/CTestCustom.cmake) include(${CTEST_SOURCE_DIRECTORY}/CTestConfig.cmake) -set(CTEST_USE_LAUNCHERS 1) # much improved error/warning message logging +ctest_read_custom_files(${CTEST_SOURCE_DIRECTORY}) +set(CTEST_USE_LAUNCHERS 0) # launchers once lead to much improved error/warning + # message logging. Nowadays they lead to no warning/ + # error messages on the dashboard at all. if(WIN32) set(MAKE_ARGS "-k") else() set(MAKE_ARGS "-j${number_of_processors} -k") endif() -message("********************************") -#message("src: ${CTEST_SOURCE_DIRECTORY}") -#message("obj: ${CTEST_BINARY_DIRECTORY}") -message("build name: ${CTEST_BUILD_NAME}") -message("site: ${CTEST_SITE}") -message("model: ${dashboard_model}") -message("********************************") - if(WIN32) if("${compiler}" STREQUAL "MSVC") find_program(JOM jom) @@ -203,7 +274,8 @@ endif() macro(go) - set_property(GLOBAL PROPERTY SubProject ${compiler}) + # SubProjects currently don't improve the overview but rather make the dashboard more cumbersume to navigate + #set_property(GLOBAL PROPERTY SubProject "0.7: ${compiler}") set_property(GLOBAL PROPERTY Label other) CTEST_START (${dashboard_model}) set(res 0) @@ -218,6 +290,10 @@ OPTIONS "${configure_options}" APPEND RETURN_VALUE res) + list(APPEND CTEST_NOTES_FILES + #"${CTEST_BINARY_DIRECTORY}/CMakeFiles/CMakeOutput.log" + "${CTEST_BINARY_DIRECTORY}/CMakeFiles/CMakeError.log" + ) ctest_submit(PARTS Notes Configure) if(res EQUAL 0) foreach(label other Scalar SSE AVX) @@ -250,6 +326,8 @@ ctest_sleep(${START_TIME} 1200 ${CTEST_ELAPSED_TIME}) endwhile() else() - CTEST_EMPTY_BINARY_DIRECTORY(${CTEST_BINARY_DIRECTORY}) + if(EXISTS "${CTEST_BINARY_DIRECTORY}") + CTEST_EMPTY_BINARY_DIRECTORY(${CTEST_BINARY_DIRECTORY}) + endif() go() endif() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/tests/CMakeLists.txt new/Vc-0.7.5/tests/CMakeLists.txt --- old/Vc-0.7.4/tests/CMakeLists.txt 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/tests/CMakeLists.txt 2015-08-26 15:22:18.000000000 +0200 @@ -1,9 +1,12 @@ include(AddFileDependencies) +add_custom_target(build_tests ALL VERBATIM) + add_definitions(-DCOMPILE_FOR_UNIT_TESTS) # -DVC_CHECK_ALIGNMENT) if(Vc_COMPILER_IS_MSVC) AddCompilerFlag("/wd4267") # Disable warning "conversion from 'size_t' to 'int', possible loss of data" AddCompilerFlag("/wd4723") # Disable warning "potential divide by 0" (suppress doesn't work) + AddCompilerFlag("/wd4290") # Disable warning "C++ exception specification ignored except to indicate a function is not __declspec(nothrow)" endif() if(DEFINED Vc_INSIDE_ROOT) @@ -166,7 +169,7 @@ add_executable(sse2_blend EXCLUDE_FROM_ALL sse_blend.cpp) add_target_property(sse2_blend COMPILE_FLAGS "-DVC_IMPL=SSE2") add_target_property(sse2_blend LABELS "SSE") - add_dependencies(build_tests ${_target}) + add_dependencies(build_tests sse2_blend) add_dependencies(SSE sse2_blend) add_test(${Vc_TEST_TARGET_PREFIX}sse2_blend "${CMAKE_CURRENT_BINARY_DIR}/sse2_blend") set_property(TEST ${Vc_TEST_TARGET_PREFIX}sse2_blend PROPERTY LABELS "SSE") @@ -176,7 +179,7 @@ add_executable(sse4_blend EXCLUDE_FROM_ALL sse_blend.cpp) add_target_property(sse4_blend COMPILE_FLAGS "-DVC_IMPL=SSE4_1") add_target_property(sse4_blend LABELS "SSE") - add_dependencies(build_tests ${_target}) + add_dependencies(build_tests sse4_blend) add_dependencies(SSE sse4_blend) add_test(${Vc_TEST_TARGET_PREFIX}sse4_blend "${CMAKE_CURRENT_BINARY_DIR}/sse4_blend") set_property(TEST ${Vc_TEST_TARGET_PREFIX}sse4_blend PROPERTY LABELS "SSE") @@ -188,7 +191,7 @@ add_executable(supportfunctions EXCLUDE_FROM_ALL supportfunctions.cpp) target_link_libraries(supportfunctions Vc) add_target_property(supportfunctions LABELS "other") -add_dependencies(build_tests ${_target}) +add_dependencies(build_tests supportfunctions) add_dependencies(other supportfunctions) add_test(${Vc_TEST_TARGET_PREFIX}supportfunctions "${CMAKE_CURRENT_BINARY_DIR}/supportfunctions") set_property(TEST ${Vc_TEST_TARGET_PREFIX}supportfunctions PROPERTY LABELS "other") diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/tests/arithmetics.cpp new/Vc-0.7.5/tests/arithmetics.cpp --- old/Vc-0.7.4/tests/arithmetics.cpp 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/tests/arithmetics.cpp 2015-08-26 15:22:18.000000000 +0200 @@ -220,7 +220,7 @@ { typedef typename Vec::EntryType T; const T step = std::max<T>(1, std::numeric_limits<T>::max() / 1000); - enum { + enum JustAnotherName__ { NShifts = sizeof(T) * 8 }; for (Vec x = std::numeric_limits<Vec>::min() + Vec::IndexesFromZero(); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/tests/expandandmerge.cpp new/Vc-0.7.5/tests/expandandmerge.cpp --- old/Vc-0.7.4/tests/expandandmerge.cpp 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/tests/expandandmerge.cpp 2015-08-26 15:22:18.000000000 +0200 @@ -22,7 +22,7 @@ using namespace Vc; -enum { +enum JustAnotherName__ { VectorSizeFactor = short_v::Size / int_v::Size }; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/tests/mask.cpp new/Vc-0.7.5/tests/mask.cpp --- old/Vc-0.7.4/tests/mask.cpp 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/tests/mask.cpp 2015-08-26 15:22:18.000000000 +0200 @@ -288,6 +288,33 @@ } #endif +template <typename V> void testCompareOperators() +{ + typedef typename V::Mask M; + const M a(true); + const M b(false); + VERIFY(!(a == b)); + + for_all_masks(V, k) + { + M randomMask; + do { + randomMask = V::Random() < V::Random(); + } while (randomMask.isEmpty()); + const M k2 = k ^ randomMask; + + VERIFY( (k == k )) << k; + VERIFY(!(k2 == k )) << k << k2; + VERIFY(!(k == k2)) << k << k2; + VERIFY( (k2 == k2)) << k << k2; + + VERIFY(!(k != k )) << k; + VERIFY( (k != k2)) << k << k2; + VERIFY( (k2 != k )) << k << k2; + VERIFY(!(k2 != k2)) << k << k2; + } +} + int main(int argc, char **argv) { initTest(argc, argv); @@ -302,6 +329,7 @@ testAllTypes(testZero); testAllTypes(testCount); testAllTypes(testFirstOne); + testAllTypes(testCompareOperators); runTest(testBinaryOperators); #ifdef VC_IMPL_SSE diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/tests/math.cpp new/Vc-0.7.5/tests/math.cpp --- old/Vc-0.7.4/tests/math.cpp 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/tests/math.cpp 2015-08-26 15:22:18.000000000 +0200 @@ -120,7 +120,7 @@ template<typename T> struct Denormals { static T *data; };/*{{{*/ template<> float *Denormals<float >::data = 0; template<> double *Denormals<double>::data = 0; -enum { +enum NDenormalsEnum { NDenormals = 64 }; /*}}}*/ @@ -533,7 +533,7 @@ COMPARE(Vc::atan2(-inf, V(T(-3.))), -Pi_2); #ifndef _WIN32 // the Microsoft implementation of atan2 fails this test const V Pi_4 = T(Vc_buildDouble(1, 0x921fb54442d18ull, -1)); - // If y is positive infinity (negative infinity) and x is negative infinity, +3*pi/4 (-3*pi/4) is returned. + // If y is positive infinity (negative infinity) and x is negative infinity, +3*pi/4 (-3*pi/4) is returned. COMPARE(Vc::atan2(+inf, -inf), T(+3.) * Pi_4); COMPARE(Vc::atan2(-inf, -inf), T(-3.) * Pi_4); // If y is positive infinity (negative infinity) and x is positive infinity, +pi/4 (-pi/4) is returned. @@ -619,7 +619,7 @@ template<typename Vec> void testRound()/*{{{*/ { typedef typename Vec::EntryType T; - enum { + enum JustAnotherName__ { Count = (16 + Vec::Size) / Vec::Size }; VectorMemoryHelper<Vec> mem1(Count); @@ -677,7 +677,7 @@ /*}}}*/ template<typename Vec> void testReduceProduct()/*{{{*/ { - enum { + enum JustAnotherName__ { Max = Vec::Size > 8 ? Vec::Size / 2 : Vec::Size }; typedef typename Vec::EntryType T; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/tests/sse_blend.cpp new/Vc-0.7.5/tests/sse_blend.cpp --- old/Vc-0.7.4/tests/sse_blend.cpp 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/tests/sse_blend.cpp 2015-08-26 15:22:18.000000000 +0200 @@ -96,7 +96,7 @@ __m128i a = _mm_set_epi16(17, 16, 15, 14, 13, 12, 11, 10); __m128i b = _mm_set_epi16(27, 26, 25, 24, 23, 22, 21, 20); -#define CALL_2(_i, code) { enum { i = _i }; code } { enum { i = _i + 1 }; code } +#define CALL_2(_i, code) { enum JustAnotherName__ { i = _i }; code } { enum JustAnotherName__ { i = _i + 1 }; code } #define CALL_4(_i, code) CALL_2(_i, code) CALL_2(_i + 2, code) #define CALL_8(_i, code) CALL_4(_i, code) CALL_4(_i + 4, code) #define CALL_16(_i, code) CALL_8(_i, code) CALL_8(_i + 8, code) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/tests/store.cpp new/Vc-0.7.5/tests/store.cpp --- old/Vc-0.7.4/tests/store.cpp 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/tests/store.cpp 2015-08-26 15:22:18.000000000 +0200 @@ -26,7 +26,7 @@ template<typename Vec> void alignedStore() { typedef typename Vec::EntryType T; - enum { + enum JustAnotherName__ { Count = 256 * 1024 / sizeof(T) }; @@ -48,7 +48,7 @@ template<typename Vec> void unalignedStore() { typedef typename Vec::EntryType T; - enum { + enum JustAnotherName__ { Count = 256 * 1024 / sizeof(T) }; @@ -70,7 +70,7 @@ template<typename Vec> void streamingAndAlignedStore() { typedef typename Vec::EntryType T; - enum { + enum JustAnotherName__ { Count = 256 * 1024 / sizeof(T) }; @@ -92,7 +92,7 @@ template<typename Vec> void streamingAndUnalignedStore() { typedef typename Vec::EntryType T; - enum { + enum JustAnotherName__ { Count = 256 * 1024 / sizeof(T) }; @@ -126,7 +126,7 @@ const int count = 256 * 1024 / sizeof(T); const int outerCount = count / Vec::Size; Vc::Memory<Vec> array(count); - array.setZero(); + array.setZero(); const T nullValue = 0; const T setValue = 170; const Vec x(setValue); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/tests/unittest.h new/Vc-0.7.5/tests/unittest.h --- old/Vc-0.7.4/tests/unittest.h 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/tests/unittest.h 2015-08-26 15:22:18.000000000 +0200 @@ -68,17 +68,20 @@ std::cout << AnsiColor::green << " PASS: " << AnsiColor::normal; } -bool _UnitTest_verify_vector_unit_supported() +namespace { - bool s = Vc::currentImplementationSupported(); - if (!s) { - std::cerr << "CPU or OS requirements not met for the compiled in vector unit!\n"; - exit(-1); +struct verify_vector_unit_supported +{ + verify_vector_unit_supported() + { + if (!Vc::currentImplementationSupported()) { + std::cerr + << "CPU or OS requirements not met for the compiled in vector unit!\n"; + exit(-1); + } } - return s; -} - -static bool _UnitTest_verify_vector_unit_supported_result = _UnitTest_verify_vector_unit_supported(); +} verify_vector_unit_supported__; +} // unnamed namespace class _UnitTest_Failure { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Vc-0.7.4/tests/utils.cpp new/Vc-0.7.5/tests/utils.cpp --- old/Vc-0.7.4/tests/utils.cpp 2014-05-15 13:38:24.000000000 +0200 +++ new/Vc-0.7.5/tests/utils.cpp 2015-08-26 15:22:18.000000000 +0200 @@ -154,7 +154,7 @@ template<typename V> void Random() { typedef typename V::EntryType T; - enum { + enum JustAnotherName__ { NBits = 3, NBins = 1 << NBits, // short int TotalBits = sizeof(T) * 8, // 16 32 @@ -200,7 +200,7 @@ template<typename V, typename I> void FloatRandom() { typedef typename V::EntryType T; - enum { + enum JustAnotherName__ { NBins = 64, NHistograms = 1, Mean = 135791,
