cmake check_cxx_source

check_cxx_source_runs(<code> <resultVar>)

geodynamics/aspect cmake/fpe_check.cmake :24

check_cxx_source_runs("
#include <fenv.h>
#include <limits>
#include <sstream>

#include <deal.II/base/utilities.h>

int main()
{
  // Some implementations seem to not initialize the FPE bits to zero.
  // Make sure we start from a clean state
  feclearexcept(FE_DIVBYZERO|FE_INVALID);

  // Enable floating point exceptions
  feenableexcept(FE_DIVBYZERO|FE_INVALID);

  std::ostringstream description;
  const double lower_bound = -std::numeric_limits<double>::max();

  description << lower_bound;
  description << dealii::Utilities::string_to_int (\"1\");

  return 0;
}
" HAVE_FP_EXCEPTIONS)

STORM-IRIT/Radium-Engine cmake/FindFilesystem.cmake :119

check_cxx_source_runs("${code}" ${var})

ANTsX/ANTs CMake/ITKSetStandardCompilerFlags.cmake :153

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)

maidsafe-archive/MaidSafe cmake_modules/find_ubsan.cmake :69

check_cxx_source_runs(
"
#include <cstdio>
#include <cstdlib>
#include <iostream>

class BarB
{
    public:
        float y;
        /* Include something that uses a virtual function. The symbols
           that are broken on current OS X libc++ involve this */
        virtual int arst(int o)
        {
            return 4 + o;
        }
    };

/* Just include something that ubsan will need to check */
int main(int argc, const char* argv[])
{
    BarB* b = new BarB();
    if (argc > 1)
    {
        fputs(argv[atoi(argv[1])], stdout);
        std::cout << b->arst(atoi(argv[1]));
    }

    delete b;
    return 0;
}
"
  HAVE_UNDEFINED_BEHAVIOR_SANITIZER)

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
)

mariadb-corporation/MaxScale cmake/CheckPlatform.cmake :100

check_cxx_source_runs("${TEST_CODE}" CRYPT_R_WORKS_WITH_ASAN)

mapnik/mapnik cmake/CheckBoostRegexIcu.cmake :5

check_cxx_source_runs([[
    #include <boost/regex/icu.hpp>
    #include <unicode/unistr.h>
    int main()
    {
        U_NAMESPACE_QUALIFIER UnicodeString ustr;
        try {
            boost::u32regex pattern = boost::make_u32regex(ustr);
        }
        // an exception is fine, still indicates support is
        // likely compiled into regex
        catch (...) {
            return 0;
        }
        return 0;
    }
    ]] BOOST_REGEX_HAS_ICU)

Kitware/ParaView CMakeLists.txt :161

check_cxx_source_runs("${VTK_REQUIRE_LARGE_FILE_SUPPORT_FILE}"
  CMAKE_REQUIRE_LARGE_FILE_SUPPORT)

BRAINSia/BRAINSTools Common.cmake :313

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)

emsec/hal cmake/FindFilesystem.cmake :190

check_cxx_source_runs("${code}" CXX_FILESYSTEM_NO_LINK_NEEDED)

trailofbits/pasta cmake/modules/FindFilesystem.cmake :122

check_cxx_source_runs("${code}" ${var})

Genivia/RE-flex cmake/SIMDTestAndSetup.cmake :13

