Chiebot-Mirror
/
meson
mirror of https://github.com/mesonbuild/meson.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity
The Meson Build System http://mesonbuild.com/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
8645 Commits
76 Branches
171 Tags
74 MiB
Tag: Branch: Tree: ca1f7726d5
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'ca1f7726d5'
${ noResults }
meson/test cases/common/39 has function/meson.build

92 lines
4.0 KiB
Raw Normal View History Unescape

tests/common: Run compiler checks for both C & C++ Without this we're just hoping that the C++ compiler behaves the same way as the C compiler, which is not always true as demonstrated by https://github.com/mesonbuild/meson/issues/958
8 years ago
project('has function', 'c', 'cpp')
Forgot this one.
12 years ago
has_function: Fix checking for builtins with includes We were checking for builtins explicitly like this because the ordinary checks don't work for builtins at all. We do exactly the same check as Autoconf and it doesn't work with Autoconf either (Autoconf is broken!) So now we check for it in two ways: if there's no #include in prefix, we check if `__builtin_symbol` exists (has_function allows checking for functions without providing includes). If there's a #include, we check if `symbol` exists. The old method was causing problems with some buggy toolchains such as MSYS2 which define some builtins in the C library but don't expose them via headers which meant that `__builtin_symbol` would be found even though `symbol` is not available. Doing this allows people to always get the correct answer as long as they specify the includes that are required to find a function while also not forcing people to always specify includes to find a function which is cumbersome. Closes #1083
8 years ago
host_system = host_machine.system()
Compiler check and extra args should always override We want compiler check arguments (-O0, -fpermissive, etc) to override all other arguments, and we want extra_args passed in by the build file to always override everything. To do this properly, we must split include arguments out, append them first, append all other arguments as usual, and then append the rest. As part of this, we also add the compiler check flags to the cc.compiles() and cc.links() helper functions since they also most likely need them. Also includes a unit test for all this.
8 years ago
# This is used in the `test_compiler_check_flags_order` unit test
unit_test_args = '-I/tmp'
compilers: Fix has_function check for builtins Use a single check for both cases when we have includes and when we don't. This way we ensure three things: 1. Built-in checks are 100% reliable with clang and on macOS since clang implements __has_builtin 2. When the #include is present, this ensures that __builtin_func is not checked for (because of MSYS, and because it is faster) 3. We fallback to checking __builtin_func when all else fails
8 years ago
defines_has_builtin = '''#ifndef __has_builtin
#error "no __has_builtin"
#endif
'''
tests/common: Run compiler checks for both C & C++ Without this we're just hoping that the C++ compiler behaves the same way as the C compiler, which is not always true as demonstrated by https://github.com/mesonbuild/meson/issues/958
8 years ago
compilers = [meson.get_compiler('c'), meson.get_compiler('cpp')]
Forgot this one.
12 years ago
tests/common: Run compiler checks for both C & C++ Without this we're just hoping that the C++ compiler behaves the same way as the C compiler, which is not always true as demonstrated by https://github.com/mesonbuild/meson/issues/958
8 years ago
foreach cc : compilers
Compiler check and extra args should always override We want compiler check arguments (-O0, -fpermissive, etc) to override all other arguments, and we want extra_args passed in by the build file to always override everything. To do this properly, we must split include arguments out, append them first, append all other arguments as usual, and then append the rest. As part of this, we also add the compiler check flags to the cc.compiles() and cc.links() helper functions since they also most likely need them. Also includes a unit test for all this.
8 years ago
if not cc.has_function('printf', prefix : '#include<stdio.h>',
args : unit_test_args)
tests/common: Run compiler checks for both C & C++ Without this we're just hoping that the C++ compiler behaves the same way as the C compiler, which is not always true as demonstrated by https://github.com/mesonbuild/meson/issues/958
8 years ago
error('"printf" function not found (should always exist).')
endif
Forgot this one.
12 years ago
tests/common: Run compiler checks for both C & C++ Without this we're just hoping that the C++ compiler behaves the same way as the C compiler, which is not always true as demonstrated by https://github.com/mesonbuild/meson/issues/958
8 years ago
# Should also be able to detect it without specifying the header
# We check for a different function here to make sure the result is
# not taken from a cache (ie. the check above)
# On MSVC fprintf is defined as an inline function in the header, so it cannot
# be found without the include.
tests/common/40: ICL behaves like MSVC and should be tested like it
6 years ago
if not ['msvc', 'intel-cl'].contains(cc.get_id())
Compiler check and extra args should always override We want compiler check arguments (-O0, -fpermissive, etc) to override all other arguments, and we want extra_args passed in by the build file to always override everything. To do this properly, we must split include arguments out, append them first, append all other arguments as usual, and then append the rest. As part of this, we also add the compiler check flags to the cc.compiles() and cc.links() helper functions since they also most likely need them. Also includes a unit test for all this.
8 years ago
assert(cc.has_function('fprintf', args : unit_test_args),
'"fprintf" function not found without include (on !msvc).')
tests/common: Run compiler checks for both C & C++ Without this we're just hoping that the C++ compiler behaves the same way as the C compiler, which is not always true as demonstrated by https://github.com/mesonbuild/meson/issues/958
8 years ago
else
Compiler check and extra args should always override We want compiler check arguments (-O0, -fpermissive, etc) to override all other arguments, and we want extra_args passed in by the build file to always override everything. To do this properly, we must split include arguments out, append them first, append all other arguments as usual, and then append the rest. As part of this, we also add the compiler check flags to the cc.compiles() and cc.links() helper functions since they also most likely need them. Also includes a unit test for all this.
8 years ago
assert(cc.has_function('fprintf', prefix : '#include <stdio.h>',
args : unit_test_args),
'"fprintf" function not found with include (on msvc).')
compilers: Don't run built-in checks on MSVC MSVC does not have built-ins, so this is totally useless. Instead, add a test for intrinsics to ensure that we do find them.
8 years ago
# Compiler intrinsics
assert(cc.has_function('strcmp'),
'strcmp intrinsic should have been found on MSVC')
assert(cc.has_function('strcmp', prefix : '#include <string.h>'),
'strcmp intrinsic should have been found with #include on MSVC')
tests/common: Run compiler checks for both C & C++ Without this we're just hoping that the C++ compiler behaves the same way as the C compiler, which is not always true as demonstrated by https://github.com/mesonbuild/meson/issues/958
8 years ago
endif
Improve cc.has_function() check to not require any includes and detect stubs We now use .links() to detect if a C compiler function is available or not, that way the user doesn't need to specify all the possible includes for the check, which simplifies things considerably. Also detect glibc stub functions that will never work and return false for them. Closes #437
9 years ago
Compiler check and extra args should always override We want compiler check arguments (-O0, -fpermissive, etc) to override all other arguments, and we want extra_args passed in by the build file to always override everything. To do this properly, we must split include arguments out, append them first, append all other arguments as usual, and then append the rest. As part of this, we also add the compiler check flags to the cc.compiles() and cc.links() helper functions since they also most likely need them. Also includes a unit test for all this.
8 years ago
if cc.has_function('hfkerhisadf', prefix : '#include<stdio.h>',
args : unit_test_args)
tests/common: Run compiler checks for both C & C++ Without this we're just hoping that the C++ compiler behaves the same way as the C compiler, which is not always true as demonstrated by https://github.com/mesonbuild/meson/issues/958
8 years ago
error('Found non-existent function "hfkerhisadf".')
endif
Improve cc.has_function() check to not require any includes and detect stubs We now use .links() to detect if a C compiler function is available or not, that way the user doesn't need to specify all the possible includes for the check, which simplifies things considerably. Also detect glibc stub functions that will never work and return false for them. Closes #437
9 years ago
compilers: Fix builtin checks with clang on Linux Our "43 has function" test should also work with clang and icc on Linux, so enable them. Also detect builtins with __has_builtin if available, which is much faster on clang. There is a feature request for the same with GCC too: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66970
8 years ago
if cc.has_function('hfkerhisadf', args : unit_test_args)
error('Found non-existent function "hfkerhisadf".')
endif
tests/common: Run compiler checks for both C & C++ Without this we're just hoping that the C++ compiler behaves the same way as the C compiler, which is not always true as demonstrated by https://github.com/mesonbuild/meson/issues/958
8 years ago
# With glibc on Linux lchmod is a stub that will always return an error,
# we want to detect that and declare that the function is not available.
# We can't check for the C library used here of course, but if it's not
# implemented in glibc it's probably not implemented in any other 'slimmer'
# C library variants either, so the check should be safe either way hopefully.
compilers: Fix has_function check for builtins Use a single check for both cases when we have includes and when we don't. This way we ensure three things: 1. Built-in checks are 100% reliable with clang and on macOS since clang implements __has_builtin 2. When the #include is present, this ensures that __builtin_func is not checked for (because of MSYS, and because it is faster) 3. We fallback to checking __builtin_func when all else fails
8 years ago
if host_system == 'linux' or host_system == 'darwin'
Compiler check and extra args should always override We want compiler check arguments (-O0, -fpermissive, etc) to override all other arguments, and we want extra_args passed in by the build file to always override everything. To do this properly, we must split include arguments out, append them first, append all other arguments as usual, and then append the rest. As part of this, we also add the compiler check flags to the cc.compiles() and cc.links() helper functions since they also most likely need them. Also includes a unit test for all this.
8 years ago
assert (cc.has_function('poll', prefix : '#include <poll.h>',
args : unit_test_args),
'couldn\'t detect "poll" when defined by a header')
lchmod_prefix = '#include <sys/stat.h>\n#include <unistd.h>'
compilers: Fix has_function check for builtins Use a single check for both cases when we have includes and when we don't. This way we ensure three things: 1. Built-in checks are 100% reliable with clang and on macOS since clang implements __has_builtin 2. When the #include is present, this ensures that __builtin_func is not checked for (because of MSYS, and because it is faster) 3. We fallback to checking __builtin_func when all else fails
8 years ago
if host_system == 'linux'
assert (not cc.has_function('lchmod', prefix : lchmod_prefix,
args : unit_test_args),
'"lchmod" check should have failed')
else
# macOS and *BSD have lchmod
assert (cc.has_function('lchmod', prefix : lchmod_prefix,
args : unit_test_args),
'"lchmod" check should have succeeded')
endif
has_function: Fix checking for builtins with includes We were checking for builtins explicitly like this because the ordinary checks don't work for builtins at all. We do exactly the same check as Autoconf and it doesn't work with Autoconf either (Autoconf is broken!) So now we check for it in two ways: if there's no #include in prefix, we check if `__builtin_symbol` exists (has_function allows checking for functions without providing includes). If there's a #include, we check if `symbol` exists. The old method was causing problems with some buggy toolchains such as MSYS2 which define some builtins in the C library but don't expose them via headers which meant that `__builtin_symbol` would be found even though `symbol` is not available. Doing this allows people to always get the correct answer as long as they specify the includes that are required to find a function while also not forcing people to always specify includes to find a function which is cumbersome. Closes #1083
8 years ago
# Check that built-ins are found properly both with and without headers
assert(cc.has_function('alloca', args : unit_test_args),
compilers: Fix has_function check for builtins Use a single check for both cases when we have includes and when we don't. This way we ensure three things: 1. Built-in checks are 100% reliable with clang and on macOS since clang implements __has_builtin 2. When the #include is present, this ensures that __builtin_func is not checked for (because of MSYS, and because it is faster) 3. We fallback to checking __builtin_func when all else fails
8 years ago
'built-in alloca must be found on ' + host_system)
has_function: Fix checking for builtins with includes We were checking for builtins explicitly like this because the ordinary checks don't work for builtins at all. We do exactly the same check as Autoconf and it doesn't work with Autoconf either (Autoconf is broken!) So now we check for it in two ways: if there's no #include in prefix, we check if `__builtin_symbol` exists (has_function allows checking for functions without providing includes). If there's a #include, we check if `symbol` exists. The old method was causing problems with some buggy toolchains such as MSYS2 which define some builtins in the C library but don't expose them via headers which meant that `__builtin_symbol` would be found even though `symbol` is not available. Doing this allows people to always get the correct answer as long as they specify the includes that are required to find a function while also not forcing people to always specify includes to find a function which is cumbersome. Closes #1083
8 years ago
assert(cc.has_function('alloca', prefix : '#include <alloca.h>',
args : unit_test_args),
compilers: Fix has_function check for builtins Use a single check for both cases when we have includes and when we don't. This way we ensure three things: 1. Built-in checks are 100% reliable with clang and on macOS since clang implements __has_builtin 2. When the #include is present, this ensures that __builtin_func is not checked for (because of MSYS, and because it is faster) 3. We fallback to checking __builtin_func when all else fails
8 years ago
'built-in alloca must be found with #include')
if not cc.compiles(defines_has_builtin, args : unit_test_args)
assert(not cc.has_function('alloca',
prefix : '#include <alloca.h>\n#undef alloca',
args : unit_test_args),
'built-in alloca must not be found with #include and #undef')
endif
tests/common: Run compiler checks for both C & C++ Without this we're just hoping that the C++ compiler behaves the same way as the C compiler, which is not always true as demonstrated by https://github.com/mesonbuild/meson/issues/958
8 years ago
endif
Improve cc.has_function() check to not require any includes and detect stubs We now use .links() to detect if a C compiler function is available or not, that way the user doesn't need to specify all the possible includes for the check, which simplifies things considerably. Also detect glibc stub functions that will never work and return false for them. Closes #437
9 years ago
tests/common: Run compiler checks for both C & C++ Without this we're just hoping that the C++ compiler behaves the same way as the C compiler, which is not always true as demonstrated by https://github.com/mesonbuild/meson/issues/958
8 years ago
# For some functions one needs to define _GNU_SOURCE before including the
# right headers to get them picked up. Make sure we can detect these functions
# as well without any prefix
Compiler check and extra args should always override We want compiler check arguments (-O0, -fpermissive, etc) to override all other arguments, and we want extra_args passed in by the build file to always override everything. To do this properly, we must split include arguments out, append them first, append all other arguments as usual, and then append the rest. As part of this, we also add the compiler check flags to the cc.compiles() and cc.links() helper functions since they also most likely need them. Also includes a unit test for all this.
8 years ago
if cc.has_header_symbol('sys/socket.h', 'recvmmsg',
prefix : '#define _GNU_SOURCE',
args : unit_test_args)
tests/common: Run compiler checks for both C & C++ Without this we're just hoping that the C++ compiler behaves the same way as the C compiler, which is not always true as demonstrated by https://github.com/mesonbuild/meson/issues/958
8 years ago
# We assume that if recvmmsg exists sendmmsg does too
Compiler check and extra args should always override We want compiler check arguments (-O0, -fpermissive, etc) to override all other arguments, and we want extra_args passed in by the build file to always override everything. To do this properly, we must split include arguments out, append them first, append all other arguments as usual, and then append the rest. As part of this, we also add the compiler check flags to the cc.compiles() and cc.links() helper functions since they also most likely need them. Also includes a unit test for all this.
8 years ago
assert (cc.has_function('sendmmsg', args : unit_test_args),
'Failed to detect function "sendmmsg" (should always exist).')
tests/common: Run compiler checks for both C & C++ Without this we're just hoping that the C++ compiler behaves the same way as the C compiler, which is not always true as demonstrated by https://github.com/mesonbuild/meson/issues/958
8 years ago
endif
endforeach