Make Gromacs compile without C++ compiler

Fixes that OpenMP is enabled if C compiler supports OpenMP
but C++ compiler does not.

Partially fixes #1021

Change-Id: I4bb109801ee57aac4826881022c34240768a841e

diff --git a/CMakeLists.txt b/CMakeLists.txt
index a5b8e02f1233a31c4438f64047d369b2c04ae9a9..f29470ec6b7df5e39d6c1fd14c5d0db033196607 100644 (file)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -11,7 +11,7 @@ if(APPLE)
     set(CMAKE_C_COMPILER_INIT "cc")
 endif(APPLE)
 
-project(Gromacs)
+project(Gromacs C)
 include(Dart)
 mark_as_advanced(DART_ROOT)
 
@@ -102,6 +102,17 @@ if(CMAKE_HOST_UNIX)
             "Hostname of the machine where the cache was generated.")
 endif()
 
+########################################################################
+# User input options - enable C++ - before any CXX flags are changed   #
+########################################################################
+option(GMX_GPU  "Enable GPU acceleration" ON)
+option(GMX_OPENMM "Accelerated execution on GPUs through the OpenMM library (rerun cmake after changing to see relevant options)" OFF)
+option(GMX_FORCE_CXX "Enable C++ compilation even if not necessary" OFF)
+mark_as_advanced(GMX_FORCE_CXX)
+if(GMX_GPU OR GMX_OPENMM OR GMX_FORCE_CXX)
+    enable_language(CXX)
+endif()
+
 ########################################################################
 # Fix stupid flags on Windows
 ########################################################################
@@ -117,10 +128,12 @@ IF( WIN32 AND NOT CYGWIN)
     SET(CMAKE_C_FLAGS_RELEASE ${CMAKE_C_FLAGS_RELEASE} CACHE STRING "" FORCE)
     STRING(REPLACE /MD /MT CMAKE_C_FLAGS_DEBUG ${CMAKE_C_FLAGS_DEBUG})
     SET(CMAKE_C_FLAGS_DEBUG ${CMAKE_C_FLAGS_DEBUG} CACHE STRING "" FORCE)
-    STRING(REPLACE /MD /MT CMAKE_CXX_FLAGS_RELEASE ${CMAKE_CXX_FLAGS_RELEASE})
-    SET(CMAKE_CXX_FLAGS_RELEASE ${CMAKE_CXX_FLAGS_RELEASE} CACHE STRING "" FORCE)
-    STRING(REPLACE /MD /MT CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG})
-    SET(CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG} CACHE STRING "" FORCE)
+    if(CMAKE_CXX_COMPILER_LOADED)
+        STRING(REPLACE /MD /MT CMAKE_CXX_FLAGS_RELEASE ${CMAKE_CXX_FLAGS_RELEASE})
+        SET(CMAKE_CXX_FLAGS_RELEASE ${CMAKE_CXX_FLAGS_RELEASE} CACHE STRING "" FORCE)
+        STRING(REPLACE /MD /MT CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG})
+        SET(CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG} CACHE STRING "" FORCE)
+    endif()
   ENDIF()
 
   #Workaround for cmake bug 13174. Replace deprecated options.
@@ -128,7 +141,7 @@ IF( WIN32 AND NOT CYGWIN)
     STRING(REPLACE /GZ /RTC1 CMAKE_C_FLAGS_DEBUG ${CMAKE_C_FLAGS_DEBUG})
     SET(CMAKE_C_FLAGS_DEBUG ${CMAKE_C_FLAGS_DEBUG} CACHE STRING "" FORCE)
   ENDIF()
-  IF( CMAKE_CXX_COMPILER_ID MATCHES "Intel" )
+  IF( CMAKE_CXX_COMPILER_ID MATCHES "Intel" AND CMAKE_CXX_COMPILER_LOADED)
     STRING(REPLACE /GZ /RTC1 CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG})
     STRING(REPLACE /GX /EHsc CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG})
     SET(CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG} CACHE STRING "" FORCE)
