trisquel-icecat/icecat/build/moz.configure/flags.configure

# -*- 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/.

# We support C++14, but we don't want to enable the sized deallocation
# facilities in C++14 yet.
check_and_add_flag("-fno-sized-deallocation", compiler=cxx_compiler)
# Likewise for C++17 and aligned allocation.  It's not immediately obvious
# from the clang and GCC documentation, but they both support this.
check_and_add_flag("-fno-aligned-new", compiler=cxx_compiler)


with only_when(building_with_gnu_compatible_cc):
    with only_when(~developer_options):
        add_flag("-ffunction-sections")
        add_flag("-fdata-sections")
    add_flag("-fno-math-errno")
    add_flag("-fno-exceptions", compiler=cxx_compiler)


# Please keep these last in this file.
add_old_configure_assignment("_COMPILATION_CFLAGS", compilation_flags.cflags)
add_old_configure_assignment("_COMPILATION_CXXFLAGS", compilation_flags.cxxflags)
add_old_configure_assignment("_COMPILATION_HOST_CFLAGS", compilation_flags.host_cflags)
add_old_configure_assignment(
    "_COMPILATION_HOST_CXXFLAGS", compilation_flags.host_cxxflags
)


option(
    "--disable-new-pass-manager",
    help="Use the legacy LLVM pass manager in clang builds",
)


@depends(
    "--enable-new-pass-manager",
    c_compiler,
    host,
    target,
    "MOZ_PGO",
    enable_fuzzing,
    ubsan,
)
def pass_manager(enabled, compiler, host, target, pgo, enable_fuzzing, ubsan):
    if compiler.type not in ("clang", "clang-cl"):
        return None

    # As of clang 13, the default pass manager is the new one.
    if compiler.version >= "13.0.0":
        if enabled:
            return namespace(flags=None, enabled=True)
        if compiler.type == "clang":
            return namespace(flags=["-flegacy-pass-manager"], enabled=False)
        if compiler.type == "clang-cl":
            return namespace(flags=["-Xclang", "-flegacy-pass-manager"], enabled=False)

    if not enabled:
        if compiler.version >= "15.0.0":
            die("--disable-new-pass-manager is only supported with clang < 15")
        return None
    if compiler.version < "9.0.0":
        if enabled.origin != "default":
            die("--enable-new-pass-manager is only supported with clang >= 9")
        return None

    if host.os == "OSX":
        # Some native Mac builds hang with the new pass manager. Given the
        # inability to test in CI, don't take the risk of further breakage.
        if enabled.origin != "default":
            die(
                "--enable-new-pass-manager causes problems on mac hosts with clang < 13"
            )
        return None
    if target.os == "OSX" and not pgo:
        # Also disable when cross-compiling to Mac, because plain-ish opt
        # builds hang. Variants like asan and ccov work fine, but it would be
        # too tedious to test them all here. PGO is the only thing that matters
        # enough to make an exception for.
        if enabled.origin != "default":
            die(
                "--enable-new-pass-manager causes problems on mac builds with clang < 13"
            )
        return None
    if enable_fuzzing and compiler.version < "10.0.0":
        # Clang 9 does not seem to play well with libFuzzer
        if enabled.origin != "default":
            die(
                "--enable-new-pass-manager causes problems on fuzzing builds with clang < 10"
            )
        return None
    if ubsan and compiler.version == "10.0.0":
        # Clang 10.0.0 hangs with some ubsan-inserted code constructs.
        # This was fixed in 10.0.1 (https://llvm.org/pr45835)
        if enabled.origin != "default":
            die(
                "--enable-new-pass-manager causes problems with ubsan builds with clang 10.0.0"
            )
        return None
    if compiler.type == "clang":
        return namespace(flags=["-fexperimental-new-pass-manager"], enabled=True)
    elif compiler.type == "clang-cl":
        return namespace(
            flags=["-Xclang", "-fexperimental-new-pass-manager"], enabled=True
        )


set_config("MOZ_PASS_MANAGER_FLAGS", pass_manager.flags)

# Debugging options
##


@depends(moz_debug, asan, target, "--enable-jemalloc")
def moz_no_debug_rtl(moz_debug, asan, target, enable_jemalloc):
    if not moz_debug or asan:
        return True
    if enable_jemalloc and target.kernel == "WINNT":
        return True


set_config("MOZ_NO_DEBUG_RTL", moz_no_debug_rtl)


@depends(
    try_compile(
        includes=["stdio.h"],
        body='puts("Hello World");',
        check_msg="for valid debug flags",
        flags=debug_flags,
        when=moz_debug,
    ),
    debug_flags,
    when=moz_debug,
)
@imports(_from="mozbuild.shellutil", _import="quote")
def check_debug_flags(check, flags):
    if not check:
        die(f"These compiler flags are invalid: {quote(*flags)}")


# Try to make builds more reproducible and allow sharing built artifacts across
# source and object directories by using -ffile-prefix-map and friends.  To
# "unwind" the prefix maps, use:
#
# (gdb) set substitute-path /topsrcdir/ $topsrcdir/
#
# (lldb) settings set target.source-map /topobjdir/ $topobjdir/
#
# See, for example, https://lldb.llvm.org/use/map.html.
@depends(
    path_remapping,
    path_remappings,
    c_compiler,
)
@imports(_from="os", _import="sep")
def file_prefix_map_flags(path_remapping, path_remappings, compiler):
    if "c" not in path_remapping:
        return []

    if (compiler.type == "gcc" and compiler.version < "8.1") or (
        compiler.type in ("clang", "clang-cl") and compiler.version < "10.0.0"
    ):
        die(
            f"Compiler of type {compiler.type} and version {compiler.version} "
            "does not support --enable-path-remapping."
        )

    flags = []
    for old, new in path_remappings:
        # We would prefer to use just -ffile-prefix-map, but clang-cl doesn't
        # seem to recognize it.
        for flag in ("-fdebug-prefix-map", "-fmacro-prefix-map"):
            flag = f"{flag}={old}={new}"
            if compiler.type in ("gcc", "clang"):
                flags.append(flag)
            elif compiler.type == "clang-cl":
                flags.extend(["-Xclang", flag])

    return flags


