mirrors/nodejs
mirrors/nodejs
0
0
Fork 0
mirror of https://github.com/nodejs/node.git synced 2024-11-28 22:46:31 +01:00
Code Issues Releases Activity
ea711876ca
nodejs/deps/cares/cmake/EnableWarnings.cmake
Node.js GitHub Bot 0090c10782 deps: update c-ares to 1.25.0 
PR-URL: https://github.com/nodejs/node/pull/51385
Reviewed-By: Richard Lau <rlau@redhat.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Michael Dawson <midawson@redhat.com>
2024-01-08 17:04:39 -05:00

400 lines
12 KiB
CMake
Raw Blame History

# Copyright (c) Monetra Technologies LLC
# SPDX-License-Identifier: MIT
# EnableWarnings.cmake
#
# Checks for and turns on a large number of warning C flags.
#
# Adds the following helper functions:
#
# remove_warnings(... list of warnings ...)
# Turn off given list of individual warnings for all targets and subdirectories added after this.
#
# remove_all_warnings()
# Remove all warning flags, add -w to suppress built-in warnings.
#
# remove_all_warnings_from_targets(... list of targets ...)
# Suppress warnings for the given targets only.
#
# push_warnings()
# Save current warning flags by pushing them onto an internal stack. Note that modifications to the internal
# stack are only visible in the current CMakeLists.txt file and its children.
#
# Note: changing warning flags multiple times in the same directory only affects add_subdirectory() calls.
# Targets in the directory will always use the warning flags in effect at the end of the CMakeLists.txt
# file - this is due to really weird and annoying legacy behavior of CMAKE_C_FLAGS.
#
# pop_warnings()
# Restore the last set of flags that were saved with push_warnings(). Note that modifications to the internal
# stack are only visible in the current CMakeLists.txt file and its children.
#
if (_internal_enable_warnings_already_run)
return()
endif ()
set(_internal_enable_warnings_already_run TRUE)
include(CheckCCompilerFlag)
include(CheckCXXCompilerFlag)
get_property(languages GLOBAL PROPERTY ENABLED_LANGUAGES)
# internal helper: _int_enable_warnings_set_flags_ex(langs_var configs_var [warnings flags])
function(_int_enable_warnings_set_flags_ex langs_var configs_var)
if (NOT ARGN)
return()
endif ()
if (NOT ${configs_var})
set(${configs_var} "NONE")
endif ()
string(TOUPPER "${${configs_var}}" ${configs_var})
foreach(_flag ${ARGN})
string(MAKE_C_IDENTIFIER "HAVE_${_flag}" varname)
if ("C" IN_LIST ${langs_var})
check_c_compiler_flag(${_flag} ${varname})
if (${varname})
foreach (config IN LISTS ${configs_var})
if (config STREQUAL "NONE")
set(config)
else ()
set(config "_${config}")
endif ()
string(APPEND CMAKE_C_FLAGS${config} " ${_flag}")
endforeach ()
endif ()
endif ()
if ("CXX" IN_LIST ${langs_var})
string(APPEND varname "_CXX")
check_cxx_compiler_flag(${_flag} ${varname})
if (${varname})
foreach (config IN LISTS ${configs_var})
if (config STREQUAL "NONE")
set(config)
else ()
set(config "_${config}")
endif ()
string(APPEND CMAKE_CXX_FLAGS${config} " ${_flag}")
endforeach ()
endif ()
endif ()
endforeach()
foreach(lang C CXX)
foreach (config IN LISTS ${configs_var})
string(TOUPPER "${config}" config)
if (config STREQUAL "NONE")
set(config)
else ()
set(config "_${config}")
endif ()
string(STRIP "${CMAKE_${lang}_FLAGS${config}}" CMAKE_${lang}_FLAGS${config})
set(CMAKE_${lang}_FLAGS${config} "${CMAKE_${lang}_FLAGS${config}}" PARENT_SCOPE)
endforeach ()
endforeach()
endfunction()
# internal helper: _int_enable_warnings_set_flags(langs_var [warnings flags])
macro(_int_enable_warnings_set_flags langs_var)
set(configs "NONE")
_int_enable_warnings_set_flags_ex(${langs_var} configs ${ARGN})
endmacro()
set(_flags_C)
set(_flags_CXX)
set(_debug_flags_C)
set(_debug_flags_CXX)
if (MSVC)
# Visual Studio uses a completely different nomenclature for warnings than gcc/mingw/clang, so none of the
# "-W[name]" warnings will work.
# W4 would be better but it produces unnecessary warnings like:
# * warning C4706: assignment within conditional expression
# Triggered when doing "while(1)"
# * warning C4115: 'timeval' : named type definition in parentheses
# * warning C4201: nonstandard extension used : nameless struct/union
# Triggered by system includes (commctrl.h, shtypes.h, Shlobj.h)
set(_flags
/W3
/we4013 # Treat "function undefined, assuming extern returning int" warning as an error. https://docs.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-3-c4013
)
list(APPEND _flags_C ${_flags})
list(APPEND _flags_CXX ${_flags})
elseif (CMAKE_C_COMPILER_ID MATCHES "Intel")
# Intel's compiler warning flags are more like Visual Studio than GCC, though the numbers aren't the same.
set(_flags
# Use warning level 3, quite wordy.
-w3
# Disable warnings we don't care about (add more as they are encountered).
-wd383 # Spammy warning about initializing from a temporary object in C++ (which is done all the time ...).
-wd11074 # Diagnostic related to inlining.
-wd11076 # Diagnostic related to inlining.
)
list(APPEND _flags_C ${_flags})
list(APPEND _flags_CXX ${_flags})
elseif (CMAKE_C_COMPILER_ID MATCHES "XL")
set (_flags
-qwarn64
-qformat=all
-qflag=i:i
)
list(APPEND _flags_C ${_flags})
list(APPEND _flags_CXX ${_flags})
else ()
# If we're compiling with GCC / Clang / MinGW (or anything else besides Visual Studio or Intel):
# C Flags:
list(APPEND _flags_C
-Wall
-Wextra
# Enable additional warnings not covered by Wall and Wextra.
-Wcast-align
-Wconversion
-Wdeclaration-after-statement
-Wdouble-promotion
-Wfloat-equal
-Wformat-security
-Winit-self
-Wjump-misses-init
-Wlogical-op
-Wmissing-braces
-Wmissing-declarations
-Wmissing-format-attribute
-Wmissing-include-dirs
-Wmissing-prototypes
-Wnested-externs
-Wno-coverage-mismatch
-Wold-style-definition
-Wpacked
-Wpointer-arith
-Wredundant-decls
-Wshadow
-Wsign-conversion
-Wstrict-overflow
-Wstrict-prototypes
-Wtrampolines
-Wundef
-Wunused
-Wvariadic-macros
-Wvla
-Wwrite-strings
# On Windows MinGW I think implicit fallthrough enabled by -Wextra must not default to 3
-Wimplicit-fallthrough=3
# Treat implicit variable typing and implicit function declarations as errors.
-Werror=implicit-int
-Werror=implicit-function-declaration
# Make MacOSX honor -mmacosx-version-min
-Werror=partial-availability
# Some clang versions might warn if an argument like "-I/path/to/headers" is unused,
# silence these.
-Qunused-arguments
)
# C++ flags:
list(APPEND _flags_CXX
-Wall
-Wextra
# Enable additional warnings not covered by Wall and Wextra.
-Wcast-align
-Wformat-security
-Wmissing-declarations
-Wmissing-format-attribute
-Wpacked-bitfield-compat
-Wredundant-decls
-Wvla
# Turn off unused parameter warnings with C++ (they happen often in C++ and Qt).
-Wno-unused-parameter
# Some clang versions might warn if an argument like "-I/path/to/headers" is unused,
# silence these.
-Qunused-arguments
)
# Note: when cross-compiling to Windows from Cygwin, the Qt Mingw packages have a bunch of
# noisy type-conversion warnings in headers. So, only enable those warnings if we're
# not building that configuration.
if (NOT (WIN32 AND (CMAKE_HOST_SYSTEM_NAME MATCHES "CYGWIN")))
list(APPEND _flags_CXX
-Wconversion
-Wfloat-equal
-Wsign-conversion
)
endif ()
# Add flags to force colored output even when output is redirected via pipe.
if (CMAKE_GENERATOR MATCHES "Ninja")
set(color_default TRUE)
else ()
set(color_default FALSE)
endif ()
option(FORCE_COLOR "Force compiler to always colorize, even when output is redirected." ${color_default})
mark_as_advanced(FORCE FORCE_COLOR)
if (FORCE_COLOR)
set(_flags
-fdiagnostics-color=always # GCC
-fcolor-diagnostics # Clang
)
list(APPEND _flags_C ${_flags})
list(APPEND _flags_CXX ${_flags})
endif ()
# Add -fno-omit-frame-pointer (and optionally -fno-inline) to make debugging and stack dumps nicer.
set(_flags
-fno-omit-frame-pointer
)
option(M_NO_INLINE "Disable function inlining for RelWithDebInfo and Debug configurations?" FALSE)
if (M_NO_INLINE)
list(APPEND _flags
-fno-inline
)
endif ()
list(APPEND _debug_flags_C ${_flags})
list(APPEND _debug_flags_CXX ${_flags})
endif ()
# Check and set compiler flags.
set(_debug_configs
RelWithDebInfo
Debug
)
foreach(_lang ${languages})
_int_enable_warnings_set_flags(_lang ${_flags_${_lang}})
_int_enable_warnings_set_flags_ex(_lang _debug_configs ${_debug_flags_${_lang}})
# Ensure pure Debug builds are NOT optimized (not possible on Visual Studio).
# Any optimization of a Debug build will prevent debuggers like lldb from
# fully displaying backtraces and stepping.
if (NOT MSVC)
set(_config Debug)
_int_enable_warnings_set_flags_ex(_lang _config -O0)
endif ()
endforeach()
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# Helper functions
# This function can be called in subdirectories, to prune out warnings that they don't want.
# vararg: warning flags to remove from list of enabled warnings. All "no" flags after EXPLICIT_DISABLE
# will be added to C flags.
#
# Ex.: remove_warnings(-Wall -Wdouble-promotion -Wcomment) prunes those warnings flags from the compile command.
function(remove_warnings)
get_property(languages GLOBAL PROPERTY ENABLED_LANGUAGES)
set(langs C)
if ("CXX" IN_LIST languages)
list(APPEND langs CXX)
endif ()
foreach(lang ${langs})
set(toadd)
set(in_explicit_disable FALSE)
foreach (flag ${ARGN})
if (flag STREQUAL "EXPLICIT_DISABLE")
set(in_explicit_disable TRUE)
elseif (in_explicit_disable)
list(APPEND toadd "${flag}")
else ()
string(REGEX REPLACE "${flag}([ \t]+|$)" "" CMAKE_${lang}_FLAGS "${CMAKE_${lang}_FLAGS}")
endif ()
endforeach ()
_int_enable_warnings_set_flags(lang ${toadd})
string(STRIP "${CMAKE_${lang}_FLAGS}" CMAKE_${lang}_FLAGS)
set(CMAKE_${lang}_FLAGS "${CMAKE_${lang}_FLAGS}" PARENT_SCOPE)
endforeach()
endfunction()
# Explicitly suppress all warnings. As long as this flag is the last warning flag, warnings will be
# suppressed even if earlier flags enabled warnings.
function(remove_all_warnings)
get_property(languages GLOBAL PROPERTY ENABLED_LANGUAGES)
set(langs C)
if ("CXX" IN_LIST languages)
list(APPEND langs CXX)
endif ()
foreach(lang ${langs})
string(REGEX REPLACE "[-/][Ww][^ \t]*([ \t]+|$)" "" CMAKE_${lang}_FLAGS "${CMAKE_${lang}_FLAGS}")
if (MSVC)
string(APPEND CMAKE_${lang}_FLAGS " /w")
else ()
string(APPEND CMAKE_${lang}_FLAGS " -w")
endif ()
string(STRIP "${CMAKE_${lang}_FLAGS}" CMAKE_${lang}_FLAGS)
set(CMAKE_${lang}_FLAGS "${CMAKE_${lang}_FLAGS}" PARENT_SCOPE)
endforeach()
endfunction()
function(remove_all_warnings_from_targets)
foreach (target ${ARGN})
if (MSVC)
target_compile_options(${target} PRIVATE "/w")
else ()
target_compile_options(${target} PRIVATE "-w")
endif ()
endforeach()
endfunction()
# Save the current warning settings to an internal variable.
function(push_warnings)
get_property(languages GLOBAL PROPERTY ENABLED_LANGUAGES)
set(langs C)
if ("CXX" IN_LIST languages)
list(APPEND langs CXX)
endif ()
foreach(lang ${langs})
if (CMAKE_${lang}_FLAGS MATCHES ";")
message(AUTHOR_WARNING "Cannot push warnings for ${lang}, CMAKE_${lang}_FLAGS contains semicolons")
continue()
endif ()
# Add current flags to end of internal list.
list(APPEND _enable_warnings_internal_${lang}_flags_stack "${CMAKE_${lang}_FLAGS}")
# Propagate results up to caller's scope.
set(_enable_warnings_internal_${lang}_flags_stack "${_enable_warnings_internal_${lang}_flags_stack}" PARENT_SCOPE)
endforeach()
endfunction()
# Restore the current warning settings from an internal variable.
function(pop_warnings)
get_property(languages GLOBAL PROPERTY ENABLED_LANGUAGES)
set(langs C)
if ("CXX" IN_LIST languages)
list(APPEND langs CXX)
endif ()
foreach(lang ${langs})
if (NOT _enable_warnings_internal_${lang}_flags_stack)
continue()
endif ()
# Pop flags off of end of list, overwrite current flags with whatever we popped off.
list(GET _enable_warnings_internal_${lang}_flags_stack -1 CMAKE_${lang}_FLAGS)
list(REMOVE_AT _enable_warnings_internal_${lang}_flags_stack -1)
# Propagate results up to caller's scope.
set(_enable_warnings_internal_${lang}_flags_stack "${_enable_warnings_internal_${lang}_flags_stack}" PARENT_SCOPE)
string(STRIP "${CMAKE_${lang}_FLAGS}" CMAKE_${lang}_FLAGS)
set(CMAKE_${lang}_FLAGS "${CMAKE_${lang}_FLAGS}" PARENT_SCOPE)
endforeach()
endfunction()
View Git Blame Copy Permalink