cmake check_cxx_source

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)

coin-or/CppAD cmake/run_source_test.cmake :34

CHECK_CXX_SOURCE_RUNS("${source}" ${variable} )

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)

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

check_cxx_source_runs("${TEST_CODE}" CRYPT_R_WORKS_WITH_ASAN)

ByConity/ByConity contrib/arrow-cmake/orc_check.cmake :91

CHECK_CXX_SOURCE_RUNS("
    #include<time.h>
    int main(int, char *[]) {
      time_t t = -14210715; // 1969-07-20 12:34:45
      struct tm *ptm = gmtime(&t);
      return !(ptm && ptm->tm_year == 69);
    }"
  HAS_PRE_1970
)

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)

NCAR/VAPOR CMakeLists.txt :29

check_cxx_source_runs("${CHECK_ARM64_SOURCE_CODE}" IS_ARM64)

emsec/hal cmake/FindFilesystem.cmake :190

check_cxx_source_runs("${code}" CXX_FILESYSTEM_NO_LINK_NEEDED)

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 )

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)

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
  )

mmp/pbrt-v3 CMakeLists.txt :162

CHECK_CXX_SOURCE_RUNS ( "
#include <signal.h>
#include <string.h>
#include <sys/time.h>
void ReportProfileSample(int, siginfo_t *, void *) { }
int main() {
    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));
    sa.sa_sigaction = ReportProfileSample;
    sa.sa_flags = SA_RESTART | SA_SIGINFO;
    sigemptyset(&sa.sa_mask);
    sigaction(SIGPROF, &sa, NULL);
    static struct itimerval timer;
    return setitimer(ITIMER_PROF, &timer, NULL) == 0 ? 0 : 1;
}
" HAVE_ITIMER )

youkely/InfrasCal cmake/BuildConfig.cmake :24

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

stlab/libraries cmake/StlabUtil.cmake :12

check_cxx_source_runs( "
#include <concepts>
#include <coroutine>
#include <exception>

struct ReturnObject {
  struct promise_type {
    ReturnObject get_return_object() { return {}; }
    std::suspend_never initial_suspend() { return {}; }
    std::suspend_never final_suspend() noexcept { return {}; }
    void unhandled_exception() {}
  };
};

struct Awaiter {
  std::coroutine_handle<> *hp_;
  constexpr bool await_ready() const noexcept { return false; }
  void await_suspend(std::coroutine_handle<> h) { *hp_ = h; }
  constexpr void await_resume() const noexcept {}
};

ReturnObject
counter(std::coroutine_handle<> *continuation_out)
{
  Awaiter a{continuation_out};
  for (unsigned i = 0;; ++i) {
    co_await a;
  }
}

int
main()
{
  std::coroutine_handle<> h;
  counter(&h);
  for (int i = 0; i < 3; ++i) {
    h();
  }
  h.destroy();
}
" STLAB_HAVE_FUNCTIONAL_COROUTINES )

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)

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
  )

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)

polarphp/polarphp cmake/modules/PolarCheckCXXNativeRegex.cmake :23

check_cxx_source_runs("${std_regex_test_source}" "${result_var_name}_TEST")

steineggerlab/foldcomp cmake/FindUBSan.cmake :64

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)

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)

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)

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

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

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 )

alibaba/AliSQLBackup configure.cmake :76

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

usnistgov/NFIQ2 cmake/compiler.cmake :34

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

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
        )

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)

phdsky/ORBSLAM24Windows Thirdparty/Pangolin/src/CMakeLists.txt :192

CHECK_CXX_SOURCE_RUNS("#include <GLUT/glut.h>\n int main () {return glutGetProcAddress(\"glutScrollFunc\") ? 0 : -1;};" HAVE_MODIFIED_OSXGLUT)

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})

tizian/tonemapper CMakeLists.txt :63

check_cxx_source_runs("#include <iostream>\nint main(int argc, char **argv) { std::cout << \"test\"; return 0; }" ${_RESULT})

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

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

hkrn/nanoem cmake/FindUBSan.cmake :67

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)

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)

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)

Gnucash/gnucash CMakeLists.txt :431

CHECK_CXX_SOURCE_RUNS("
#include <time.h>
#include <stdlib.h>
#include <string>
extern time_t ofxdate_to_time_t(const std::string ofxdate);

int main(int argc, char** argv)
{
    const std::string timestr = \"20160319000000\";
    struct tm ts;
    ts.tm_year = 116;
    ts.tm_mon = 2;
    ts.tm_mday = 19;
#ifdef _WIN32
    putenv(\"TZ=PST-8PDT-7,M 4.1.0/0,M 10.6.0/0\");
#else
    setenv(\"TZ\", \"PST 08P DT 07 M 4.1.0, M 10.6.0\", 1);
#endif
    time_t t = ofxdate_to_time_t(timestr);
    if (t == mktime(&ts))
        exit(1);
    exit(0);
}
" HAVE_OFX_BUG_39)

soedinglab/hh-suite 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)

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})

erthink/libmdbx cmake/compiler.cmake :346

check_cxx_source_runs("int main(void) { return 0; }" CMAKE_HOST_CAN_RUN_EXECUTABLES_BUILT_FOR_TARGET)

cmake check_cxx_source_runs examples

Signatures

Examples