@@ -151,7 +164,6 @@ option(GMX_POWERPC_INVSQRT "Use PowerPC hardware 1/sqrt" OFF)
 mark_as_advanced(GMX_POWERPC_INVSQRT)
 option(GMX_FAHCORE "Build a library with mdrun functionality" OFF)
 mark_as_advanced(GMX_FAHCORE)
-option(GMX_OPENMM "Accelerated execution on GPUs through the OpenMM library (rerun cmake after changing to see relevant options)" OFF)
 
 include(gmxDetectAcceleration)
 if(NOT DEFINED GMX_ACCELERATION)
@@ -179,7 +191,6 @@ mark_as_advanced(GMX_MPI_IN_PLACE)
 option(GMX_LOAD_PLUGINS "Compile with plugin support, needed to read VMD supported file formats" ON)
 mark_as_advanced(GMX_LOAD_PLUGINS)
 
-option(GMX_GPU  "Enable GPU acceleration" ON)
 option(GMX_OPENMP "Enable OpenMP-based multithreading" ON)
 
 option(USE_VERSION_H "Generate development version string/information" ON)
@@ -206,7 +217,9 @@ mark_as_advanced(GMX_CYCLE_SUBCOUNTERS)
 # Remove these files from the source tree when a CMake version that
 # includes the features in question becomes required.
 include(CheckCCompilerFlag)
-include(CheckCXXCompilerFlag)
+if(CMAKE_CXX_COMPILER_LOADED)
+    include(CheckCXXCompilerFlag)
+endif()
 
 # OpenMP check must come before other CFLAGS!
 if(GMX_OPENMP)
@@ -681,10 +694,12 @@ elseif(${GMX_ACCELERATION} STREQUAL "SSE2")
         GMX_TEST_CFLAG(MSVC_SSE2_CFLAG "/arch:SSE2" GROMACS_C_FLAGS)
     endif(NOT GNU_SSE2_CFLAG)
 
-    GMX_TEST_CXXFLAG(GNU_SSE2_CXXFLAG "-msse2" GROMACS_CXX_FLAGS)
-    if(NOT GNU_SSE2_CXXFLAG)
-        GMX_TEST_CXXFLAG(MSVC_SSE2_CXXFLAG "/arch:SSE2" GROMACS_CXX_FLAGS)
-    endif(NOT GNU_SSE2_CXXFLAG)
+    if (CMAKE_CXX_COMPILER_LOADED)
+        GMX_TEST_CXXFLAG(GNU_SSE2_CXXFLAG "-msse2" GROMACS_CXX_FLAGS)
+        if(NOT GNU_SSE2_CXXFLAG)
+            GMX_TEST_CXXFLAG(MSVC_SSE2_CXXFLAG "/arch:SSE2" GROMACS_CXX_FLAGS)
+        endif(NOT GNU_SSE2_CXXFLAG)
+    endif()
 
     # We dont warn for lacking SSE2 flag support, since that is probably standard today.
 
@@ -714,16 +729,18 @@ elseif(${GMX_ACCELERATION} STREQUAL "SSE4.1")
         GMX_TEST_CFLAG(MSVC_SSE2_CFLAG "/arch:SSE2" GROMACS_C_FLAGS)
     endif(NOT GNU_SSE4_CFLAG AND NOT MSVC_SSE4_CFLAG)
 
