[AIX] For XL, pick GCC-compatible std & default warning options

[hubert.reinterpretcast]

Summary

LLVM now requires C++14. For IBM XL compilers with C++14 support, this can be done with the GCC-style options. The relevant block in the CMake file is split up into smaller parts as part of this patch to allow the common cases to be shared.

[jfb]

Can XL enable all the same flags which GCC can? There's a lot under that elseif! At that point, isn't XL GCC compatible?

[hubert.reinterpretcast]

In D66256#1630326, @jfb wrote:

Can XL enable all the same flags which GCC can?

It can except the modules stuff, which should would be detected via the CHECK_CXX_SOURCE_COMPILES.

There's a lot under that elseif!

Most of it is the modules stuff.

At that point, isn't XL GCC compatible?

It isn't, because the object-file generation options (e.g., -fno-unwind-tables) differ.

I guess I should say "default warning" options in the commit message, because the LLVM_ENABLE_WARNINGS and LLVM_ENABLE_PEDANTIC modes aren't enabled with this patch.

[jfb]

In D66256#1630347, @hubert.reinterpretcast wrote:

In D66256#1630326, @jfb wrote:

Can XL enable all the same flags which GCC can?

It can except the modules stuff, which should would be detected via the CHECK_CXX_SOURCE_COMPILES.

There's a lot under that elseif!

Most of it is the modules stuff.

At that point, isn't XL GCC compatible?

It isn't, because the object-file generation options (e.g., -fno-unwind-tables) differ.

I guess I should say "default warning" options in the commit message, because the LLVM_ENABLE_WARNINGS and LLVM_ENABLE_PEDANTIC modes aren't enabled with this patch.

I'm worried because this entire section is for "GCC compatible command line stuff". If someone added something new in there, would it inadvertently break XL? Maybe it's better to factor out the bits you want to enable and leave the rest separate from XL?

[hubert.reinterpretcast]

In D66256#1630348, @jfb wrote:

I'm worried because this entire section is for "GCC compatible command line stuff". If someone added something new in there, would it inadvertently break XL? Maybe it's better to factor out the bits you want to enable and leave the rest separate from XL?

Good point. Will do.

[hubert.reinterpretcast]

Address comments: Split large GCC-compatible options block

[hubert.reinterpretcast]

Fix spelling error

[xingxue]

LGTM.

[daltenty]

llvm/trunk/cmake/modules/HandleLLVMOptions.cmake

435 ↗

(On Diff #215482)

I'm not sure you needed to wrap everything in this else now, since everything inside is now guarded on LLVM_COMPILER_IS_GCC_COMPATIBLE and if (MSVC) LLVM_COMPILER_IS_GCC_COMPATIBLE=OFF

[hubert.reinterpretcast]

llvm/trunk/cmake/modules/HandleLLVMOptions.cmake

435 ↗

(On Diff #215482)

Thanks; committed NFC patch rL369221 to address this.

cmake/modules/HandleLLVMOptions.cmake

if (SUPPORTS_BREPRO)
       if (${linker_flag_idx} GREATER -1)
         message(WARNING "/Brepro not compatible with /INCREMENTAL linking - builds will be non-deterministic")
       else()
         append("/Brepro" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
       endif()
     endif()
   endif()
 
-elseif( LLVM_COMPILER_IS_GCC_COMPATIBLE )
+else( MSVC )
+  # Warnings-as-errors handling for GCC-compatible compilers:
+  if ( LLVM_COMPILER_IS_GCC_COMPATIBLE )
     append_if(LLVM_ENABLE_WERROR "-Werror" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
     append_if(LLVM_ENABLE_WERROR "-Wno-error" CMAKE_REQUIRED_FLAGS)
+  endif( LLVM_COMPILER_IS_GCC_COMPATIBLE )
+
+  # Specific default warnings-as-errors for compilers accepting GCC-compatible warning flags:
+  if ( LLVM_COMPILER_IS_GCC_COMPATIBLE OR CMAKE_CXX_COMPILER_ID MATCHES "XL" )
     add_flag_if_supported("-Werror=date-time" WERROR_DATE_TIME)
     add_flag_if_supported("-Werror=unguarded-availability-new" WERROR_UNGUARDED_AVAILABILITY_NEW)
+  endif( LLVM_COMPILER_IS_GCC_COMPATIBLE OR CMAKE_CXX_COMPILER_ID MATCHES "XL" )
+
+  # C++ language standard selection for compilers accepting the GCC-style option:
+  if ( LLVM_COMPILER_IS_GCC_COMPATIBLE OR CMAKE_CXX_COMPILER_ID MATCHES "XL" )
     check_cxx_compiler_flag("-std=${LLVM_CXX_STD}" CXX_SUPPORTS_CXX_STD)
     if (CXX_SUPPORTS_CXX_STD)
      if (CYGWIN OR MINGW)
         # MinGW and Cygwin are a bit stricter and lack things like
         # 'strdup', 'stricmp', etc in c++11 mode.
         string(REPLACE "c++" "gnu++" gnu_LLVM_CXX_STD "${LLVM_CXX_STD}")
         append("-std=${gnu_LLVM_CXX_STD}" CMAKE_CXX_FLAGS)
       else()
         append("-std=${LLVM_CXX_STD}" CMAKE_CXX_FLAGS)
       endif()
     else()
       message(FATAL_ERROR "The host compiler does not support '-std=${LLVM_CXX_STD}'.")
     endif()
-  if (LLVM_ENABLE_MODULES)
+  endif( LLVM_COMPILER_IS_GCC_COMPATIBLE OR CMAKE_CXX_COMPILER_ID MATCHES "XL" )
+
+  # Modules enablement for GCC-compatile compilers:
+  if ( LLVM_COMPILER_IS_GCC_COMPATIBLE AND LLVM_ENABLE_MODULES )
     set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
     set(module_flags "-fmodules -fmodules-cache-path=${PROJECT_BINARY_DIR}/module.cache")
     if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
       # On Darwin -fmodules does not imply -fcxx-modules.
       set(module_flags "${module_flags} -fcxx-modules")
     endif()
     if (LLVM_ENABLE_LOCAL_SUBMODULE_VISIBILITY)
       set(module_flags "${module_flags} -Xclang -fmodules-local-submodule-visibility")
CHECK_CXX_SOURCE_COMPILES("#undef NDEBUG
                                int main() { assert(this code is not compiled); }"
                                CXX_SUPPORTS_MODULES)
     set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
     if (CXX_SUPPORTS_MODULES)
       append("${module_flags}" CMAKE_CXX_FLAGS)
     else()
       message(FATAL_ERROR "LLVM_ENABLE_MODULES is not supported by this compiler")
     endif()
-  endif(LLVM_ENABLE_MODULES)
+  endif( LLVM_COMPILER_IS_GCC_COMPATIBLE AND LLVM_ENABLE_MODULES )
 endif( MSVC )
 
 if (MSVC)
   if (NOT CLANG_CL)
     set(msvc_warning_flags
       # Disabled warnings.
       -wd4141 # Suppress ''modifier' : used more than once' (because of __forceinline combined with inline)
       -wd4146 # Suppress 'unary minus operator applied to unsigned type, result still unsigned'