diff options
Diffstat (limited to 'build/moz.configure/warnings.configure')
| -rwxr-xr-x | build/moz.configure/warnings.configure | 253 |
1 files changed, 253 insertions, 0 deletions
diff --git a/build/moz.configure/warnings.configure b/build/moz.configure/warnings.configure new file mode 100755 index 0000000000..d0db70f6d3 --- /dev/null +++ b/build/moz.configure/warnings.configure @@ -0,0 +1,253 @@ +# -*- Mode: python; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +option( + "--enable-warnings-as-errors", + env="MOZ_ENABLE_WARNINGS_AS_ERRORS", + default=depends("MOZ_AUTOMATION")(lambda x: bool(x)), + help="{Enable|Disable} treating warnings as errors", +) + + +@depends("--enable-warnings-as-errors") +def rust_warning_flags(warnings_as_errors): + flags = [] + + # Note that cargo passes --cap-lints warn to rustc for third-party code, so + # we don't need a very complicated setup. + if warnings_as_errors: + flags.append("-Dwarnings") + else: + flags.extend(("--cap-lints", "warn")) + + return flags + + +c_warning_flag = dependable("-Werror") + + +@depends("--enable-warnings-as-errors", c_warning_flag) +def warnings_as_errors(warnings_as_errors, c_warning_flag): + if not warnings_as_errors: + return "" + + return c_warning_flag + + +set_config("WARNINGS_AS_ERRORS", warnings_as_errors) +# We have a peculiar setup in old-configure.in where some compilation tests +# depend on enabling warnings-as-errors even if it's disabled for Firefox +# compilation. We therefore need this assignment. +add_old_configure_assignment("WARNINGS_AS_ERRORS", c_warning_flag) + + +# GCC/Clang warnings: +# https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html +# https://clang.llvm.org/docs/DiagnosticsReference.html + +# lots of useful warnings +add_gcc_warning("-Wall") + +# catch implicit truncation of enum values assigned to smaller bit fields +check_and_add_gcc_warning("-Wbitfield-enum-conversion") + +# catches bugs, e.g. "if (c); foo();", few false positives +add_gcc_warning("-Wempty-body") + +# catches return types with qualifiers like const +add_gcc_warning("-Wignored-qualifiers") + +# function declaration hides virtual function from base class. +# Don't enable for GCC, since it's more strict than clang, +# and the additional cases it covers are not valuable. +add_gcc_warning( + "-Woverloaded-virtual", + cxx_compiler, + when=depends(cxx_compiler)(lambda c: c.type != "gcc"), +) + +# catches pointer arithmetic using NULL or sizeof(void) +add_gcc_warning("-Wpointer-arith") + +# catch modifying constructor parameter that shadows member variable +check_and_add_gcc_warning("-Wshadow-field-in-constructor-modified") + +# catches comparing signed/unsigned ints +add_gcc_warning("-Wsign-compare") + +# catches overflow bugs, few false positives +add_gcc_warning("-Wtype-limits") + +# catches some dead code +add_gcc_warning("-Wunreachable-code") +check_and_add_gcc_warning("-Wunreachable-code-return") + +# catches treating string literals as non-const +add_gcc_warning("-Wwrite-strings", cxx_compiler) + +# turned on by -Wall, but we use offsetof on non-POD types frequently +add_gcc_warning("-Wno-invalid-offsetof", cxx_compiler) + +# catches objects passed by value to variadic functions. +check_and_add_gcc_warning("-Wclass-varargs") + +# catches empty if/switch/for initialization statements that have no effect +check_and_add_gcc_warning("-Wempty-init-stmt", cxx_compiler) + +# catches some implicit conversion of floats to ints +check_and_add_gcc_warning("-Wfloat-overflow-conversion") +check_and_add_gcc_warning("-Wfloat-zero-conversion") + +# catches issues around loops +check_and_add_gcc_warning("-Wloop-analysis") +# But, disable range-loop-analysis because it can raise unhelpful false +# positives. +check_and_add_gcc_warning("-Wno-range-loop-analysis") + +# catches C++ version forward-compat issues +check_and_add_gcc_warning("-Wc++2a-compat", cxx_compiler) + +# catches possible misuse of the comma operator +check_and_add_gcc_warning("-Wcomma", cxx_compiler) + +# catches duplicated conditions in if-else-if chains +check_and_add_gcc_warning("-Wduplicated-cond") + +# catches unintentional switch case fallthroughs +check_and_add_gcc_warning("-Wimplicit-fallthrough", cxx_compiler) + +# catches unused variable/function declarations +check_and_add_gcc_warning("-Wunused-function", cxx_compiler) +check_and_add_gcc_warning("-Wunused-variable", cxx_compiler) + +# catches expressions used as a null pointer constant +# XXX: at the time of writing, the version of clang used on the OS X test +# machines has a bug that causes it to reject some valid files if both +# -Wnon-literal-null-conversion and -Wsometimes-uninitialized are +# specified. We work around this by instead using +# -Werror=non-literal-null-conversion, but we only do that when +# --enable-warnings-as-errors is specified so that no unexpected fatal +# warnings are produced. +check_and_add_gcc_warning( + "-Werror=non-literal-null-conversion", when="--enable-warnings-as-errors" +) + +# catches string literals used in boolean expressions +check_and_add_gcc_warning("-Wstring-conversion") + +# catches comparisons that are always true or false +check_and_add_gcc_warning("-Wtautological-overlap-compare") +check_and_add_gcc_warning("-Wtautological-unsigned-enum-zero-compare") +check_and_add_gcc_warning("-Wtautological-unsigned-zero-compare") +# This can be triggered by certain patterns used deliberately in portable code +check_and_add_gcc_warning("-Wno-error=tautological-type-limit-compare") + +# we inline 'new' and 'delete' in mozalloc +check_and_add_gcc_warning("-Wno-inline-new-delete", cxx_compiler) + +# Prevent the following GCC warnings from being treated as errors: +# too many false positives +check_and_add_gcc_warning("-Wno-error=maybe-uninitialized") + +# we don't want our builds held hostage when a platform-specific API +# becomes deprecated. +check_and_add_gcc_warning("-Wno-error=deprecated-declarations") + +# false positives depending on optimization +check_and_add_gcc_warning("-Wno-error=array-bounds") + +# can't get rid of those PGO warnings +check_and_add_gcc_warning("-Wno-error=coverage-mismatch") + +# -Wbackend-plugin warnings from Android PGO profile-use builds: +# error: /builds/worker/workspace/build/src/mozglue/misc/AutoProfilerLabel.cpp: +# Function control flow change detected (hash mismatch) +# _ZN7mozilla17AutoProfilerLabelD2Ev [-Werror,-Wbackend-plugin] +check_and_add_gcc_warning("-Wno-error=backend-plugin") + +# false positives depending on optimizations +check_and_add_gcc_warning("-Wno-error=free-nonheap-object") + +# Would be a pain to fix all occurrences, for very little gain +check_and_add_gcc_warning("-Wno-multistatement-macros") + +# Disable the -Werror for return-std-move because of a false positive +# on nsTAutoStringN: https://bugs.llvm.org/show_bug.cgi?id=37249 +check_and_add_gcc_warning("-Wno-error=return-std-move") + +# Disable the -Werror for -Wclass-memaccess as we have a long +# tail of issues to fix +check_and_add_gcc_warning("-Wno-error=class-memaccess") + +# -Watomic-alignment is a new warning in clang 7 that seems way too broad. +# https://bugs.llvm.org/show_bug.cgi?id=38593 +check_and_add_gcc_warning("-Wno-error=atomic-alignment") + +# New warning with gcc 9. Not useful +# https://bugzilla.mozilla.org/show_bug.cgi?id=1515356 +check_and_add_gcc_warning("-Wno-error=deprecated-copy") + +# catches format/argument mismatches with printf +c_format_warning, cxx_format_warning = check_and_add_gcc_warning( + "-Wformat", when=depends(target)(lambda t: t.kernel != "WINNT") +) + +# Add compile-time warnings for unprotected functions and format functions +# that represent possible security problems. Enable this only when -Wformat +# is enabled, otherwise it is an error +check_and_add_gcc_warning( + "-Wformat-security", when=c_format_warning & cxx_format_warning +) +check_and_add_gcc_warning( + "-Wformat-overflow=2", when=c_format_warning & cxx_format_warning +) + +# Other MinGW specific things +with only_when(depends(target)(lambda t: t.kernel == "WINNT")): + # When compiling for Windows with gcc, we encounter lots of "#pragma warning"'s + # which is an MSVC-only pragma that GCC does not recognize. + check_and_add_gcc_warning("-Wno-unknown-pragmas") + + # When compiling for Windows with gcc, gcc throws false positives and true + # positives where the callsite is ifdef-ed out + check_and_add_gcc_warning("-Wno-unused-function") + + # When compiling for Windows with gcc, gcc cannot produce this warning + # correctly: it mistakes DWORD_PTR and ULONG_PTR as types you cannot + # give NULL to. (You can in fact do that.) + check_and_add_gcc_warning("-Wno-conversion-null") + + # Throughout the codebase we regularly have switch statements off of enums + # without covering every value in the enum. We don't care about these warnings. + check_and_add_gcc_warning("-Wno-switch") + + # Another code pattern we have is using start and end constants in enums of + # different types. We do this for safety, but then when comparing it throws + # an error, which we would like to ignore. This seems to only affect the MinGW + # build, but we're not sure why. + check_and_add_gcc_warning("-Wno-enum-compare") + +# We hit this all over the place with the gtest INSTANTIATE_TEST_CASE_P macro +check_and_add_gcc_warning("-Wno-gnu-zero-variadic-macro-arguments") + +# Make it an error to be missing function declarations for C code. +check_and_add_gcc_warning("-Werror=implicit-function-declaration", c_compiler) + +# New in clang 11. We can't really do anything about this warning. +check_and_add_gcc_warning("-Wno-psabi") + +# Disable broken missing-braces warning on old clang versions +check_and_add_gcc_warning( + "-Wno-missing-braces", + when=depends(c_compiler)(lambda c: c.type == "clang" and c.version < "6.0"), +) + + +# Please keep these last in this file +add_old_configure_assignment("_WARNINGS_CFLAGS", warnings_flags.cflags) +add_old_configure_assignment("_WARNINGS_CXXFLAGS", warnings_flags.cxxflags) +add_old_configure_assignment("_WARNINGS_HOST_CFLAGS", warnings_flags.host_cflags) +add_old_configure_assignment("_WARNINGS_HOST_CXXFLAGS", warnings_flags.host_cxxflags) |