cmake examples

ornladios/ADIOS2 cmake/DetectOptions.cmake :480

check_cxx_source_runs([=[
    #include <chrono>
    #include <future>
    #include <mpi.h>
    #include <thread>
    #include <stdlib.h>

    #if !defined(MPICH)
    #error "MPICH is the only supported library"
    #endif

    int main()
    {
      // Timeout after 5 second
      auto task = std::async(std::launch::async, []() {
                             std::this_thread::sleep_for(std::chrono::seconds(5));
                             exit(EXIT_FAILURE);
      });

      char* port_name = new char[MPI_MAX_PORT_NAME];
      MPI_Init_thread(NULL, NULL, MPI_THREAD_MULTIPLE, NULL);
      MPI_Open_port(MPI_INFO_NULL, port_name);
      MPI_Close_port(port_name);
      MPI_Finalize();
      exit(EXIT_SUCCESS);
    }]=]
ADIOS2_SST_HAVE_MPI_DP_HEURISTICS_PASSED)

projectchrono/chrono cmake/FindSIMD.cmake :27

check_cxx_source_runs("
#include <emmintrin.h>
#include <nmmintrin.h>
int main()
{
  long long a[2] = {  1, 2 };
  long long b[2] = { -1, 3 };
  long long c[2];
  __m128i va = _mm_loadu_si128((__m128i*)a);
  __m128i vb = _mm_loadu_si128((__m128i*)b);
  __m128i vc = _mm_cmpgt_epi64(va, vb);

  _mm_storeu_si128((__m128i*)c, vc);
  if (c[0] == -1LL && c[1] == 0LL)
    return 0;
  else
    return 1;
}" 
DETECTED_SSE_42)

projectchrono/chrono cmake/FindSIMD.cmake :53

