|
|
|
@ -348,35 +348,32 @@ class CLikeCompiler(Compiler): |
|
|
|
def check_header(self, hname: str, prefix: str, env: 'Environment', *, |
|
|
|
def check_header(self, hname: str, prefix: str, env: 'Environment', *, |
|
|
|
extra_args: T.Optional[T.List[str]] = None, |
|
|
|
extra_args: T.Optional[T.List[str]] = None, |
|
|
|
dependencies: T.Optional[T.List['Dependency']] = None) -> T.Tuple[bool, bool]: |
|
|
|
dependencies: T.Optional[T.List['Dependency']] = None) -> T.Tuple[bool, bool]: |
|
|
|
fargs = {'prefix': prefix, 'header': hname} |
|
|
|
code = f'''{prefix} |
|
|
|
code = '''{prefix} |
|
|
|
#include <{hname}>''' |
|
|
|
#include <{header}>''' |
|
|
|
return self.compiles(code, env, extra_args=extra_args, |
|
|
|
return self.compiles(code.format(**fargs), env, extra_args=extra_args, |
|
|
|
|
|
|
|
dependencies=dependencies) |
|
|
|
dependencies=dependencies) |
|
|
|
|
|
|
|
|
|
|
|
def has_header(self, hname: str, prefix: str, env: 'Environment', *, |
|
|
|
def has_header(self, hname: str, prefix: str, env: 'Environment', *, |
|
|
|
extra_args: T.Optional[T.List[str]] = None, |
|
|
|
extra_args: T.Optional[T.List[str]] = None, |
|
|
|
dependencies: T.Optional[T.List['Dependency']] = None, |
|
|
|
dependencies: T.Optional[T.List['Dependency']] = None, |
|
|
|
disable_cache: bool = False) -> T.Tuple[bool, bool]: |
|
|
|
disable_cache: bool = False) -> T.Tuple[bool, bool]: |
|
|
|
fargs = {'prefix': prefix, 'header': hname} |
|
|
|
code = f'''{prefix} |
|
|
|
code = '''{prefix} |
|
|
|
|
|
|
|
#ifdef __has_include |
|
|
|
#ifdef __has_include |
|
|
|
#if !__has_include("{header}") |
|
|
|
#if !__has_include("{hname}") |
|
|
|
#error "Header '{header}' could not be found" |
|
|
|
#error "Header '{hname}' could not be found" |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
#else |
|
|
|
#else |
|
|
|
#include <{header}> |
|
|
|
#include <{hname}> |
|
|
|
#endif''' |
|
|
|
#endif''' |
|
|
|
return self.compiles(code.format(**fargs), env, extra_args=extra_args, |
|
|
|
return self.compiles(code, env, extra_args=extra_args, |
|
|
|
dependencies=dependencies, mode='preprocess', disable_cache=disable_cache) |
|
|
|
dependencies=dependencies, mode='preprocess', disable_cache=disable_cache) |
|
|
|
|
|
|
|
|
|
|
|
def has_header_symbol(self, hname: str, symbol: str, prefix: str, |
|
|
|
def has_header_symbol(self, hname: str, symbol: str, prefix: str, |
|
|
|
env: 'Environment', *, |
|
|
|
env: 'Environment', *, |
|
|
|
extra_args: T.Optional[T.List[str]] = None, |
|
|
|
extra_args: T.Optional[T.List[str]] = None, |
|
|
|
dependencies: T.Optional[T.List['Dependency']] = None) -> T.Tuple[bool, bool]: |
|
|
|
dependencies: T.Optional[T.List['Dependency']] = None) -> T.Tuple[bool, bool]: |
|
|
|
fargs = {'prefix': prefix, 'header': hname, 'symbol': symbol} |
|
|
|
t = f'''{prefix} |
|
|
|
t = '''{prefix} |
|
|
|
#include <{hname}> |
|
|
|
#include <{header}> |
|
|
|
|
|
|
|
int main(void) {{ |
|
|
|
int main(void) {{ |
|
|
|
/* If it's not defined as a macro, try to use as a symbol */ |
|
|
|
/* If it's not defined as a macro, try to use as a symbol */ |
|
|
|
#ifndef {symbol} |
|
|
|
#ifndef {symbol} |
|
|
|
@ -384,7 +381,7 @@ class CLikeCompiler(Compiler): |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
}}''' |
|
|
|
}}''' |
|
|
|
return self.compiles(t.format(**fargs), env, extra_args=extra_args, |
|
|
|
return self.compiles(t, env, extra_args=extra_args, |
|
|
|
dependencies=dependencies) |
|
|
|
dependencies=dependencies) |
|
|
|
|
|
|
|
|
|
|
|
def _get_basic_compiler_args(self, env: 'Environment', mode: CompileCheckMode) -> T.Tuple[T.List[str], T.List[str]]: |
|
|
|
def _get_basic_compiler_args(self, env: 'Environment', mode: CompileCheckMode) -> T.Tuple[T.List[str], T.List[str]]: |
|
|
|
@ -499,11 +496,10 @@ class CLikeCompiler(Compiler): |
|
|
|
def _compile_int(self, expression: str, prefix: str, env: 'Environment', |
|
|
|
def _compile_int(self, expression: str, prefix: str, env: 'Environment', |
|
|
|
extra_args: T.Optional[T.List[str]], |
|
|
|
extra_args: T.Optional[T.List[str]], |
|
|
|
dependencies: T.Optional[T.List['Dependency']]) -> bool: |
|
|
|
dependencies: T.Optional[T.List['Dependency']]) -> bool: |
|
|
|
fargs = {'prefix': prefix, 'expression': expression} |
|
|
|
t = f'''#include <stdio.h> |
|
|
|
t = '''#include <stdio.h> |
|
|
|
|
|
|
|
{prefix} |
|
|
|
{prefix} |
|
|
|
int main(void) {{ static int a[1-2*!({expression})]; a[0]=0; return 0; }}''' |
|
|
|
int main(void) {{ static int a[1-2*!({expression})]; a[0]=0; return 0; }}''' |
|
|
|
return self.compiles(t.format(**fargs), env, extra_args=extra_args, |
|
|
|
return self.compiles(t, env, extra_args=extra_args, |
|
|
|
dependencies=dependencies)[0] |
|
|
|
dependencies=dependencies)[0] |
|
|
|
|
|
|
|
|
|
|
|
def cross_compute_int(self, expression: str, low: T.Optional[int], high: T.Optional[int], |
|
|
|
def cross_compute_int(self, expression: str, low: T.Optional[int], high: T.Optional[int], |
|
|
|
@ -565,14 +561,13 @@ class CLikeCompiler(Compiler): |
|
|
|
extra_args = [] |
|
|
|
extra_args = [] |
|
|
|
if self.is_cross: |
|
|
|
if self.is_cross: |
|
|
|
return self.cross_compute_int(expression, low, high, guess, prefix, env, extra_args, dependencies) |
|
|
|
return self.cross_compute_int(expression, low, high, guess, prefix, env, extra_args, dependencies) |
|
|
|
fargs = {'prefix': prefix, 'expression': expression} |
|
|
|
t = f'''#include<stdio.h> |
|
|
|
t = '''#include<stdio.h> |
|
|
|
|
|
|
|
{prefix} |
|
|
|
{prefix} |
|
|
|
int main(void) {{ |
|
|
|
int main(void) {{ |
|
|
|
printf("%ld\\n", (long)({expression})); |
|
|
|
printf("%ld\\n", (long)({expression})); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
}};''' |
|
|
|
}};''' |
|
|
|
res = self.run(t.format(**fargs), env, extra_args=extra_args, |
|
|
|
res = self.run(t, env, extra_args=extra_args, |
|
|
|
dependencies=dependencies) |
|
|
|
dependencies=dependencies) |
|
|
|
if not res.compiled: |
|
|
|
if not res.compiled: |
|
|
|
return -1 |
|
|
|
return -1 |
|
|
|
@ -585,14 +580,13 @@ class CLikeCompiler(Compiler): |
|
|
|
dependencies: T.Optional[T.List['Dependency']] = None) -> int: |
|
|
|
dependencies: T.Optional[T.List['Dependency']] = None) -> int: |
|
|
|
if extra_args is None: |
|
|
|
if extra_args is None: |
|
|
|
extra_args = [] |
|
|
|
extra_args = [] |
|
|
|
fargs = {'prefix': prefix, 'type': typename} |
|
|
|
t = f'''#include <stdio.h> |
|
|
|
t = '''#include <stdio.h> |
|
|
|
|
|
|
|
{prefix} |
|
|
|
{prefix} |
|
|
|
int main(void) {{ |
|
|
|
int main(void) {{ |
|
|
|
{type} something; |
|
|
|
{typename} something; |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
}}''' |
|
|
|
}}''' |
|
|
|
if not self.compiles(t.format(**fargs), env, extra_args=extra_args, |
|
|
|
if not self.compiles(t, env, extra_args=extra_args, |
|
|
|
dependencies=dependencies)[0]: |
|
|
|
dependencies=dependencies)[0]: |
|
|
|
return -1 |
|
|
|
return -1 |
|
|
|
return self.cross_compute_int('sizeof(%s)' % typename, None, None, None, prefix, env, extra_args, dependencies) |
|
|
|
return self.cross_compute_int('sizeof(%s)' % typename, None, None, None, prefix, env, extra_args, dependencies) |
|
|
|
@ -602,17 +596,16 @@ class CLikeCompiler(Compiler): |
|
|
|
dependencies: T.Optional[T.List['Dependency']] = None) -> int: |
|
|
|
dependencies: T.Optional[T.List['Dependency']] = None) -> int: |
|
|
|
if extra_args is None: |
|
|
|
if extra_args is None: |
|
|
|
extra_args = [] |
|
|
|
extra_args = [] |
|
|
|
fargs = {'prefix': prefix, 'type': typename} |
|
|
|
|
|
|
|
if self.is_cross: |
|
|
|
if self.is_cross: |
|
|
|
return self.cross_sizeof(typename, prefix, env, extra_args=extra_args, |
|
|
|
return self.cross_sizeof(typename, prefix, env, extra_args=extra_args, |
|
|
|
dependencies=dependencies) |
|
|
|
dependencies=dependencies) |
|
|
|
t = '''#include<stdio.h> |
|
|
|
t = f'''#include<stdio.h> |
|
|
|
{prefix} |
|
|
|
{prefix} |
|
|
|
int main(void) {{ |
|
|
|
int main(void) {{ |
|
|
|
printf("%ld\\n", (long)(sizeof({type}))); |
|
|
|
printf("%ld\\n", (long)(sizeof({typename}))); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
}};''' |
|
|
|
}};''' |
|
|
|
res = self.run(t.format(**fargs), env, extra_args=extra_args, |
|
|
|
res = self.run(t, env, extra_args=extra_args, |
|
|
|
dependencies=dependencies) |
|
|
|
dependencies=dependencies) |
|
|
|
if not res.compiled: |
|
|
|
if not res.compiled: |
|
|
|
return -1 |
|
|
|
return -1 |
|
|
|
@ -625,23 +618,22 @@ class CLikeCompiler(Compiler): |
|
|
|
dependencies: T.Optional[T.List['Dependency']] = None) -> int: |
|
|
|
dependencies: T.Optional[T.List['Dependency']] = None) -> int: |
|
|
|
if extra_args is None: |
|
|
|
if extra_args is None: |
|
|
|
extra_args = [] |
|
|
|
extra_args = [] |
|
|
|
fargs = {'prefix': prefix, 'type': typename} |
|
|
|
t = f'''#include <stdio.h> |
|
|
|
t = '''#include <stdio.h> |
|
|
|
|
|
|
|
{prefix} |
|
|
|
{prefix} |
|
|
|
int main(void) {{ |
|
|
|
int main(void) {{ |
|
|
|
{type} something; |
|
|
|
{typename} something; |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
}}''' |
|
|
|
}}''' |
|
|
|
if not self.compiles(t.format(**fargs), env, extra_args=extra_args, |
|
|
|
if not self.compiles(t, env, extra_args=extra_args, |
|
|
|
dependencies=dependencies)[0]: |
|
|
|
dependencies=dependencies)[0]: |
|
|
|
return -1 |
|
|
|
return -1 |
|
|
|
t = '''#include <stddef.h> |
|
|
|
t = f'''#include <stddef.h> |
|
|
|
{prefix} |
|
|
|
{prefix} |
|
|
|
struct tmp {{ |
|
|
|
struct tmp {{ |
|
|
|
char c; |
|
|
|
char c; |
|
|
|
{type} target; |
|
|
|
{typename} target; |
|
|
|
}};''' |
|
|
|
}};''' |
|
|
|
return self.cross_compute_int('offsetof(struct tmp, target)', None, None, None, t.format(**fargs), env, extra_args, dependencies) |
|
|
|
return self.cross_compute_int('offsetof(struct tmp, target)', None, None, None, t, env, extra_args, dependencies) |
|
|
|
|
|
|
|
|
|
|
|
def alignment(self, typename: str, prefix: str, env: 'Environment', *, |
|
|
|
def alignment(self, typename: str, prefix: str, env: 'Environment', *, |
|
|
|
extra_args: T.Optional[T.List[str]] = None, |
|
|
|
extra_args: T.Optional[T.List[str]] = None, |
|
|
|
@ -651,19 +643,18 @@ class CLikeCompiler(Compiler): |
|
|
|
if self.is_cross: |
|
|
|
if self.is_cross: |
|
|
|
return self.cross_alignment(typename, prefix, env, extra_args=extra_args, |
|
|
|
return self.cross_alignment(typename, prefix, env, extra_args=extra_args, |
|
|
|
dependencies=dependencies) |
|
|
|
dependencies=dependencies) |
|
|
|
fargs = {'prefix': prefix, 'type': typename} |
|
|
|
t = f'''#include <stdio.h> |
|
|
|
t = '''#include <stdio.h> |
|
|
|
|
|
|
|
#include <stddef.h> |
|
|
|
#include <stddef.h> |
|
|
|
{prefix} |
|
|
|
{prefix} |
|
|
|
struct tmp {{ |
|
|
|
struct tmp {{ |
|
|
|
char c; |
|
|
|
char c; |
|
|
|
{type} target; |
|
|
|
{typename} target; |
|
|
|
}}; |
|
|
|
}}; |
|
|
|
int main(void) {{ |
|
|
|
int main(void) {{ |
|
|
|
printf("%d", (int)offsetof(struct tmp, target)); |
|
|
|
printf("%d", (int)offsetof(struct tmp, target)); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
}}''' |
|
|
|
}}''' |
|
|
|
res = self.run(t.format(**fargs), env, extra_args=extra_args, |
|
|
|
res = self.run(t, env, extra_args=extra_args, |
|
|
|
dependencies=dependencies) |
|
|
|
dependencies=dependencies) |
|
|
|
if not res.compiled: |
|
|
|
if not res.compiled: |
|
|
|
raise mesonlib.EnvironmentException('Could not compile alignment test.') |
|
|
|
raise mesonlib.EnvironmentException('Could not compile alignment test.') |
|
|
|
@ -679,18 +670,17 @@ class CLikeCompiler(Compiler): |
|
|
|
dependencies: T.Optional[T.List['Dependency']], |
|
|
|
dependencies: T.Optional[T.List['Dependency']], |
|
|
|
disable_cache: bool = False) -> T.Tuple[str, bool]: |
|
|
|
disable_cache: bool = False) -> T.Tuple[str, bool]: |
|
|
|
delim = '"MESON_GET_DEFINE_DELIMITER"' |
|
|
|
delim = '"MESON_GET_DEFINE_DELIMITER"' |
|
|
|
fargs = {'prefix': prefix, 'define': dname, 'delim': delim} |
|
|
|
code = f''' |
|
|
|
code = ''' |
|
|
|
|
|
|
|
{prefix} |
|
|
|
{prefix} |
|
|
|
#ifndef {define} |
|
|
|
#ifndef {dname} |
|
|
|
# define {define} |
|
|
|
# define {dname} |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
{delim}\n{define}''' |
|
|
|
{delim}\n{dname}''' |
|
|
|
args = self.build_wrapper_args(env, extra_args, dependencies, |
|
|
|
args = self.build_wrapper_args(env, extra_args, dependencies, |
|
|
|
mode=CompileCheckMode.PREPROCESS).to_native() |
|
|
|
mode=CompileCheckMode.PREPROCESS).to_native() |
|
|
|
func = functools.partial(self.cached_compile, code.format(**fargs), env.coredata, extra_args=args, mode='preprocess') |
|
|
|
func = functools.partial(self.cached_compile, code, env.coredata, extra_args=args, mode='preprocess') |
|
|
|
if disable_cache: |
|
|
|
if disable_cache: |
|
|
|
func = functools.partial(self.compile, code.format(**fargs), extra_args=args, mode='preprocess', temp_dir=env.scratch_dir) |
|
|
|
func = functools.partial(self.compile, code, extra_args=args, mode='preprocess', temp_dir=env.scratch_dir) |
|
|
|
with func() as p: |
|
|
|
with func() as p: |
|
|
|
cached = p.cached |
|
|
|
cached = p.cached |
|
|
|
if p.returncode != 0: |
|
|
|
if p.returncode != 0: |
|
|
|
@ -713,25 +703,24 @@ class CLikeCompiler(Compiler): |
|
|
|
cast = '(long long int)' |
|
|
|
cast = '(long long int)' |
|
|
|
else: |
|
|
|
else: |
|
|
|
raise AssertionError(f'BUG: Unknown return type {rtype!r}') |
|
|
|
raise AssertionError(f'BUG: Unknown return type {rtype!r}') |
|
|
|
fargs = {'prefix': prefix, 'f': fname, 'cast': cast, 'fmt': fmt} |
|
|
|
code = f'''{prefix} |
|
|
|
code = '''{prefix} |
|
|
|
|
|
|
|
#include <stdio.h> |
|
|
|
#include <stdio.h> |
|
|
|
int main(void) {{ |
|
|
|
int main(void) {{ |
|
|
|
printf ("{fmt}", {cast} {f}()); |
|
|
|
printf ("{fmt}", {cast} {fname}()); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
}}'''.format(**fargs) |
|
|
|
}}''' |
|
|
|
res = self.run(code, env, extra_args=extra_args, dependencies=dependencies) |
|
|
|
res = self.run(code, env, extra_args=extra_args, dependencies=dependencies) |
|
|
|
if not res.compiled: |
|
|
|
if not res.compiled: |
|
|
|
m = 'Could not get return value of {}()' |
|
|
|
m = f'Could not get return value of {fname}()' |
|
|
|
raise mesonlib.EnvironmentException(m.format(fname)) |
|
|
|
raise mesonlib.EnvironmentException(m) |
|
|
|
if rtype == 'string': |
|
|
|
if rtype == 'string': |
|
|
|
return res.stdout |
|
|
|
return res.stdout |
|
|
|
elif rtype == 'int': |
|
|
|
elif rtype == 'int': |
|
|
|
try: |
|
|
|
try: |
|
|
|
return int(res.stdout.strip()) |
|
|
|
return int(res.stdout.strip()) |
|
|
|
except ValueError: |
|
|
|
except ValueError: |
|
|
|
m = 'Return value of {}() is not an int' |
|
|
|
m = f'Return value of {fname}() is not an int' |
|
|
|
raise mesonlib.EnvironmentException(m.format(fname)) |
|
|
|
raise mesonlib.EnvironmentException(m) |
|
|
|
assert False, 'Unreachable' |
|
|
|
assert False, 'Unreachable' |
|
|
|
|
|
|
|
|
|
|
|
@staticmethod |
|
|
|
@staticmethod |
|
|
|
@ -896,28 +885,25 @@ class CLikeCompiler(Compiler): |
|
|
|
dependencies: T.Optional[T.List['Dependency']] = None) -> T.Tuple[bool, bool]: |
|
|
|
dependencies: T.Optional[T.List['Dependency']] = None) -> T.Tuple[bool, bool]: |
|
|
|
if extra_args is None: |
|
|
|
if extra_args is None: |
|
|
|
extra_args = [] |
|
|
|
extra_args = [] |
|
|
|
fargs = {'prefix': prefix, 'type': typename, 'name': 'foo'} |
|
|
|
|
|
|
|
# Create code that accesses all members |
|
|
|
# Create code that accesses all members |
|
|
|
members = '' |
|
|
|
members = '' |
|
|
|
for member in membernames: |
|
|
|
for member in membernames: |
|
|
|
members += '{}.{};\n'.format(fargs['name'], member) |
|
|
|
members += f'foo.{member};\n' |
|
|
|
fargs['members'] = members |
|
|
|
t = f'''{prefix} |
|
|
|
t = '''{prefix} |
|
|
|
|
|
|
|
void bar(void) {{ |
|
|
|
void bar(void) {{ |
|
|
|
{type} {name}; |
|
|
|
{typename} foo; |
|
|
|
{members} |
|
|
|
{members} |
|
|
|
}};''' |
|
|
|
}};''' |
|
|
|
return self.compiles(t.format(**fargs), env, extra_args=extra_args, |
|
|
|
return self.compiles(t, env, extra_args=extra_args, |
|
|
|
dependencies=dependencies) |
|
|
|
dependencies=dependencies) |
|
|
|
|
|
|
|
|
|
|
|
def has_type(self, typename: str, prefix: str, env: 'Environment', extra_args: T.List[str], |
|
|
|
def has_type(self, typename: str, prefix: str, env: 'Environment', extra_args: T.List[str], |
|
|
|
dependencies: T.Optional[T.List['Dependency']] = None) -> T.Tuple[bool, bool]: |
|
|
|
dependencies: T.Optional[T.List['Dependency']] = None) -> T.Tuple[bool, bool]: |
|
|
|
fargs = {'prefix': prefix, 'type': typename} |
|
|
|
t = f'''{prefix} |
|
|
|
t = '''{prefix} |
|
|
|
|
|
|
|
void bar(void) {{ |
|
|
|
void bar(void) {{ |
|
|
|
sizeof({type}); |
|
|
|
sizeof({typename}); |
|
|
|
}};''' |
|
|
|
}};''' |
|
|
|
return self.compiles(t.format(**fargs), env, extra_args=extra_args, |
|
|
|
return self.compiles(t, env, extra_args=extra_args, |
|
|
|
dependencies=dependencies) |
|
|
|
dependencies=dependencies) |
|
|
|
|
|
|
|
|
|
|
|
def symbols_have_underscore_prefix(self, env: 'Environment') -> bool: |
|
|
|
def symbols_have_underscore_prefix(self, env: 'Environment') -> bool: |
|
|
|
@ -937,11 +923,11 @@ class CLikeCompiler(Compiler): |
|
|
|
n = 'symbols_have_underscore_prefix' |
|
|
|
n = 'symbols_have_underscore_prefix' |
|
|
|
with self._build_wrapper(code, env, extra_args=args, mode='compile', want_output=True, temp_dir=env.scratch_dir) as p: |
|
|
|
with self._build_wrapper(code, env, extra_args=args, mode='compile', want_output=True, temp_dir=env.scratch_dir) as p: |
|
|
|
if p.returncode != 0: |
|
|
|
if p.returncode != 0: |
|
|
|
m = 'BUG: Unable to compile {!r} check: {}' |
|
|
|
m = f'BUG: Unable to compile {n!r} check: {p.stdout}' |
|
|
|
raise RuntimeError(m.format(n, p.stdout)) |
|
|
|
raise RuntimeError(m) |
|
|
|
if not os.path.isfile(p.output_name): |
|
|
|
if not os.path.isfile(p.output_name): |
|
|
|
m = 'BUG: Can\'t find compiled test code for {!r} check' |
|
|
|
m = f'BUG: Can\'t find compiled test code for {n!r} check' |
|
|
|
raise RuntimeError(m.format(n)) |
|
|
|
raise RuntimeError(m) |
|
|
|
with open(p.output_name, 'rb') as o: |
|
|
|
with open(p.output_name, 'rb') as o: |
|
|
|
for line in o: |
|
|
|
for line in o: |
|
|
|
# Check if the underscore form of the symbol is somewhere |
|
|
|
# Check if the underscore form of the symbol is somewhere |
|
|
|
@ -1065,8 +1051,7 @@ class CLikeCompiler(Compiler): |
|
|
|
if archs and env.machines.host.cpu_family in archs: |
|
|
|
if archs and env.machines.host.cpu_family in archs: |
|
|
|
return p |
|
|
|
return p |
|
|
|
else: |
|
|
|
else: |
|
|
|
mlog.debug('Rejected {}, supports {} but need {}' |
|
|
|
mlog.debug(f'Rejected {p}, supports {archs} but need {env.machines.host.cpu_family}') |
|
|
|
.format(p, archs, env.machines.host.cpu_family)) |
|
|
|
|
|
|
|
return None |
|
|
|
return None |
|
|
|
|
|
|
|
|
|
|
|
@functools.lru_cache() |
|
|
|
@functools.lru_cache() |
|
|
|
@ -1236,14 +1221,13 @@ class CLikeCompiler(Compiler): |
|
|
|
if arg.startswith('-Wno-'): |
|
|
|
if arg.startswith('-Wno-'): |
|
|
|
new_args.append('-W' + arg[5:]) |
|
|
|
new_args.append('-W' + arg[5:]) |
|
|
|
if arg.startswith('-Wl,'): |
|
|
|
if arg.startswith('-Wl,'): |
|
|
|
mlog.warning('{} looks like a linker argument, ' |
|
|
|
mlog.warning(f'{arg} looks like a linker argument, ' |
|
|
|
'but has_argument and other similar methods only ' |
|
|
|
'but has_argument and other similar methods only ' |
|
|
|
'support checking compiler arguments. Using them ' |
|
|
|
'support checking compiler arguments. Using them ' |
|
|
|
'to check linker arguments are never supported, ' |
|
|
|
'to check linker arguments are never supported, ' |
|
|
|
'and results are likely to be wrong regardless of ' |
|
|
|
'and results are likely to be wrong regardless of ' |
|
|
|
'the compiler you are using. has_link_argument or ' |
|
|
|
'the compiler you are using. has_link_argument or ' |
|
|
|
'other similar method can be used instead.' |
|
|
|
'other similar method can be used instead.') |
|
|
|
.format(arg)) |
|
|
|
|
|
|
|
new_args.append(arg) |
|
|
|
new_args.append(arg) |
|
|
|
return self.has_arguments(new_args, env, code, mode='compile') |
|
|
|
return self.has_arguments(new_args, env, code, mode='compile') |
|
|
|
|
|
|
|
|
|
|
|
|
Eli Schwartz
4 years ago