forked from mirrors/gecko-dev
eaca1f3dd4
For a few NDK releases now, the situation has been simplified wrt headers and libraries, and while we're currently still using things here and there because we never changed our ways, we can simplify things a lot by using the new simplified things. This involves: - Using a --target that contains the Android version, making clang set __ANDROID_API__ itself, and makes it look in $sysroot/usr/lib/$target/$ver when linking. - Using the sysroot that is under toolchains/llvm/prebuilt/*. - Removing the hacks around libstdc++/libc++. This ends up emptying stlport compiler flags, which allows to remove a bunch of things. Differential Revision: https://phabricator.services.mozilla.com/D172039
148 lines
4.9 KiB
Python
148 lines
4.9 KiB
Python
# -*- Mode: python; 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/.
|
|
|
|
|
|
@template
|
|
@imports("textwrap")
|
|
@imports(_from="mozbuild.configure", _import="SandboxDependsFunction")
|
|
def compiler_class(compiler, host_or_target):
|
|
is_target = host_or_target is target
|
|
|
|
class Compiler(SandboxDependsFunction):
|
|
# Generates a test program and attempts to compile it. In case of
|
|
# failure, the resulting check will return None. If the test program
|
|
# succeeds, it will return the output of the test program.
|
|
# - `includes` are the includes (as file names) that will appear at the
|
|
# top of the generated test program.
|
|
# - `body` is the code that will appear in the main function of the
|
|
# generated test program. `return 0;` is appended to the function
|
|
# body automatically.
|
|
# - `flags` are the flags to be passed to the compiler, in addition to
|
|
# `-c`.
|
|
# - `check_msg` is the message to be printed to accompany compiling the
|
|
# test program.
|
|
def try_compile(
|
|
self,
|
|
includes=None,
|
|
body="",
|
|
flags=None,
|
|
check_msg=None,
|
|
when=None,
|
|
onerror=lambda: None,
|
|
):
|
|
@depends(dependable(flags))
|
|
def flags(flags):
|
|
flags = list(flags or [])
|
|
flags.append("-c")
|
|
return flags
|
|
|
|
@depends(dependable(includes))
|
|
def header(includes):
|
|
includes = includes or []
|
|
return ["#include <%s>" % f for f in includes]
|
|
|
|
return self.try_run(
|
|
header=header,
|
|
body=body,
|
|
flags=flags,
|
|
check_msg=check_msg,
|
|
when=when,
|
|
onerror=onerror,
|
|
)
|
|
|
|
# Generates a test program and run the compiler against it. In case of
|
|
# failure, the resulting check will return None.
|
|
# - `header` is code that will appear at the top of the generated test
|
|
# program.
|
|
# - `body` is the code that will appear in the main function of the
|
|
# generated test program. `return 0;` is appended to the function
|
|
# body automatically.
|
|
# - `flags` are the flags to be passed to the compiler.
|
|
# - `check_msg` is the message to be printed to accompany compiling the
|
|
# test program.
|
|
# - `onerror` is a function called when the check fails.
|
|
def try_run(
|
|
self,
|
|
header=None,
|
|
body="",
|
|
flags=None,
|
|
check_msg=None,
|
|
when=None,
|
|
onerror=lambda: None,
|
|
):
|
|
source = textwrap.dedent(
|
|
"""\
|
|
int
|
|
main(void)
|
|
{
|
|
%s
|
|
;
|
|
return 0;
|
|
}
|
|
"""
|
|
% body
|
|
)
|
|
|
|
if check_msg:
|
|
|
|
def checking_fn(fn):
|
|
return checking(check_msg)(fn)
|
|
|
|
else:
|
|
|
|
def checking_fn(fn):
|
|
return fn
|
|
|
|
# We accept onerror being a @depends function that returns a callable.
|
|
# So, create a similar @depends function when it's not already one.
|
|
if not isinstance(onerror, SandboxDependsFunction):
|
|
onerror = dependable(lambda: onerror)
|
|
|
|
@depends(
|
|
self,
|
|
dependable(flags),
|
|
extra_toolchain_flags,
|
|
dependable(header),
|
|
onerror,
|
|
configure_cache,
|
|
when=when,
|
|
)
|
|
@checking_fn
|
|
def func(
|
|
compiler,
|
|
flags,
|
|
extra_flags,
|
|
header,
|
|
onerror,
|
|
configure_cache,
|
|
):
|
|
flags = list(flags or [])
|
|
if is_target:
|
|
flags += extra_flags or []
|
|
header = header or ""
|
|
if isinstance(header, (list, tuple)):
|
|
header = "\n".join(header)
|
|
if header:
|
|
header += "\n"
|
|
|
|
if (
|
|
try_invoke_compiler(
|
|
configure_cache,
|
|
[compiler.compiler] + compiler.flags,
|
|
compiler.language,
|
|
header + source,
|
|
flags,
|
|
onerror=onerror,
|
|
wrapper=compiler.wrapper,
|
|
)
|
|
is not None
|
|
):
|
|
return True
|
|
|
|
return func
|
|
|
|
compiler.__class__ = Compiler
|
|
return compiler
|