-    GMX_TEST_CXXFLAG(GNU_SSE4_CXXFLAG "-msse4.1" GROMACS_CXX_FLAG)
-    if (NOT GNU_SSE4_CXXFLAG)
-       GMX_TEST_CXXFLAG(MSVC_SSE4_CXXFLAG "/arch:SSE4.1" GROMACS_CXX_FLAGS)
-    endif(NOT GNU_SSE4_CXXFLAG)
-    if (NOT GNU_SSE4_CXXFLAG AND NOT MSVC_SSE4_CXXFLAG)
-        message(WARNING "No C++ SSE4.1 flag found. Consider a newer compiler, or disable SSE4.1 for slightly lower performance.")
-        # Not surprising if we end up here! MSVC current does not support the SSE4.1 flag. However, it appears to accept SSE4.1
-        # intrinsics when SSE2 support is enabled, so we try that instead.
-        GMX_TEST_CXXFLAG(MSVC_SSE2_CXXFLAG "/arch:SSE2" GROMACS_CXX_FLAGS)
-    endif(NOT GNU_SSE4_CXXFLAG AND NOT MSVC_SSE4_CXXFLAG)
+    if (CMAKE_CXX_COMPILER_LOADED)
+        GMX_TEST_CXXFLAG(GNU_SSE4_CXXFLAG "-msse4.1" GROMACS_CXX_FLAG)
+        if (NOT GNU_SSE4_CXXFLAG)
+            GMX_TEST_CXXFLAG(MSVC_SSE4_CXXFLAG "/arch:SSE4.1" GROMACS_CXX_FLAGS)
+        endif(NOT GNU_SSE4_CXXFLAG)
+        if (NOT GNU_SSE4_CXXFLAG AND NOT MSVC_SSE4_CXXFLAG) 
+            message(WARNING "No C++ SSE4.1 flag found. Consider a newer compiler, or disable SSE4.1 for slightly lower performance.")
+            # Not surprising if we end up here! MSVC current does not support the SSE4.1 flag. However, it appears to accept SSE4.1
+            # intrinsics when SSE2 support is enabled, so we try that instead.
+            GMX_TEST_CXXFLAG(MSVC_SSE2_CXXFLAG "/arch:SSE2" GROMACS_CXX_FLAGS)
+        endif(NOT GNU_SSE4_CXXFLAG AND NOT MSVC_SSE4_CXXFLAG)
+    endif()
 
     # This must come after we have added the -msse4.1 flag on some platforms.
     check_include_file(smmintrin.h  HAVE_SMMINTRIN_H ${GROMACS_C_FLAGS})
@@ -751,13 +768,15 @@ elseif(${GMX_ACCELERATION} STREQUAL "AVX_128_FMA" OR ${GMX_ACCELERATION} STREQUA
         message(WARNING "No C AVX flag found. Consider a newer compiler, or disable AVX for much lower performance.")
     endif (NOT GNU_AVX_CFLAG AND NOT MSVC_AVX_CFLAG)
 
-    GMX_TEST_CXXFLAG(GNU_AVX_CXXFLAG "-mavx" GROMACS_CXX_FLAGS)
-    if (NOT GNU_AVX_CXXFLAG)
-       GMX_TEST_CXXFLAG(MSVC_AVX_CXXFLAG "/arch:AVX" GROMACS_CXX_FLAGS)
-    endif (NOT GNU_AVX_CXXFLAG)
-    if (NOT GNU_AVX_CXXFLAG AND NOT MSVC_AVX_CXXFLAG)
-       message(WARNING "No C++ AVX flag found. Consider a newer compiler, or disable AVX for much lower performance.")
-    endif (NOT GNU_AVX_CXXFLAG AND NOT MSVC_AVX_CXXFLAG)
+    if (CMAKE_CXX_COMPILER_LOADED)
+        GMX_TEST_CXXFLAG(GNU_AVX_CXXFLAG "-mavx" GROMACS_CXX_FLAGS)
+        if (NOT GNU_AVX_CXXFLAG)
+            GMX_TEST_CXXFLAG(MSVC_AVX_CXXFLAG "/arch:AVX" GROMACS_CXX_FLAGS)
+        endif (NOT GNU_AVX_CXXFLAG)
+        if (NOT GNU_AVX_CXXFLAG AND NOT MSVC_AVX_CXXFLAG)
+            message(WARNING "No C++ AVX flag found. Consider a newer compiler, or disable AVX for much lower performance.")
+        endif (NOT GNU_AVX_CXXFLAG AND NOT MSVC_AVX_CXXFLAG)
+    endif()
 
     # Only test the header after we have tried to add the flag for AVX support
     check_include_file(immintrin.h  HAVE_IMMINTRIN_H ${GROMACS_C_FLAGS})
@@ -1024,8 +1043,10 @@ if (NOT DEFINED GROMACS_C_FLAGS_SET)
         FORCE)
     set(CMAKE_C_FLAGS "${GROMACS_C_FLAGS} ${CMAKE_C_FLAGS}" CACHE STRING 
         "Flags used by the compiler during all build types" FORCE)