set_config("MOZ_FILE_PREFIX_MAP_FLAGS", file_prefix_map_flags)


@depends(developer_options, when=building_with_gnu_compatible_cc)
def check_build_id_uuid(developer_options):
    return developer_options


@depends(developer_options, when=building_with_gnu_compatible_cc)
def check_build_id_sha1(developer_options):
    return not developer_options


check_and_add_flag("-pipe", when=building_with_gcc)

check_and_add_linker_flag("-Wl,--build-id=uuid", when=check_build_id_uuid)
check_and_add_linker_flag("-Wl,--build-id=sha1", when=check_build_id_sha1)

check_and_add_asm_flag("-Wa,--noexecstack", when=building_with_gnu_compatible_cc)
check_and_add_linker_flag("-Wl,-z,noexecstack", when=building_with_gnu_compatible_cc)
check_and_add_linker_flag("-Wl,-z,text", when=building_with_gnu_compatible_cc)
check_and_add_linker_flag("-Wl,-z,relro", when=building_with_gnu_compatible_cc)
check_and_add_linker_flag("-Wl,-z,now", when=building_with_gnu_compatible_cc)
check_and_add_linker_flag("-Wl,-z,nocopyreloc", when=building_with_gnu_compatible_cc)

check_and_add_linker_optimize_flag("-Wl,-dead_strip", when=target_is_darwin & ~dtrace)

have_linker_support_ignore_unresolved = try_link(
    flags=["-Wl,--ignore-unresolved-symbol,environ"],
    check_msg="for --ignore-unresolved-symbol option to the linker",
    when=building_with_gnu_compatible_cc & gcc_use_gnu_ld,
)
add_old_configure_assignment(
    "HAVE_LINKER_SUPPORT_IGNORE_UNRESOLVED", have_linker_support_ignore_unresolved
)


@depends("--enable-address-sanitizer", building_with_gnu_compatible_cc)
def check_Bsymbolic(enable_asan, building_with_gnu_compatible_cc):
    return enable_asan and building_with_gnu_compatible_cc


# ASan assumes no symbols are being interposed, and when that happens,
# it's not happy with it. Inconveniently, since IceCat is exporting
# libffi symbols and Gtk+3 pulls system libffi via libwayland-client,
# system libffi interposes libffi symbols that ASan assumes are in
# libxul, so it barfs about buffer overflows.
# Using -Wl,-Bsymbolic ensures no exported symbol can be interposed.
check_and_add_linker_flag("-Wl,-Bsymbolic", when=check_Bsymbolic)


# Check what kind of list files are supported by the linker
@depends(c_compiler, link, linker_ldflags, extra_toolchain_flags)
@checking("what kind of list files are supported by the linker")
@imports("os")
@imports(_from="__builtin__", _import="open")
@imports(_from="tempfile", _import="mkstemp")
def expand_libs_list_style(c_compiler, link, linker_flags, extra_flags):
    objfd, objname = mkstemp(prefix="conftest.", suffix=".o")
    os.close(objfd)

    listfd, listname = mkstemp(prefix="conftest.", suffix=".list")
    os.write(listfd, objname.encode())
    os.close(listfd)

    outfd, outname = mkstemp(prefix="conftest.", suffix=".out")
    os.close(outfd)

    try:
        cflags = c_compiler.flags

        if (
            try_invoke_compiler(
                # No configure_cache because it would not create the
                # expected output file.
                None,
                [c_compiler.compiler] + cflags,
                c_compiler.language,
                "int main() {}",
                ["-c", "-o", objname],
                wrapper=c_compiler.wrapper,
                onerror=lambda: None,
            )
            is None
        ):
            die("couldn't compile a simple C file")

        ldflags = linker_flags + (extra_flags or [])

        if c_compiler.type == "clang-cl":
            base_linker_cmd = [link] + ldflags + [f"-OUT:{outname}"]
        else:
            base_linker_cmd = [c_compiler.compiler] + cflags + ldflags + ["-o", outname]

        # -filelist is for the OS X linker.  We need to try -filelist
        # first because clang understands @file, but may pass an
        # oversized argument list to the linker depending on the
        # contents of @file.
        options = [
            ("linkerlist", f"-Wl,@{listname}"),
            ("filelist", f"-Wl,@{listname}"),
            ("list", f"@{listname}"),
        ]
        for kind, option in options:
            linker_cmd = base_linker_cmd + [option]
            if check_cmd_output(*linker_cmd, onerror=lambda: None) is not None:
                return kind
        die("Couldn't find one that works")

    finally:
        os.remove(objname)
        os.remove(listname)
        os.remove(outname)


set_config("EXPAND_LIBS_LIST_STYLE", expand_libs_list_style)

# Please keep these last in this file.
add_old_configure_assignment("_COMPILATION_ASFLAGS", asm_flags.asflags)
add_old_configure_assignment("_COMPILATION_HOST_ASFLAGS", asm_flags.host_asflags)
add_old_configure_assignment("_COMPILATION_LDFLAGS", linker_flags.ldflags)
add_old_configure_assignment(
    "_COMPILATION_OPTIMIZE_LDFLAGS", linker_optimize_flags.ldflags
)
add_old_configure_assignment("_COMPILATION_HOST_LDFLAGS", linker_flags.host_ldflags)