Turn off uninitialized-use warnings for gcc in cmake build

[revane]

Summary

Copied logic from autoconf/configure.ac and added support to the cmake
build to turn off uninitialized use warnings for gcc. This cleans the
build up somewhat.

[gribozavr]

I don't see anything wrong with this, but I don't know enough CMake to LGTM this.

[doug.gregor]

Gross that we have to do so many checks, but LGTM.

[chandlerc]

If I can jump in...

cmake/config-ix.cmake

320–322

So, why not test for -Wmaybe-uninitialized?

Many versions of GCC ignore -Wno-... flags they don't understand, but I think they're very rigorous about supporting a -Wno-... variant for every flag the support a -W... variant of, so test for the positive one.

My expected logic here is:

• If GCC
  • If -Wmaybe-uninitiaziled is supported, use -Wno-maybe-uninitialized
  • Else use -Wno-uninitialized

[revane]

Vast simplification based on reviewer observation that although gcc
won't complain about unsupported -Wno-* flags it *will* complain about
unsupported -W flags. Instead of testing for -Wno-maybe-uninitialized we
test for the positive.

Someone should fix up the logic in autoconf/configure.ac the same way
too.

[revane]

Argh. I got my branches mixed up and now this diff contains changes for my missing field initializer change. Please ignore that hunk. I'll be sending that for review separately.

[doug.gregor]

LGTM

[revane]

Committed as r174299.

cmake/config-ix.cmake

 if (LIBXML2_FOUND)
   set(CLANG_HAVE_LIBXML 1)
 endif ()
 
 include(CheckCXXCompilerFlag)
 
 check_cxx_compiler_flag("-Wno-variadic-macros" SUPPORTS_NO_VARIADIC_MACROS_FLAG)
 
+set(USE_NO_MAYBE_UNINITIALIZED 0)
+set(USE_NO_UNINITIALIZED 0)
+
+# Disable gcc's potentially uninitialized use analysis as it presents lots of
+# false positives.
+if (CMAKE_COMPILER_IS_GNUCXX)
+  check_cxx_compiler_flag("-Wmaybe-uninitialized" HAS_MAYBE_UNINITIALIZED)
+  if (HAS_MAYBE_UNINITIALIZED)
+    set(USE_NO_MAYBE_UNINITIALIZED 1)
+  else()
+    # Only recent versions of gcc make the distinction between -Wuninitialized
+    # and -Wmaybe-uninitialized. If -Wmaybe-uninitialized isn't supported, just
+    # turn off all uninitialized use warnings.
+    check_cxx_compiler_flag("-Wuninitialized" HAS_UNINITIALIZED)
+    set(USE_NO_UNINITIALIZED ${HAS_UNINITIALIZED})
+  endif()
+endif()
+
 include(GetHostTriple)
 get_host_triple(LLVM_HOST_TRIPLE)
 
 # By default, we target the host, but this can be overridden at CMake
 # invocation time.
 set(LLVM_HOSTTRIPLE "${LLVM_HOST_TRIPLE}")
 
 # Determine the native architecture.

cmake/modules/HandleLLVMOptions.cmake

if (LLVM_ENABLE_WARNINGS)
     endif (LLVM_ENABLE_PEDANTIC)
   endif (LLVM_ENABLE_WARNINGS)
   if (LLVM_ENABLE_WERROR)
     add_llvm_definitions( /WX )
   endif (LLVM_ENABLE_WERROR)
 elseif( LLVM_COMPILER_IS_GCC_COMPATIBLE )
   if (LLVM_ENABLE_WARNINGS)
     add_llvm_definitions( -Wall -W -Wno-unused-parameter -Wwrite-strings )
+    # Turn off missing field initializer warnings for gcc to avoid noise from
+    # false positives with empty {}. Turn them on otherwise (they're off by
+    # default for clang).
+    if (CMAKE_COMPILER_IS_GNUCXX)
+      add_llvm_definitions( -Wno-missing-field-initializers )
+    else()
+      add_llvm_definitions( -Wmissing-field-initializers )
+    endif()
     if (LLVM_ENABLE_PEDANTIC)
       add_llvm_definitions( -pedantic -Wno-long-long )
     endif (LLVM_ENABLE_PEDANTIC)
     check_cxx_compiler_flag("-Werror -Wcovered-switch-default" CXX_SUPPORTS_COVERED_SWITCH_DEFAULT_FLAG)
     if( CXX_SUPPORTS_COVERED_SWITCH_DEFAULT_FLAG )
       set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wcovered-switch-default" )
     endif()
     check_c_compiler_flag("-Werror -Wcovered-switch-default" C_SUPPORTS_COVERED_SWITCH_DEFAULT_FLAG)
     if( C_SUPPORTS_COVERED_SWITCH_DEFAULT_FLAG )
       set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wcovered-switch-default" )
     endif()
+    if (USE_NO_UNINITIALIZED)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-uninitialized")
+    endif()
+    if (USE_NO_MAYBE_UNINITIALIZED)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-maybe-uninitialized")
+    endif()
   endif (LLVM_ENABLE_WARNINGS)
   if (LLVM_ENABLE_WERROR)
     add_llvm_definitions( -Werror )
   endif (LLVM_ENABLE_WERROR)
 endif( MSVC )
 
 add_llvm_definitions( -D__STDC_CONSTANT_MACROS )
 add_llvm_definitions( -D__STDC_FORMAT_MACROS )
 add_llvm_definitions( -D__STDC_LIMIT_MACROS )