Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

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)