# -*- 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/. js_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') add_old_configure_assignment( 'MOZ_ENABLE_WARNINGS_AS_ERRORS', depends('--enable-warnings-as-errors')(lambda x: bool(x))) @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') return flags # 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 add_gcc_warning('-Woverloaded-virtual', cxx_compiler) # 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 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') # catches C++ version forward-compat issues check_and_add_gcc_warning('-Wc++1z-compat', cxx_compiler) 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 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') # 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', when='MOZ_PGO') # 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-error=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') # 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') # Disable a warning with gcc 7. See bug 1320656 # We are far from using C++17 and the impact of the warning will be # limited to a potential public ABI. # Currently only affecting js/ check_and_add_gcc_warning('-Wno-noexcept-type', cxx_compiler, when=depends(build_project) (lambda build_project: build_project == 'js')) # 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)