check_cxx_source_runs("
#include <emmintrin.h>
#include <smmintrin.h>
int main()
{
  long long a[2] = {  1, 2 };
  long long b[2] = { -1, 2 };
  long long c[2];
  __m128i va = _mm_loadu_si128((__m128i*)a);
  __m128i vb = _mm_loadu_si128((__m128i*)b);
  __m128i vc = _mm_cmpeq_epi64(va, vb);

  _mm_storeu_si128((__m128i*)c, vc);
  if (c[0] == 0LL && c[1] == -1LL)
    return 0;
  else
    return 1;
}" DETECTED_SSE_41)

projectchrono/chrono cmake/FindSIMD.cmake :78

check_cxx_source_runs("
#include <emmintrin.h>
#ifdef _WIN32
  #include <intrin.h>
#else
  #include <x86intrin.h>
#endif

int main()
{
  float a[4] = { 1.0f, 2.0f, 3.0f, 4.0f };
  float b[4] = { 3.0f, 5.0f, 7.0f, 9.0f };
  float c[4];

  __m128 va = _mm_loadu_ps(a);
  __m128 vb = _mm_loadu_ps(b);
  __m128 vc = _mm_hadd_ps(va, vb);

  _mm_storeu_ps(c, vc);
  if (c[0] == 3.0f && c[1] == 7.0f && c[2] == 8.0f && c[3] == 16.0f)
    return 0;
  else
    return 1;
}" DETECTED_SSE_30)

projectchrono/chrono cmake/FindSIMD.cmake :184

check_cxx_source_runs("
#include <immintrin.h>
int main()
  {
  __m256d a = _mm256_set_pd (-1, 2, -3, 4);
  __m256d b = _mm256_set_pd (-2, 3, -4, 1);
  __m256d c = _mm256_set_pd (-11, 6, 4, -1);

  __m256d result =  _mm256_fmsub_pd (a, b, c);
  return 0;
  }" DETECTED_FMA)

projectchrono/chrono cmake/FindSIMD.cmake :236

check_cxx_source_runs("
#include <immintrin.h>
int main()
  {
  __m256i a = _mm256_set_epi32 (-1, 2, -3, 4, -1, 2, -3, 4);
  __m256i result = _mm256_abs_epi32 (a);
  return 0;
  }" AVX2_FOUND)

projectchrono/chrono cmake/FindSIMD.cmake :282

check_cxx_source_runs("
#include <immintrin.h>
int main()
  {
  __m256 a = _mm256_set_ps (-1.0f, 2.0f, -3.0f, 4.0f, -1.0f, 2.0f, -3.0f, 4.0f);
  __m256 b = _mm256_set_ps (1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f);
  __m256 result = _mm256_add_ps (a, b);
  return 0;
  }" AVX_FOUND)

projectchrono/chrono cmake/FindSIMD.cmake :325

check_cxx_source_runs("
#include <arm_neon.h>
int main()
{
  float64_t a[2] = {  1., 2. };
  float64_t b[2] = { -1., 3. };
  float64_t c[2];

  float64x2_t va = vld1q_f64(&a[0]);
  float64x2_t vb = vld1q_f64(&b[0]);
  float64x2_t vc = vaddq_f64(va, vb);
  vst1q_f64(&c[0], vc);

  if (c[0] == 0. && c[1] == 5.)
    return 0;
  else
    return 0;
}
" DETECTED_NEON)

mono/corert src/Native/gc/unix/configure.cmake :25

check_cxx_source_runs("
    #include <sched.h>

    int main()
    {
        int result = sched_getcpu();
        if (result == -1)
        {
            return 1;
        }

        return 0;
    }
    " HAVE_SCHED_GETCPU)

mono/corert src/Native/Runtime/unix/configure.cmake :53

check_cxx_source_runs("
#include <stdlib.h>
#include <sched.h>

int main(void)
{
  if (sched_getcpu() >= 0)
  {
    exit(0);
  }
  exit(1);
}" HAVE_SCHED_GETCPU)

mono/corert src/Native/Runtime/unix/configure.cmake :67

check_cxx_source_runs("
#include <stdlib.h>
#include <time.h>
#include <sys/time.h>

int main()
{
  int ret;
  struct timespec ts;
  ret = clock_gettime(CLOCK_MONOTONIC, &ts);

  exit(ret);
}" HAVE_CLOCK_MONOTONIC)

mono/corert src/Native/Runtime/unix/configure.cmake :81

check_cxx_source_runs("
#include <stdlib.h>
#include <time.h>
#include <sys/time.h>

int main()
{
  int ret;
  struct timespec ts;
  ret = clock_gettime(CLOCK_MONOTONIC_COARSE, &ts);

  exit(ret);
}" HAVE_CLOCK_MONOTONIC_COARSE)

mono/corert src/Native/Runtime/unix/configure.cmake :95

check_cxx_source_runs("
#include <stdlib.h>
#include <mach/mach_time.h>

int main()
{
  int ret;
  mach_timebase_info_data_t timebaseInfo;
  ret = mach_timebase_info(&timebaseInfo);
  mach_absolute_time();
  exit(ret);
}" HAVE_MACH_ABSOLUTE_TIME)

mono/corert src/Native/System.Private.CoreLib.Native/configure.cmake :8

check_cxx_source_runs("
#include <stdlib.h>
#include <time.h>
#include <sys/time.h>

int main()
{
  int ret;
  struct timespec ts;
  ret = clock_gettime(CLOCK_MONOTONIC, &ts);

  exit(ret);
}" HAVE_CLOCK_MONOTONIC)

mono/corert src/Native/System.Private.CoreLib.Native/configure.cmake :22

check_cxx_source_runs("
#include <stdlib.h>
#include <time.h>
#include <sys/time.h>

int main()
{
  int ret;
  struct timespec ts;
  ret = clock_gettime(CLOCK_MONOTONIC_COARSE, &ts);

  exit(ret);
}" HAVE_CLOCK_MONOTONIC_COARSE)

mono/corert src/Native/System.Private.CoreLib.Native/configure.cmake :36

check_cxx_source_runs("
#include <stdlib.h>
#include <mach/mach_time.h>

int main()
{
  int ret;
  mach_timebase_info_data_t timebaseInfo;
  ret = mach_timebase_info(&timebaseInfo);
  mach_absolute_time();
  exit(ret);
}" HAVE_MACH_ABSOLUTE_TIME)

mono/corert src/Native/System.Private.CoreLib.Native/configure.cmake :50

check_cxx_source_runs("
#include <stdlib.h>
#include <sched.h>

int main(void)
{
  if (sched_getcpu() >= 0)
  {
    exit(0);
  }
  exit(1);
}" HAVE_SCHED_GETCPU)

libcpr/cpr cmake/sanitizer.cmake :12

check_cxx_source_runs("int main() { return 0; }" THREAD_SANITIZER_AVAILABLE_AND_ENABLED)

libcpr/cpr cmake/sanitizer.cmake :22

check_cxx_source_runs("int main() { return 0; }" ADDRESS_SANITIZER_AVAILABLE_AND_ENABLED)

libcpr/cpr cmake/sanitizer.cmake :34

check_cxx_source_runs("int main() { return 0; }" LEAK_SANITIZER_AVAILABLE_AND_ENABLED)

libcpr/cpr cmake/sanitizer.cmake :46

check_cxx_source_runs("int main() { return 0; }" UNDEFINED_BEHAVIOR_SANITIZER_AVAILABLE_AND_ENABLED)

libcpr/cpr cmake/sanitizer.cmake :57

check_cxx_source_runs("int main() { return 0; }" ALL_SANITIZERS_AVAILABLE_AND_ENABLED)

facebook/folly CMake/FollyConfigChecks.cmake :111

check_cxx_source_runs("
  int main(int, char**) {
    char buf[64] = {0};
    unsigned long *ptr = (unsigned long *)(buf + 1);
    *ptr = 0xdeadbeef;
    return (*ptr & 0xff) == 0xef ? 0 : 1;
  }"
  FOLLY_HAVE_UNALIGNED_ACCESS
)

facebook/folly CMake/FollyConfigChecks.cmake :128

check_cxx_source_runs("
  extern \"C\" int folly_example_undefined_weak_symbol() __attribute__((weak));
  int main(int argc, char** argv) {
    auto f = folly_example_undefined_weak_symbol; // null pointer
    return f ? f() : 0; // must compile, link, and run with null pointer
  }"
  FOLLY_HAVE_WEAK_SYMBOLS
)

facebook/folly CMake/FollyConfigChecks.cmake :136

check_cxx_source_runs("
  #include <dlfcn.h>
  int main() {
    void *h = dlopen(\"linux-vdso.so.1\", RTLD_LAZY | RTLD_LOCAL | RTLD_NOLOAD);
    if (h == nullptr) {
      return -1;
    }
    dlclose(h);
    return 0;
  }"
  FOLLY_HAVE_LINUX_VDSO
)

facebook/folly CMake/FollyConfigChecks.cmake :149

check_cxx_source_runs("
  #include <cstddef>
  #include <cwchar>
  int main(int argc, char** argv) {
    return wcstol(L\"01\", nullptr, 10) == 1 ? 0 : 1;
  }"
  FOLLY_HAVE_WCHAR_SUPPORT
)

facebook/folly CMake/FollyConfigChecks.cmake :167

check_cxx_source_runs("
  #include <stdarg.h>
  #include <stdio.h>

  int call_vsnprintf(const char* fmt, ...) {
    char buf[256];
    va_list ap;
    va_start(ap, fmt);
    int result = vsnprintf(buf, sizeof(buf), fmt, ap);
    va_end(ap);
    return result;
  }

  int main(int argc, char** argv) {
    return call_vsnprintf(\"%\", 1) < 0 ? 0 : 1;
  }"
  HAVE_VSNPRINTF_ERRORS
)

OSGeo/gdal cmake/helpers/CheckDependentLibraries.cmake :70

check_cxx_source_runs("${ICONV_HAS_EXTRA_CHARSETS_CODE}" ICONV_HAS_EXTRA_CHARSETS)

google/glog CMakeLists.txt :250

check_cxx_source_runs ([=[
#include <windows.h>
#include <dbghelp.h>
#include <cstdlib>

void foobar() { }

int main()
{
    HANDLE process = GetCurrentProcess();

    if (!SymInitialize(process, NULL, TRUE))
        return EXIT_FAILURE;

    char buf[sizeof(SYMBOL_INFO) + MAX_SYM_NAME];
    SYMBOL_INFO *symbol = reinterpret_cast<SYMBOL_INFO *>(buf);
    symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
    symbol->MaxNameLen = MAX_SYM_NAME;

    void* const pc = reinterpret_cast<void*>(&foobar);
    BOOL ret = SymFromAddr(process, reinterpret_cast<DWORD64>(pc), 0, symbol);

    return ret ? EXIT_SUCCESS : EXIT_FAILURE;
}
]=] HAVE_SYMBOLIZE)

InsightSoftwareConsortium/ITK CMake/ITKSetStandardCompilerFlags.cmake :171

check_cxx_source_runs(
  "
  #include <immintrin.h>
  int main()
  {
    __m256 a, b, c;
    const float src[8] = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f };
    float dst[8];
    a = _mm256_loadu_ps(src);
    b = _mm256_loadu_ps(src);
    c = _mm256_add_ps(a, b);
    _mm256_storeu_ps(dst, c);

    for(int i = 0; i < 8; i++){
      if(( src[i] + src[i]) != dst[i]){
        return -1;
      }
    }

    return 0;
  }"
  have_avx_extensions_var)

InsightSoftwareConsortium/ITK CMake/ITKSetStandardCompilerFlags.cmake :198

check_cxx_source_runs(
  "
  #include <immintrin.h>
  int main()
  {
    __m256i a, b, c;
    const int src[8] = { 1, 2, 3, 4, 5, 6, 7, 8 };
    int dst[8];
    a =  _mm256_loadu_si256( (__m256i*)src);
    b =  _mm256_loadu_si256( (__m256i*)src);
    c = _mm256_add_epi32( a, b);
    _mm256_storeu_si256( (__m256i*)dst, c);

    for(int i = 0; i < 8; i++){
      if(( src[i] + src[i]) != dst[i]){
        return -1;
      }
    }

    return 0;
  }"
  have_avx2_extensions_var)

InsightSoftwareConsortium/ITK CMake/ITKSetStandardCompilerFlags.cmake :246

check_cxx_source_runs(
  "
    #include <emmintrin.h>
    int main()
    {
      //try to do some sse2 calculations
      double d_a[]  = { 6.75, 3.42 };
      double d_b[]  = { 2.3, 9.2 };
      double res[2] = {0.0};

      __m128d z;
      z = _mm_mul_pd(_mm_loadu_pd(d_a),_mm_loadu_pd(d_b));

      _mm_storeu_pd(res,z);

      return 0;
    }"
  have_sse2_extensions_var)

ledger/ledger CMakeLists.txt :173

check_cxx_source_runs("
#include <boost/regex/icu.hpp>

using namespace boost;

int main() {
  std::string text = \"Активы\";
  u32regex r = make_u32regex(\"активы\", regex::perl | regex::icase);
  return u32regex_search(text, r) ? 0 : 1;
}" BOOST_REGEX_UNICODE_RUNS)

LibreSprite/LibreSprite CMakeLists.txt :214

  check_cxx_source_runs("
    #include <v8.h>
    #include <libplatform/libplatform.h>
    int main(void) {
      v8::V8::InitializeICU();
      static std::unique_ptr<v8::Platform> m_platform;
      m_platform = v8::platform::NewDefaultPlatform();
      v8::V8::InitializePlatform(m_platform.get());
      v8::V8::Initialize();
      return 0;
    }
	" DISABLE_POINTER_COMPRESSION)

mfem/mfem config/cmake/modules/FindPackageMultipass.cmake :125

check_cxx_source_runs ("${source}" ${testname})

ollama/ollama ml/backend/ggml/ggml/src/ggml-cpu/CMakeLists.txt :124

check_cxx_source_runs("${code}" GGML_MACHINE_SUPPORTS_${tag})

onnx/onnx cmake/external/FindSanitizer.cmake :104

check_cxx_source_runs("${_source_code}" __res)

onnx/onnx cmake/external/FindSanitizer.cmake :119

check_cxx_source_runs("${_bug_${sanitizer_name}_code}" __res)

openbabel/openbabel cmake/modules/OptimizeNative.cmake :33

check_cxx_source_runs("
  #include <emmintrin.h>
  int main() {
    __m128d a, b;
    double vals[2] = {0};
    a = _mm_loadu_pd(vals);
    b = _mm_add_pd(a, a);
    _mm_storeu_pd(vals, b);
    return 0;
  }"
  HAVE_SSE2)

openbabel/openbabel cmake/modules/OptimizeNative.cmake :46

check_cxx_source_runs("
  #include <emmintrin.h>
  #include <nmmintrin.h>
  int main() {
    long long a[2] = { 1, 2};
    long long b[2] = {-1, 3};
    long long c[2];
    __m128i va = _mm_loadu_si128((__m128i*)a);
    __m128i vb = _mm_loadu_si128((__m128i*)b);
    __m128i vc = _mm_cmpgt_epi64(va, vb);
    _mm_storeu_si128((__m128i*)c, vc);
    if (c[0] == -1LL && c[1] == 0LL)
      return 0;
    else
      return 1;
  }"
  HAVE_SSE4_2)

openbabel/openbabel cmake/modules/OptimizeNative.cmake :65

check_cxx_source_runs("
  #include <immintrin.h>
  int main()
  {
    __m256 a;
    a = _mm256_set1_ps(0);
    return 0;
  }"
  HAVE_AVX)

openbabel/openbabel cmake/modules/OptimizeNative.cmake :76

check_cxx_source_runs("
  #include <immintrin.h>
  int main()
  {
    __m256i a = {0};
    a = _mm256_abs_epi16(a);
    return 0;
  }"
  HAVE_AVX2)

openscenegraph/OpenSceneGraph CMakeModules/CheckAtomicOps.cmake :32

CHECK_CXX_SOURCE_RUNS("
#include <cstdlib>

int main()
{
   unsigned value = 0;
   void* ptr = &value;
   __sync_add_and_fetch(&value, 1);
   __sync_synchronize();
   __sync_sub_and_fetch(&value, 1);
   if (!__sync_bool_compare_and_swap(&value, 0, 1))
      return EXIT_FAILURE;

   if (!__sync_bool_compare_and_swap(&ptr, ptr, ptr))
      return EXIT_FAILURE;

   return EXIT_SUCCESS;
}
" _OPENTHREADS_ATOMIC_USE_GCC_BUILTINS)

openscenegraph/OpenSceneGraph CMakeModules/CheckAtomicOps.cmake :52

CHECK_CXX_SOURCE_RUNS("
#include <stdlib.h>

int main(int, const char**)
{
   unsigned value = 0;
   void* ptr = &value;
   __add_and_fetch(&value, 1);
   __synchronize(value);
   __sub_and_fetch(&value, 1);
   if (!__compare_and_swap(&value, 0, 1))
      return EXIT_FAILURE;

   if (!__compare_and_swap((unsigned long*)&ptr, (unsigned long)ptr, (unsigned long)ptr))
      return EXIT_FAILURE;

   return EXIT_SUCCESS;
}
" _OPENTHREADS_ATOMIC_USE_MIPOSPRO_BUILTINS)

openscenegraph/OpenSceneGraph CMakeModules/CheckAtomicOps.cmake :72

CHECK_CXX_SOURCE_RUNS("
#include <atomic.h>
#include <cstdlib>

int main(int, const char**)
{
   uint_t value = 0;
   void* ptr = &value;
   atomic_inc_uint_nv(&value);
   membar_consumer();
   atomic_dec_uint_nv(&value);
   if (0 != atomic_cas_uint(&value, 0, 1))
      return EXIT_FAILURE;

   if (ptr != atomic_cas_ptr(&ptr, ptr, ptr))
      return EXIT_FAILURE;

   return EXIT_SUCCESS;
}
" _OPENTHREADS_ATOMIC_USE_SUN)

openscenegraph/OpenSceneGraph CMakeModules/CheckAtomicOps.cmake :93

CHECK_CXX_SOURCE_RUNS("
#include <windows.h>
#include <intrin.h>
#include <cstdlib>

#pragma intrinsic(_InterlockedAnd)
#pragma intrinsic(_InterlockedOr)
#pragma intrinsic(_InterlockedXor)

int main(int, const char**)
{
   volatile long value = 0;
   long data = 0;
   long* volatile ptr = &data;

   InterlockedIncrement(&value);
   MemoryBarrier();
   InterlockedDecrement(&value);

   if (0 != InterlockedCompareExchange(&value, 1, 0))
      return EXIT_FAILURE;

   if (ptr != InterlockedCompareExchangePointer((PVOID volatile*)&ptr, (PVOID)ptr, (PVOID)ptr))
      return EXIT_FAILURE;

   return EXIT_SUCCESS;
}
" _OPENTHREADS_ATOMIC_USE_WIN32_INTERLOCKED)

openscenegraph/OpenSceneGraph CMakeModules/CheckAtomicOps.cmake :122

CHECK_CXX_SOURCE_RUNS("
#include <libkern/OSAtomic.h>

int main()
{
  volatile int32_t value = 0;
  long data = 0;
  long * volatile ptr = &data;

  OSAtomicIncrement32(&value);
  OSMemoryBarrier();
  OSAtomicDecrement32(&value);
  OSAtomicCompareAndSwapInt(value, 1, &value);
  OSAtomicCompareAndSwapPtr(ptr, ptr, (void * volatile *)&ptr);
}
" _OPENTHREADS_ATOMIC_USE_BSD_ATOMIC)

openscenegraph/OpenSceneGraph CMakeModules/FindPoppler-glib.cmake :15

CHECK_CXX_SOURCE_RUNS("
#include <cstdlib>
#include <poppler.h>
int main()
{
#ifdef POPPLER_HAS_CAIRO
   return EXIT_SUCCESS;
#else
   return EXIT_FAILURE
#endif
}
" POPPLER_HAS_CAIRO)

qtwebkit/qtwebkit Source/cmake/DetectSSE2.cmake :39

check_cxx_source_runs("
    #include <emmintrin.h>
    int main ()
    {
        __m128d a, b;
        double vals[2] = {0};
        a = _mm_loadu_pd (vals);
        b = _mm_add_pd (a,a);
        _mm_storeu_pd (vals,b);
        return 0;
    }"
    HAVE_SSE2_EXTENSIONS)

trilinos/Trilinos packages/kokkos-kernels/CheckHostBlasReturnComplex.cmake :49

CHECK_CXX_SOURCE_RUNS("${SOURCE}" KK_BLAS_RESULT_AS_POINTER_ARG)

trilinos/Trilinos packages/teuchos/cmake/CheckBlasFloat.cmake :57

CHECK_CXX_SOURCE_RUNS("${SOURCE}" ${VARNAME})

trilinos/Trilinos packages/teuchos/cmake/CheckBlasFloatAppleVeclibBugfix.cmake :42

CHECK_CXX_SOURCE_RUNS("${SOURCE}" ${VARNAME})

trilinos/Trilinos packages/teuchos/cmake/CheckBlasFloatReturnsDouble.cmake :57

CHECK_CXX_SOURCE_RUNS("${SOURCE}" ${VARNAME})

trilinos/Trilinos packages/teuchos/cmake/CheckCXXComplexBlasProblem.cmake :35

CHECK_CXX_SOURCE_RUNS("${SOURCE}" CXX_COMPLEX_BLAS_WORKS)

trilinos/Trilinos packages/teuchos/cmake/CheckCXXComplexBlasProblemCanBeFixed.cmake :35

CHECK_CXX_SOURCE_RUNS("${SOURCE}" ${VARNAME})

trilinos/Trilinos packages/teuchos/cmake/CheckCXXComplexBlasProblemCanBeFixed.cmake :64

CHECK_CXX_SOURCE_RUNS("${SOURCE}" ${VARNAME})

trilinos/Trilinos packages/teuchos/cmake/CheckForAbiDemangle.cmake :30

CHECK_CXX_SOURCE_RUNS("${SOURCE}" ${VARNAME})

trilinos/Trilinos packages/teuchos/cmake/CheckLapackLARND.cmake :29

CHECK_CXX_SOURCE_RUNS("${SOURCE}" ${VARNAME})

trilinos/Trilinos packages/teuchos/cmake/CheckSlapy2Problem.cmake :24

CHECK_CXX_SOURCE_RUNS("${SOURCE}" LAPACK_SLAPY2_WORKS)

trilinos/Trilinos packages/teuchos/cmake/CheckSlapy2ReturnsDouble.cmake :24

CHECK_CXX_SOURCE_RUNS("${SOURCE}" LAPACK_SLAPY2_WITH_DOUBLE_WORKS)

movableink/webkit Source/cmake/DetectSSE2.cmake :39

check_cxx_source_runs("
    #include <emmintrin.h>
    int main ()
    {
        __m128d a, b;
        double vals[2] = {0};
        a = _mm_loadu_pd (vals);
        b = _mm_add_pd (a,a);
        _mm_storeu_pd (vals,b);
        return 0;
    }"
    HAVE_SSE2_EXTENSIONS)

cmake check_cxx_source_runs() examples