check_cxx_source_runs("
    #include <immintrin.h>
    int main() {
      __m512 n = _mm512_set1_epi8(42);
      (void)_mm512_cmpeq_epi8_mask(n, n);
      return 0;
    }
  " HAVE_AVX512BW)

ceph/ceph cmake/modules/CephChecks.cmake :111

check_cxx_source_runs("
#include <cstdint>
#include <iterator>

#ifdef _WIN32
#include <winsock2.h>
#else
#include <arpa/inet.h>
#endif

uint32_t load(char* p, size_t offset)
{
  return *reinterpret_cast<uint32_t*>(p + offset);
}

bool good(uint32_t lhs, uint32_t big_endian)
{
  return lhs == ntohl(big_endian);
}

int main(int argc, char **argv)
{
  char a1[] = \"ABCDEFG\";
  uint32_t a2[] = {0x41424344,
                   0x42434445,
                   0x43444546,
                   0x44454647};
  for (size_t i = 0; i < std::size(a2); i++) {
    if (!good(load(a1, i), a2[i])) {
      return 1;
    }
  }
}"
    HAVE_UNALIGNED_ACCESS)

root-project/root cmake/modules/CheckIntrinsics.cmake :13

CHECK_CXX_SOURCE_RUNS("#include <immintrin.h> \n int main () {__m256i xmm =  _mm256_set1_epi64x(0); xmm =  _mm256_add_epi64(xmm,xmm);};" AVX2_RUN)

percona/percona-xtrabackup cmake/floating_point.cmake :61

CHECK_CXX_SOURCE_RUNS("${code}" HAVE_CXX_FLOATING_POINT_FUSED_MADD)

mysql/mysql-server cmake/floating_point.cmake :61

CHECK_CXX_SOURCE_RUNS("${code}" HAVE_CXX_FLOATING_POINT_FUSED_MADD)

manticoresoftware/manticoresearch cmake/check_unaligned_ram_access.cmake :3

CHECK_CXX_SOURCE_RUNS ( "
#include <stdlib.h>
#include <string.h>

int main()
{
int ichars[8];
char * sBuf = (char*)ichars;
for ( int i=0; i<8*sizeof(int); i++ )
	sBuf[i] = i;

// check for crashes (SPARC)
volatile int iRes = 0;
for ( int i=0; i<(int)sizeof(int); ++i )
{
	int * pPtr = (int*)( sBuf+i );
	iRes += *pPtr;
}

// check for correct values (ARM)
iRes = *(int*)( sBuf+1 );
if (!( iRes==0x01020304 || iRes==0x04030201 ))
	return 1;
// all seems ok
return 0;
}
" UNALIGNED_RAM_ACCESS )

scylladb/seastar cmake/FindSourceLocation.cmake :35

check_cxx_source_runs ("${_source_location_test_code}" CxxSourceLocation_IMPLEMENTS_CWG2631)

alibaba/AliSQL configure.cmake :97

CHECK_CXX_SOURCE_RUNS("
#include <ciso646>
int main()
{
#ifdef _LIBCPP_VERSION
  return 0;
#else
  return 1;
#endif
}" HAVE_LLVM_LIBCPP)

Codesire-Deng/co_context cmake/check/check_asan.cmake :4

check_cxx_source_runs(
        [====[
        int main()
        {
            return 0;
        }
        ]====]
        ${_RESULT}
    )

muse-sequencer/muse src/cmake/CheckIStringStreamHexfloat.cmake :4

check_cxx_source_runs("
  #include <sstream>
  #include <clocale>
  int main() {
  std::istringstream ss(\"0x1.8p+0\");
  ss.imbue(std::locale(\"C\"));
  double value = 0.0;
  ss >> value;
  return value != 1.5;
  }
  " ${varname})

strawberrymusicplayer/strawberry CMakeLists.txt :394

check_cxx_source_runs("
    #include <QCoreApplication>
    #include <QSqlDatabase>
    #include <QSqlQuery>
    int main(int argc, char *argv[]) {
      QCoreApplication app(argc, argv);
      QSqlDatabase db = QSqlDatabase::addDatabase(\"QSQLITE\");
      db.setDatabaseName(\":memory:\");
      if (!db.open()) { return 1; }
      QSqlQuery q(db);
      q.prepare(\"CREATE TABLE test (test TEXT);\");
      if (!q.exec()) return 1;
    }
    "
    QT_SQLITE_TEST
  )

InsightSoftwareConsortium/ITK CMake/ITKSetStandardCompilerFlags.cmake :167

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
  )

ladnir/cryptoTools cmake/CheckISA.cmake :45

check_cxx_source_runs("${TEST_SRC}" ${_KEY})

logicalclocks/rondb cmake/floating_point.cmake :61

CHECK_CXX_SOURCE_RUNS("${code}" HAVE_CXX_FLOATING_POINT_FUSED_MADD)

Warzone2100/warzone2100 .ci/vcpkg/overlay-ports/angle/cmake-buildsystem/cmake/DetectSSE2.cmake :41

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)

Jackarain/proxy third_party/boost/libs/charconv/CMakeLists.txt :37

check_cxx_source_runs("${BOOST_CHARCONV_QUADMATH_TEST_SOURCE}" BOOST_CHARCONV_QUADMATH_FOUND)

chsl/PLADE code/3rd_party/pcl-1.8.1/cmake/pcl_find_sse.cmake :34

check_cxx_source_runs("
        #include <mm_malloc.h>
        int main()
        {
          void* mem = _mm_malloc (100, 16);
          return 0;
        }"
        HAVE_MM_MALLOC)

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)

boutproject/BOUT-dev cmake/FindPackageMultipass.cmake :101

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

sxs-collaboration/spectre cmake/SetupHdf5.cmake :134

check_cxx_source_runs(
  [=[
#include <hdf5.h>

#ifdef __APPLE__
#ifndef __arm64__
#define SPECTRE_FPE_CSR 1
#include <xmmintrin.h>
#endif
#else
#define SPECTRE_FPE_FENV 1
#include <cfenv>
#endif

int main(int /*argc*/, char** /*argv*/) {
#if SPECTRE_FPE_CSR
  _mm_setcsr(_MM_MASK_MASK &
             ~(_MM_MASK_OVERFLOW | _MM_MASK_INVALID | _MM_MASK_DIV_ZERO));
#elif SPECTRE_FPE_FENV
  feenableexcept(FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW);
#endif
  H5Tcopy(H5T_NATIVE_DOUBLE);
  return 0;
}
]=]
  HDF5_INIT_WITHOUT_FPES
  )

ledger/ledger CMakeLists.txt :173

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

using namespace boost;

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

mysql/mysql-shell configure.cmake :74

CHECK_CXX_SOURCE_RUNS("
#include <ciso646>
int main()
{
#ifdef _LIBCPP_VERSION
  return 0;
#else
  return 1;
#endif
}" HAVE_LLVM_LIBCPP)

john30/ebusd CMakeLists.txt :139

check_cxx_source_runs("
#include <stdint.h>
int main() {
  union {
    uint32_t i;
    float f;
  } test;
  test.f = 0.15;
  return test.i == 0x3e19999a ? 0 : 1;
}
" HAVE_DIRECT_FLOAT_FORMAT)

QMCPACK/qmcpack src/QMCTools/ppconvert/CMakeLists.txt :23

check_cxx_source_runs(
"
#include <cmath>
int main()
{
  if (std::isnan(std::sqrt(-1.)))
    return 0;
  return 1;
}
"
  ISNAN_WORKS)

facebook/mysql-5.6 cmake/compiler_features.cmake :28

CHECK_CXX_SOURCE_RUNS("
  int main() {
    return !__builtin_cpu_supports(\"${FEATURE}\");
  }
  " HAVE_X86_CPU_FEATURE_${FEATURE})

polardb/polardbx-engine cmake/floating_point.cmake :56

CHECK_CXX_SOURCE_RUNS("${code}" HAVE_CXX_FLOATING_POINT_FUSED_MADD)

dealii/dealii cmake/checks/check_01_cpu_features.cmake :78

CHECK_CXX_SOURCE_RUNS(
    "
    #include <x86intrin.h>
    int main()
    {
    __m128d a, b;
    const unsigned int vector_bytes = sizeof(__m128d);
    const int n_vectors = vector_bytes/sizeof(double);
    __m128d * data =
      reinterpret_cast<__m128d*>(_mm_malloc (2*vector_bytes, vector_bytes));
    double * ptr = reinterpret_cast<double*>(&a);
    ptr[0] = static_cast<volatile double>(1.0);
    for (int i=1; i<n_vectors; ++i)
      ptr[i] = 0.0;
    b = _mm_set1_pd (static_cast<volatile double>(2.25));
    data[0] = _mm_add_pd (a, b);
    data[1] = _mm_mul_pd (b, data[0]);
    ptr = reinterpret_cast<double*>(&data[1]);
    int return_value = 0;
    if (ptr[0] != 7.3125)
      return_value = 1;
    for (int i=1; i<n_vectors; ++i)
      if (ptr[i] != 5.0625)
        return_value = 1;
    _mm_free (data);
    return return_value;
    }
    "
    DEAL_II_HAVE_SSE2)

douban/paracel cmakes/FindEigen.cmake :18

check_cxx_source_runs("
#include <eigen3/Eigen/Dense>
#include <eigen3/Eigen/Sparse>
int main(int argc, char *argv[])
{
  Eigen::VectorXd tmp(7);
  return 0;
}
" Eigen_CHECK_FINE)

PaddlePaddle/Paddle cmake/simd.cmake :44

check_cxx_source_runs(
  "
#include <mmintrin.h>
int main()
{
    _mm_setzero_si64();
    return 0;
}"
  MMX_FOUND)

feelpp/feelpp feelpp/cmake/modules/FindCLN.cmake :177

check_cxx_source_runs("
		#include <cln/version.h>
		int main() {
			return (CL_VERSION_MAJOR == cln::version_major) &&
			       (CL_VERSION_MINOR == cln::version_minor) &&
			       (CL_VERSION_PATCHLEVEL == cln::version_patchlevel) ? 0 : 1;
		}
		"
		_cl_version_matches)

ned14/llfio CMakeLists.txt :220

check_cxx_source_runs("${prog}" ${var})

PaddlePaddle/Serving cmake/simd.cmake :27

CHECK_CXX_SOURCE_RUNS("
#include <mmintrin.h>
int main()
{
    _mm_setzero_si64();
    return 0;
}" MMX_FOUND)

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

CHECK_CXX_SOURCE_RUNS("${SOURCE}" KK_BLAS_RESULT_AS_POINTER_ARG)

flashlight/flashlight cmake/FindFilesystem.cmake :119

check_cxx_source_runs("${code}" ${var})

GreatSQL/GreatSQL cmake/compiler_features.cmake :22

CHECK_CXX_SOURCE_RUNS("
#include <cstdint>
#include <nmmintrin.h>
int main() {
  auto x = _mm_crc32_u32(0, 0);
  return 0;
}
" HAVE_SSE42)

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)

cb-geo/mpm cmake/FindKaHIP.cmake :92

check_cxx_source_runs("
      #define MPICH_IGNORE_CXX_SEEK 1
      #include <mpi.h>

      #include <kaHIP_interface.h>

      int main()
      {

      int n = 5;
      int *xadj = new int[6];
      xadj[0] = 0;
      xadj[1] = 2;
      xadj[2] = 5;
      xadj[3] = 7;
      xadj[4] = 9;
      xadj[5] = 12;

      int *adjncy = new int[12];
      adjncy[0] = 1;
      adjncy[1] = 4;
      adjncy[2] = 0;
      adjncy[3] = 2;
      adjncy[4] = 4;
      adjncy[5] = 1;
      adjncy[6] = 3;
      adjncy[7] = 2;
      adjncy[8] = 4;
      adjncy[9] = 0;
      adjncy[10] = 1;
      adjncy[11] = 3;

      double imbalance = 0.03;
      int *part = new int[n];
      int edge_cut = 0;
      int nparts = 2;
      int *vwgt = nullptr;;
      int *adjcwgt = nullptr;;

      kaffpa(&n, vwgt, xadj, adjcwgt, adjncy, &nparts, &imbalance, false, 0, ECO,
             &edge_cut, part);

      return 0;
      }
      " KAHIP_TEST_RUNS)

percona/percona-xtradb-cluster cmake/compiler_features.cmake :28

CHECK_CXX_SOURCE_RUNS("
  int main() {
    return !__builtin_cpu_supports(\"${FEATURE}\");
  }
  " HAVE_X86_CPU_FEATURE_${FEATURE})

xrootd/xrootd cmake/XRootDSystemCheck.cmake :121

check_cxx_source_runs(
"
  int main()
  {
    unsigned long long val = 111, *mem = &val;

    if (__sync_fetch_and_add(&val, 111) != 111 || val != 222) return 1;
    if (__sync_add_and_fetch(&val, 111) != 333)               return 1;
    if (__sync_sub_and_fetch(&val, 111) != 222)               return 1;
    if (__sync_fetch_and_sub(&val, 111) != 222 || val != 111) return 1;

    if (__sync_fetch_and_or (&val, 0)   != 111 || val != 111) return 1;
    if (__sync_fetch_and_and(&val, 0)   != 111 || val != 0  ) return 1;

    if (__sync_bool_compare_and_swap(mem, 0, 444) == 0 || val != 444)
      return 1;

    return 0;
  }
"
  HAVE_ATOMICS )

ggml-org/llama.cpp ggml/src/ggml-cpu/CMakeLists.txt :140

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

zju-abclab/NEXUS thirdparty/SEAL-4.1-bs/cmake/CheckCXXIntrinsicsSpecific.cmake :13

check_cxx_source_runs("
            #include <${SEAL_INTRIN_HEADER}>
            int main() {
                unsigned long long a = 0, b = 0;
                unsigned long long c;
                volatile unsigned long long d;
                d = _umul128(a, b, &c);
                return 0;
            }"
            SEAL__UMUL128_FOUND
        )

microsoft/APSI cmake/DetectArch.cmake :7

check_cxx_source_runs("
        #if defined(_M_ARM64)
            int main() {
                return 0;
            }
        #else
            #error
        #endif
        "
        APSI_FOURQ_ARM64
    )

volkszaehler/vzlogger modules/CompilerFlags.cmake :118

check_cxx_source_runs("
		  #include <regex>

		  int main() {
		    return std::regex_match(\"test\", std::regex(\"\^\\\\\\\\s*(//(.*|)|\$)\"));
		  }
	" HAVE_CPP_REGEX)

Kitware/VTK CMakeLists.txt :153

check_cxx_source_runs("${VTK_REQUIRE_LARGE_FILE_SUPPORT_FILE}"
  VTK_REQUIRE_LARGE_FILE_SUPPORT)

SeisSol/SeisSol cmake/FindBLIS.cmake :49

check_cxx_source_runs("
  #include <blis.h>

  int main()
  {
    dim_t m = 4, n = 5, k = 3;
    inc_t rsa = 1, csa = m;
    inc_t rsb = 1, csb = k;
    inc_t rsc = 1, csc= m;

    double c[m * n];
    double a[m * k];
    double b[k * n];

    double alpha = 1.0;
	  double beta = 1.0;

    bli_dgemm(BLIS_NO_TRANSPOSE, BLIS_NO_TRANSPOSE,
	            m, n, k, 
              &alpha, a, rsa, csa, 
              b, rsb, csb, 
              &beta, c, rsc, csc);
  return 0;
  }
  " BLIS_TEST_RUNS)

percona/percona-server cmake/compiler_features.cmake :28

CHECK_CXX_SOURCE_RUNS("
  int main() {
    return !__builtin_cpu_supports(\"${FEATURE}\");
  }
  " HAVE_X86_CPU_FEATURE_${FEATURE})

torch/DEPRECEATED-torch7-distro lib/TH/cmake/FindSSE.cmake :67

CHECK_CXX_SOURCE_RUNS("${${type}_CODE}" ${lang}_HAS_${type}_${__FLAG_I})

steineggerlab/foldmason lib/foldseek/lib/mmseqs/cmake/CheckSSEFeatures.cmake :4

check_cxx_source_runs("
      #include <immintrin.h>
      int main()
      {
        volatile __m256i a, b;
        a = _mm256_set1_epi8 (1);
        b = _mm256_add_epi8 (a,a);
        return 0;
      }"
      HAVE_AVX2_EXTENSIONS)

oofem/oofem cmake/Modules/FindPackageMultipass.cmake :99

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

ucla-vision/xivo thirdparty/glog/CMakeLists.txt :406

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)

chatopera/clause thirdparty/glog/CMakeLists.txt :362

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)

Telosnex/fllama ios/llama.cpp/ggml/src/ggml-cpu/CMakeLists.txt :140

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

jrk/gradient-halide apps/linear_algebra/benchmarks/CMakeLists.txt :10

CHECK_CXX_SOURCE_RUNS(
    "#include <xmmintrin.h>
    #include <pmmintrin.h>
    int main()
    {
      // Flush denormals to zero (the FTZ flag).
      _MM_SET_FLUSH_ZERO_MODE(_MM_FLUSH_ZERO_ON);
      // Interpret denormal inputs as zero (the DAZ flag).
      _MM_SET_DENORMALS_ZERO_MODE(_MM_DENORMALS_ZERO_ON);
      return 0;
    }" CAN_ENABLE_FTZ_DAZ)

google/mysql-protobuf configure.cmake :80

CHECK_CXX_SOURCE_RUNS("
#include <ciso646>
int main()
{
#ifdef _LIBCPP_VERSION
  return 0;
#else
  return 1;
#endif
}" HAVE_LLVM_LIBCPP)

NGSolve/netgen CMakeLists.txt :545

check_cxx_source_runs("
                #include <immintrin.h>
                int main()
                {
                    __m256d a{1.,2.,3.,4.};
                    __m256d b{2.,0.,3.,5.};
                    __m256d c = _mm256_mul_pd(a,b);
                    return 0;
                } " NG_HAVE_AVX)

letoram/arcan src/platform/cmake/modules/FindSSE.cmake :69

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;
  }" SSE_42_DETECTED QUIET)

mongodb/mongo-bi-connector-odbc-driver configure.cmake :100

CHECK_CXX_SOURCE_RUNS("
#include <ciso646>
int main()
{
#ifdef _LIBCPP_VERSION
  return 0;
#else
  return 1;
#endif
}" HAVE_LLVM_LIBCPP)

merzlab/QUICK cmake/jedbrown/FindPackageMultipass.cmake :99

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

cmake check_cxx_source_runs examples

Signatures

Examples