-    set(CMAKE_CXX_FLAGS "${GROMACS_CXX_FLAGS} ${CMAKE_CXX_FLAGS}" CACHE STRING 
-        "Flags used by the compiler during all build types" FORCE)
+    if (CMAKE_CXX_COMPILER_LOADED)
+        set(CMAKE_CXX_FLAGS "${GROMACS_CXX_FLAGS} ${CMAKE_CXX_FLAGS}" CACHE STRING 
+            "Flags used by the compiler during all build types" FORCE)
+    endif()
     set(CMAKE_EXE_LINKER_FLAGS 
         "${GROMACS_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS}" 
         CACHE STRING "Linker flags for creating executables" FORCE) 

diff --git a/cmake/FindOpenMP.cmake b/cmake/FindOpenMP.cmake
new file mode 100644 (file)
index 0000000..24231ba
--- /dev/null
+++ b/cmake/FindOpenMP.cmake
@@ -0,0 +1,171 @@
+# - Finds OpenMP support
+# Copied from cmake 2.8.7 prior versions were assuming C++
+# compiler is enabled. Can be removed when 2.8.7 becomes 
+# required or C++ becomes required.
+#
+# This module can be used to detect OpenMP support in a compiler.
+# If the compiler supports OpenMP, the flags required to compile with
+# openmp support are set.
+#
+# The following variables are set:
+#   OpenMP_C_FLAGS - flags to add to the C compiler for OpenMP support
+#   OpenMP_CXX_FLAGS - flags to add to the CXX compiler for OpenMP support
+#   OPENMP_FOUND - true if openmp is detected
+#
+# Supported compilers can be found at http://openmp.org/wp/openmp-compilers/
+
+#=============================================================================
+# Copyright 2009 Kitware, Inc.
+# Copyright 2008-2009 André Rigland Brodtkorb <Andre.Brodtkorb@ifi.uio.no>
+# Copyright 2012 Rolf Eike Beer <eike@sf-mail.de>
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+set(_OPENMP_REQUIRED_VARS)
+
+function(_OPENMP_FLAG_CANDIDATES LANG)
+  set(OpenMP_FLAG_CANDIDATES
+    #GNU
+    "-fopenmp"
+    #Microsoft Visual Studio
+    "/openmp"
+    #Intel windows
+    "-Qopenmp"
+    #PathScale, Intel
+    "-openmp"
+    #Empty, if compiler automatically accepts openmp
+    " "
+    #Sun
+    "-xopenmp"
+    #HP
+    "+Oopenmp"
+    #IBM XL C/c++
+    "-qsmp"
+    #Portland Group, MIPSpro
+    "-mp"
+  )
+
+  set(OMP_FLAG_GNU "-fopenmp")
+  set(OMP_FLAG_HP "+Oopenmp")
+  if(WIN32)
+    set(OMP_FLAG_Intel "-Qopenmp")
+  else()
+    set(OMP_FLAG_Intel "-openmp")
+  endif()
+  set(OMP_FLAG_MIPSpro "-mp")
+  set(OMP_FLAG_MSVC "/openmp")
+  set(OMP_FLAG_PathScale "-openmp")
+  set(OMP_FLAG_PGI "-mp")
+  set(OMP_FLAG_SunPro "-xopenmp")
+  set(OMP_FLAG_XL "-qsmp")
+
+  # Move the flag that matches the compiler to the head of the list,
+  # this is faster and doesn't clutter the output that much. If that
+  # flag doesn't work we will still try all.
+  if(OMP_FLAG_${CMAKE_${LANG}_COMPILER_ID})
+    list(REMOVE_ITEM OpenMP_FLAG_CANDIDATES "${OMP_FLAG_${CMAKE_${LANG}_COMPILER_ID}}")
+    list(INSERT OpenMP_FLAG_CANDIDATES 0 "${OMP_FLAG_${CMAKE_${LANG}_COMPILER_ID}}")
+  endif()
+
+  set(OpenMP_${LANG}_FLAG_CANDIDATES "${OpenMP_FLAG_CANDIDATES}" PARENT_SCOPE)
+endfunction(_OPENMP_FLAG_CANDIDATES)
+
+# sample openmp source code to test
+set(OpenMP_C_TEST_SOURCE 
+"
+#include <omp.h>
+int main() { 
+#ifdef _OPENMP
+  return 0; 
+#else
+  breaks_on_purpose
+#endif
+}
+")
+
+# check c compiler
+if(CMAKE_C_COMPILER_LOADED)
+  # if these are set then do not try to find them again,
+  # by avoiding any try_compiles for the flags
+  if(OpenMP_C_FLAGS)
+    unset(OpenMP_C_FLAG_CANDIDATES)
+  else()
+    _OPENMP_FLAG_CANDIDATES("C")
+    include(CheckCSourceCompiles)
+  endif()
+
+  foreach(FLAG ${OpenMP_C_FLAG_CANDIDATES})
+    set(SAFE_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
+    set(CMAKE_REQUIRED_FLAGS "${FLAG}")
+    unset(OpenMP_FLAG_DETECTED CACHE)
+    message(STATUS "Try OpenMP C flag = [${FLAG}]")
+    check_c_source_compiles("${OpenMP_C_TEST_SOURCE}" OpenMP_FLAG_DETECTED)
+    set(CMAKE_REQUIRED_FLAGS "${SAFE_CMAKE_REQUIRED_FLAGS}")
+    if(OpenMP_FLAG_DETECTED)
+      set(OpenMP_C_FLAGS_INTERNAL "${FLAG}")
+      break()
+    endif(OpenMP_FLAG_DETECTED)
+  endforeach(FLAG ${OpenMP_C_FLAG_CANDIDATES})
+
+  set(OpenMP_C_FLAGS "${OpenMP_C_FLAGS_INTERNAL}"
+    CACHE STRING "C compiler flags for OpenMP parallization")
+
+  list(APPEND _OPENMP_REQUIRED_VARS OpenMP_C_FLAGS)
+  unset(OpenMP_C_FLAG_CANDIDATES)
+endif()
+
+# check cxx compiler
+if(CMAKE_CXX_COMPILER_LOADED)
+  # if these are set then do not try to find them again,
+  # by avoiding any try_compiles for the flags
+  if(OpenMP_CXX_FLAGS)
+    unset(OpenMP_CXX_FLAG_CANDIDATES)
+  else()
+    _OPENMP_FLAG_CANDIDATES("CXX")
+    include(CheckCXXSourceCompiles)
+
+    # use the same source for CXX as C for now
+    set(OpenMP_CXX_TEST_SOURCE ${OpenMP_C_TEST_SOURCE})
+  endif()
+
+  foreach(FLAG ${OpenMP_CXX_FLAG_CANDIDATES})
+    set(SAFE_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
+    set(CMAKE_REQUIRED_FLAGS "${FLAG}")
+    unset(OpenMP_FLAG_DETECTED CACHE)
+    message(STATUS "Try OpenMP CXX flag = [${FLAG}]")
+    check_cxx_source_compiles("${OpenMP_CXX_TEST_SOURCE}" OpenMP_FLAG_DETECTED)
+    set(CMAKE_REQUIRED_FLAGS "${SAFE_CMAKE_REQUIRED_FLAGS}")
+    if(OpenMP_FLAG_DETECTED)
+      set(OpenMP_CXX_FLAGS_INTERNAL "${FLAG}")
+      break()
+    endif(OpenMP_FLAG_DETECTED)
+  endforeach(FLAG ${OpenMP_CXX_FLAG_CANDIDATES})
+
+  set(OpenMP_CXX_FLAGS "${OpenMP_CXX_FLAGS_INTERNAL}"
+    CACHE STRING "C++ compiler flags for OpenMP parallization")
+
+  list(APPEND _OPENMP_REQUIRED_VARS OpenMP_CXX_FLAGS)
+  unset(OpenMP_CXX_FLAG_CANDIDATES)
+  unset(OpenMP_CXX_TEST_SOURCE)
+endif()
+
+if(_OPENMP_REQUIRED_VARS)
+  include(FindPackageHandleStandardArgs)
+
+  find_package_handle_standard_args(OpenMP
+                                    REQUIRED_VARS ${_OPENMP_REQUIRED_VARS})
+
+  mark_as_advanced(${_OPENMP_REQUIRED_VARS})
+
+  unset(_OPENMP_REQUIRED_VARS)
+else()
+  message(SEND_ERROR "FindOpenMP requires C or CXX language to be enabled")
+endif()

diff --git a/cmake/gmxCFlags.cmake b/cmake/gmxCFlags.cmake
index 11de448eb967e725c782ba951c746072e409a744..b901579b428898f8c7ff3da5caae886219d1464f 100644 (file)
--- a/cmake/gmxCFlags.cmake
+++ b/cmake/gmxCFlags.cmake
@@ -13,12 +13,12 @@ ENDMACRO(GMX_TEST_CFLAG VARIABLE FLAGS CFLAGSVAR)
 # Test C++ flags FLAGS, and set VARIABLE to true if the work. Also add the
 # flags to CXXFLAGSVAR.
 MACRO(GMX_TEST_CXXFLAG VARIABLE FLAGS CXXFLAGSVAR)
-    IF(NOT DEFINED ${VARIABLE})
+    IF(NOT DEFINED ${VARIABLE} AND CMAKE_CXX_COMPILER_LOADED)
         CHECK_CXX_COMPILER_FLAG("${FLAGS}" ${VARIABLE})
         IF (${VARIABLE})
             SET (${CXXFLAGSVAR} "${FLAGS} ${${CXXFLAGSVAR}}")
         ENDIF (${VARIABLE}) 
-    ENDIF(NOT DEFINED ${VARIABLE})
+    ENDIF(NOT DEFINED ${VARIABLE} AND CMAKE_CXX_COMPILER_LOADED)
 ENDMACRO(GMX_TEST_CXXFLAG VARIABLE FLAGS CXXFLAGSVAR)
 
 
@@ -180,7 +180,7 @@ MACRO(gmx_c_flags)
     endif()
 
     # C++
-    if ( NOT DEFINED GMXCXXFLAGS_SET AND NOT DEFINED ENV{CXXFLAGS} )
+    if ( NOT DEFINED GMXCXXFLAGS_SET AND NOT DEFINED ENV{CXXFLAGS} AND CMAKE_CXX_COMPILER_LOADED)
         set(GMXCXXFLAGS_SET true CACHE INTERNAL "Whether to reset the C++ flags" 
             FORCE)
         set(CMAKE_CXX_FLAGS "${GMXC_CXXFLAGS} ${CMAKE_CXX_FLAGS}" 

diff --git a/cmake/gmxGetCompilerVersion.cmake b/cmake/gmxGetCompilerVersion.cmake
index 529577aebcbc5c1a25d11bd325206eae5204af6e..10d8cfdc5b3e879235bdae33dee3bbedad8d3d2a 100644 (file)
--- a/cmake/gmxGetCompilerVersion.cmake
+++ b/cmake/gmxGetCompilerVersion.cmake
@@ -22,7 +22,7 @@ macro(get_compiler_version)
         endif ()
     endif()
 
-    if(NOT CXX_COMPILER_VERSION)
+    if(NOT CXX_COMPILER_VERSION AND CMAKE_CXX_COMPILER_LOADED)
         execute_process(COMMAND ${CMAKE_CXX_COMPILER} -dumpversion
             RESULT_VARIABLE _cxx_dumpversion_res
             OUTPUT_VARIABLE _cxx_dumpversion_out
@@ -38,7 +38,7 @@ macro(get_compiler_version)
         endif ()
     endif ()
 
-    if (NOT "${C_COMPILER_VERSION}" STREQUAL "${CXX_COMPILER_VERSION}")
+    if (NOT "${C_COMPILER_VERSION}" STREQUAL "${CXX_COMPILER_VERSION}" AND CMAKE_CXX_COMPILER_LOADED)
         message(WARNING "The version string of the C and C++ compilers does not match!")
     endif ()