Makefile.config

#
# Copyright (C) 2013-2021 Canonical, Ltd.
# Copyright (C) 2021-2024 Colin Ian King
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
CONFIGS=configs

override CFLAGS += -Wall -Wextra -DVERSION='"$(VERSION)"' -O2 -std=gnu99 -I.
override CFLAGS := $(filter-out -Werror,$(CFLAGS))

APPARMOR_PARSER=/sbin/apparmor_parser

LIB_APPARMOR := -lapparmor
KERNEL=$(shell uname -s)
ifeq (,$(findstring $(KERNEL),Darwin DragonFly FreeBSD NetBSD OpenBSD))
LIB_BSD := -lbsd
endif
LIB_Z := -lz
LIB_CRYPT := -lcrypt
LIB_RT := -lrt
LIB_PTHREAD := -lpthread
LIB_AIO := -laio
LIB_SCTP := -lsctp
LIB_DL := -ldl
LIB_IPSEC_MB := -lIPSec_MB
LIB_JPEG := -ljpeg
LIB_JUDY := -lJudy
LIB_KMOD := -lkmod
ifneq ($(findstring musl-gcc,$(CC)),musl-gcc)
LIB_ATOMIC := -latomic
endif
LIB_MATH := -lm
LIB_XXHASH := -lxxhash
LIB_EGL := -lEGL
LIB_GLES2 := -lGLESv2
LIB_GBM := -lgbm
LIB_MD := -lmd
LIB_MPFR := -lmpfr
LIB_ACL := -lacl
LIB_GMP := -lgmp
LIB_C := -lc
LIB_NETWORK := -lnetwork
LIB_SOCKET := -lsocket
LIB_NSL := -lnsl

LIB_ORDER := $(LIB_ACL) $(LIB_AIO) $(LIB_APPARMOR) $(LIB_ATOMIC) $(LIB_BSD) \
	$(LIB_CRYPT) $(LIB_DL) $(LIB_IPSEC_MB) $(LIB_JPEG) $(LIB_JUDY) \
	$(LIB_KMOD) $(LIB_EGL) $(LIB_GLES2) $(LIB_MPFR) $(LIB_GMP) $(LIB_GBM) $(LIB_MD) \
	$(LIB_SCTP) $(LIB_XXHASH) $(LIB_Z) $(LIB_RT) \
	$(LIB_PTHREAD) $(LIB_MATH) $(LIB_NETWORK) $(LIB_SOCKET) $(LIB_NSL) $(LIB_C)

ifeq ($(shell $(CC) -v 2>&1 | grep 'gcc version' | grep -v 'icc' | wc -l),1)
ifeq ($(shell $(CC) -v 2>&1 | grep 'musl-gcc' | wc -l),0)
USING_GCC := yes
endif
endif
ifeq ($(shell $(CXX) -v 2>&1 | grep 'gcc version' | grep -v 'icc' | wc -l),1)
USING_GXX := yes
endif

DIR=test

.SUFFIXES: .c .o

override LDFLAGS += $(CONFIG_LDFLAGS)

#
# Static flags, only to be used when using GCC
#
ifeq ($(STATIC),1)
	override LDFLAGS += -static
	override CFLAGS += -DBUILD_STATIC
endif

ifeq ($(shell uname -s),SunOS)
	CONFIG_LDFLAGS += $(LIB_SOCKET) $(LIB_NSL)
endif
#
#  This must always come after -pthread so that static linking works
#
ifeq ($(shell uname -s),Haiku)
	CONFIG_LDFLAGS += $(LIB_NETWORK)
else
	CONFIG_LDFLAGS += $(LIB_C)
endif
CONFIG_LDFLAGS += $(LIB_MATH)

MAKE_OPTS=CC="$(CC)" -f Makefile.config --no-print-directory

comma = ,

#
# $1 = test program
# $2 = HAVE config name
# $3 = "using" message
# $4 = libraries required
# $5 = cflags required for test
# $6 = target clone settings
# $7 = cflags to be added to CONFIG_CFLAGS and test
# $8 = temp file
#
define check_tmp
	@if [ ! -f $(CONFIGS)/$(2) ]; then \
		$(CC) $(CFLAGS) $(CPPFLAGS) -Itest $(5) $(7) -DTARGET_CLONE=$(6) $(DIR)/$(1).c $(4) -o $(8) $(LDFLAGS) 2> /dev/null || true ; \
		if [ -s $(8) ]; then \
			echo "using $(3) ... yes"; \
			echo "# using $(2)" >> $(CONFIGS)/$(2); \
			if [ -n "$(7)" ]; then \
				echo "CONFIG_CFLAGS += $(7)" >> $(CONFIGS)/$(2); \
			fi; \
			if [ -n "$(4)" ]; then \
				for I in $(4); do \
					echo "CONFIG_LDFLAGS += $$I" >> $(CONFIGS)/$(2); \
				done; \
			fi; \
		else \
			echo "using $(3) ... no"; \
		fi; \
		mkdir -p $(CONFIGS); \
		touch $(CONFIGS)/$(2); \
		rm -f $(8); \
	fi
endef

define check
	$(call check_tmp,$1,$2,$3,$4,$5,$6,$7,$(shell mktemp))
endef

#
# $1 = test program
# $2 = HAVE config name
# $3 = "using" message
# $4 = libraries required
# $5 = cflags required for test
# $6 = target clone settings
# $7 = cflags to be added to CONFIG_CFLAGS and test
# $8 = temp file
#
define check_tmp_gxx
	@if [ ! -f $(CONFIGS)/$(2) ]; then \
		if [ -n "$(USING_GCC)" -a -n "$(USING_GXX)" ]; then \
			echo "building eigen matrix test..."; \
			$(CXX) $(CFLAGS) $(CPPFLAGS) -Itest $(5) $(7) -DTARGET_CLONE=$(6) $(DIR)/$(1).cpp $(4) -o $(8) $(LDFLAGS) 2> /dev/null || true ; \
			if [ -s $(8) ]; then \
				echo "using $(3) ... yes"; \
				echo "# using $(2)" >> $(CONFIGS)/$(2); \
				if [ -n "$(7)" ]; then \
					echo "CONFIG_CFLAGS += $(7)" >> $(CONFIGS)/$(2); \
				fi; \
				if [ -n "$(4)" ]; then \
					for I in $(4); do \
						echo "CONFIG_LDFLAGS += $$I" >> $(CONFIGS)/$(2); \
					done; \
				fi; \
			else \
				echo "using $(3) ... no"; \
			fi; \
			mkdir -p $(CONFIGS); \
			touch $(CONFIGS)/$(2); \
			rm -f $(8); \
		else \
			echo "using $(3) ... no, not using gcc"; \
		fi; \
	fi
endef

#
#  check for g++ compilation
#
define check_gxx
	$(call check_tmp_gxx,$1,$2,$3,$4,$5,$6,$7,$(shell mktemp))
endef

#
# $1 = float type
# $2 = HAVE config name
# $3 = message
# $4 = temp file
#
define check_float_tmp
	@if [ ! -f $(CONFIGS)/$(2) ]; then \
		$(CC) $(CFLAGS) $(CPPFLAGS) -DFLOAT=$(1) -o $(4) $(DIR)/test-float.c $(LIB_MATH) 2> /dev/null || true; \
		if [ -s $(4) ]; then \
			echo "using $(3) ... yes"; \
			echo "" >> $(CONFIGS)/$(2); \
		else \
			echo "using $(3) ... no"; \
		fi; \
	fi
	@mkdir -p $(CONFIGS)
	@touch $(CONFIGS)/$2
	@rm -f $4
endef

define check_float
	$(call check_float_tmp,$1,$2,$3,$(shell mktemp))
endef

#
# $1 = test program
# $2 = HAVE config name
# $3 = message
# $4 = temp file
#
define check_vecmath_tmp
	@if [ ! -f $(CONFIGS)/$(2) ]; then \
		$(CC) $(CFLAGS) $(CPPFLAGS) -Itest -DHAVE_VECMATH -c -o $(4) $(1).c 2> /dev/null || true; \
		if [ -s $(4) ]; then \
			echo "using $(3) ... yes"; \
			echo "" >> $(CONFIGS)/$(2); \
		else \
			echo "using $(3) ... no"; \
		fi; \
	fi
	@mkdir -p $(CONFIGS)
	@touch $(CONFIGS)/$(2)
	@rm -f $(4)
endef

define check_vecmath
	$(call check_vecmath_tmp,$1,$2,$3,$(shell mktemp))
endef

#
# $1 = test program
# $2 = HAVE config name
# $3 = message
# $4 = libs
#
define check_apparmor
	@if [ ! -f $(CONFIGS)/$(2) ]; then \
		$(CC) $(CFLAGS) $(CPPFLAGS) $(DIR)/$(1).c $4 -o $(DIR)/$(1) 2> /dev/null || true; \
		if [ -f $(DIR)/$(1) ]; then \
			$(APPARMOR_PARSER) -Q usr.bin.pulseaudio.eg -o apparmor-data.bin 2> /dev/null; \
			if [ $$? -eq 0 ] && [ -x "$(APPARMOR_PARSER)" ] && [ -f apparmor-data.bin ]; then \
				echo "using $(3) ... yes"; \
				echo "# using $(2)" >> $(CONFIGS)/$(2); \
				echo "CONFIG_LDFLAGS += $(4)" >> $(CONFIGS)/$(2); \
			else \
				echo "using $(3) ... no"; \
			fi; \
		else \
			echo "using $(3) ... no"; \
		fi; \
		mkdir -p $(CONFIGS); \
		touch $(CONFIGS)/$(2); \
	fi
	@rm -f $(DIR)/test-apparmor apparmor-data.bin
endef

#
# $1 = header file
# $2 = HAVE config name
# $3 = temp directory
#
define check_header_tmp
	@if [ ! -f $(CONFIGS)/$(2) ]; then \
		echo "#include <stdio.h>" >> $(3)/a.c; \
		echo "#include <sys/types.h>" >> $(3)/a.c; \
		for I in $1; do \
			echo "#include <$$I>" >> $(3)/a.c; \
		done; \
		$(CC) $(CFLAGS) $(CPPFLAGS) -c -o $(3)/a.o $(3)/a.c 2> /dev/null || true; \
		if [ -f $(3)/a.o ]; then \
			echo "using $(1) ... yes"; \
			echo "" >> $(CONFIGS)/$(2); \
		else \
			echo "using $(1) ... no"; \
		fi; \
		rm -rf $(3); \
		mkdir -p $(CONFIGS); \
		touch $(CONFIGS)/$(2); \
	fi
endef

define check_header
	$(call check_header_tmp,$1,$2,$(shell mktemp -d))
endef

#
# $1 = test program
# $2 = HAVE config name
# $3 = linker
#
define check_ld_tmp
	@if [ ! -f $(CONFIGS)/$(2) ]; then \
		$(CC) -fuse-ld=$(3) $(CFLAGS) $(CPPFLAGS) $(DIR)/$(1).c -o $(1) 2> /dev/null || true; \
		if [ -f $(1) ]; then \
			echo "using -fuse-ld=$(3) ... yes"; \
			echo "CONFIG_LDFLAGS += -fuse-ld=$(3)" >> $(CONFIGS)/$(2); \
		else \
			echo "using -fuse-ld=$(3) ... no"; \
		fi; \
		rm -f $(1); \
		mkdir -p $(CONFIGS); \
		touch $(CONFIGS)/$(2); \
	fi
endef

define check_ld
	$(call check_ld_tmp,$1,$2,$3)
endef

#
# Note echo "" > config.sort is required to workaround a makefile issue
# on Nixos
#
all: libraries headers cpufeatures types symbols functions
	@for I in $$(ls $(CONFIGS)); do \
		if [ -s $(CONFIGS)/$$I ]; then \
			echo "#define $$I"; \
		else \
			echo "/* #define $$I */"; \
		fi; \
	done | sort | uniq > config.h
	@echo $$(wc -l < config.h) configurations checked
	@rm -f $(CONFIGS)/HAVE_LDFLAGS_TMP
	@for I in $(CONFIG_LDFLAGS); do \
		echo "CONFIG_LDFLAGS += $$I" >> $(CONFIGS)/HAVE_LDFLAGS_TMP; \
	done
	@cat $(CONFIGS)/* | grep -v "#" | grep CONFIG_LDFLAGS | sed '/^$$/d' | sort | uniq > config.sort
	@rm -f config
	@for I in $(LIB_ORDER); do \
		grep "CONFIG_LDFLAGS += $$I\$$" config.sort >> config; \
		echo "" >> config.sort; \
	done
	@rm -f config.sort $(CONFIGS)/HAVE_LDFLAGS_TMP

configdir:
	@mkdir -p $(CONFIGS)

#.NOTPARALLEL:

.PHONY: clean
clean:
	@rm -rf $(CONFIGS) config config.h

.PHONY: libraries
libraries: \
	configdir \
	LIB_ACL LIB_AIO LIB_APPARMOR LIB_BSD LIB_CRYPT LIB_DL \
	LIB_EGL LIB_GBM LIB_GLES2 LIB_GMP LIB_IPSEC_MB LIB_JPEG \
	LIB_JUDY LIB_KMOD LIB_MD LIB_MPFR LIB_PTHREAD LIB_PTHREAD_SPINLOCK \
	LIB_RT LIB_SCTP LIB_XXHASH LIB_Z

LIB_ACL:
	$(call check,test-libacl,HAVE_LIB_ACL,$(LIB_ACL),$(LIB_ACL))

LIB_AIO:
	$(call check,test-libaio,HAVE_LIB_AIO,$(LIB_AIO),$(LIB_AIO))

LIB_APPARMOR:
	$(call check_apparmor,test-apparmor,HAVE_APPARMOR,$(LIB_APPARMOR),$(LIB_APPARMOR))

LIB_BSD:
ifeq ($(LIB_BSD),)
	@echo using -lbsd ... no
else
	$(call check,test-libbsd,HAVE_LIB_BSD,$(LIB_BSD),$(LIB_BSD))
endif

LIB_CRYPT:
	$(call check,test-libcrypt,HAVE_LIB_CRYPT,$(LIB_CRYPT),$(LIB_CRYPT))

LIB_DL:
	$(call check,test-libdl,HAVE_LIB_DL,$(LIB_DL),$(LIB_DL))

LIB_EGL:
	$(call check,test-libegl,HAVE_LIB_EGL,$(LIB_EGL),$(LIB_EGL))

LIB_GBM:
	$(call check,test-libgbm,HAVE_LIB_GBM,$(LIB_GBM),$(LIB_GBM))

LIB_GLES2:
	$(call check,test-libgles,HAVE_LIB_GLES2,$(LIB_GLES2),$(LIB_GLES2))

LIB_GMP:
	$(call check,test-libgmp,HAVE_LIB_GMP,$(LIB_GMP),$(LIB_GMP))

LIB_IPSEC_MB:
	$(call check,test-libipsec-mb,HAVE_LIB_IPSEC_MB,$(LIB_IPSEC_MB),$(LIB_IPSEC_MB))

LIB_JPEG:
	$(call check,test-libjpeg,HAVE_LIB_JPEG,$(LIB_JPEG),$(LIB_JPEG))

LIB_JUDY:
	$(call check,test-judy,HAVE_LIB_JUDY,$(LIB_JUDY),$(LIB_JUDY))

LIB_KMOD:
	$(call check,test-libkmod,HAVE_LIB_KMOD,$(LIB_KMOD),$(LIB_KMOD))

LIB_MD:
	$(call check,test-libmd,HAVE_LIB_MD,$(LIB_MD),$(LIB_MD))

LIB_MPFR:
	$(call check,test-libmpfr,HAVE_LIB_MPFR,$(LIB_MPFR),$(LIB_MPFR) $(LIB_GMP))

LIB_PTHREAD:
	$(call check,test-libpthread,HAVE_LIB_PTHREAD,$(LIB_PTHREAD),$(LIB_PTHREAD))

LIB_PTHREAD_SPINLOCK:
	$(call check,test-libpthread-spinlock,HAVE_LIB_PTHREAD_SPINLOCK,$(LIB_PTHREAD) spinlock,$(LIB_PTHREAD))

LIB_RT:
	$(call check,test-librt,HAVE_LIB_RT,$(LIB_RT),$(LIB_RT))

LIB_SCTP:
	$(call check,test-libsctp,HAVE_LIB_SCTP,$(LIB_SCTP),$(LIB_SCTP))

LIB_XXHASH:
	$(call check,test-libxxhash,HAVE_LIB_XXHASH,$(LIB_XXHASH),$(LIB_XXHASH))

LIB_Z:
	$(call check,test-libz,HAVE_LIB_Z,$(LIB_Z),$(LIB_Z))

.PHONY: headers
headers: \
	ACL_LIBACL_H \
	AIO_H \
	ASM_CACHECTL_H \
	ASM_LDT_H \
	ASM_MTRR_H \
	ASM_PRCTL_H \
	ATTR_XATTR_H \
	BSD_STDLIB_H \
	BSD_STRING_H \
	BSD_SYS_TREE_H \
	BSD_UNISTD_H \
	BSD_WCHAR_H \
	COMPLEX_H \
	CRYPT_H \
	EGL_EXT_H \
	EGL_H \
	FEATURES_H \
	FENV_H \
	FLOAT_H \
	GBM_H \
	GLES2_H \
	GMP_H \
	GRP_H \
	IFADDRS_H \
	IMMINTRIN_H \
	INTEL_IPSEC_MB_H \
	JPEG_H \
	JUDY_H \
	KEYUTILS_H \
	LIBAIO_H \
	LIBGEN_H \
	LIBKMOD_H \
	LINK_H \
	LINUX_ANDROID_BINDERFS_H \
	LINUX_ANDROID_BINDER_H \
	LINUX_AUDIT_H \
	LINUX_BLKZONED_H \
	LINUX_CDROM_H \
	LINUX_CN_PROC_H \
	LINUX_CONNECTOR_H \
	LINUX_DM_IOCTL_H \
	LINUX_FB_H \
	LINUX_FD_H \
	LINUX_FIEMAP_H \
	LINUX_FILTER_H \
	LINUX_FS_H \
	LINUX_FSVERITY_H \
	LINUX_FUTEX_H \
	LINUX_GENETLINK_H \
	LINUX_HDREG_H \
	LINUX_HIDDEV_H \
	LINUX_HIDRAW_H \
	LINUX_HPET_H \
	LINUX_IF_ALG_H \
	LINUX_IF_PACKET_H \
	LINUX_IF_TUN_H \
	LINUX_INPUT_H \
	LINUX_IO_URING_H \
	LINUX_KD_H \
	LINUX_KVM_H \
	LINUX_LANDLOCK_H \
	LINUX_LIRC_H \
	LINUX_LOOP_H \
	LINUX_LSM_H \
	LINUX_MAGIC_H \
	LINUX_MEDIA_H \
	LINUX_MEMBARRIER_H \
	LINUX_MEMFD_H \
	LINUX_MEMPOLICY_H \
	LINUX_MODULE_H \
	LINUX_NETLINK_H \
	LINUX_OPENAT2_H \
	LINUX_PCI_H \
	LINUX_PERF_EVENT_H \
	LINUX_POSIX_TYPES_H \
	LINUX_PPDEV_H \
	LINUX_PTP_CLOCK_H \
	LINUX_RANDOM_H \
	LINUX_RSEQ_H \
	LINUX_RTC_H \
	LINUX_RTNETLINK_H \
	LINUX_SECCOMP_H \
	LINUX_SERIAL_H \
	LINUX_SOCK_DIAG_H \
	LINUX_SOCKET_H \
	LINUX_SOCKIOS_H \
	LINUX_SYSCTL_H \
	LINUX_TASKSTATS_H \
	LINUX_UDP_H \
	LINUX_UINPUT_H \
	LINUX_UNIX_DIAG_H \
	LINUX_USB_CDC_WDM_H \
	LINUX_USBDEVICE_FS_H \
	LINUX_USERFAULTFD_H \
	LINUX_VERSION_H \
	LINUX_VIDEODEV2_H \
	LINUX_VT_H \
	LINUX_WATCHDOG_H \
	LOCALE_H \
	MACH_MACH_H \
	MACH_MACHINE_H \
	MACH_VM_STATISTICS_H \
	MALLOC_H \
	MNTENT_H \
	MPFR_H \
	MQUEUE_H \
	NET_IF_H \
	NETINET_IP_H \
	NETINET_IP_ICMP_H \
	NETINET_SCTP_H \
	NETINET_TCP_H \
	NETINET_UDP_H \
	POLL_H \
	PTHREAD_NP_H \
	SCSI_SCSI_H \
	SCSI_SCSI_IOCTL_H \
	SCSI_SG_H \
	SEARCH_H \
	SEMAPHORE_H \
	SOUND_ASOUND_H \
	SPAWN_H \
	STRINGS_H \
	SYS_ACL_H \
	SYS_APPARMOR_H \
	SYS_AUXV_H \
	SYSCALL_H \
	SYS_CAPABILITY_H \
	SYS_EPOLL_H \
	SYS_EVENTFD_H \
	SYS_FANOTIFY_H \
	SYS_FSUID_H \
	SYS_INOTIFY_H \
	SYS_IO_H \
	SYS_IPC_H \
	SYS_LOADAVG_H \
	SYSLOG_H \
	SYS_MKDEV_H \
	SYS_MOUNT_H \
	SYS_MSG_H \
	SYS_PARAM_H \
	SYS_PERSONALITY_H \
	SYS_PIDFD_H \
	SYS_PLATFORM_PPC_H \
	SYS_PRCTL_H \
	SYS_QUEUE_H \
	SYS_QUOTA_H \
	SYS_RANDOM_H \
	SYS_RSEQ_H \
	SYS_SELECT_H \
	SYS_SENDFILE_H \
	SYS_SHM_H \
	SYS_SIGNALFD_H \
	SYS_STATFS_H \
	SYS_STATVFS_H \
	SYS_SWAP_H \
	SYS_SYSCTL_H \
	SYS_SYSINFO_H \
	SYS_SYSMACROS_H \
	SYS_TIMERFD_H \
	SYS_TIMEX_H \
	SYS_TREE_H \
	SYS_UCRED_H \
	SYS_UIO_H \
	SYS_UN_H \
	SYS_UTSNAME_H \
	SYS_VFS_H \
	SYS_VMMETER_H \
	SYS_XATTR_H \
	TERMIO_H \
	TERMIOS_H \
	THREADS_H \
	UCONTEXT_H \
	USTAT_H \
	UTIME_H \
	UVM_UVM_EXTERN_H \
	WCHAR_H \
	X86INTRIN_H \
	XMMINTRIN_H \
	XXHASH_H

ACL_LIBACL_H:
	$(call check_header,acl/libacl.h,HAVE_ACL_LIBACL_H)

AIO_H:
	$(call check_header,aio.h,HAVE_AIO_H)

ASM_CACHECTL_H:
	$(call check_header,asm/cachectl.h,HAVE_ASM_CACHECTL_H)

ASM_LDT_H:
	$(call check_header,asm/ldt.h,HAVE_ASM_LDT_H)

ASM_MTRR_H:
	$(call check_header,asm/mtrr.h,HAVE_ASM_MTRR_H)

ASM_PRCTL_H:
	$(call check_header,asm/prctl.h,HAVE_ASM_PRCTL_H)

ATTR_XATTR_H:
	$(call check_header,attr/xattr.h,HAVE_ATTR_XATTR_H)

BSD_STDLIB_H:
	$(call check_header,bsd/stdlib.h,HAVE_BSD_STDLIB_H)

BSD_STRING_H:
	$(call check_header,bsd/string.h,HAVE_BSD_STRING_H)

BSD_SYS_TREE_H:
	$(call check_header,bsd/sys/tree.h,HAVE_BSD_SYS_TREE_H)

BSD_UNISTD_H:
	$(call check_header,bsd/unistd.h,HAVE_BSD_UNISTD_H)

BSD_WCHAR_H:
	$(call check_header,bsd/wchar.h,HAVE_BSD_WCHAR_H)

COMPLEX_H:
	$(call check_header,complex.h,HAVE_COMPLEX_H)

WCHAR_H:
	$(call check_header,wchar.h,HAVE_WCHAR_H)

CRYPT_H:
	$(call check_header,crypt.h,HAVE_CRYPT_H)

FEATURES_H:
	$(call check_header,features.h,HAVE_FEATURES_H)

FENV_H:
	$(call check_header,fenv.h,HAVE_FENV_H)

EGL_H:
	$(call check_header,EGL/egl.h,HAVE_EGL_H)

EGL_EXT_H:
	$(call check_header,EGL/egl.h EGL/eglext.h,HAVE_EGL_EXT_H)

FLOAT_H:
	$(call check_header,float.h,HAVE_FLOAT_H)

GBM_H:
	$(call check_header,gbm.h,HAVE_GBM_H)

GLES2_H:
	$(call check_header,GLES2/gl2.h,HAVE_GLES2_H)

GMP_H:
	$(call check_header,gmp.h,HAVE_GMP_H)

GRP_H:
	$(call check_header,grp.h,HAVE_GRP_H)

IFADDRS_H:
	$(call check_header,ifaddrs.h,HAVE_IFADDRS_H)

IMMINTRIN_H:
	$(call check_header,immintrin.h,HAVE_IMMINTRIN_H)

INTEL_IPSEC_MB_H:
	$(call check_header,intel-ipsec-mb.h,HAVE_INTEL_IPSEC_MB_H)

JPEG_H:
	$(call check_header,jpeglib.h,HAVE_LIBJPEG_H)

JUDY_H:
	$(call check_header,Judy.h,HAVE_JUDY_H)

KEYUTILS_H:
	$(call check_header,keyutils.h,HAVE_KEYUTILS_H)

LIBAIO_H:
	$(call check_header,libaio.h,HAVE_LIBAIO_H)

LIBGEN_H:
	$(call check_header,libgen.h,HAVE_LIBGEN_H)

LIBKMOD_H:
	$(call check_header,libkmod.h,HAVE_LIBKMOD_H)

LINK_H:
	$(call check_header,link.h,HAVE_LINK_H)

LINUX_ANDROID_BINDER_H:
	$(call check_header,linux/android/binder.h,HAVE_LINUX_ANDROID_BINDER_H)

LINUX_ANDROID_BINDERFS_H:
	$(call check_header,linux/android/binderfs.h,HAVE_LINUX_ANDROID_BINDERFS_H)

LINUX_AUDIT_H:
	$(call check_header,linux/audit.h,HAVE_LINUX_AUDIT_H)

LINUX_BLKZONED_H:
	$(call check_header,linux/blkzoned.h,HAVE_LINUX_BLKZONED_H)

LINUX_CDROM_H:
	$(call check_header,linux/cdrom.h,HAVE_LINUX_CDROM_H)

LINUX_CN_PROC_H:
	$(call check_header,linux/cn_proc.h,HAVE_LINUX_CN_PROC_H)

LINUX_CONNECTOR_H:
	$(call check_header,linux/connector.h,HAVE_LINUX_CONNECTOR_H)

LINUX_DM_IOCTL_H:
	$(call check_header,linux/dm-ioctl.h,HAVE_LINUX_DM_IOCTL_H)

LINUX_FB_H:
	$(call check_header,linux/fb.h,HAVE_LINUX_FB_H)

LINUX_FD_H:
	$(call check_header,linux/fd.h,HAVE_LINUX_FD_H)

LINUX_FIEMAP_H:
	$(call check_header,linux/fiemap.h,HAVE_LINUX_FIEMAP_H)

LINUX_FILTER_H:
	$(call check_header,linux/filter.h,HAVE_LINUX_FILTER_H)

LINUX_FSVERITY_H:
	$(call check_header,linux/fsverity.h,HAVE_LINUX_FSVERITY_H)

LINUX_FUTEX_H:
	$(call check_header,linux/futex.h,HAVE_LINUX_FUTEX_H)

LINUX_FS_H:
	$(call check_header,linux/fs.h,HAVE_LINUX_FS_H)

LINUX_GENETLINK_H:
	$(call check_header,linux/genetlink.h,HAVE_LINUX_GENETLINK_H)

LINUX_HDREG_H:
	$(call check_header,linux/hdreg.h,HAVE_LINUX_HDREG_H)

LINUX_HIDDEV_H:
	$(call check_header,linux/hiddev.h,HAVE_LINUX_HIDDEV)

LINUX_HIDRAW_H:
	$(call check_header,linux/hidraw.h,HAVE_LINUX_HIDRAW_H)

LINUX_HPET_H:
	$(call check_header,linux/hpet.h,HAVE_LINUX_HPET_H)

LINUX_IF_ALG_H:
	$(call check_header,linux/if_alg.h,HAVE_LINUX_IF_ALG_H)

LINUX_IF_PACKET_H:
	$(call check_header,linux/if_packet.h,HAVE_LINUX_IF_PACKET_H)

LINUX_IF_TUN_H:
	$(call check_header,linux/if_tun.h,HAVE_LINUX_IF_TUN_H)

LINUX_INPUT_H:
	$(call check_header,linux/input.h,HAVE_LINUX_INPUT_H)

LINUX_IO_URING_H:
	$(call check_header,linux/io_uring.h,HAVE_LINUX_IO_URING_H)

LINUX_KD_H:
	$(call check_header,linux/kd.h,HAVE_LINUX_KD_H)

LINUX_KVM_H:
	$(call check_header,linux/kvm.h,HAVE_LINUX_KVM_H)

LINUX_LANDLOCK_H:
	$(call check_header,linux/landlock.h,HAVE_LINUX_LANDLOCK_H)

LINUX_LIRC_H:
	$(call check_header,linux/lirc.h,HAVE_LINUX_LIRC_H)

LINUX_LOOP_H:
	$(call check_header,linux/loop.h,HAVE_LINUX_LOOP_H)

LINUX_LSM_H:
	$(call check_header,linux/lsm.h,HAVE_LINUX_LSM_H)

LINUX_MAGIC_H:
	$(call check_header,linux/magic.h,HAVE_LINUX_MAGIC_H)

LINUX_MEDIA_H:
	$(call check_header,linux/media.h,HAVE_LINUX_MEDIA_H)

LINUX_MEMBARRIER_H:
	$(call check_header,linux/membarrier.h,HAVE_LINUX_MEMBARRIER_H)

LINUX_MEMFD_H:
	$(call check_header,linux/memfd.h,HAVE_LINUX_MEMFD_H)

LINUX_MEMPOLICY_H:
	$(call check_header,linux/mempolicy.h,HAVE_LINUX_MEMPOLICY_H)

LINUX_MODULE_H:
	$(call check_header,linux/module.h,HAVE_LINUX_MODULE_H)

LINUX_NETLINK_H:
	$(call check_header,linux/netlink.h,HAVE_LINUX_NETLINK_H)

LINUX_OPENAT2_H:
	$(call check_header,linux/openat2.h,HAVE_LINUX_OPENAT2_H)

LINUX_PCI_H:
	$(call check_header,linux/pci.h,HAVE_LINUX_PCI_H)

LINUX_PERF_EVENT_H:
	$(call check_header,linux/perf_event.h,HAVE_LINUX_PERF_EVENT_H)

LINUX_POSIX_TYPES_H:
	$(call check_header,linux/posix_types.h,HAVE_LINUX_POSIX_TYPES_H)

LINUX_PPDEV_H:
	$(call check_header,linux/ppdev.h,HAVE_LINUX_PPDEV_H)

LINUX_PTP_CLOCK_H:
	$(call check_header,linux/ptp_clock.h,HAVE_LINUX_PTP_CLOCK_H)

LINUX_RANDOM_H:
	$(call check_header,linux/random.h,HAVE_LINUX_RANDOM_H)

LINUX_RSEQ_H:
	$(call check_header,linux/rseq.h,HAVE_LINUX_RSEQ_H)

LINUX_RTC_H:
	$(call check_header,linux/rtc.h,HAVE_LINUX_RTC_H)

LINUX_RTNETLINK_H:
	$(call check_header,linux/rtnetlink.h,HAVE_LINUX_RTNETLINK_H)

LINUX_SECCOMP_H:
	$(call check_header,linux/seccomp.h,HAVE_LINUX_SECCOMP_H)

LINUX_SERIAL_H:
	$(call check_header,linux/serial.h,HAVE_LINUX_SERIAL_H)

LINUX_SOCK_DIAG_H:
	$(call check,test-sock-diag,HAVE_LINUX_SOCK_DIAG_H,linux/sockdiag.h)

LINUX_SOCKET_H:
	$(call check_header,linux/socket.h,HAVE_LINUX_SOCKET_H)

LINUX_SOCKIOS_H:
	$(call check_header,linux/sockios.h,HAVE_LINUX_SOCKIOS_H)

LINUX_SYSCTL_H:
	$(call check_header,linux/sysctl.h,HAVE_LINUX_SYSCTL_H)

LINUX_TASKSTATS_H:
	$(call check_header,linux/taskstats.h,HAVE_LINUX_TASKSTATS_H)

LINUX_UDP_H:
	$(call check_header,linux/udp.h,HAVE_LINUX_UDP_H)

LINUX_UINPUT_H:
	$(call check_header,linux/uinput.h,HAVE_LINUX_UINPUT_H)

LINUX_UNIX_DIAG_H:
	$(call check_header,linux/unix_diag.h,HAVE_LINUX_UNIX_DIAG_H)

LINUX_USBDEVICE_FS_H:
	$(call check_header,linux/usbdevice_fs.h,HAVE_LINUX_USBDEVICE_FS_H)

LINUX_USB_CDC_WDM_H:
	$(call check_header,linux/usb/cdc-wdm.h,HAVE_LINUX_USB_CDC_WDM_H)

LINUX_USERFAULTFD_H:
	$(call check_header,linux/userfaultfd.h,HAVE_LINUX_USERFAULTFD_H)

LINUX_VERSION_H:
	$(call check_header,linux/version.h,HAVE_LINUX_VERSION_H)

LINUX_VIDEODEV2_H:
	$(call check_header,linux/videodev2.h,HAVE_LINUX_VIDEODEV2_H)

LINUX_VT_H:
	$(call check_header,linux/vt.h,HAVE_LINUX_VT_H)

LINUX_WATCHDOG_H:
	$(call check_header,linux/watchdog.h,HAVE_LINUX_WATCHDOG_H)

LOCALE_H:
	$(call check_header,locale.h,HAVE_LOCALE_H)

MACH_MACH_H:
	$(call check_header,mach/mach.h,HAVE_MACH_MACH_H)

MACH_MACHINE_H:
	$(call check_header,mach/machine.h,HAVE_MACH_MACHINE_H)

MACH_VM_STATISTICS_H:
	$(call check_header,mach/vm_statistics.h,HAVE_MACH_VM_STATISTICS_H)

MALLOC_H:
	$(call check_header,malloc.h,HAVE_MALLOC_H)

MNTENT_H:
	$(call check_header,mntent.h,HAVE_MNTENT_H)

MPFR_H:
	$(call check_header,mpfr.h,HAVE_MPFR_H)

MQUEUE_H:
	$(call check_header,mqueue.h,HAVE_MQUEUE_H)

POLL_H:
	$(call check_header,poll.h,HAVE_POLL_H)

PTHREAD_NP_H:
	$(call check_header,pthread_np.h,HAVE_PTHREAD_NP_H)

SCSI_SCSI_H:
	$(call check_header,scsi/scsi.h,HAVE_SCSI_SCSI_H)

SCSI_SCSI_IOCTL_H:
	$(call check_header,scsi/scsi_ioctl.h,HAVE_SCSI_SCSI_IOCTL_H)

SCSI_SG_H:
	$(call check_header,scsi/sg.h,HAVE_SCSI_SG_H)

SEARCH_H:
	$(call check_header,search.h,HAVE_SEARCH_H)

SEMAPHORE_H:
	$(call check_header,semaphore.h,HAVE_SEMAPHORE_H)

STRINGS_H:
	$(call check_header,strings.h,HAVE_STRINGS_H)

SOUND_ASOUND_H:
	$(call check_header,sound/asound.h,HAVE_SOUND_ASOUND_H)

SPAWN_H:
	$(call check_header,spawn.h,HAVE_SPAWN_H)

SYSLOG_H:
	$(call check_header,syslog.h,HAVE_SYSLOG_H)

SYS_ACL_H:
	$(call check_header,sys/acl.h,HAVE_SYS_ACL_H)

SYS_APPARMOR_H:
	$(call check_header,sys/apparmor.h,HAVE_SYS_APPARMOR_H)

SYS_AUXV_H:
	$(call check_header,sys/auxv.h,HAVE_SYS_AUXV_H)

SYS_CAPABILITY_H:
	$(call check,test-cap,HAVE_SYS_CAPABILITY_H,sys/capability.h)

SYS_EPOLL_H:
	$(call check_header,sys/epoll.h,HAVE_SYS_EPOLL_H)

SYS_EVENTFD_H:
	$(call check_header,sys/eventfd.h,HAVE_SYS_EVENTFD_H)

SYS_FANOTIFY_H:
	$(call check_header,sys/fanotify.h,HAVE_SYS_FANOTIFY_H)

SYS_FSUID_H:
	$(call check_header,sys/fsuid.h,HAVE_SYS_FSUID_H)

SYS_INOTIFY_H:
	$(call check_header,sys/inotify.h,HAVE_SYS_INOTIFY_H)

SYS_IO_H:
	$(call check_header,sys/io.h,HAVE_SYS_IO_H)

SYS_IPC_H:
	$(call check_header,sys/ipc.h,HAVE_SYS_IPC_H)

SYS_LOADAVG_H:
	$(call check_header,sys/loadavg.h,HAVE_SYS_LOADAVG_H)

SYS_MKDEV_H:
	$(call check_header,sys/mkdev.h,HAVE_SYS_MKDEV_H)

SYS_MOUNT_H:
	$(call check_header,sys/mount.h,HAVE_SYS_MOUNT_H)

SYS_MSG_H:
	$(call check_header,sys/msg.h,HAVE_SYS_MSG_H)

SYS_PARAM_H:
	$(call check_header,sys/param.h,HAVE_SYS_PARAM_H)

SYS_PERSONALITY_H:
	$(call check_header,sys/personality.h,HAVE_SYS_PERSONALITY_H)

SYS_PIDFD_H:
	$(call check_header,sys/pidfd.h,HAVE_SYS_PIDFD_H)

SYS_PLATFORM_PPC_H:
	$(call check_header,sys/platform/ppc.h,HAVE_SYS_PLATFORM_PPC_H)

SYS_PRCTL_H:
	$(call check_header,sys/prctl.h,HAVE_SYS_PRCTL_H)

SYS_RANDOM_H:
	$(call check_header,sys/random.h,HAVE_SYS_RANDOM_H)

SYS_RSEQ_H:
	$(call check_header,sys/rseq.h,HAVE_SYS_RSEQ_H)

SYS_SYSCTL_H:
	$(call check_header,sys/sysctl.h,HAVE_SYS_SYSCTL_H)

SYS_TREE_H:
	$(call check_header,sys/tree.h,HAVE_SYS_TREE_H)

SYS_QUEUE_H:
	$(call check_header,sys/queue.h,HAVE_SYS_QUEUE_H)

SYS_QUOTA_H:
	$(call check_header,sys/quota.h,HAVE_SYS_QUOTA_H)

SYS_SELECT_H:
	$(call check_header,sys/select.h,HAVE_SYS_SELECT_H)

SYS_SENDFILE_H:
	$(call check_header,sys/sendfile.h,HAVE_SYS_SENDFILE_H)

SYS_SHM_H:
	$(call check_header,sys/shm.h,HAVE_SYS_SHM_H)

SYS_SIGNALFD_H:
	$(call check_header,sys/signalfd.h,HAVE_SYS_SIGNALFD_H)

SYS_STATFS_H:
	$(call check_header,sys/statfs.h,HAVE_SYS_STATFS_H)

SYS_STATVFS_H:
	$(call check_header,sys/statvfs.h,HAVE_SYS_STATVFS_H)

SYS_SWAP_H:
	$(call check_header,sys/swap.h,HAVE_SYS_SWAP_H)

SYSCALL_H:
	$(call check_header,sys/syscall.h,HAVE_SYSCALL_H)

SYS_SYSINFO_H:
	$(call check_header,sys/sysinfo.h,HAVE_SYS_SYSINFO_H)

SYS_SYSMACROS_H:
	$(call check_header,sys/sysmacros.h,HAVE_SYS_SYSMACROS_H)

SYS_TIMERFD_H:
	$(call check_header,sys/timerfd.h,HAVE_SYS_TIMERFD_H)

SYS_TIMEX_H:
	$(call check_header,sys/timex.h,HAVE_SYS_TIMEX_H)

SYS_UIO_H:
	$(call check_header,sys/uio.h,HAVE_SYS_UIO_H)

SYS_UCRED_H:
	$(call check_header,sys/ucred.h,HAVE_SYS_UCRED_H)

SYS_UN_H:
	$(call check_header,sys/un.h,HAVE_SYS_UN_H)

SYS_UTSNAME_H:
	$(call check_header,sys/utsname.h,HAVE_SYS_UTSNAME_H)

SYS_VFS_H:
	$(call check_header,sys/vfs.h,HAVE_SYS_VFS_H)

SYS_VMMETER_H:
	$(call check_header,sys/vmmeter.h,HAVE_SYS_VMMETER_H)

SYS_XATTR_H:
	$(call check_header,sys/xattr.h,HAVE_SYS_XATTR_H)

TERMIO_H:
	$(call check_header,termio.h,HAVE_TERMIO_H)

TERMIOS_H:
	$(call check_header,termios.h,HAVE_TERMIOS_H)

THREADS_H:
	$(call check_header,threads.h,HAVE_THREADS_H)

NET_IF_H:
	$(call check_header,net/if.h,HAVE_NET_IF_H)

NETINET_IP_H:
	$(call check_header,netinet/ip.h,HAVE_NETINET_IP_H)

NETINET_IP_ICMP_H:
	$(call check_header,netinet/ip_icmp.h,HAVE_NETINET_IP_ICMP_H)

NETINET_SCTP_H:
	$(call check_header,netinet/sctp.h,HAVE_NETINET_SCTP_H)

NETINET_TCP_H:
	$(call check_header,netinet/tcp.h,HAVE_NETINET_TCP_H)

NETINET_UDP_H:
	$(call check_header,netinet/udp.h,HAVE_NETINET_UDP_H)

UCONTEXT_H:
	$(call check_header,ucontext.h,HAVE_UCONTEXT_H)

USTAT_H:
	$(call check_header,ustat.h,HAVE_USTAT_H)

UTIME_H:
	$(call check_header,utime.h,HAVE_UTIME_H)

UVM_UVM_EXTERN_H:
	$(call check_header,uvm/uvm_extern.h,HAVE_UVM_UVM_EXTERN_H)

X86INTRIN_H:
	$(call check_header,x86intrin.h,HAVE_X86INTRIN_H)

XMMINTRIN_H:
	$(call check_header,xmmintrin.h,HAVE_XMMINTRIN_H)

XXHASH_H:
	$(call check_header,xxhash.h,HAVE_XXHASH_H)

.PHONY: cpufeatures
cpufeatures: \
	configdir \
	ALIGNED_128 \
	ALIGNED_64 \
	ALIGNED_64K \
	ASM_ALPHA_DRAINA \
	ASM_ALPHA_HALT \
	ASM_ARM_TLBI \
	ASM_ARM_YIELD \
	ASM_HPPA_DIAG \
	ASM_HPPA_RFI \
	ASM_LOONG64_CPUCFG \
	ASM_LOONG64_DBAR \
	ASM_LOONG64_RDTIME \
	ASM_LOONG64_TLBRD \
	ASM_LOONG64_TLBSRCH \
	ASM_M68K_EORI_SR \
	ASM_MB \
	ASM_MIPS_WAIT \
	ASM_NOP \
	ASM_NOTHING \
	ASM_PPC64_DARN \
	ASM_PPC64_DCBST \
	ASM_PPC64_DCBT \
	ASM_PPC64_DCBTST \
	ASM_PPC64_ICBI \
	ASM_PPC64_MSYNC \
	ASM_PPC64_TLBIE \
	ASM_RISCV_FENCE \
	ASM_RISCV_FENCE_I \
	ASM_RISCV_SFENCE_VMA \
	ASM_RISCV_CBO_ZERO \
	ASM_S390_PTLB \
	ASM_SH4_RTE \
	ASM_SH4_SLEEP \
	ASM_SPARC_MEMBAR \
	ASM_SPARC_RDPR \
	ASM_SPARC_TICK \
	ASM_X86_CLDEMOTE \
	ASM_X86_CLFLUSH \
	ASM_X86_CLFLUSHOPT \
	ASM_X86_CLTS \
	ASM_X86_CLWB \
	ASM_X86_HLT \
	ASM_X86_INVD \
	ASM_X86_INVLPG \
	ASM_X86_LFENCE \
	ASM_X86_LGDT \
	ASM_X86_LLDT \
	ASM_X86_LMSW \
	ASM_X86_MFENCE \
	ASM_X86_MOV_CR0 \
	ASM_X86_MOV_DR0 \
	ASM_X86_PAUSE \
	ASM_X86_PREFETCHNTA \
	ASM_X86_PREFETCHT0 \
	ASM_X86_PREFETCHT1 \
	ASM_X86_PREFETCHT2 \
	ASM_X86_RDMSR \
	ASM_X86_RDPMC \
	ASM_X86_RDRAND \
	ASM_X86_RDSEED \
	ASM_X86_RDTSC \
	ASM_X86_RDTSCP \
	ASM_X86_REP_STOSB \
	ASM_X86_REP_STOSD \
	ASM_X86_REP_STOSQ \
	ASM_X86_REP_STOSW \
	ASM_X86_SERIALIZE \
	ASM_X86_SFENCE \
	ASM_X86_TPAUSE \
	ASM_X86_WBINVD \
	ASM_X86_WRMSR \
	ATTRIBUTE_ALWAYS_INLINE \
	ATTRIBUTE_FAST_MATH \
	ATTRIBUTE_NOINLINE \
	ATTRIBUTE_NORETURN \
	ATTRIBUTE_PACKED \
	ATTRIBUTE_PURE \
	ATTRIBUTE_WARN_UNUSED_RESULT \
	ATTRIBUTE_WEAK \
	LABEL_AS_VALUE \
	MM256_ADD_EPI8 \
	MM256_DPBUSD_EPI32 \
	MM256_DPWSSD_EPI32 \
	MM256_LOADU_SI256 \
	MM256_STOREU_SI256 \
	MM512_ADD_EPI8 \
	MM512_DPBUSD_EPI32 \
	MM512_DPWSSD_EPI32 \
	MM512_LOADU_SI512 \
	MM512_STOREU_SI512 \
	MM_ADD_EPI8 \
	MM_DPBUSD_EPI32 \
	MM_DPWSSD_EPI32 \
	MM_LOADU_SI128 \
	MM_STOREU_SI128 \
	PRAGMA \
	PRAGMA_INSIDE \
	PRAGMA_NO_HARD_DFP \
	RESTRICT \
	TARGET_CLONES \
	TARGET_CLONES_ALDERLAKE \
	TARGET_CLONES_ARROWLAKE \
	TARGET_CLONES_AVX \
	TARGET_CLONES_AVX2 \
	TARGET_CLONES_AVXVNNI \
	TARGET_CLONES_COOPERLAKE \
	TARGET_CLONES_GRANITERAPIDS \
	TARGET_CLONES_MMX \
	TARGET_CLONES_PANTHERLAKE \
	TARGET_CLONES_POWER9 \
	TARGET_CLONES_ROCKETLAKE \
	TARGET_CLONES_SAPPHIRERAPIDS \
	TARGET_CLONES_SKYLAKE_AVX512 \
	TARGET_CLONES_SSE \
	TARGET_CLONES_SSE2 \
	TARGET_CLONES_SSE3 \
	TARGET_CLONES_SSE4_1 \
	TARGET_CLONES_SSE4_2 \
	TARGET_CLONES_SSSE3 \
	TARGET_CLONES_TIGERLAKE \
	VLA_ARG \
	VECMATH

ALIGNED_64:
	$(call check,test-aligned-64,HAVE_ALIGNED_64,64 byte alignment attribute)

ALIGNED_128:
	$(call check,test-aligned-128,HAVE_ALIGNED_128,128 byte alignment attribute)

ALIGNED_64K:
	$(call check,test-aligned-64K,HAVE_ALIGNED_64K,64K byte alignment attribute)

ATTRIBUTE_ALWAYS_INLINE:
	$(call check,test-attr-always_inline,HAVE_ATTRIBUTE_ALWAYS_INLINE,__attribute__((always_inline)))

ATTRIBUTE_FAST_MATH:
	$(call check,test-attr-fast-math,HAVE_ATTRIBUTE_FAST_MATH,__attribute__((fast_math)))

ATTRIBUTE_NOINLINE:
	$(call check,test-attr-noinline,HAVE_ATTRIBUTE_NOINLINE,__attribute__((noinline)))

ATTRIBUTE_NORETURN:
	$(call check,test-attr-noreturn,HAVE_ATTRIBUTE_NORETURN,__attribute__((noreturn)))

ATTRIBUTE_PACKED:
	$(call check,test-attr-packed,HAVE_ATTRIBUTE_PACKED,__attribute__((packed)))

ATTRIBUTE_PURE:
	$(call check,test-attr-pure,HAVE_ATTRIBUTE_PURE,__attribute__((pure)))

ATTRIBUTE_WARN_UNUSED_RESULT:
	$(call check,test-attr-unused,HAVE_ATTRIBUTE_WARN_UNUSED_RESULT,__attribute__((warn_unused_result)))

ATTRIBUTE_WEAK:
	$(call check,test-attr-weak,HAVE_ATTRIBUTE_WEAK,__attribute__((weak)))

ASM_ALPHA_DRAINA:
	$(call check,test-asm-alpha-draina,HAVE_ASM_ALPHA_DRAINA,ALPHA draina instruction)

ASM_ALPHA_HALT:
	$(call check,test-asm-alpha-halt,HAVE_ASM_ALPHA_HALT,ALPHA halt instruction)

ASM_ARM_TLBI:
	$(call check,test-asm-arm-tlbi,HAVE_ASM_ARM_TLBI,ARM tlbi instruction)

ASM_ARM_YIELD:
	$(call check,test-asm-arm-yield,HAVE_ASM_ARM_YIELD,ARM yield instruction)

ASM_MB:
	$(call check,test-asm-mb,HAVE_ASM_MB,memory barrier)

ASM_HPPA_DIAG:
	$(call check,test-asm-hppa-diag,HAVE_ASM_HPPA_DIAG,hppa diag instruction)

ASM_HPPA_RFI:
	$(call check,test-asm-hppa-rfi,HAVE_ASM_HPPA_RFI,hppa rfi instruction)

ASM_LOONG64_CPUCFG:
	$(call check,test-asm-loong64-cpucfg,HAVE_ASM_LOONG64_CPUCFG,loong64 cpucfg instruction)

ASM_LOONG64_DBAR:
	$(call check,test-asm-loong64-dbar,HAVE_ASM_LOONG64_DBAR,loong64 dbar instruction)

ASM_LOONG64_RDTIME:
	$(call check,test-asm-loong64-rdtime,HAVE_ASM_LOONG64_RDTIME,loong64 rdtime instruction)

ASM_LOONG64_TLBRD:
	$(call check,test-asm-loong64-tlbrd,HAVE_ASM_LOONG64_TLBRD,loong64 tlbrd instruction)

ASM_LOONG64_TLBSRCH:
	$(call check,test-asm-loong64-tlbsrch,HAVE_ASM_LOONG64_TLBSRCH,loong64 tlbsrch instruction)

ASM_M68K_EORI_SR:
	$(call check,test-asm-m68k-eori-sr,HAVE_ASM_M68K_EORI_SR,M68K eori.w on sr instruction)

ASM_MIPS_WAIT:
	$(call check,test-asm-mips-wait,HAVE_ASM_MIPS_WAIT,MIPS wait instruction)

ASM_PPC64_DARN:
	$(call check,test-asm-ppc64-darn,HAVE_ASM_PPC64_DARN,ppc64 darn instruction)

ASM_PPC64_DCBST:
	$(call check,test-asm-ppc64-dcbst,HAVE_ASM_PPC64_DCBST,ppc64 dcbst instruction)

ASM_PPC64_DCBT:
	$(call check,test-asm-ppc64-dcbt,HAVE_ASM_PPC64_DCBT,ppc64 dcbt instruction)

ASM_PPC64_DCBTST:
	$(call check,test-asm-ppc64-dcbtst,HAVE_ASM_PPC64_DCBTST,ppc64 dcbtst instruction)

ASM_PPC64_ICBI:
	$(call check,test-asm-ppc64-icbi,HAVE_ASM_PPC64_ICBI,ppc64 icbi instruction)

ASM_PPC64_MSYNC:
	$(call check,test-asm-ppc64-msync,HAVE_ASM_PPC64_MSYNC,ppc64 msync instruction)

ASM_PPC64_TLBIE:
	$(call check,test-asm-ppc64-tlbie,HAVE_ASM_PPC64_TLBIE,ppc64 tlbie instruction)

ASM_RISCV_FENCE:
	$(call check,test-asm-riscv-fence,HAVE_ASM_RISCV_FENCE,RISC-V fence instruction)

ASM_RISCV_FENCE_I:
	$(call check,test-asm-riscv-fence_i,HAVE_ASM_RISCV_FENCE_I,RISC-V fence.i instruction)

ASM_RISCV_SFENCE_VMA:
	$(call check,test-asm-riscv-sfence-vma,HAVE_ASM_RISCV_SFENCE_VMA,RISC-V sfence.vma instruction)

ASM_RISCV_CBO_ZERO:
	$(call check,test-asm-riscv-cbo_zero,HAVE_ASM_RISCV_CBO_ZERO,RISC-V cbo.zero instruction)

ASM_S390_PTLB:
	$(call check,test-asm-s390-ptlb,HAVE_ASM_S390_PTLB,s390 ptlb instruction)

ASM_SH4_RTE:
	$(call check,test-asm-sh4-rte,HAVE_ASM_SH4_RTE,SH4 rte instruction)

ASM_SH4_SLEEP:
	$(call check,test-asm-sh4-sleep,HAVE_ASM_SH4_SLEEP,SH4 sleep instruction)

ASM_SPARC_MEMBAR:
	$(call check,test-asm-sparc-membar,HAVE_ASM_SPARC_MEMBAR,SPARC membar instruction)

ASM_SPARC_RDPR:
	$(call check,test-asm-sparc-rdpr,HAVE_ASM_SPARC_RDPR,SPARC rdpr instruction)

ASM_SPARC_TICK:
	$(call check,test-asm-sparc-tick,HAVE_ASM_SPARC_TICK,SPARC tick instruction)

ASM_X86_CLDEMOTE:
	$(call check,test-asm-x86-cldemote,HAVE_ASM_X86_CLDEMOTE,x86 cldemote instruction)

ASM_X86_CLFLUSH:
	$(call check,test-asm-x86-clflush,HAVE_ASM_X86_CLFLUSH,x86 clflush instruction)

ASM_X86_CLFLUSHOPT:
	$(call check,test-asm-x86-clflushopt,HAVE_ASM_X86_CLFLUSHOPT,x86 clflushopt instruction)

ASM_X86_CLTS:
	$(call check,test-asm-x86-clts,HAVE_ASM_X86_CLTS,x86 clts instruction)

ASM_X86_CLWB:
	$(call check,test-asm-x86-clwb,HAVE_ASM_X86_CLWB,x86 clwb instruction)

ASM_X86_HLT:
	$(call check,test-asm-x86-hlt,HAVE_ASM_X86_HLT,x86 hlt instruction)

ASM_X86_INVD:
	$(call check,test-asm-x86-invd,HAVE_ASM_X86_INVD,x86 invd instruction)

ASM_X86_INVLPG:
	$(call check,test-asm-x86-invlpg,HAVE_ASM_X86_INVLPG,x86 invpg instruction)

ASM_X86_LFENCE:
	$(call check,test-asm-x86-lfence,HAVE_ASM_X86_LFENCE,x86 lfence instruction)

ASM_X86_LGDT:
	$(call check,test-asm-x86-lgdt,HAVE_ASM_X86_LGDT,x86 lgdt instruction)

ASM_X86_LLDT:
	$(call check,test-asm-x86-lldt,HAVE_ASM_X86_LLDT,x86 lldt instruction)

ASM_X86_LMSW:
	$(call check,test-asm-x86-lmsw,HAVE_ASM_X86_LMSW,x86 lmsw instruction)

ASM_X86_MFENCE:
	$(call check,test-asm-x86-mfence,HAVE_ASM_X86_MFENCE,x86 mfence instruction)

ASM_X86_MOV_CR0:
	$(call check,test-asm-x86-mov-cr0,HAVE_ASM_X86_MOV_CR0,x86 mov to cr0 instruction)

ASM_X86_MOV_DR0:
	$(call check,test-asm-x86-mov-dr0,HAVE_ASM_X86_MOV_DR0,x86 mov to dr0 instruction)

ASM_X86_PAUSE:
	$(call check,test-asm-x86-pause,HAVE_ASM_X86_PAUSE,x86 pause instruction)

ASM_X86_PREFETCHT0:
	$(call check,test-asm-x86-prefetcht0,HAVE_ASM_X86_PREFETCHT0,x86 prefetcht0 instruction)

ASM_X86_PREFETCHT1:
	$(call check,test-asm-x86-prefetcht1,HAVE_ASM_X86_PREFETCHT1,x86 prefetcht1 instruction)

ASM_X86_PREFETCHT2:
	$(call check,test-asm-x86-prefetcht2,HAVE_ASM_X86_PREFETCHT2,x86 prefetcht2 instruction)

ASM_X86_PREFETCHNTA:
	$(call check,test-asm-x86-prefetchnta,HAVE_ASM_X86_PREFETCHNTA,x86 prefetchtnta instruction)

ASM_X86_RDMSR:
	$(call check,test-asm-x86-rdmsr,HAVE_ASM_X86_RDMSR,x86 rdmsr instruction)

ASM_X86_RDPMC:
	$(call check,test-asm-x86-rdpmc,HAVE_ASM_X86_RDPMC,x86 rdpmc instruction)

ASM_X86_RDRAND:
	$(call check,test-asm-x86-rdrand,HAVE_ASM_X86_RDRAND,x86 rdrand instruction)

ASM_X86_RDSEED:
	$(call check,test-asm-x86-rdseed,HAVE_ASM_X86_RDSEED,x86 rdseed instruction)

ASM_X86_RDTSC:
	$(call check,test-asm-x86-rdtsc,HAVE_ASM_X86_RDTSC,x86 rdtsc instruction)

ASM_X86_RDTSCP:
	$(call check,test-asm-x86-rdtscp,HAVE_ASM_X86_RDTSCP,x86 rdtscp instruction)

ASM_X86_REP_STOSB:
	$(call check,test-asm-x86-rep-stosb,HAVE_ASM_X86_REP_STOSB,x86 rep stosb instruction)

ASM_X86_REP_STOSW:
	$(call check,test-asm-x86-rep-stosw,HAVE_ASM_X86_REP_STOSW,x86 rep stosw instruction)

ASM_X86_REP_STOSD:
	$(call check,test-asm-x86-rep-stosd,HAVE_ASM_X86_REP_STOSD,x86 rep stosd instruction)

ASM_X86_REP_STOSQ:
	$(call check,test-asm-x86-rep-stosq,HAVE_ASM_X86_REP_STOSQ,x86 rep stosq instruction)

ASM_X86_SERIALIZE:
	$(call check,test-asm-x86-serialize,HAVE_ASM_X86_SERIALIZE,x86 serialize instruction)

ASM_X86_SFENCE:
	$(call check,test-asm-x86-sfence,HAVE_ASM_X86_SFENCE,x86 sfence instruction)

ASM_X86_TPAUSE:
	$(call check,test-asm-x86-tpause,HAVE_ASM_X86_TPAUSE,x86 tpause instruction)

ASM_X86_WRMSR:
	$(call check,test-asm-x86-wrmsr,HAVE_ASM_X86_WRMSR,x86 wrmsr instruction)

ASM_X86_WBINVD:
	$(call check,test-asm-x86-wbinvd,HAVE_ASM_X86_WRINVD,x86 wrinvd instruction)

LABEL_AS_VALUE:
	$(call check,test-label-as-value,HAVE_LABEL_AS_VALUE,label as value feature)

ASM_NOP:
	$(call check,test-asm-nop,HAVE_ASM_NOP,generic nop instruction)

ASM_NOTHING:
	$(call check,test-asm-nothing,HAVE_ASM_NOTHING,asm(\"\"))

FAST_MATH:
	$(call check,test-mathfunc,HAVE_FAST_MATH,-ffast-math,$(LIB_M),-DMATHFUNC=sin,,-ffast-math)

MM_ADD_EPI8:
	$(call check,test-mm_add_epi8,HAVE_MM_ADD_EPI8,_mm_add_epi8 intrinsic)

MM_DPBUSD_EPI32:
	$(call check,test-mm_dpbusd_epi32,HAVE_MM_DPBUSD_EPI32,_mm_dpbusd_epi32 intrinsic)

MM_DPWSSD_EPI32:
	$(call check,test-mm_dpwssd_epi32,HAVE_MM_DPWSSD_EPI32,_mm_dpwssd_epi32 intrinsic)

MM_LOADU_SI128:
	$(call check,test-mm_loadu_si128,HAVE_MM_LOADU_SI128,_mm_loadu_si128 intrinsic)

MM_STOREU_SI128:
	$(call check,test-mm_storeu_si128,HAVE_MM_STOREU_SI128,_mm_storeu_si128 intrinsic)

MM256_ADD_EPI8:
	$(call check,test-mm256_add_epi8,HAVE_MM256_ADD_EPI8,_mm256_add_epi8 intrinsic)

MM256_DPBUSD_EPI32:
	$(call check,test-mm256_dpbusd_epi32,HAVE_MM256_DPBUSD_EPI32,_mm256_dpbusd_epi32 intrinsic)

MM256_DPWSSD_EPI32:
	$(call check,test-mm256_dpwssd_epi32,HAVE_MM256_DPWSSD_EPI32,_mm256_dpwssd_epi32 intrinsic)

MM256_LOADU_SI256:
	$(call check,test-mm256_loadu_si256,HAVE_MM256_LOADU_SI256,_mm256_loadu_si256 intrinsic)

MM256_STOREU_SI256:
	$(call check,test-mm256_storeu_si256,HAVE_MM256_STOREU_SI256,_mm256_storeu_si256 intrinsic)

MM512_ADD_EPI8:
	$(call check,test-mm512_add_epi8,HAVE_MM512_ADD_EPI8,_mm512_add_epi8 intrinsic)

MM512_DPBUSD_EPI32:
	$(call check,test-mm512_dpbusd_epi32,HAVE_MM512_DPBUSD_EPI32,_mm512_dpbusd_epi32 intrinsic)

MM512_DPWSSD_EPI32:
	$(call check,test-mm512_dpwssd_epi32,HAVE_MM512_DPWSSD_EPI32,_mm512_dpwssd_epi32 intrinsic)

MM512_LOADU_SI512:
	$(call check,test-mm512_loadu_si512,HAVE_MM512_LOADU_SI512,_mm512_loadu_si512 intrinsic)

MM512_STOREU_SI512:
	$(call check,test-mm512_storeu_si512,HAVE_MM512_STOREU_SI512,_mm512_storeu_si512 intrinsic)

PRAGMA:
	$(call check,test-pragma,HAVE_PRAGMA,pragma push/pop)

PRAGMA_INSIDE:
	$(call check,test-pragma-inside,HAVE_PRAGMA_INSIDE,pragma inside functions)

PRAGMA_NO_HARD_DFP:
	$(call check,test-pragma-no-hard-dfp,HAVE_PRAGMA_NO_HARD_DFP,pragma gcc no-hard-dfp)

RESTRICT:
	$(call check,test-__restrict,HAVE___RESTRICT,__restrict keyword)

TARGET_CLONES:
	$(call check,test-target-clones,HAVE_TARGET_CLONES,target_clones attribute,,,'"default"')

TARGET_CLONES_MMX:
	$(call check,test-target-clones,HAVE_TARGET_CLONES_MMX,target_clones mmx attribute (x86),,,'"default$(comma)mmx"')

TARGET_CLONES_AVX:
	$(call check,test-target-clones,HAVE_TARGET_CLONES_AVX,target_clones avx attribute (x86),,,'"default$(comma)avx"')

TARGET_CLONES_AVX2:
	$(call check,test-target-clones,HAVE_TARGET_CLONES_AVX2,target_clones avx2 attribute (x86),,,'"default$(comma)avx2"')

TARGET_CLONES_AVXVNNI:
	$(call check,test-target-clones,HAVE_TARGET_CLONES_AVXVNNI,target_clones avxvnni attribute (x86),,,'"default$(comma)avxvnni"')

TARGET_CLONES_SSE:
	$(call check,test-target-clones,HAVE_TARGET_CLONES_SSE,target_clones sse attribute (x86),,,'"default$(comma)sse"')

TARGET_CLONES_SSE2:
	$(call check,test-target-clones,HAVE_TARGET_CLONES_SSE2,target_clones sse2 attribute (x86),,,'"default$(comma)sse2"')

TARGET_CLONES_SSE3:
	$(call check,test-target-clones,HAVE_TARGET_CLONES_SSE3,target_clones sse3 attribute (x86),,,'"default$(comma)sse3"')

TARGET_CLONES_SSSE3:
	$(call check,test-target-clones,HAVE_TARGET_CLONES_SSSE3,target_clones ssse3 attribute (x86),,,'"default$(comma)ssse3"')

TARGET_CLONES_SSE4_1:
	$(call check,test-target-clones,HAVE_TARGET_CLONES_SSE4_1,target_clones sse4_1 attribute (x86),,,'"default$(comma)sse4.1"')

TARGET_CLONES_SSE4_2:
	$(call check,test-target-clones,HAVE_TARGET_CLONES_SSE4_2,target_clones sse4_2 attribute (x86),,,'"default$(comma)sse4.2"')

TARGET_CLONES_SKYLAKE_AVX512:
	$(call check,test-target-clones,HAVE_TARGET_CLONES_SKYLAKE_AVX512,target_clones arch=skylake-avx512 attribute (x86),,,'"default$(comma)arch=skylake-avx512"')

TARGET_CLONES_COOPERLAKE:
	$(call check,test-target-clones,HAVE_TARGET_CLONES_COOPERLAKE,target_clones arch=cooperlake attribute (x86),,,'"default$(comma)arch=cooperlake"')

TARGET_CLONES_TIGERLAKE:
	$(call check,test-target-clones,HAVE_TARGET_CLONES_TIGERLAKE,target_clones arch=tigerlake attribute (x86),,,'"default$(comma)arch=tigerlake"')

TARGET_CLONES_SAPPHIRERAPIDS:
	$(call check,test-target-clones,HAVE_TARGET_CLONES_SAPPHIRERAPIDS,target_clones arch=sapphirerapids attribute (x86),,,'"default$(comma)arch=sapphirerapids"')

TARGET_CLONES_ALDERLAKE:
	$(call check,test-target-clones,HAVE_TARGET_CLONES_ALDERLAKE,target_clones arch=alderlake attribute (x86),,,'"default$(comma)arch=alderlake"')

TARGET_CLONES_ROCKETLAKE:
	$(call check,test-target-clones,HAVE_TARGET_CLONES_ROCKETLAKE,target_clones arch=rocketlake attribute (x86),,,'"default$(comma)arch=rocketlake"')

TARGET_CLONES_GRANITERAPIDS:
	$(call check,test-target-clones,HAVE_TARGET_CLONES_GRANITERAPIDS,target_clones arch=graniterapids attribute (x86),,,'"default$(comma)arch=graniterapids"')

TARGET_CLONES_ARROWLAKE:
	$(call check,test-target-clones,HAVE_TARGET_CLONES_ARROWLAKE,target_clones arch=arrowlake attribute (x86),,,'"default$(comma)arch=arrowlake"')

TARGET_CLONES_PANTHERLAKE:
	$(call check,test-target-clones,HAVE_TARGET_CLONES_PANTHERLAKE,target_clones arch=pantherlake attribute (x86),,,'"default$(comma)arch=pantherlake"')

TARGET_CLONES_POWER9:
	$(call check,test-target-clones,HAVE_TARGET_CLONES_POWER9,target_clones cpu=power attribute (power9),,,'"default$(comma)cpu=power9"')

VECMATH:
	$(call check_vecmath,stress-vecmath,HAVE_VECMATH,vector math)

VLA_ARG:
	$(call check,test-vla-arg,HAVE_VLA_ARG,variable length array function args)

.PHONY: types
types: \
	configdir \
	CDROM_BLK \
	CDROM_MCN \
	CDROM_MSF \
	CDROM_READ_AUDIO \
	CDROM_SUBCHNL \
	CDROM_TI \
	CDROM_TOCENTRY \
	CDROM_TOCHDR \
	CDROM_VOLCTRL \
	COMPLEX \
	CONSOLEFONTDESC \
	DATTR_T \
	DECIMAL128 \
	DECIMAL32 \
	DECIMAL64 \
	DIRENT_D_TYPE \
	DM_IOCTL \
	DVD_AUTHINFO \
	DVD_STRUCT \
	FLOAT128 \
	FLOAT16 \
	FLOAT32 \
	FLOAT64 \
	FLOAT80 \
	FLOPPY_DRIVE_STRUCT \
	FLOPPY_FDC_STATE \
	FLOPPY_STRUCT \
	FLOPPY_WRITE_ERRORS \
	FS_SYSFS_PATH FSUUID2 \
	FSVERITY_DIGEST \
	FSVERITY_ENABLE_ARG \
	FSXATTR_STRUCT \
	ICMPHDR \
	IFCONF \
	IFREQ \
	INO64_T \
	INT128_T \
	IPHDR \
	ITIMER_WHICH_T \
	KBDIACRS \
	KBENTRY \
	KBKEYCODE \
	KBSENTRY \
	KERNEL_LONG_T \
	KERNEL_ULONG_T \
	KEY_T \
	LANDLOCK_RULESET_ATTR \
	LANDLOCK_RULE_TYPE \
	LOFF_T \
	MEDIA_DEVICE_INFO \
	MNT_ID_REQ \
	MODE_T \
	MTX_T \
	MSGINFO \
	MTRR_GENTRY \
	MTRR_SENTRY \
	OFF64_T \
	OFF_T \
	OPEN_HOW \
	PID_TYPE \
	PRIORITY_WHICH_T \
	PTHREAD_MUTEXATTR_T \
	PTHREAD_MUTEX_T \
	PTRACE_REQUEST \
	RLIMIT_RESOURCE_T \
	RTC_PARAM \
	RUSAGE_RU_MAXRSS \
	RUSAGE_RU_MINFLT \
	RUSAGE_RU_NVCSW \
	RUSAGE_WHO \
	SCTP_ASSOCIATION \
	SCTP_ASSOCPARAMS \
	SCTP_ASSOC_STATS \
	SCTP_ASSOC_VALUE \
	SCTP_DEFAULT_PRINFO \
	SCTP_EVENT_SUBSCRIBE \
	SCTP_GETADDRS \
	SCTP_INITMSG \
	SCTP_PADDRINFO \
	SCTP_PADDRPARAMS \
	SCTP_PRIM \
	SCTP_PROBEINTERVAL \
	SCTP_RTOINFO \
	SCTP_SCHED_TYPE \
	SCTP_SETADAPTION \
	SCTP_STATUS \
	SCTP_STREAM_VALUE \
	SECCOMP_NOTIF_SIZES \
	SERIAL_ICOUNTER \
	SERIAL_STRUCT \
	SHMID_DS SHMINFO \
	SND_CTL_CARD_INFO \
	SND_CTL_TLV \
	SOCKADDR_UN \
	TERMIOS \
	TIMEX \
	TPACKET_REQ3 \
	UNIMAPDESC \
	USBDEVFS_GETDRIVER \
	USER_DESC \
	UTIMBUF \
	V2DI \
	V4L2_AUDIO \
	V4L2_AUDIOOUT \
	V4L2_CAPABILITY \
	V4L2_DV_TIMINGS \
	V4L2_ENC_IDX \
	V4L2_FRAMEBUFFER \
	V4L2_JPEGCOMPRESSION \
	V4L2_STD_ID \
	VT_CONSIZE \
	VT_MODE \
	VT_SIZES \
	VT_STAT \
	WINSIZE

COMPLEX:
	$(call check,test-complex,HAVE_COMPLEX,complex)

DATTR_T:
	$(call check,test-daddr_t,HAVE_DADDR_T,daddr_t)

DVD_AUTHINFO:
	$(call check,test-dvd_authinfo,HAVE_DVD_AUTHINFO,dvd_authinfo)

DVD_STRUCT:
	$(call check,test-dvd_struct,HAVE_DVD_STRUCT,dvd_struct)

DECIMAL32:
	$(call check_float,_Decimal32,HAVE_Decimal32,_Decimal32)

DECIMAL64:
	$(call check_float,_Decimal64,HAVE_Decimal64,_Decimal64)

DECIMAL128:
	$(call check_float,_Decimal128,HAVE_Decimal128,_Decimal128)

FLOAT16:
	$(call check_float,__fp16,HAVE_fp16,__fp16)
	$(call check_float,_Float16,HAVE_Float16,_Float16)
	$(call check_float,_Float16x,HAVE_Float16x,_Float16x)

FLOAT32:
	$(call check_float,_Float32,HAVE_Float32,_Float32)
	$(call check_float,_Float32x,HAVE_Float32x,_Float32x)

FLOAT64:
	$(call check_float,_Float64,HAVE_Float64,_Float64)
	$(call check_float,_Float64x,HAVE_Float64x,_Float64x)

FLOAT80:
	$(call check_float,__float80,HAVE__float80,__float80)
	$(call check_float,_Float80,HAVE_Float80,_Float80)
	$(call check_float,_Float80x,HAVE_Float80x,_Float80x)

FLOAT128:
	$(call check_float,__float128,HAVE__float128,__float128)
	$(call check_float,_Float128,HAVE_Float128,_Float128)
	$(call check_float,_Float128x,HAVE_Float128x,_Float128x)

ITIMER_WHICH_T:
	$(call check,test-itimer_which_t,HAVE_ITIMER_WHICH_T,__itimer_which_t)

INO64_T:
	$(call check,test-ino64_t,HAVE_INO64_T,ino64_t)

INT128_T:
	$(call check,test-int128_t,HAVE_INT128_T,int128_t)

KERNEL_LONG_T:
	$(call check,test-kernel_long_t,HAVE_KERNEL_LONG_T,__kernel_long_t)

KERNEL_ULONG_T:
	$(call check,test-kernel_ulong_t,HAVE_KERNEL_ULONG_T,__kernel_ulong_t)

KEY_T:
	$(call check,test-key_t,HAVE_KEY_T,key_t)

LANDLOCK_RULE_TYPE:
	$(call check,test-landlock_rule_type,HAVE_LANDLOCK_RULE_TYPE,landlock_rule_type)

LOFF_T:
	$(call check,test-loff_t,HAVE_LOFF_T,loff_t)

MODE_T:
	$(call check,test-mode_t,HAVE_MODE_T,mode_t)

MTX_T:
	$(call check,test-mtx_t,HAVE_MTX_T,mtx_t)

OFF_T:
	$(call check,test-off_t,HAVE_OFF_T,off_t)

OFF64_T:
	$(call check,test-off64_t,HAVE_OFF64_T,off64_t)

PID_TYPE:
	$(call check,test-pid_type,HAVE_PID_TYPE,__pid_type)

PRIORITY_WHICH_T:
	$(call check,test-priority_which_t,HAVE_PRIORITY_WHICH_T,__priority_which_t)

PTHREAD_MUTEX_T:
	$(call check,test-pthread-mutex_t,HAVE_PTHREAD_MUTEX_T,pthread_mutex_t)

PTHREAD_MUTEXATTR_T:
	$(call check,test-pthread-mutexattr_t,HAVE_PTHREAD_MUTEXATTR_T,pthread_mutexattr_t)

PTRACE_REQUEST:
	$(call check,test-ptrace_request,HAVE_PTRACE_REQUEST,ptrace_request)

RLIMIT_RESOURCE_T:
	$(call check,test-rlimit_resource_t,HAVE_RLIMIT_RESOURCE_T,__rlimit_resource_t)

RUSAGE_WHO:
	$(call check,test-rusage_who_t,HAVE_RUSAGE_WHO_T,__rusage_who_t)

CDROM_BLK:
	$(call check,test-cdrom_blk,HAVE_CDROM_BLK,struct cdrom_blk)

CDROM_MCN:
	$(call check,test-cdrom_mcn,HAVE_CDROM_MCN,struct cdrom_mcn)

CDROM_MSF:
	$(call check,test-cdrom_msf,HAVE_CDROM_MSF,struct cdrom_msf)

CDROM_READ_AUDIO:
	$(call check,test-cdrom_read_audio,HAVE_CDROM_READ_AUDIO,struct cdrom_read_audio)

CDROM_SUBCHNL:
	$(call check,test-cdrom_subchnl,HAVE_CDROM_SUBCHNL,struct cdrom_subchnl)

CDROM_TI:
	$(call check,test-cdrom_ti,HAVE_CDROM_TI,struct cdrom_ti)

CDROM_TOCENTRY:
	$(call check,test-cdrom_tocentry,HAVE_CDROM_TOCENTRY,struct cdrom_tocentry)

CDROM_TOCHDR:
	$(call check,test-cdrom_tochdr,HAVE_CDROM_TOCHDR,struct cdrom_tochdr)

CDROM_VOLCTRL:
	$(call check,test-cdrom_volctrl,HAVE_CDROM_VOLCTRL,struct cdrom_volctrl)

CONSOLEFONTDESC:
	$(call check,test-consolefontdesc,HAVE_CONSOLEFONTDESC,struct consolefontdesc)

DIRENT_D_TYPE:
	$(call check,test-dirent-d_type,HAVE_DIRENT_D_TYPE,struct dirent d_type)

DM_IOCTL:
	$(call check,test-dm_ioctl,HAVE_DM_IOCTL,struct dm_ioctl)

FLOPPY_FDC_STATE:
	$(call check,test-floppy_fdc_state,HAVE_FLOPPY_FDC_STATE,struct floppy_fdc_state)

FLOPPY_DRIVE_STRUCT:
	$(call check,test-floppy_drive_struct,HAVE_FLOPPY_DRIVE_STRUCT,struct floppy_drive_struct)

FLOPPY_STRUCT:
	$(call check,test-floppy_struct,HAVE_FLOPPY_STRUCT,struct floppy_struct)

FLOPPY_WRITE_ERRORS:
	$(call check,test-floppy_write_errors,HAVE_FLOPPY_WRITE_ERRORS,struct floppy_write_errors)

FSUUID2:
	$(call check,test-fsuuid2,HAVE_FSUUID2,struct fsuuid2)

FS_SYSFS_PATH:
	$(call check,test-fs_sysfs_path,HAVE_FS_SYSFS_PATH,struct fs_sysfs_path)

FSVERITY_DIGEST:
	$(call check,test-fsverity_digest,HAVE_FSVERITY_DIGEST,struct fsverity_digest)

FSVERITY_ENABLE_ARG:
	$(call check,test-fsverity_enable_arg,HAVE_FSVERITY_ENABLE_ARG,struct fsverity_enable_arg)

FSXATTR_STRUCT:
	$(call check,test-fsxattr,HAVE_FSXATTR_STRUCT,struct fsxattr)

ICMPHDR:
	$(call check,test-icmphdr,HAVE_ICMPHDR,struct iphdr and icmphdr)

IFCONF:
	$(call check,test-ifconf,HAVE_IFCONF,struct ifconf)

IFREQ:
	$(call check,test-ifreq,HAVE_IFREQ,struct ifreq)

IPHDR:
	$(call check,test-iphdr,HAVE_IPHDR,struct iphdr)

KBDIACRS:
	$(call check,test-kbdiacrs,HAVE_KBDIACRS,struct kbdiacrs)

KBENTRY:
	$(call check,test-kbentry,HAVE_KBENTRY,struct kbentry)

KBKEYCODE:
	$(call check,test-kbkeycode,HAVE_KBKEYCODE,struct kbkeycode)

KBSENTRY:
	$(call check,test-kbsentry,HAVE_KBSENTRY,struct kbsentry)

LANDLOCK_RULESET_ATTR:
	$(call check,test-landlock_ruleset_attr,HAVE_LANDLOCK_RULESET_ATTR,struct landlock_ruleset_attr)

MEDIA_DEVICE_INFO:
	$(call check,test-media_device_info,HAVE_MEDIA_DEVICE_INFO,struct media_device_info)

MNT_ID_REQ:
	$(call check,test-mnt_id_req,HAVE_MNT_ID_REQ,struct mnt_id_req)

MSGINFO:
	$(call check,test-msginfo,HAVE_MSGINFO,struct msginfo)

MTRR_GENTRY:
	$(call check,test-mtrr_gentry,HAVE_MTRR_GENTRY,struct mtrr_gentry)

MTRR_SENTRY:
	$(call check,test-mtrr_sentry,HAVE_MTRR_SENTRY,struct mtrr_sentry)

OPEN_HOW:
	$(call check,test-open_how,HAVE_OPEN_HOW,struct open_how)

RTC_PARAM:
	$(call check,test-rtc_param,HAVE_RTC_PARAM,struct rtc_param)

RUSAGE_RU_MAXRSS:
	$(call check,test-rusage_ru_maxrss,HAVE_RUSAGE_RU_MAXRSS,struct rusage.ru_maxrss)

RUSAGE_RU_MINFLT:
	$(call check,test-rusage_ru_minflt,HAVE_RUSAGE_RU_MINFLT,struct rusage.ru_minflt)

RUSAGE_RU_NVCSW:
	$(call check,test-rusage_ru_nvcsw,HAVE_RUSAGE_RU_NVCSW,struct rusage.ru_nvcsw)

SCTP_ASSOCIATION:
	$(call check,test-sctp_associatin,HAVE_SCTP_ASSOCIATION,struct sctp_association)

SCTP_ASSOC_STATS:
	$(call check,test-sctp_assoc_stats,HAVE_SCTP_ASSOC_STATS,struct sctp_assoc_stats)

SCTP_ASSOC_VALUE:
	$(call check,test-sctp_assoc_value,HAVE_SCTP_ASSOC_VALUE,struct sctp_assoc_value)

SCTP_ASSOCPARAMS:
	$(call check,test-sctp_assocparams,HAVE_SCTP_ASSOCPARAMS,struct sctp_assocparams)

SCTP_DEFAULT_PRINFO:
	$(call check,test-sctp_default_prinfo,HAVE_SCTP_DEFAULT_PRINFO,struct sctp_default_prinfo)

SCTP_EVENT_SUBSCRIBE:
	$(call check,test-sctp_event_subscribe,HAVE_SCTP_EVENT_SUBSCRIBE,struct sctp_event_subscribe)

SCTP_GETADDRS:
	$(call check,test-sctp_getaddrs,HAVE_SCTP_GETADDRS,struct sctp_getaddrs)

SCTP_INITMSG:
	$(call check,test-sctp_initmsg,HAVE_SCTP_INITMSG,struct sctp_initmsg)

SCTP_PADDRPARAMS:
	$(call check,test-sctp_paddrparams,HAVE_SCTP_PADDRPARAMS,struct sctp_paddrparams)

SCTP_PADDRINFO:
	$(call check,test-sctp_paddrinfo,HAVE_SCTP_PADDRINFO,struct sctp_paddrinfo)

SCTP_PRIM:
	$(call check,test-sctp_prim,HAVE_SCTP_PRIM,struct sctp_prim)

SCTP_PROBEINTERVAL:
	$(call check,test-sctp_probeinterval,HAVE_SCTP_PROBEINTERVAL,struct sctp_probeinterval)

SCTP_RTOINFO:
	$(call check,test-sctp_rtoinfo,HAVE_SCTP_RTOINFO,struct sctp_rtoinfo)

SCTP_SCHED_TYPE:
	$(call check,test-sctp_sched_type,HAVE_SCTP_SCHED_TYPE,struct sctp_sched_type)

SCTP_SETADAPTION:
	$(call check,test-sctp_setadaption,HAVE_SCTP_SETADAPTION,struct sctp_setadaption)

SCTP_STATUS:
	$(call check,test-sctp_status,HAVE_SCTP_STATUS,struct sctp_status)

SCTP_STREAM_VALUE:
	$(call check,test-sctp_stream_value,HAVE_SCTP_STREAM_VALUE,struct sctp_stream_value)

SECCOMP_NOTIF_SIZES:
	$(call check,test-seccomp_notif_sizes,HAVE_SECCOMP_NOTIF_SIZES,struct seccomp_notif_sizes)

SERIAL_ICOUNTER:
	$(call check,test-serial-icounter,HAVE_SERIAL_ICOUNTER,struct serial_icounter_struct)

SERIAL_STRUCT:
	$(call check,test-serial-struct,HAVE_SERIAL_STRUCT,struct serial_struct)

SHMID_DS:
	$(call check,test-shmid-ds,HAVE_SHMID_DS,struct shmid_ds)

SHMINFO:
	$(call check,test-shminfo,HAVE_SHMINFO,struct shminfo)

SND_CTL_CARD_INFO:
	$(call check,test-snd_ctl_card_info,HAVE_SND_CTL_CARD_INFO,struct snd_ctl_card_info)

SND_CTL_TLV:
	$(call check,test-snd_ctl_tlv,HAVE_SND_CTL_TLV,struct snd_ctl_tlv)

SOCKADDR_UN:
	$(call check,test-sockaddr_un,HAVE_SOCKADDR_UN,struct sockaddr_un)

TERMIOS:
	$(call check,test-termios,HAVE_TERMIOS,struct termios)

TIMEX:
	$(call check,test-timex,HAVE_TIMEX,struct timex)

TPACKET_REQ3:
	$(call check,test-tpacket_req3,HAVE_TPACKET_REQ3,struct tpacket_req3)

UNIMAPDESC:
	$(call check,test-unimapdesc,HAVE_UNIMAPDESC,struct unimapdesc)

USBDEVFS_GETDRIVER:
	$(call check,test-usbdevfs_getdriver,HAVE_USBDEVFS_GETDRIVER,struct usbdevfs_getdriver)

USER_DESC:
	$(call check,test-user-desc,HAVE_USER_DESC,struct user_desc)

UTIMBUF:
	$(call check,test-utimbuf,HAVE_UTIMBUF,struct utimbuf)

VT_CONSIZE:
	$(call check,test-vt_consize,HAVE_VT_CONSIZE,struct vt_consize)

VT_MODE:
	$(call check,test-vt_mode,HAVE_VT_MODE,struct vt_mode)

VT_SIZES:
	$(call check,test-vt_sizes,HAVE_VT_SIZES,struct vt_sizes)

VT_STAT:
	$(call check,test-vt_stat,HAVE_VT_STAT,struct vt_stat)

V4L2_AUDIO:
	$(call check,test-v4l2_audio,HAVE_V4L2_AUDIO,struct v4l2_audio)

V4L2_AUDIOOUT:
	$(call check,test-v4l2_audioout,HAVE_V4L2_AUDIOOUT,struct v4l2_audioout)

V4L2_CAPABILITY:
	$(call check,test-v4l2_capability,HAVE_V4L2_CAPABILITY,struct v4l2_capability)

V4L2_DV_TIMINGS:
	$(call check,test-v4l2_dv_timings,HAVE_V4L2_DV_TIMINGS,struct v4l2_dv_timings)

V4L2_ENC_IDX:
	$(call check,test-v4l2_enc_idx,HAVE_V4L2_ENC_IDX,struct v4l2_enc_idx)

V4L2_FRAMEBUFFER:
	$(call check,test-v4l2_framebuffer,HAVE_V4L2_FRAMEBUFFER,struct v4l2_framebuffer)

V4L2_JPEGCOMPRESSION:
	$(call check,test-v4l2_jpegcompression,HAVE_V4L2_JPEGCOMPRESSION,struct v4l2_jpegcompression)

V4L2_STD_ID:
	$(call check,test-v4l2_std_id,HAVE_V4L2_STD_ID,v4l2_std_id)

V2DI:
	$(call check,test-v2di,HAVE_V2DI,__v2di)

WINSIZE:
	$(call check,test-winsize,HAVE_WINSIZE,struct winsize)

.PHONY: symbols
symbols: \
	configdir \
	RSEQ_OFFSET

RSEQ_OFFSET:
	$(call check,test-__rseq_offset,HAVE___RSEQ_OFFSET,__rseq_offset)

.PHONY: functions
functions: \
	configdir \
	ACCEPT4 \
	ADJTIME \
	ADJTIMEX \
	AIO_CANCEL \
	AIO_FSYNC \
	AIO_READ AIO_WRITE \
	ALIGNED_ALLOC \
	ARC4RANDOM \
	ARCH_PRCTL \
	ATOMIC \
	ATOMIC_ADD_FETCH \
	ATOMIC_AND_FETCH \
	ATOMIC_CLEAR \
	ATOMIC_COMPARE_EXCHANGE \
	ATOMIC_FETCH_ADD \
	ATOMIC_FETCH_ADD_2 \
	ATOMIC_FETCH_ADD_4 \
	ATOMIC_FETCH_ADD_8 \
	ATOMIC_FETCH_AND \
	ATOMIC_FETCH_NAND \
	ATOMIC_FETCH_OR \
	ATOMIC_FETCH_SUB \
	ATOMIC_FETCH_XOR \
	ATOMIC_LOAD \
	ATOMIC_LOAD_DOUBLE \
	ATOMIC_NAND_FETCH \
	ATOMIC_OR_FETCH \
	ATOMIC_STORE \
	ATOMIC_STORE_DOUBLE \
	ATOMIC_SUB_FETCH \
	ATOMIC_TEST_AND_SET \
	ATOMIC_XOR_FETCH BRK \
	BSD_STRLCAT \
	BSD_STRLCPY \
	BSEARCH \
	BUILTIN_ASSUME_ALIGNED \
	BUILTIN_BITREVERSE \
	BUILTIN_BSWAP32 \
	BUILTIN_CABS \
	BUILTIN_CABSF \
	BUILTIN_CABSL \
	BUILTIN_CBRT \
	BUILTIN_CBRTF \
	BUILTIN_CBRTL \
	BUILTIN_CCOS \
	BUILTIN_CCOSF \
	BUILTIN_CCOSL \
	BUILTIN_CEXP \
	BUILTIN_CEXPF \
	BUILTIN_CEXPL \
	BUILTIN___CLEAR_CACHE \
	BUILTIN_CLOG \
	BUILTIN_CLOGF \
	BUILTIN_CLOGL \
	BUILTIN_CLZ \
	BUILTIN_CLZL \
	BUILTIN_CLZLL \
	BUILTIN_CONSTANT_P \
	BUILTIN_COS \
	BUILTIN_COSF \
	BUILTIN_COSHF \
	BUILTIN_COSHL \
	BUILTIN_COSHL \
	BUILTIN_COSL \
	BUILTIN_CPOW \
	BUILTIN_CPOWF \
	BUILTIN_CPOWL \
	BUILTIN_CPU_IS_POWER9 \
	BUILTIN_CSIN \
	BUILTIN_CSINF \
	BUILTIN_CSINL \
	BUILTIN_CSQRT \
	BUILTIN_CSQRTF \
	BUILTIN_CSQRTL \
	BUILTIN_CTZ \
	BUILTIN_EXP \
	BUILTIN_EXP10 \
	BUILTIN_EXP10F \
	BUILTIN_EXP10L \
	BUILTIN_EXP2 \
	BUILTIN_EXP2F \
	BUILTIN_EXP2L \
	BUILTIN_EXPECT \
	BUILTIN_EXPF \
	BUILTIN_EXPL \
	BUILTIN_FABS \
	BUILTIN_FABSF \
	BUILTIN_FABSL \
	BUILTIN_FMA \
	BUILTIN_FMAF \
	BUILTIN_HYPOT \
	BUILTIN_HYPOTF \
	BUILTIN_HYPOTL \
	BUILTIN_IA32_MOVNTDQ \
	BUILTIN_IA32_MOVNTI \
	BUILTIN_IA32_MOVNTI64 \
	BUILTIN_J0 \
	BUILTIN_J1 \
	BUILTIN_JN \
	BUILTIN_J0F \
	BUILTIN_J1F \
	BUILTIN_JNF \
	BUILTIN_J0L \
	BUILTIN_J1L \
	BUILTIN_JNL \
	BUILTIN_LGAMMAL \
	BUILTIN_LLABS \
	BUILTIN_LOG \
	BUILTIN_LOG10 \
	BUILTIN_LOG10F \
	BUILTIN_LOG10L \
	BUILTIN_LOG2 \
	BUILTIN_LOG2F \
	BUILTIN_LOG2L \
	BUILTIN_LOGB \
	BUILTIN_LOGBF \
	BUILTIN_LOGBL \
	BUILTIN_LOGF \
	BUILTIN_LOGL \
	BUILTIN_MEMCMP \
	BUILTIN_MEMCPY \
	BUILTIN_MEMMOVE \
	BUILTIN_MEMSET \
	BUILTIN_NONTEMPORAL_LOAD \
	BUILTIN_NONTEMPORAL_STORE \
	BUILTIN_PARITY \
	BUILTIN_POPCOUNT \
	BUILTIN_POPCOUNTL \
	BUILTIN_POPCOUNTLL \
	BUILTIN_POW BUILTIN_POWF \
	BUILTIN_POWL \
	BUILTIN_PREFETCH \
	BUILTIN_RINT \
	BUILTIN_RINTL \
	BUILTIN_ROTATELEFT16 \
	BUILTIN_ROTATELEFT32 \
	BUILTIN_ROTATELEFT64 \
	BUILTIN_ROTATELEFT8 \
	BUILTIN_ROTATERIGHT16 \
	BUILTIN_ROTATERIGHT32 \
	BUILTIN_ROTATERIGHT64 \
	BUILTIN_ROTATERIGHT8 \
	BUILTIN_ROUNDL \
	BUILTIN_SFENCE \
	BUILTIN_SHUFFLE \
	BUILTIN_SIN \
	BUILTIN_SINCOS \
	BUILTIN_SINCOSF \
	BUILTIN_SINCOSL \
	BUILTIN_SINF \
	BUILTIN_SINH \
	BUILTIN_SINHF \
	BUILTIN_SINHL \
	BUILTIN_SINL \
	BUILTIN_SQRT \
	BUILTIN_SQRTF \
	BUILTIN_SQRTL \
	BUILTIN_SUPPORTS \
	BUILTIN_TAN \
	BUILTIN_TANF \
	BUILTIN_TANL \
	BUILTIN_THREAD_POINTER \
	BUILTIN_Y0 \
	BUILTIN_Y1 \
	BUILTIN_YN \
	BUILTIN_Y0F \
	BUILTIN_Y1F \
	BUILTIN_YNF \
	BUILTIN_Y0L \
	BUILTIN_Y1L \
	BUILTIN_YNL \
	CABSL \
	CACHEFLUSH \
	CBRT \
	CBRTF \
	CBRTL \
	CCOS \
	CCOSF \
	CCOSL \
	CEXP \
	CEXPF \
	CEXPF \
	CEXPL \
	CEXPL \
	CFGETISPEED \
	CFGETOSPEED \
	CHROOT \
	CIMAG \
	CIMAGF \
	CIMAGL \
	CLEARENV \
	CLOCK_ADJTIME \
	CLOCK_GETRES \
	CLOCK_GETTIME \
	CLOCK_NANOSLEEP \
	CLOCK_SETTIME \
	CLOG \
	CLOGF \
	CLOGL \
	CLONE \
	COPY_FILE_RANGE \
	COSH \
	COSHF \
	COSHL \
	COSL \
	CPOW \
	CPOWF \
	CPOWL \
	CREAL \
	CREALF \
	CREALL \
	CRYPT_R \
	CSIN \
	CSINF \
	CSINL \
	CSQRT \
	CSQRTF \
	CSQRTL \
	DELETE_MODULE \
	DRAND48 \
	DUP3 \
	EIGEN ENDMNTENT \
	ENDPWENT \
	EPOLL_CREATE \
	EPOLL_CREATE1 \
	EVENTFD \
	EXECUTABLE_START \
	EXECVEAT \
	EXP \
	EXP10 \
	EXP10F \
	EXP10L \
	EXP2 \
	EXP2F \
	EXP2L \
	EXPF \
	EXPL \
	FACCESSAT \
	FACCESSAT2 \
	FALLOCATE \
	FANOTIFY \
	FCHMODAT \
	FCHMODAT2 \
	FCHOWNAT \
	FDATASYNC \
	FGETXATTR \
	FINIT_MODULE \
	FLISTXATTR \
	FLOCK \
	FMA \
	FMAF \
	FREMOVEXATTR \
	FSETXATTR \
	FSTAT \
	FSTATAT \
	FSYNC \
	FUTIMENS \
	FUTIMES \
	FUTIMESAT \
	GETAUXVAL \
	GETCPU \
	GETDOMAINNAME \
	GETDTABLESIZE \
	GETENTROPY \
	GETEXECNAME \
	GETHOSTID \
	GETHOSTNAME \
	GETITIMER \
	GETLOADAVG \
	GETMNTENT \
	GETMNTINFO \
	GETPAGESIZE \
	GETPGID \
	GETPGRP \
	GETPRIORITY \
	GETPWENT \
	GETRANDOM \
	GETRESGID \
	GETRESUID \
	GETRUSAGE \
	GETSID \
	GETTID \
	GETTIMEOFDAY \
	GETXATTR \
	HSEARCH \
	HYPOT \
	HYPOTF \
	HYPOTL \
	INDEX \
	INOTIFY \
	INOTIFY1 \
	INTRINSIC_ROLB \
	INTRINSIC_ROLD \
	INTRINSIC_ROLQ \
	INTRINSIC_ROLW \
	INTRINSIC_RORB \
	INTRINSIC_RORD \
	INTRINSIC_RORQ \
	INTRINSIC_RORW \
	IOPL \
	IOPORT \
	J0 \
	J1 \
	JN \
	J0F \
	J1F \
	JNF \
	J0L \
	J1L \
	JNL \
	LGAMMAL \
	LGETXATTR \
	LINKAT \
	LISTXATTR \
	LLISTXATTR \
	LOCALTIME_R \
	LOCKF \
	LOG \
	LOG10 \
	LOG10F \
	LOG10L \
	LOG2 \
	LOG2F \
	LOG2L \
	LOGB \
	LOGBF \
	LOGBL \
	LOGF \
	LOGL \
	LOOKUP_DCOOKIE \
	LRAND48 \
	LREMOVEXATTR \
	LSEARCH \
	LSEEK64 \
	LSETXATTR \
	LSM_GET_SELF_ATTR \
	LSM_LIST_MODULES \
	LSTAT \
	MADVISE \
	MALLOC_TRIM \
	MALLOC_USABLE_SIZE \
	MALLOPT \
	MEMALIGN \
	MEMBARRIER \
	MEMFD_CREATE \
	MINCORE \
	MKDIRAT \
	MKNODAT \
	MLOCK \
	MLOCK2 \
	MLOCKALL \
	MM_STREAM_SI128 \
	MM_STREAM_SI32 \
	MM_STREAM_SI64 \
	MODIFY_LDT \
	MPROTECT \
	MQ_POSIX \
	MQ_SYSV \
	MQUERY \
	MREMAP \
	MSEAL \
	MSYNC \
	MTX_DESTROY \
	MTX_INIT \
	MUNLOCK \
	MUNLOCKALL \
	NAME_TO_HANDLE_AT \
	NANOSLEEP \
	NICE \
	OPENAT \
	OPENAT2 \
	OPEN_BY_HANDLE_AT \
	OPEN_MEMSTREAM \
	PERSONALITY \
	PIDFD_GETFD \
	PIDFD_OPEN \
	PIDFD_SEND_SIGNAL \
	PIPE2 \
	PKEY_ALLOC \
	PKEY_FREE \
	PKEY_GET \
	PKEY_MPROTECT \
	PKEY_SET \
	POSIX_FADVISE \
	POSIX_FALLOCATE \
	POSIX_MADVISE \
	POSIX_MEMALIGN \
	POSIX_OPENPT \
	POSIX_SPAWN \
	POW \
	POWF \
	POWL \
	PPC_GET_TIMEBASE \
	PPOLL \
	PRCTL \
	PREAD \
	PREADV \
	PREADV2 \
	PRLIMIT \
	PROCESS_VM_READV \
	PROCESS_VM_WRITEV \
	PROGRAM_INVOCATION_NAME \
	PSELECT \
	PTHREAD_ATTR_SETSTACK \
	PTHREAD_MUTEXATTR_DESTROY \
	PTHREAD_MUTEXATTR_INIT \
	PTHREAD_MUTEXATTR_SETPRIOCEILING \
	PTHREAD_MUTEXATTR_SETPROTOCOL \
	PTHREAD_MUTEXATTR_SETROBUST \
	PTHREAD_MUTEX_DESTROY \
	PTHREAD_MUTEX_INIT \
	PTHREAD_SETAFFINITY_NP \
	PTHREAD_SETSCHEDPARAM \
	PTHREAD_SIGQUEUE \
	PTRACE \
	PTSNAME \
	PWRITE \
	PWRITEV \
	PWRITEV2 \
	QUOTACTL_FD \
	READLINKAT \
	RECVMMSG \
	REMAP_FILE_PAGES \
	REMOVEXATTR \
	RENAMEAT \
	RENAMEAT2 \
	RFORK \
	RINDEX \
	RINTL \
	SBRK \
	SCHED_GETAFFINITY \
	SCHED_GETCPU \
	SCHED_GET_PRIORITY_MAX \
	SCHED_GET_PRIORITY_MIN \
	SCHED_RR_GET_INTERVAL \
	SCHED_SETAFFINITY \
	SCHED_SETSCHEDULER \
	SCHED_YIELD \
	SELECT \
	SEM_POSIX \
	SEM_SYSV \
	SEMTIMEDOP \
	SENDFILE \
	SENDMMSG \
	SETDOMAINNAME \
	SETFSGID \
	SETFSUID \
	SETITIMER \
	SETMNTENT \
	SETNS \
	SETPGID \
	SETPGRP \
	SETPRIORITY \
	SETPROCTITLE \
	SETPWENT \
	SETREGID \
	SETRESGID \
	SETRESUID \
	SETREUID \
	SETTIMEOFDAY \
	SETXATTR \
	SHM_SYSV \
	SIGALTSTACK \
	SIGNALFD \
	SIGQUEUE \
	SIGWAITINFO \
	SINCOS \
	SINCOSF \
	SINCOSL \
	SINH \
	SINHF \
	SINHL \
	SINL \
	SPLICE \
	SQRT \
	SQRTF \
	SQRTL \
	SRAND48 \
	STAT \
	STATFS \
	STATX \
	STIME \
	SWAP \
	SWAPCONTEXT \
	SYMLINKAT \
	SYNC_BOOL_COMPARE_AND_SWAP \
	SYNC_FILE_RANGE \
	SYNCFS \
	SYNC_SYNCHRONIZE \
	SYSCALL \
	SYSINFO \
	TCDRAIN \
	TCFLOW \
	TCFLUSH \
	TCGETATTR \
	TEE \
	TGKILL_LIBC \
	TIMER_DELETE \
	TIMERFD_CREATE \
	TIMERFD_GETTIME \
	TIMERFD_SETTIME \
	TIMER_GETOVERRUN \
	TIMER_GETTIME \
	TIMER_SETTIME \
	TIME TIMER_CREATE \
	TSEARCH \
	TTYNAME \
	UMOUNT2 \
	UNAME \
	UNLINKAT \
	UNSHARE \
	USTAT \
	UTIME \
	UTIMENSAT \
	VALLOC \
	VFORK \
	VHANGUP \
	VMSPLICE \
	WAIT3 \
	WAIT4 \
	WAITID \
	WAITPID \
	WCSCASECMP \
	WCSCAT \
	WCSCHR \
	WCSCMP \
	WCSCOLL \
	WCSCPY \
	WCSLCAT \
	WCSLCPY \
	WCSLEN \
	WCSNCASECMP \
	WCSNCAT \
	WCSNCMP \
	WCSRCHR \
	WCSXFRM \
	Y0 \
	Y1 \
	YN \
	Y0F \
	Y1F \
	YNF \
	Y0L \
	Y1L \
	YNL

ACCEPT4:
	$(call check,test-accept4,HAVE_ACCEPT4,accept4)

ADJTIME:
	$(call check,test-adjtime,HAVE_ADJTIME,adjtime)

ADJTIMEX:
	$(call check,test-adjtimex,HAVE_ADJTIMEX,adjtimex)

AIO_CANCEL:
	$(call check,test-aio-cancel,HAVE_AIO_CANCEL,aio_cancel,$(LIB_AIO) $(LIB_RT))

AIO_FSYNC:
	$(call check,test-aio-fsync,HAVE_AIO_FSYNC,aio_fsync,$(LIB_AIO) $(LIB_RT))

AIO_READ:
	$(call check,test-aio-read,HAVE_AIO_READ,aio_read,$(LIB_AIO) $(LIB_RT))

AIO_WRITE:
	$(call check,test-aio-write,HAVE_AIO_WRITE,aio_write,$(LIB_AIO) $(LIB_RT))

ALIGNED_ALLOC:
	$(call check,test-aligned-alloc,HAVE_ALIGNED_ALLOC,aligned_alloc)

ARC4RANDOM:
	$(call check,test-arc4random,HAVE_ARC4RANDOM,arc4random)

ARCH_PRCTL:
	$(call check,test-arch_prctl,HAVE_ARCH_PRCTL,arch_prctl)

ATOMIC_ADD_FETCH:
	$(call check,test-atomic_add_fetch,HAVE_ATOMIC_ADD_FETCH,__atomic_add_fetch)

ATOMIC_AND_FETCH:
	$(call check,test-atomic_and_fetch,HAVE_ATOMIC_AND_FETCH,__atomic_and_fetch)

ATOMIC_CLEAR:
	$(call check,test-atomic_clear,HAVE_ATOMIC_CLEAR,__atomic_clear)

ATOMIC_COMPARE_EXCHANGE:
	$(call check,test-atomic_compare_exchange,HAVE_ATOMIC_COMPARE_EXCHANGE,__atomic_compare_exchange)

ATOMIC_FETCH_ADD:
	$(call check,test-atomic_fetch_add,HAVE_ATOMIC_FETCH_ADD,__atomic_fetch_add)

ATOMIC_FETCH_ADD_2:
	$(call check,test-atomic_fetch_add_2,HAVE_ATOMIC_FETCH_ADD_2,__atomic_fetch_add_2)

ATOMIC_FETCH_ADD_4:
	$(call check,test-atomic_fetch_add_4,HAVE_ATOMIC_FETCH_ADD_4,__atomic_fetch_add_4)

ATOMIC_FETCH_ADD_8:
	$(call check,test-atomic_fetch_add_8,HAVE_ATOMIC_FETCH_ADD_8,__atomic_fetch_add_8)

ATOMIC_FETCH_AND:
	$(call check,test-atomic_fetch_and,HAVE_ATOMIC_FETCH_AND,__atomic_fetch_and)

ATOMIC_FETCH_NAND:
	$(call check,test-atomic_fetch_nand,HAVE_ATOMIC_FETCH_NAND,__atomic_fetch_nand)

ATOMIC_FETCH_OR:
	$(call check,test-atomic_fetch_or,HAVE_ATOMIC_FETCH_OR,__atomic_fetch_or)

ATOMIC_FETCH_SUB:
	$(call check,test-atomic_fetch_sub,HAVE_ATOMIC_FETCH_SUB,__atomic_fetch_sub)

ATOMIC_FETCH_XOR:
	$(call check,test-atomic_fetch_xor,HAVE_ATOMIC_FETCH_XOR,__atomic_fetch_xor)

ATOMIC_LOAD:
	$(call check,test-atomic_load,HAVE_ATOMIC_LOAD,__atomic_load)

ATOMIC_LOAD_DOUBLE:
	$(call check,test-atomic_load_double,HAVE_ATOMIC_LOAD_DOUBLE,__atomic_load_double)

ATOMIC_NAND_FETCH:
	$(call check,test-atomic_nand_fetch,HAVE_ATOMIC_NAND_FETCH,__atomic_nand_fetch)

ATOMIC_OR_FETCH:
	$(call check,test-atomic_or_fetch,HAVE_ATOMIC_OR_FETCH,__atomic_or_fetch)

ATOMIC_STORE:
	$(call check,test-atomic_store,HAVE_ATOMIC_STORE,__atomic_store)

ATOMIC_STORE_DOUBLE:
	$(call check,test-atomic_store_double,HAVE_ATOMIC_STORE_DOUBLE,__atomic_store_double)

ATOMIC_SUB_FETCH:
	$(call check,test-atomic_sub_fetch,HAVE_ATOMIC_SUB_FETCH,__atomic_sub_fetch)

ATOMIC_TEST_AND_SET:
	$(call check,test-atomic_test_and_set,HAVE_ATOMIC_TEST_AND_SET,__atomic_test_and_set)

ATOMIC_XOR_FETCH:
	$(call check,test-atomic_xor_fetch,HAVE_ATOMIC_XOR_FETCH,__atomic_xor_fetch)

ATOMIC:
	$(call check,test-atomic_clear,HAVE_ATOMIC,atomics with $(LIB_ATOMIC),$(LIB_ATOMIC))

BRK:
	$(call check,test-brk,HAVE_BRK,brk)

BSEARCH:
	$(call check,test-bsearch,HAVE_BSEARCH,bsearch)

BUILTIN___CLEAR_CACHE:
	$(call check,test-builtin-__clear_cache,HAVE_BUILTIN___CLEAR_CACHE,__builtin___clear_cache)

BUILTIN_ASSUME_ALIGNED:
	$(call check,test-builtin-assume-aligned,HAVE_BUILTIN_ASSUME_ALIGNED,__builtin_assume_aligned)

BUILTIN_BITREVERSE:
	$(call check,test-builtin-bitreverse,HAVE_BUILTIN_BITREVERSE,__builtin_bitreverse)

BUILTIN_BSWAP32:
	$(call check,test-builtin-bswap32,HAVE_BUILTIN_BSWAP32,__builtin_bswap32)

BUILTIN_CABS:
	$(call check,test-mathfunc,HAVE_BUILTIN_CABS,__builtin_cabs,$(LIB_M),-DMATHFUNC=__builtin_cabs)

BUILTIN_CABSF:
	$(call check,test-mathfunc,HAVE_BUILTIN_CABSF,__builtin_cabsf,$(LIB_M),-DMATHFUNC=__builtin_cabsf)

BUILTIN_CABSL:
	$(call check,test-mathfunc,HAVE_BUILTIN_CABSL,__builtin_cabsl,$(LIB_M),-DMATHFUNC=__builtin_cabsl)

BUILTIN_CBRT:
	$(call check,test-mathfunc,HAVE_BUILTIN_CBRT,__builtin_cbrt,$(LIB_M),-DMATHFUNC=__builtin_cbrt)

BUILTIN_CBRTF:
	$(call check,test-mathfunc,HAVE_BUILTIN_CBRTF,__builtin_cbrtf,$(LIB_M),-DMATHFUNC=__builtin_cbrtf)

BUILTIN_CBRTL:
	$(call check,test-mathfunc,HAVE_BUILTIN_CBRTL,__builtin_cbrtl,$(LIB_M),-DMATHFUNC=__builtin_cbrtl)

BUILTIN_CEXP:
	$(call check,test-mathfunc,HAVE_BUILTIN_CEXP,__builtin_cexp,$(LIB_M),-DMATHFUNC=__builtin_cexp)

BUILTIN_CEXPF:
	$(call check,test-mathfunc,HAVE_BUILTIN_CEXPF,__builtin_cexpf,$(LIB_M),-DMATHFUNC=__builtin_cexpf)

BUILTIN_CEXPL:
	$(call check,test-mathfunc,HAVE_BUILTIN_CEXPL,__builtin_cexpl,$(LIB_M),-DMATHFUNC=__builtin_cexpl)

BUILTIN_CCOS:
	$(call check,test-mathfunc,HAVE_BUILTIN_CCOS,__builtin_ccos,$(LIB_M),-DMATHFUNC=__builtin_ccos)

BUILTIN_CCOSF:
	$(call check,test-mathfunc,HAVE_BUILTIN_CCOSF,__builtin_ccosf,$(LIB_M),-DMATHFUNC=__builtin_ccosf)

BUILTIN_CCOSL:
	$(call check,test-mathfunc,HAVE_BUILTIN_CCOSL,__builtin_ccosl,$(LIB_M),-DMATHFUNC=__builtin_ccosl)

BUILTIN_CLOG:
	$(call check,test-mathfunc,HAVE_BUILTIN_CLOG,__builtin_clog,$(LIB_M),-DMATHFUNC=__builtin_clog)

BUILTIN_CLOGF:
	$(call check,test-mathfunc,HAVE_BUILTIN_CLOGF,__builtin_clogf,$(LIB_M),-DMATHFUNC=__builtin_clogf)

BUILTIN_CLOGL:
	$(call check,test-mathfunc,HAVE_BUILTIN_CLOGL,__builtin_clogl,$(LIB_M),-DMATHFUNC=__builtin_clogl)

BUILTIN_CLZ:
	$(call check,test-builtin-clz,HAVE_BUILTIN_CLZ,__builtin_clz)

BUILTIN_CLZL:
	$(call check,test-builtin-clzl,HAVE_BUILTIN_CLZL,__builtin_clzl)

BUILTIN_CLZLL:
	$(call check,test-builtin-clzll,HAVE_BUILTIN_CLZLL,__builtin_clzll)

BUILTIN_CONSTANT_P:
	$(call check,test-builtin-constant_p,HAVE_BUILTIN_CONSTANT_P,__builtin_constant_p)

BUILTIN_COS:
	$(call check,test-mathfunc,HAVE_BUILTIN_COS,__builtin_cos,$(LIB_M),-DMATHFUNC=__builtin_cos)

BUILTIN_COSF:
	$(call check,test-mathfunc,HAVE_BUILTIN_COSF,__builtin_cosf,$(LIB_M),-DMATHFUNC=__builtin_cosf)

BUILTIN_COSL:
	$(call check,test-mathfunc,HAVE_BUILTIN_COSL,__builtin_cosl,$(LIB_M),-DMATHFUNC=__builtin_cosl)

BUILTIN_COSH:
	$(call check,test-mathfunc,HAVE_BUILTIN_COSH,__builtin_cosh,$(LIB_M),-DMATHFUNC=__builtin_cosh)

BUILTIN_COSHF:
	$(call check,test-mathfunc,HAVE_BUILTIN_COSHF,__builtin_coshf,$(LIB_M),-DMATHFUNC=__builtin_coshf)

BUILTIN_COSHL:
	$(call check,test-mathfunc,HAVE_BUILTIN_COSHL,__builtin_coshl,$(LIB_M),-DMATHFUNC=__builtin_coshl)

BUILTIN_CPOW:
	$(call check,test-mathfunc,HAVE_BUILTIN_CPOW,__builtin_cpow,$(LIB_M),-DMATHFUNC=__builtin_cpow)

BUILTIN_CPOWF:
	$(call check,test-mathfunc,HAVE_BUILTIN_CPOWF,__builtin_cpowf,$(LIB_M),-DMATHFUNC=__builtin_cpowf)

BUILTIN_CPOWL:
	$(call check,test-mathfunc,HAVE_BUILTIN_CPOWL,__builtin_cpowl,$(LIB_M),-DMATHFUNC=__builtin_cpowl)

BUILTIN_CSIN:
	$(call check,test-mathfunc,HAVE_BUILTIN_CSIN,__builtin_csin,$(LIB_M),-DMATHFUNC=__builtin_csin)

BUILTIN_CSINF:
	$(call check,test-mathfunc,HAVE_BUILTIN_CSINF,__builtin_csinf,$(LIB_M),-DMATHFUNC=__builtin_csinf)

BUILTIN_CSINL:
	$(call check,test-mathfunc,HAVE_BUILTIN_CSINL,__builtin_csinl,$(LIB_M),-DMATHFUNC=__builtin_csinl)

BUILTIN_CSQRT:
	$(call check,test-mathfunc,HAVE_BUILTIN_CSQRT,__builtin_csqrt,$(LIB_M),-DMATHFUNC=__builtin_csqrt)

BUILTIN_CSQRTF:
	$(call check,test-mathfunc,HAVE_BUILTIN_CSQRTF,__builtin_csqrtf,$(LIB_M),-DMATHFUNC=__builtin_csqrtf)

BUILTIN_CSQRTL:
	$(call check,test-mathfunc,HAVE_BUILTIN_CSQRTL,__builtin_csqrtl,$(LIB_M),-DMATHFUNC=__builtin_csqrtl)

BUILTIN_CTZ:
	$(call check,test-builtin-ctz,HAVE_BUILTIN_CTZ,__builtin_ctz)

BUILTIN_CPU_IS_POWER9:
	$(call check,test-builtin-cpu-is-power9,HAVE_BUILTIN_CPU_IS_POWER9,__builtin_cpu_is("power9"))

BUILTIN_EXP:
	$(call check,test-mathfunc,HAVE_BUILTIN_EXP,__builtin_exp,$(LIB_M),-DMATHFUNC=__builtin_exp)

BUILTIN_EXPF:
	$(call check,test-mathfunc,HAVE_BUILTIN_EXPF,__builtin_expf,$(LIB_M),-DMATHFUNC=__builtin_expf)

BUILTIN_EXPL:
	$(call check,test-mathfunc,HAVE_BUILTIN_EXPL,__builtin_expl,$(LIB_M),-DMATHFUNC=__builtin_expl)

BUILTIN_EXP2:
	$(call check,test-mathfunc,HAVE_BUILTIN_EXP2,__builtin_exp2,$(LIB_M),-DMATHFUNC=__builtin_exp2)

BUILTIN_EXP2F:
	$(call check,test-mathfunc,HAVE_BUILTIN_EXP2F,__builtin_exp2f,$(LIB_M),-DMATHFUNC=__builtin_exp2f)

BUILTIN_EXP2L:
	$(call check,test-mathfunc,HAVE_BUILTIN_EXP2L,__builtin_exp2l,$(LIB_M),-DMATHFUNC=__builtin_exp2l)

BUILTIN_EXP10:
	$(call check,test-mathfunc,HAVE_BUILTIN_EXP10,__builtin_exp10,$(LIB_M),-DMATHFUNC=__builtin_exp10)

BUILTIN_EXP10F:
	$(call check,test-mathfunc,HAVE_BUILTIN_EXP10F,__builtin_exp10f,$(LIB_M),-DMATHFUNC=__builtin_exp10f)

BUILTIN_EXP10L:
	$(call check,test-mathfunc,HAVE_BUILTIN_EXP10L,__builtin_exp10l,$(LIB_M),-DMATHFUNC=__builtin_exp10l)

BUILTIN_EXPECT:
	$(call check,test-builtin-expect,HAVE_BUILTIN_EXPECT,__builtin_expect)

BUILTIN_FABS:
	$(call check,test-builtin-fabs,HAVE_BUILTIN_FABS,__builtin_fabs)

BUILTIN_FABSF:
	$(call check,test-builtin-fabsf,HAVE_BUILTIN_FABSF,__builtin_fabsf)

BUILTIN_FABSL:
	$(call check,test-builtin-fabsl,HAVE_BUILTIN_FABSL,__builtin_fabsl)

BUILTIN_FMA:
	$(call check,test-mathfunc,HAVE_BUILTIN_FMA,__builtin_fma,$(LIB_M),-DMATHFUNC=__builtin_fma)

BUILTIN_FMAF:
	$(call check,test-mathfunc,HAVE_BUILTIN_FMAF,__builtin_fmaf,$(LIB_M),-DMATHFUNC=__builtin_fmaf)

BUILTIN_HYPOT:
	$(call check,test-mathfunc,HAVE_BUILTIN_HYPOT,__builtin_hypot,$(LIB_M),-DMATHFUNC=__builtin_hypot)

BUILTIN_HYPOTF:
	$(call check,test-mathfunc,HAVE_BUILTIN_HYPOTF,__builtin_hypotf,$(LIB_M),-DMATHFUNC=__builtin_hypotf)

BUILTIN_HYPOTL:
	$(call check,test-mathfunc,HAVE_BUILTIN_HYPOTL,__builtin_hypotl,$(LIB_M),-DMATHFUNC=__builtin_hypotl)

BUILTIN_IA32_MOVNTDQ:
	$(call check,test-builtin-ia32_movntdq,HAVE_BUILTIN_IA32_MOVNTDQ,__builtin_ia32_movntdq)

BUILTIN_IA32_MOVNTI:
	$(call check,test-builtin-ia32_movnti,HAVE_BUILTIN_IA32_MOVNTI,__builtin_ia32_movnti)

BUILTIN_IA32_MOVNTI64:
	$(call check,test-builtin-ia32_movnti64,HAVE_BUILTIN_IA32_MOVNTI64,__builtin_ia32_movnti64)

BUILTIN_J0:
	$(call check,test-mathfunc,HAVE_BUILTIN_J0,__builtin_j0,$(LIB_M),-DMATHFUNC=__builtin_j0)

BUILTIN_J1:
	$(call check,test-mathfunc,HAVE_BUILTIN_J1,__builtin_j1,$(LIB_M),-DMATHFUNC=__builtin_j1)

BUILTIN_JN:
	$(call check,test-mathfunc,HAVE_BUILTIN_JN,__builtin_jn,$(LIB_M),-DMATHFUNC=__builtin_jn)

BUILTIN_J0F:
	$(call check,test-mathfunc,HAVE_BUILTIN_J0F,__builtin_j0f,$(LIB_M),-DMATHFUNC=__builtin_j0f)

BUILTIN_J1F:
	$(call check,test-mathfunc,HAVE_BUILTIN_J1F,__builtin_j1f,$(LIB_M),-DMATHFUNC=__builtin_j1f)

BUILTIN_JNF:
	$(call check,test-mathfunc,HAVE_BUILTIN_JNF,__builtin_jnf,$(LIB_M),-DMATHFUNC=__builtin_jnf)

BUILTIN_J0L:
	$(call check,test-mathfunc,HAVE_BUILTIN_J0L,__builtin_j0l,$(LIB_M),-DMATHFUNC=__builtin_j0l)

BUILTIN_J1L:
	$(call check,test-mathfunc,HAVE_BUILTIN_J1L,__builtin_j1l,$(LIB_M),-DMATHFUNC=__builtin_j1l)

BUILTIN_JNL:
	$(call check,test-mathfunc,HAVE_BUILTIN_JNL,__builtin_jnl,$(LIB_M),-DMATHFUNC=__builtin_jnl)

BUILTIN_LGAMMAL:
	$(call check,test-mathfunc,HAVE_BUILTIN_LGAMMAL,__builtin_lgammal,$(LIB_M),-DMATHFUNC=__builtin_lgammal)

BUILTIN_LLABS:
	$(call check,test-builtin-llabs,HAVE_BUILTIN_LLABS,__builtin_llabs)

BUILTIN_LOG10F:
	$(call check,test-mathfunc,HAVE_BUILTIN_LOG10F,__builtin_log10f,$(LIB_M),-DMATHFUNC=__builtin_log10f)

BUILTIN_LOG10:
	$(call check,test-mathfunc,HAVE_BUILTIN_LOG10,__builtin_log10,$(LIB_M),-DMATHFUNC=__builtin_log10)

BUILTIN_LOG10L:
	$(call check,test-mathfunc,HAVE_BUILTIN_LOG10L,__builtin_log10l,$(LIB_M),-DMATHFUNC=__builtin_log10l)

BUILTIN_LOG2F:
	$(call check,test-mathfunc,HAVE_BUILTIN_LOG2F,__builtin_log2f,$(LIB_M),-DMATHFUNC=__builtin_log2f)

BUILTIN_LOG2:
	$(call check,test-mathfunc,HAVE_BUILTIN_LOG2,__builtin_log2,$(LIB_M),-DMATHFUNC=__builtin_log2)

BUILTIN_LOG2L:
	$(call check,test-mathfunc,HAVE_BUILTIN_LOG2L,__builtin_log2l,$(LIB_M),-DMATHFUNC=__builtin_log2l)

BUILTIN_LOG:
	$(call check,test-mathfunc,HAVE_BUILTIN_LOG,__builtin_log,$(LIB_M),-DMATHFUNC=__builtin_log)

BUILTIN_LOGF:
	$(call check,test-mathfunc,HAVE_BUILTIN_LOGF,__builtin_logf,$(LIB_M),-DMATHFUNC=__builtin_logf)

BUILTIN_LOGL:
	$(call check,test-mathfunc,HAVE_BUILTIN_LOGL,__builtin_logl,$(LIB_M),-DMATHFUNC=__builtin_logl)

BUILTIN_LOGB:
	$(call check,test-mathfunc,HAVE_BUILTIN_LOGB,__builtin_logb,$(LIB_M),-DMATHFUNC=__builtin_logb)

BUILTIN_LOGBF:
	$(call check,test-mathfunc,HAVE_BUILTIN_LOGBF,__builtin_logbf,$(LIB_M),-DMATHFUNC=__builtin_logbf)

BUILTIN_LOGBL:
	$(call check,test-mathfunc,HAVE_BUILTIN_LOGBL,__builtin_logbl,$(LIB_M),-DMATHFUNC=__builtin_logbl)

BUILTIN_MEMCPY:
	$(call check,test-builtin-memcpy,HAVE_BUILTIN_MEMCPY,__builtin_memcpy)

BUILTIN_MEMCMP:
	$(call check,test-builtin-memcmp,HAVE_BUILTIN_MEMCMP,__builtin_memcmp)

BUILTIN_MEMMOVE:
	$(call check,test-builtin-memmove,HAVE_BUILTIN_MEMMOVE,__builtin_memmove)

BUILTIN_MEMSET:
	$(call check,test-builtin-memset,HAVE_BUILTIN_MEMSET,__builtin_memset)

BUILTIN_NONTEMPORAL_LOAD:
	$(call check,test-builtin-nontemporal-load,HAVE_BUILTIN_NONTEMPORAL_LOAD,__builtin_nontemporal_load)

BUILTIN_NONTEMPORAL_STORE:
	$(call check,test-builtin-nontemporal-store,HAVE_BUILTIN_NONTEMPORAL_STORE,__builtin_nontemporal_store)

BUILTIN_PARITY:
	$(call check,test-builtin-parity,HAVE_BUILTIN_PARITY,__builtin_parity)

BUILTIN_POPCOUNT:
	$(call check,test-builtin-popcount,HAVE_BUILTIN_POPCOUNT,__builtin_popcount)

BUILTIN_POPCOUNTL:
	$(call check,test-builtin-popcountl,HAVE_BUILTIN_POPCOUNTL,__builtin_popcountl)

BUILTIN_POPCOUNTLL:
	$(call check,test-builtin-popcountll,HAVE_BUILTIN_POPCOUNTLL,__builtin_popcountll)

BUILTIN_POW:
	$(call check,test-mathfunc,HAVE_BUILTIN_POW,__builtin_pow,$(LIB_M),-DMATHFUNC=__builtin_pow)

BUILTIN_POWF:
	$(call check,test-mathfunc,HAVE_BUILTIN_POWF,__builtin_powf,$(LIB_M),-DMATHFUNC=__builtin_powf)

BUILTIN_POWL:
	$(call check,test-mathfunc,HAVE_BUILTIN_POWL,__builtin_powl,$(LIB_M),-DMATHFUNC=__builtin_powl)

BUILTIN_PREFETCH:
	$(call check,test-builtin-prefetch,HAVE_BUILTIN_PREFETCH,__builtin_prefetch)

BUILTIN_RINT:
	$(call check,test-builtin-rint,HAVE_BUILTIN_RINT,__builtin_rint)

BUILTIN_RINTL:
	$(call check,test-builtin-rintl,HAVE_BUILTIN_RINTL,__builtin_rintl)

BUILTIN_ROTATELEFT8:
	$(call check,test-builtin-rotateleft8,HAVE_BUILTIN_ROTATELEFT8,__builtin_rotateleft8)

BUILTIN_ROTATELEFT16:
	$(call check,test-builtin-rotateleft16,HAVE_BUILTIN_ROTATELEFT16,__builtin_rotateleft16)

BUILTIN_ROTATELEFT32:
	$(call check,test-builtin-rotateleft32,HAVE_BUILTIN_ROTATELEFT32,__builtin_rotateleft32)

BUILTIN_ROTATELEFT64:
	$(call check,test-builtin-rotateleft64,HAVE_BUILTIN_ROTATELEFT64,__builtin_rotateleft64)

BUILTIN_ROTATERIGHT8:
	$(call check,test-builtin-rotateright8,HAVE_BUILTIN_ROTATERIGHT8,__builtin_rotateright8)

BUILTIN_ROTATERIGHT16:
	$(call check,test-builtin-rotateright16,HAVE_BUILTIN_ROTATERIGHT16,__builtin_rotateright16)

BUILTIN_ROTATERIGHT32:
	$(call check,test-builtin-rotateright32,HAVE_BUILTIN_ROTATERIGHT32,__builtin_rotateright32)

BUILTIN_ROTATERIGHT64:
	$(call check,test-builtin-rotateright64,HAVE_BUILTIN_ROTATERIGHT64,__builtin_rotateright64)

BUILTIN_ROUNDL:
	$(call check,test-mathfunc,HAVE_BUILTIN_ROUNDL,__builtin_roundl,$(LIB_M),-DMATHFUNC=__builtin_roundl)

BUILTIN_SFENCE:
	$(call check,test-builtin-sfence,HAVE_BUILTIN_SFENCE,__builtin_ia32_sfence)

BUILTIN_SHUFFLE:
	$(call check,test-builtin-shuffle,HAVE_BUILTIN_SHUFFLE,__builtin_shuffle)

BUILTIN_SIN:
	$(call check,test-mathfunc,HAVE_BUILTIN_SIN,__builtin_sin,$(LIB_M),-DMATHFUNC=__builtin_sin)

BUILTIN_SINH:
	$(call check,test-mathfunc,HAVE_BUILTIN_SINH,__builtin_sinh,$(LIB_M),-DMATHFUNC=__builtin_sinh)

BUILTIN_SINHF:
	$(call check,test-mathfunc,HAVE_BUILTIN_SINHF,__builtin_sinhf,$(LIB_M),-DMATHFUNC=__builtin_sinhf)

BUILTIN_SINHL:
	$(call check,test-mathfunc,HAVE_BUILTIN_SINHL,__builtin_sinhl,$(LIB_M),-DMATHFUNC=__builtin_sinhl)

BUILTIN_SINF:
	$(call check,test-mathfunc,HAVE_BUILTIN_SINF,__builtin_sinf,$(LIB_M),-DMATHFUNC=__builtin_sinf)

BUILTIN_SINL:
	$(call check,test-mathfunc,HAVE_BUILTIN_SINL,__builtin_sinl,$(LIB_M),-DMATHFUNC=__builtin_sinl)

BUILTIN_SINCOS:
	$(call check,test-mathfunc,HAVE_BUILTIN_SINCOS,__builtin_sincos,$(LIB_M),-DMATHFUNC=__builtin_sincos)

BUILTIN_SINCOSF:
	$(call check,test-mathfunc,HAVE_BUILTIN_SINCOSF,__builtin_sincosf,$(LIB_M),-DMATHFUNC=__builtin_sincosf)

BUILTIN_SINCOSL:
	$(call check,test-mathfunc,HAVE_BUILTIN_SINCOSL,__builtin_sincosl,$(LIB_M),-DMATHFUNC=__builtin_sincosl)

BUILTIN_SQRT:
	$(call check,test-mathfunc,HAVE_BUILTIN_SQRT,__builtin_sqrt,$(LIB_M),-DMATHFUNC=__builtin_sqrt)

BUILTIN_SQRTF:
	$(call check,test-mathfunc,HAVE_BUILTIN_SQRTF,__builtin_sqrtf,$(LIB_M),-DMATHFUNC=__builtin_sqrtf)

BUILTIN_SQRTL:
	$(call check,test-mathfunc,HAVE_BUILTIN_SQRTL,__builtin_sqrtl,$(LIB_M),-DMATHFUNC=__builtin_sqrtl)

BUILTIN_SUPPORTS:
	$(call check,test-builtin-supports,HAVE_BUILTIN_SUPPORTS,__builtin_supports)

BUILTIN_TAN:
	$(call check,test-mathfunc,HAVE_BUILTIN_TAN,__builtin_tan,$(LIB_M),-DMATHFUNC=__builtin_tan)

BUILTIN_TANF:
	$(call check,test-mathfunc,HAVE_BUILTIN_TANF,__builtin_tanf,$(LIB_M),-DMATHFUNC=__builtin_tanf)

BUILTIN_TANL:
	$(call check,test-mathfunc,HAVE_BUILTIN_TANL,__builtin_tanl,$(LIB_M),-DMATHFUNC=__builtin_tanl)

BUILTIN_THREAD_POINTER:
	$(call check,test-builtin-thread-pointer,HAVE_BUILTIN_THREAD_POINTER,__builtin_thread_pointer)

BUILTIN_Y0:
	$(call check,test-mathfunc,HAVE_BUILTIN_Y0,__builtin_y0,$(LIB_M),-DMATHFUNC=__builtin_y0)

BUILTIN_Y1:
	$(call check,test-mathfunc,HAVE_BUILTIN_Y1,__builtin_y1,$(LIB_M),-DMATHFUNC=__builtin_y1)

BUILTIN_YN:
	$(call check,test-mathfunc,HAVE_BUILTIN_YN,__builtin_yn,$(LIB_M),-DMATHFUNC=__builtin_yn)

BUILTIN_Y0F:
	$(call check,test-mathfunc,HAVE_BUILTIN_Y0F,__builtin_y0f,$(LIB_M),-DMATHFUNC=__builtin_y0f)

BUILTIN_Y1F:
	$(call check,test-mathfunc,HAVE_BUILTIN_Y1F,__builtin_y1f,$(LIB_M),-DMATHFUNC=__builtin_y1f)

BUILTIN_YNF:
	$(call check,test-mathfunc,HAVE_BUILTIN_YNF,__builtin_ynf,$(LIB_M),-DMATHFUNC=__builtin_ynf)

BUILTIN_Y0L:
	$(call check,test-mathfunc,HAVE_BUILTIN_Y0L,__builtin_y0l,$(LIB_M),-DMATHFUNC=__builtin_y0l)

BUILTIN_Y1L:
	$(call check,test-mathfunc,HAVE_BUILTIN_Y1L,__builtin_y1l,$(LIB_M),-DMATHFUNC=__builtin_y1l)

BUILTIN_YNL:
	$(call check,test-mathfunc,HAVE_BUILTIN_YNL,__builtin_ynl,$(LIB_M),-DMATHFUNC=__builtin_ynl)

INTRINSIC_ROLB:
	$(call check,test-__rolb,HAVE_INTRINSIC_ROLB,intrinsic __rolb)

INTRINSIC_ROLD:
	$(call check,test-__rold,HAVE_INTRINSIC_ROLD,intrinsic __rold)

INTRINSIC_ROLW:
	$(call check,test-__rolw,HAVE_INTRINSIC_ROLW,intrinsic __rolw)

INTRINSIC_ROLQ:
	$(call check,test-__rolq,HAVE_INTRINSIC_ROLQ,intrinsic __rolq)

INTRINSIC_RORB:
	$(call check,test-__rorb,HAVE_INTRINSIC_RORB,intrinsic __rorb)

INTRINSIC_RORD:
	$(call check,test-__rord,HAVE_INTRINSIC_RORD,intrinsic __rord)

INTRINSIC_RORW:
	$(call check,test-__rorw,HAVE_INTRINSIC_RORW,intrinsic __rorw)

INTRINSIC_RORQ:
	$(call check,test-__rorq,HAVE_INTRINSIC_RORQ,intrinsic __rorq)

CABSL:
	$(call check,test-mathfunc,HAVE_CABSL,cabsl,$(LIB_M),-DMATHFUNC=cabsl)

CBRT:
	$(call check,test-mathfunc,HAVE_CBRT,cbrt,$(LIB_M),-DMATHFUNC=cbrt)

CBRTF:
	$(call check,test-mathfunc,HAVE_CBRTF,cbrtf,$(LIB_M),-DMATHFUNC=cbrtf)

CBRTL:
	$(call check,test-mathfunc,HAVE_CBRTL,cbrtl,$(LIB_M),-DMATHFUNC=cbrtl)

CACHEFLUSH:
	$(call check,test-cacheflush,HAVE_CACHEFLUSH,cacheflush)

CCOS:
	$(call check,test-mathfunc,HAVE_CCOS,ccosf,$(LIB_M),-DMATHFUNC=ccos)

CCOSF:
	$(call check,test-mathfunc,HAVE_CCOSF,ccosf,$(LIB_M),-DMATHFUNC=ccosf)

CCOSL:
	$(call check,test-mathfunc,HAVE_CCOSL,ccosl,$(LIB_M),-DMATHFUNC=ccosl)

CEXP:
	$(call check,test-mathfunc,HAVE_CEXP,cexp,$(LIB_M),-DMATHFUNC=cexp)

CEXPF:
	$(call check,test-mathfunc,HAVE_CEXPF,cexp,$(LIB_M),-DMATHFUNC=cexpf)

CEXPL:
	$(call check,test-mathfunc,HAVE_CEXPL,cexpl,$(LIB_M),-DMATHFUNC=cexpl)

CFGETISPEED:
	$(call check,test-cfgetispeed,HAVE_CFGETISPEED,cfgetispeed)

CFGETOSPEED:
	$(call check,test-cfgetospeed,HAVE_CFGETOSPEED,cfgetospeed)

CHROOT:
	$(call check,test-chroot,HAVE_CHROOT,chroot)

CIMAG:
	$(call check,test-mathfunc,HAVE_CIMAG,cimag,$(LIB_M),-DMATHFUNC=cimag)

CIMAGF:
	$(call check,test-mathfunc,HAVE_CIMAGF,cimagf,$(LIB_M),-DMATHFUNC=cimagf)

CIMAGL:
	$(call check,test-mathfunc,HAVE_CIMAGL,cimagl,$(LIB_M),-DMATHFUNC=cimagl)

CRYPT_R:
	$(call check,test-crypt-r,HAVE_CRYPT_R,crypt_r,$(LIB_CRYPT))

CLEARENV:
	$(call check,test-clearenv,HAVE_CLEARENV,clearenv)

CLOCK_ADJTIME:
	$(call check,test-clock-adjtime,HAVE_CLOCK_ADJTIME,clock_adjtime)

CLOCK_GETRES:
	$(call check,test-clock-getres,HAVE_CLOCK_GETRES,clock_getres)

CLOCK_GETTIME:
	$(call check,test-clock-gettime,HAVE_CLOCK_GETTIME,clock_gettime)

CLOCK_NANOSLEEP:
	$(call check,test-clock-nanosleep,HAVE_CLOCK_NANOSLEEP,clock_nanosleep)

CLOCK_SETTIME:
	$(call check,test-clock-settime,HAVE_CLOCK_SETTIME,clock_settime)

CLOG:
	$(call check,test-mathfunc,HAVE_CLOG,clog,$(LIB_M),-DMATHFUNC=clog)

CLOGF:
	$(call check,test-mathfunc,HAVE_CLOGF,clogf,$(LIB_M),-DMATHFUNC=clogf)

CLOGL:
	$(call check,test-mathfunc,HAVE_CLOGL,clogl,$(LIB_M),-DMATHFUNC=clogl)

CLONE:
	$(call check,test-clone,HAVE_CLONE,clone)

COPY_FILE_RANGE:
	$(call check,test-copy-file-range,HAVE_COPY_FILE_RANGE,copy_file_range)

COSH:
	$(call check,test-mathfunc,HAVE_COSH,cosh,$(LIB_M),-DMATHFUNC=cosh)

COSHF:
	$(call check,test-mathfunc,HAVE_COSHF,coshf,$(LIB_M),-DMATHFUNC=coshf)

COSHL:
	$(call check,test-mathfunc,HAVE_COSHL,coshl,$(LIB_M),-DMATHFUNC=coshl)

COSL:
	$(call check,test-mathfunc,HAVE_COSL,cosl,$(LIB_M),-DMATHFUNC=cosl)

CPOW:
	$(call check,test-mathfunc,HAVE_CPOW,cpow,$(LIB_M),-DMATHFUNC=cpow)

CPOWF:
	$(call check,test-mathfunc,HAVE_CPOWF,cpowf,$(LIB_M),-DMATHFUNC=cpowf)

CPOWL:
	$(call check,test-mathfunc,HAVE_CPOWL,cpowl,$(LIB_M),-DMATHFUNC=cpowl)

CREAL:
	$(call check,test-mathfunc,HAVE_CREAL,creal,$(LIB_M),-DMATHFUNC=creal)

CREALF:
	$(call check,test-mathfunc,HAVE_CREALF,crealf,$(LIB_M),-DMATHFUNC=crealf)

CREALL:
	$(call check,test-mathfunc,HAVE_CREALL,creall,$(LIB_M),-DMATHFUNC=creall)

CSIN:
	$(call check,test-mathfunc,HAVE_CSIN,csin,$(LIB_M),-DMATHFUNC=csin)

CSINF:
	$(call check,test-mathfunc,HAVE_CSINF,csinf,$(LIB_M),-DMATHFUNC=csinf)

CSINL:
	$(call check,test-mathfunc,HAVE_CSINL,csinl,$(LIB_M),-DMATHFUNC=csinl)

CSQRT:
	$(call check,test-mathfunc,HAVE_CSQRT,csqrt,$(LIB_M),-DMATHFUNC=csqrt)

CSQRTF:
	$(call check,test-mathfunc,HAVE_CSQRTF,csqrtf,$(LIB_M),-DMATHFUNC=csqrtf)

CSQRTL:
	$(call check,test-mathfunc,HAVE_CSQRTL,csqrtl,$(LIB_M),-DMATHFUNC=csqrtl)

DRAND48:
	$(call check,test-drand48,HAVE_DRAND48,drand48)

DELETE_MODULE:
	$(call check,test-delete-module,HAVE_DELETE_MODULE,delete_module)

DUP3:
	$(call check,test-dup3,HAVE_DUP3,dup3)

EIGEN:
	$(call check_gxx,test-eigen,HAVE_EIGEN,eigen C++ functions)

ENDMNTENT:
	$(call check,test-endmntent,HAVE_ENDMNTENT,endmntent)

ENDPWENT:
	$(call check,test-endpwent,HAVE_ENDPWENT,endpwent)

EPOLL_CREATE:
	$(call check,test-epoll-create,HAVE_EPOLL_CREATE,epoll_create)

EPOLL_CREATE1:
	$(call check,test-epoll-create1,HAVE_EPOLL_CREATE1,epoll_create1)

EVENTFD:
	$(call check,test-eventfd,HAVE_EVENTFD,eventfd)

EXECVEAT:
	$(call check,test-execveat,HAVE_EXECVEAT,execveat)

EXP:
	$(call check,test-mathfunc,HAVE_EXP,exp,$(LIB_M),-DMATHFUNC=exp)

EXPF:
	$(call check,test-mathfunc,HAVE_EXPF,expf,$(LIB_M),-DMATHFUNC=expf)

EXPL:
	$(call check,test-mathfunc,HAVE_EXPL,expl,$(LIB_M),-DMATHFUNC=expl)

EXP2:
	$(call check,test-mathfunc,HAVE_EXP2,exp2,$(LIB_M),-DMATHFUNC=exp2)

EXP2F:
	$(call check,test-mathfunc,HAVE_EXP2F,exp2f,$(LIB_M),-DMATHFUNC=exp2f)

EXP2L:
	$(call check,test-mathfunc,HAVE_EXP2L,exp2l,$(LIB_M),-DMATHFUNC=exp2l)

EXP10:
	$(call check,test-mathfunc,HAVE_EXP10,exp10,$(LIB_M),-DMATHFUNC=exp10)

EXP10F:
	$(call check,test-mathfunc,HAVE_EXP10F,exp10f,$(LIB_M),-DMATHFUNC=exp10f)

EXP10L:
	$(call check,test-mathfunc,HAVE_EXP10L,exp10l,$(LIB_M),-DMATHFUNC=exp10l)

EXECUTABLE_START:
	$(call check,test-executable_start,HAVE_EXECUTABLE_START,__executable_start)

FACCESSAT:
	$(call check,test-faccessat,HAVE_FACCESSAT,faccessat)

FACCESSAT2:
	$(call check,test-faccessat2,HAVE_FACCESSAT2,faccessat2)

FALLOCATE:
	$(call check,test-fallocate,HAVE_FALLOCATE,fallocate)

FANOTIFY:
	$(call check,test-fanotify,HAVE_FANOTIFY,fanotify)

FCHMODAT:
	$(call check,test-fchmodat,HAVE_FCHMODAT,fchmodat)

FCHMODAT2:
	$(call check,test-fchmodat2,HAVE_FCHMODAT2,fchmodat2)

FCHOWNAT:
	$(call check,test-fchownat,HAVE_FCHOWNAT,fchownat)

FDATASYNC:
	$(call check,test-fdatasync,HAVE_FDATASYNC,fdatasync)

FGETXATTR:
	$(call check,test-fgetxattr,HAVE_FGETXATTR,fgetxattr)

FINIT_MODULE:
	$(call check,test-finit-module,HAVE_FINIT_MODULE,finit_module)

FLISTXATTR:
	$(call check,test-flistxattr,HAVE_FLISTXATTR,flistxattr)

FLOCK:
	$(call check,test-flock,HAVE_FLOCK,flock)

FMA:
	$(call check,test-mathfunc,HAVE_FMA,fma,$(LIB_M),-DMATHFUNC=fma)

FMAF:
	$(call check,test-mathfunc,HAVE_FMAF,fmaf,$(LIB_M),-DMATHFUNC=fmaf)

FREMOVEXATTR:
	$(call check,test-fremovexattr,HAVE_FREMOVEXATTR,fremovexattr)

FSETXATTR:
	$(call check,test-fsetxattr,HAVE_FSETXATTR,fsetxattr)

FSTAT:
	$(call check,test-fstat,HAVE_FSTAT,fstat)

FSTATAT:
	$(call check,test-fstatat,HAVE_FSTATAT,fstatat)

FSYNC:
	$(call check,test-fsync,HAVE_FSYNC,fsync)

FUTIMENS:
	$(call check,test-futimens,HAVE_FUTIMENS,futimens)

FUTIMES:
	$(call check,test-futimes,HAVE_FUTIMES,futimes)

FUTIMESAT:
	$(call check,test-futimesat,HAVE_FUTIMESAT,futimesat)

GETAUXVAL:
	$(call check,test-getauxval,HAVE_GETAUXVAL,getauxval)

GETCPU:
	$(call check,test-getcpu,HAVE_GETCPU,getcpu)

GETDOMAINNAME:
	$(call check,test-getdomainname,HAVE_GETDOMAINNAME,getdomainname)

GETDTABLESIZE:
	$(call check,test-getdtablesize,HAVE_GETDTABLESIZE,getdtablesize)

GETENTROPY:
	$(call check,test-getentropy,HAVE_GETENTROPY,getentropy)

GETEXECNAME:
	$(call check,test-getexecname,HAVE_GETEXECNAME,getexecname)

GETHOSTNAME:
	$(call check,test-gethostname,HAVE_GETHOSTNAME,gethostname)

GETHOSTID:
	$(call check,test-gethostid,HAVE_GETHOSTID,gethostid)

GETITIMER:
	$(call check,test-getitimer,HAVE_GETITIMER,getitimer)

GETLOADAVG:
	$(call check,test-getloadavg,HAVE_GETLOADAVG,getloadavg)

GETMNTENT:
	$(call check,test-getmntent,HAVE_GETMNTENT,getmntent)

GETMNTINFO:
	$(call check,test-getmntinfo,HAVE_GETMNTINFO,getmntinfo)

GETPAGESIZE:
	$(call check,test-getpagesize,HAVE_GETPAGESIZE,getpagesize)

GETPGID:
	$(call check,test-getpgid,HAVE_GETPGID,getpgid)

GETPGRP:
	$(call check,test-getpgrp,HAVE_GETPGRP,getpgrp)

GETPRIORITY:
	$(call check,test-getpriority,HAVE_GETPRIORITY,getpriority)

GETPWENT:
	$(call check,test-getpwent,HAVE_GETPWENT,getpwent)

GETRANDOM:
	$(call check,test-getrandom,HAVE_GETRANDOM,getrandom)

GETRESGID:
	$(call check,test-getresgid,HAVE_GETRESGID,getresgid)

GETRESUID:
	$(call check,test-getresuid,HAVE_GETRESUID,getresuid)

GETRUSAGE:
	$(call check,test-getrusage,HAVE_GETRUSAGE,getrusage)

GETSID:
	$(call check,test-getsid,HAVE_GETSID,getsid)

GETTID:
	$(call check,test-gettid,HAVE_GETTID,gettid)

GETTIMEOFDAY:
	$(call check,test-gettimeofday,HAVE_GETTIMEOFDAY,gettimeofday)

GETXATTR:
	$(call check,test-getxattr,HAVE_GETXATTR,getxattr)

HSEARCH:
	$(call check,test-hsearch,HAVE_HSEARCH,hsearch)

HYPOT:
	$(call check,test-mathfunc,HAVE_HYPOT,hypot,$(LIB_M),-DMATHFUNC=hypot)

HYPOTF:
	$(call check,test-mathfunc,HAVE_HYPOTF,hypotf,$(LIB_M),-DMATHFUNC=hypotf)

HYPOTL:
	$(call check,test-mathfunc,HAVE_HYPOTL,hypotl,$(LIB_M),-DMATHFUNC=hypotl)

INDEX:
	$(call check,test-strfunc,HAVE_INDEX,index,,-DSTRFUNC=index)

INOTIFY:
	$(call check,test-inotify,HAVE_INOTIFY,inotify)

INOTIFY1:
	$(call check,test-inotify1,HAVE_INOTIFY1,inotify1)

IOPORT:
	$(call check,test-ioport,HAVE_IOPORT,ioport)

IOPL:
	$(call check,test-iopl,HAVE_IOPL,iopl)

J0:
	$(call check,test-mathfunc,HAVE_J0,j0,$(LIB_M),-DMATHFUNC=j0)

J1:
	$(call check,test-mathfunc,HAVE_J1,j1,$(LIB_M),-DMATHFUNC=j1)

JN:
	$(call check,test-mathfunc,HAVE_JN,jn,$(LIB_M),-DMATHFUNC=jn)

J0F:
	$(call check,test-mathfunc,HAVE_J0F,j0f,$(LIB_M),-DMATHFUNC=j0f)

J1F:
	$(call check,test-mathfunc,HAVE_J1F,j1f,$(LIB_M),-DMATHFUNC=j1f)

JNF:
	$(call check,test-mathfunc,HAVE_JNF,jnf,$(LIB_M),-DMATHFUNC=jnf)

J0L:
	$(call check,test-mathfunc,HAVE_J0L,j0l,$(LIB_M),-DMATHFUNC=j0l)

J1L:
	$(call check,test-mathfunc,HAVE_J1L,j1l,$(LIB_M),-DMATHFUNC=j1l)

JNL:
	$(call check,test-mathfunc,HAVE_JNL,jnl,$(LIB_M),-DMATHFUNC=jnl)

LGAMMAL:
	$(call check,test-mathfunc,HAVE_LGAMMAL,lgammal,$(LIB_M),-DMATHFUNC=lgammal)

LGETXATTR:
	$(call check,test-lgetxattr,HAVE_LGETXATTR,lgetxattr)

LINKAT:
	$(call check,test-linkat,HAVE_LINKAT,linkat)

LISTXATTR:
	$(call check,test-listxattr,HAVE_LISTXATTR,listxattr)

LLISTXATTR:
	$(call check,test-llistxattr,HAVE_LLISTXATTR,llistxattr)

LREMOVEXATTR:
	$(call check,test-lremovexattr,HAVE_LREMOVEXATTR,lremovexattr)

LSTAT:
	$(call check,test-lstat,HAVE_LSTAT,lstat)

LSM_GET_SELF_ATTR:
	$(call check,test-lsm_get_self_attr,HAVE_LSM_GET_SELF_ATTR,lsm_get_self_attr)

LSM_LIST_MODULES:
	$(call check,test-lsm_list_modules,HAVE_LSM_LIST_MODULES,lsm_list_modules)

LOCALTIME_R:
	$(call check,test-localtime_r,HAVE_LOCALTIME_R,localtime_r)

LOCKF:
	$(call check,test-lockf,HAVE_LOCKF,lockf)

LOG:
	$(call check,test-mathfunc,HAVE_LOG,log,$(LIB_M),-DMATHFUNC=log)

LOGF:
	$(call check,test-mathfunc,HAVE_LOGF,logf,$(LIB_M),-DMATHFUNC=logf)

LOGL:
	$(call check,test-mathfunc,HAVE_LOGL,logl,$(LIB_M),-DMATHFUNC=logl)

LOGB:
	$(call check,test-mathfunc,HAVE_LOGB,logb,$(LIB_M),-DMATHFUNC=logb)

LOGBF:
	$(call check,test-mathfunc,HAVE_LOGBF,logbf,$(LIB_M),-DMATHFUNC=logbf)

LOGBL:
	$(call check,test-mathfunc,HAVE_LOGBL,logbl,$(LIB_M),-DMATHFUNC=logbl)

LOG2:
	$(call check,test-mathfunc,HAVE_LOG2,log2,$(LIB_M),-DMATHFUNC=log2)

LOG2F:
	$(call check,test-mathfunc,HAVE_LOG2F,log2f,$(LIB_M),-DMATHFUNC=log2f)

LOG2L:
	$(call check,test-mathfunc,HAVE_LOG2L,log2l,$(LIB_M),-DMATHFUNC=log2l)

LOG10:
	$(call check,test-mathfunc,HAVE_LOG10,log10,$(LIB_M),-DMATHFUNC=log10)

LOG10F:
	$(call check,test-mathfunc,HAVE_LOG10F,log10f,$(LIB_M),-DMATHFUNC=log10f)

LOG10L:
	$(call check,test-mathfunc,HAVE_LOG10L,log10l,$(LIB_M),-DMATHFUNC=log10l)


LOOKUP_DCOOKIE:
	$(call check,test-lookup-dcookie,HAVE_LOOKUP_DCOOKIE,lookup_dcookie)

LRAND48:
	$(call check,test-lrand48,HAVE_LRAND48,lrand48)

LSEARCH:
	$(call check,test-lsearch,HAVE_LSEARCH,lsearch)

LSEEK64:
	$(call check,test-lseek64,HAVE_LSEEK64,lseek64)

LSETXATTR:
	$(call check,test-lsetxattr,HAVE_LSETXATTR,lsetxattr)

MADVISE:
	$(call check,test-madvise,HAVE_MADVISE,madvise)

MALLOC_TRIM:
	$(call check,test-malloc-trim,HAVE_MALLOC_TRIM,malloc_trim)

MALLOC_USABLE_SIZE:
	$(call check,test-malloc-usable-size,HAVE_MALLOC_USABLE_SIZE,malloc_usable_size)

MALLOPT:
	$(call check,test-mallopt,HAVE_MALLOPT,mallopt)

MEMALIGN:
	$(call check,test-memalign,HAVE_MEMALIGN,memalign)

MEMBARRIER:
	$(call check,test-membarrier,HAVE_MEMBARRIER,membarrier)

MEMFD_CREATE:
	$(call check,test-memfd-create,HAVE_MEMFD_CREATE,memfd_create)

MINCORE:
	$(call check,test-mincore,HAVE_MINCORE,mincore)

MKDIRAT:
	$(call check,test-mkdirat,HAVE_MKDIRAT,mkdirat)

MKNODAT:
	$(call check,test-mknodat,HAVE_MKNODAT,mknodat)

MLOCK:
	$(call check,test-mlock,HAVE_MLOCK,mlock)

MLOCK2:
	$(call check,test-mlock2,HAVE_MLOCK2,mlock2)

MLOCKALL:
	$(call check,test-mlockall,HAVE_MLOCKALL,mlockall)

MM_STREAM_SI128:
	$(call check,test-icc-mm_stream_si128,HAVE_MM_STREAM_SI128,_mm_stream_si128)

MM_STREAM_SI64:
	$(call check,test-icc-mm_stream_si64,HAVE_MM_STREAM_SI64,_mm_stream_si64)

MM_STREAM_SI32:
	$(call check,test-icc-mm_stream_si32,HAVE_MM_STREAM_SI32,_mm_stream_si32)

MODIFY_LDT:
	$(call check,test-modify-ldt,HAVE_MODIFY_LDT,modify_ldt)

MPROTECT:
	$(call check,test-mprotect,HAVE_MPROTECT,mprotect)

MQUERY:
	$(call check,test-mquery,HAVE_MQUERY,mquery)

MREMAP:
	$(call check,test-mremap,HAVE_MREMAP,mremap)

MSEAL:
	$(call check,test-mseal,HAVE_MSEAL,mseal)

MSYNC:
	$(call check,test-msync,HAVE_MSYNC,msync)

MTX_DESTROY:
	$(call check,test-mtx-destroy,HAVE_MTX_DESTROY,mtx_destroy)

MTX_INIT:
	$(call check,test-mtx-init,HAVE_MTX_INIT,mtx_init)

MUNLOCK:
	$(call check,test-munlock,HAVE_MUNLOCK,munlock)

MUNLOCKALL:
	$(call check,test-munlockall,HAVE_MUNLOCKALL,munlockall)

NAME_TO_HANDLE_AT:
	$(call check,test-name-to-handle-at,HAVE_NAME_TO_HANDLE_AT,name_to_handle_at)

NANOSLEEP:
	$(call check,test-nanosleep,HAVE_NANOSLEEP,nanosleep)

NICE:
	$(call check,test-nice,HAVE_NICE,nice)

OPENAT:
	$(call check,test-openat,HAVE_OPENAT,openat)

OPENAT2:
	$(call check,test-openat2,HAVE_OPENAT2,openat2)

OPEN_BY_HANDLE_AT:
	$(call check,test-open-by-handle-at,HAVE_OPEN_BY_HANDLE_AT,open_by_handle_at)

OPEN_MEMSTREAM:
	$(call check,test-open_memstream,HAVE_OPEN_MEMSTREAM,open_memstream)

PIDFD_GETFD:
	$(call check,test-pidfd-getfd,HAVE_PIDFD_GETFD,pidfd_getfd)

PIDFD_OPEN:
	$(call check,test-pidfd-open,HAVE_PIDFD_OPEN,pidfd_open)

PIDFD_SEND_SIGNAL:
	$(call check,test-pidfd-send-signal,HAVE_PIDFD_SEND_SIGNAL,pidfd_send_signal)

PERSONALITY:
	$(call check,test-personality,HAVE_PERSONALITY,personality)

PIPE2:
	$(call check,test-pipe2,HAVE_PIPE2,pipe2)

PKEY_ALLOC:
	$(call check,test-pkey-alloc,HAVE_PKEY_ALLOC,pkey_alloc)

PKEY_FREE:
	$(call check,test-pkey-free,HAVE_PKEY_FREE,pkey_free)

PKEY_GET:
	$(call check,test-pkey-get,HAVE_PKEY_GET,pkey_get)

PKEY_SET:
	$(call check,test-pkey-set,HAVE_PKEY_SET,pkey_set)

PKEY_MPROTECT:
	$(call check,test-pkey-mprotect,HAVE_PKEY_MPROTECT,pkey_mprotect)

POSIX_FADVISE:
	$(call check,test-posix-fadvise,HAVE_POSIX_FADVISE,posix_fadvise)

POSIX_FALLOCATE:
	$(call check,test-posix-fallocate,HAVE_POSIX_FALLOCATE,posix_fallocate)

POSIX_MADVISE:
	$(call check,test-posix-madvise,HAVE_POSIX_MADVISE,posix_madvise)

POSIX_MEMALIGN:
	$(call check,test-posix-memalign,HAVE_POSIX_MEMALIGN,posix_memalign)

MQ_POSIX:
	$(call check,test-mq-posix,HAVE_MQ_POSIX,POSIX message queues,$(LIB_RT))

PPC_GET_TIMEBASE:
	$(call check,test-ppc-get-timebase,HAVE_PPC_GET_TIMEBASE,__ppc_get_timebase)

POSIX_OPENPT:
	$(call check,test-posix-openpt,HAVE_POSIX_OPENPT,posix_openpt)

QUOTACTL_FD:
	$(call check,test-quotactl-fd,HAVE_QUOTACTL_FD,quotactl_fd)

SEM_POSIX:
	$(call check,test-sem-posix,HAVE_SEM_POSIX,POSIX semaphores,$(LIB_PTHREAD))

POSIX_SPAWN:
	$(call check,test-posix-spawn,HAVE_POSIX_SPAWN,posix_spawn)

POW:
	$(call check,test-mathfunc,HAVE_POW,pow,$(LIB_M),-DMATHFUNC=pow)

POWF:
	$(call check,test-mathfunc,HAVE_POWF,powf,$(LIB_M),-DMATHFUNC=powf)

POWL:
	$(call check,test-mathfunc,HAVE_POWL,powl,$(LIB_M),-DMATHFUNC=powl)

PPOLL:
	$(call check,test-ppoll,HAVE_PPOLL,ppoll)

PRCTL:
	$(call check,test-prctl,HAVE_PRCTL,prctl)

PREAD:
	$(call check,test-pread,HAVE_PREAD,pread)

PREADV:
	$(call check,test-preadv,HAVE_PREADV,preadv)

PREADV2:
	$(call check,test-preadv2,HAVE_PREADV2,preadv2)

PRLIMIT:
	$(call check,test-prlimit,HAVE_PRLIMIT,prlimit)

PROCESS_VM_READV:
	$(call check,test-process-vm-readv,HAVE_PROCESS_VM_READV,process_vm_readv)

PROCESS_VM_WRITEV:
	$(call check,test-process-vm-writev,HAVE_PROCESS_VM_WRITEV,process_vm_writev)

PROGRAM_INVOCATION_NAME:
	$(call check,test-program_invocation_name,HAVE_PROGRAM_INVOCATION_NAME,program_invocation_name)

PSELECT:
	$(call check,test-pselect,HAVE_PSELECT,pselect)

PTHREAD_ATTR_SETSTACK:
	$(call check,test-pthread-attr-setstack,HAVE_PTHREAD_ATTR_SETSTACK,pthread_attr_setstack,$(LIB_PTHREAD))

PTHREAD_MUTEX_INIT:
	$(call check,test-pthread-mutex-init,HAVE_PTHREAD_MUTEX_INIT,pthread_mutex_init,$(LIB_PTHREAD))

PTHREAD_MUTEX_DESTROY:
	$(call check,test-pthread-mutex-destroy,HAVE_PTHREAD_MUTEX_DESTROY,pthread_mutex_destroy,$(LIB_PTHREAD))

PTHREAD_MUTEXATTR_DESTROY:
	$(call check,test-pthread-mutexattr-destroy,HAVE_PTHREAD_MUTEXATTR_DESTROY,pthread_mutexattr_destroy,$(LIB_PTHREAD))


PTHREAD_MUTEXATTR_INIT:
	$(call check,test-pthread-mutexattr-init,HAVE_PTHREAD_MUTEXATTR_INIT,pthread_mutexattr_init,$(LIB_PTHREAD))

PTHREAD_MUTEXATTR_SETPRIOCEILING:
	$(call check,test-pthread-mutexattr-setprioceiling,HAVE_PTHREAD_MUTEXATTR_SETPRIOCEILING,pthread_mutexattr_setprioceiling,$(LIB_PTHREAD))

PTHREAD_MUTEXATTR_SETPROTOCOL:
	$(call check,test-pthread-mutexattr-setprotocol,HAVE_PTHREAD_MUTEXATTR_SETPROTOCOL,pthread_mutexattr_setprotocol,$(LIB_PTHREAD))

PTHREAD_MUTEXATTR_SETROBUST:
	$(call check,test-pthread-mutexattr-setrobust,HAVE_PTHREAD_MUTEXATTR_SETROBUST,pthread_mutexattr_setrobust,$(LIB_PTHREAD))

PTHREAD_SETAFFINITY_NP:
	$(call check,test-pthread-setaffinity-np,HAVE_PTHREAD_SETAFFINITY_NP,pthread_setaffinity_np,$(LIB_PTHREAD))

PTHREAD_SETSCHEDPARAM:
	$(call check,test-pthread-setschedparam,HAVE_PTHREAD_SETSCHEDPARAM,pthread_setschedparam,$(LIB_PTHREAD))

PTHREAD_SIGQUEUE:
	$(call check,test-pthread_sigqueue,HAVE_PTHREAD_SIGQUEUE,pthread_sigqueue,$(LIB_PTHREAD))

PTRACE:
	$(call check,test-ptrace,HAVE_PTRACE,ptrace)

PTSNAME:
	$(call check,test-ptsname,HAVE_PTSNAME,ptsname)

PWRITE:
	$(call check,test-pwrite,HAVE_PWRITE,pwrite)

PWRITEV:
	$(call check,test-pwritev,HAVE_PWRITEV,pwritev)

PWRITEV2:
	$(call check,test-pwritev2,HAVE_PWRITEV2,pwritev2)

READLINKAT:
	$(call check,test-readlinkat,HAVE_READLINKAT,readlinkat)

RECVMMSG:
	$(call check,test-recvmmsg,HAVE_RECVMMSG,recvmmsg)

REMAP_FILE_PAGES:
	$(call check,test-remap-file-pages,HAVE_REMAP_FILE_PAGES,remap_file_pages)

REMOVEXATTR:
	$(call check,test-removexattr,HAVE_REMOVEXATTR,removexattr)

RENAMEAT:
	$(call check,test-renameat,HAVE_RENAMEAT,renameat)

RENAMEAT2:
	$(call check,test-renameat2,HAVE_RENAMEAT2,renameat2)

RFORK:
	$(call check,test-rfork,HAVE_RFORK,rfork)

RINDEX:
	$(call check,test-strfunc,HAVE_RINDEX,rindex,,-DSTRFUNC=rindex)

RINTL:
	$(call check,test-mathfunc,HAVE_RINTL,rintl,$(LIB_M),-DMATHFUNC=rintl)

SBRK:
	$(call check,test-sbrk,HAVE_SBRK,sbrk)

SCHED_GET_PRIORITY_MAX:
	$(call check,test-sched-get-priority-max,HAVE_SCHED_GET_PRIORITY_MAX,sched_get_priority_max)

SCHED_GET_PRIORITY_MIN:
	$(call check,test-sched-get-priority-min,HAVE_SCHED_GET_PRIORITY_MIN,sched_get_priority_min)

SCHED_GETAFFINITY:
	$(call check,test-sched-getaffinity,HAVE_SCHED_GETAFFINITY,sched_getaffinity)

SCHED_GETCPU:
	$(call check,test-sched-getcpu,HAVE_SCHED_GETCPU,sched_getcpu)

SCHED_RR_GET_INTERVAL:
	$(call check,test-sched-rr-get-interval,HAVE_SCHED_RR_GET_INTERVAL,sched_rr_get_interval)

SCHED_SETAFFINITY:
	$(call check,test-sched-setaffinity,HAVE_SCHED_SETAFFINITY,sched_setaffinity)

SCHED_SETSCHEDULER:
	$(call check,test-sched-setscheduler,HAVE_SCHED_SETSCHEDULER,sched_setscheduler)

SYNC_SYNCHRONIZE:
	$(call check,test-sync-synchronize,HAVE_SYNC_SYNCHRONIZE,__sync_synchronize)

SCHED_YIELD:
	$(call check,test-sched-yield,HAVE_SCHED_YIELD,sched_yield)

SELECT:
	$(call check,test-select,HAVE_SELECT,select)

SENDFILE:
	$(call check,test-sendfile,HAVE_SENDFILE,sendfile)

SENDMMSG:
	$(call check,test-sendmmsg,HAVE_SENDMMSG,sendmmsg)

SETDOMAINNAME:
	$(call check,test-setdomainname,HAVE_SETDOMAINNAME,setdomainname)

SETFSGID:
	$(call check,test-setfsgid,HAVE_SETFSGID,setfsgid)

SETFSUID:
	$(call check,test-setfsuid,HAVE_SETFSUID,setfsuid)

SETITIMER:
	$(call check,test-setitimer,HAVE_SETITIMER,setitimer)

SETMNTENT:
	$(call check,test-setmntent,HAVE_SETMNTENT,setmntent)

SETNS:
	$(call check,test-setns,HAVE_SETNS,setns)

SETPROCTITLE:
	$(call check,test-setproctitle,HAVE_SETPROCTITLE,setproctitle,$(LIB_BSD))

SETPGID:
	$(call check,test-setpgid,HAVE_SETPGID,setpgid)

SETPGRP:
	$(call check,test-setpgrp,HAVE_SETPGRP,setpgrp)

SETPRIORITY:
	$(call check,test-setpriority,HAVE_SETPRIORITY,setpriority)

SETPWENT:
	$(call check,test-setpwent,HAVE_SETPWENT,setpwent)

SETREGID:
	$(call check,test-setregid,HAVE_SETREGID,setregid)

SETRESGID:
	$(call check,test-setresgid,HAVE_SETRESGID,setresgid)

SETRESUID:
	$(call check,test-setresuid,HAVE_SETRESUID,setresuid)

SETREUID:
	$(call check,test-setreuid,HAVE_SETREUID,setreuid)

SETTIMEOFDAY:
	$(call check,test-settimeofday,HAVE_SETTIMEOFDAY,settimeofday)

SETXATTR:
	$(call check,test-setxattr,HAVE_SETXATTR,setxattr)

SIGALTSTACK:
	$(call check,test-sigaltstack,HAVE_SIGALTSTACK,sigaltstack)

SIGNALFD:
	$(call check,test-signalfd,HAVE_SIGNALFD,signalfd)

SIGQUEUE:
	$(call check,test-sigqueue,HAVE_SIGQUEUE,sigqueue)

SIGWAITINFO:
	$(call check,test-sigwaitinfo,HAVE_SIGWAITINFO,sigwaitinfo)

SINCOS:
	$(call check,test-mathfunc,HAVE_SINCOS,sincos,$(LIB_M),-DMATHFUNC=sincos)

SINCOSF:
	$(call check,test-mathfunc,HAVE_SINCOSF,sincosf,$(LIB_M),-DMATHFUNC=sincosf)

SINCOSL:
	$(call check,test-mathfunc,HAVE_SINCOSL,sincosl,$(LIB_M),-DMATHFUNC=sincosl)

SINH:
	$(call check,test-mathfunc,HAVE_SINH,sinh,$(LIB_M),-DMATHFUNC=sinh)

SINHF:
	$(call check,test-mathfunc,HAVE_SINHF,sinhf,$(LIB_M),-DMATHFUNC=sinhf)

SINHL:
	$(call check,test-mathfunc,HAVE_SINHL,sinhl,$(LIB_M),-DMATHFUNC=sinhl)

SINL:
	$(call check,test-mathfunc,HAVE_SINL,sinl,$(LIB_M),-DMATHFUNC=sin)

SPLICE:
	$(call check,test-splice,HAVE_SPLICE,splice)

SQRT:
	$(call check,test-mathfunc,HAVE_SQRT,sqrt,$(LIB_M),-DMATHFUNC=sqrt)

SQRTF:
	$(call check,test-mathfunc,HAVE_SQRTF,sqrtf,$(LIB_M),-DMATHFUNC=sqrtf)

SQRTL:
	$(call check,test-mathfunc,HAVE_SQRTL,sqrtl,$(LIB_M),-DMATHFUNC=sqrtl)

SRAND48:
	$(call check,test-srand48,HAVE_SRAND48,srand48)

STAT:
	$(call check,test-stat,HAVE_STAT,stat)

STATFS:
	$(call check,test-statfs,HAVE_STATFS,statfs)

STATX:
	$(call check,test-statx,HAVE_STATX,statx)

STIME:
	$(call check,test-stime,HAVE_STIME,stime)

SYMLINKAT:
	$(call check,test-symlinkat,HAVE_SYMLINKAT,symlinkat)

BSD_STRLCAT:
	$(call check,test-strfunc,HAVE_BSD_STRLCAT,strlcat,$(LIB_BSD),-DSTRFUNC=strlcat)

BSD_STRLCPY:
	$(call check,test-strfunc,HAVE_BSD_STRLCPY,strlcpy,$(LIB_BSD),-DSTRFUNC=strlcpy)

SWAPCONTEXT:
	$(call check,test-swapcontext,HAVE_SWAPCONTEXT,swapcontext)

SWAP:
	$(call check,test-swap,HAVE_SWAP,swapon)

SYNC_FILE_RANGE:
	$(call check,test-sync-file-range,HAVE_SYNC_FILE_RANGE,sync_file_range)

SYNC_BOOL_COMPARE_AND_SWAP:
	$(call check,test-sync-bool-compare-and-swap,HAVE_SYNC_BOOL_COMPARE_AND_SWAP,sync_bool_compare_and_swap)

SYNCFS:
	$(call check,test-syncfs,HAVE_SYNCFS,syncfs)

SYSCALL:
	$(call check,test-syscall,HAVE_SYSCALL,syscall)

SYSINFO:
	$(call check,test-sysinfo,HAVE_SYSINFO,sysinfo)

MQ_SYSV:
	$(call check,test-mq-sysv,HAVE_MQ_SYSV,SYSV message queues)

SEM_SYSV:
	$(call check,test-sem-sysv,HAVE_SEM_SYSV,SYSV semaphores)

SEMTIMEDOP:
	$(call check,test-semtimedop,HAVE_SEMTIMEDOP,semtimedop)

SHM_SYSV:
	$(call check,test-shm-sysv,HAVE_SHM_SYSV,SYSV shm)

TCDRAIN:
	$(call check,test-tcdrain,HAVE_TCDRAIN,tcdrain)

TCFLOW:
	$(call check,test-tcflow,HAVE_TCFLOW,tcflow)

TCFLUSH:
	$(call check,test-tcflush,HAVE_TCFLUSH,tcflush)

TCGETATTR:
	$(call check,test-tcgetattr,HAVE_TCGETATTR,tcgetattr)

TEE:
	$(call check,test-tee,HAVE_TEE,tee)

TGKILL_LIBC:
	$(call check,test-tgkill,HAVE_TGKILL_LIBC,tgkill)

TIME:
	$(call check,test-time,HAVE_TIME,time)

TIMER_CREATE:
	$(call check,test-timer-create,HAVE_TIMER_CREATE,timer_create,$(LIB_RT))

TIMER_DELETE:
	$(call check,test-timer-delete,HAVE_TIMER_DELETE,timer_delete,$(LIB_RT))

TIMER_GETTIME:
	$(call check,test-timer-gettime,HAVE_TIMER_GETTIME,timer_gettime,$(LIB_RT))

TIMER_GETOVERRUN:
	$(call check,test-timer-getoverrun,HAVE_TIMER_GETOVERRUN,timer_getoverrrun,$(LIB_RT))

TIMER_SETTIME:
	$(call check,test-timer-settime,HAVE_TIMER_SETTIME,timer_settime,$(LIB_RT))

TIMERFD_CREATE:
	$(call check,test-timerfd-create,HAVE_TIMERFD_CREATE,timerfd_create)

TIMERFD_GETTIME:
	$(call check,test-timerfd-gettime,HAVE_TIMERFD_GETTIME,timerfd_gettime)

TIMERFD_SETTIME:
	$(call check,test-timerfd-settime,HAVE_TIMERFD_SETTIME,timerfd_settime)

TSEARCH:
	$(call check,test-tsearch,HAVE_TSEARCH,tsearch)

TTYNAME:
	$(call check,test-ttyname,HAVE_TTYNAME,ttyname)

UMOUNT2:
	$(call check,test-umount2,HAVE_UMOUNT2,umount2)

UNAME:
	$(call check,test-uname,HAVE_UNAME,uname)

UNLINKAT:
	$(call check,test-unlinkat,HAVE_UNLINKAT,unlinkat)

UNSHARE:
	$(call check,test-unshare,HAVE_UNSHARE,unshare)

USTAT:
	$(call check,test-ustat,HAVE_USTAT,ustat)

UTIME:
	$(call check,test-utime,HAVE_UTIME,utime)

UTIMENSAT:
	$(call check,test-utimensat,HAVE_UTIMENSAT,utimensat)

VALLOC:
	$(call check,test-valloc,HAVE_VALLOC,valloc)

VFORK:
	$(call check,test-vfork,HAVE_VFORK,vfork)

VHANGUP:
	$(call check,test-vhangup,HAVE_VHANGUP,vhangup)

VMSPLICE:
	$(call check,test-vmsplice,HAVE_VMSPLICE,vmsplice)

WAITID:
	$(call check,test-waitid,HAVE_WAITID,waitid)

WAITPID:
	$(call check,test-waitpid,HAVE_WAITPID,waitpid)

WAIT3:
	$(call check,test-wait3,HAVE_WAIT3,wait3)

WAIT4:
	$(call check,test-wait4,HAVE_WAIT4,wait4)

WCSCASECMP:
	$(call check,test-wcsfunc,HAVE_WCSCASECMP,wcscasecmp,$(LIB_BSD),-DWCSFUNC=wcscasecmp)

WCSCAT:
	$(call check,test-wcsfunc,HAVE_WCSCAT,wcscat,$(LIB_BSD),-DWCSFUNC=wcscat)

WCSCHR:
	$(call check,test-wcsfunc,HAVE_WCSCHR,wcschr,$(LIB_BSD),-DWCSFUNC=wcschr)

WCSCMP:
	$(call check,test-wcsfunc,HAVE_WCSCMP,wcscmp,$(LIB_BSD),-DWCSFUNC=wcscmp)

WCSCOLL:
	$(call check,test-wcsfunc,HAVE_WCSCOLL,wcscoll,$(LIB_BSD),-DWCSFUNC=wcscoll)

WCSCPY:
	$(call check,test-wcsfunc,HAVE_WCSCPY,wcscpy,$(LIB_BSD),-DWCSFUNC=wcscpy)

WCSLCAT:
	$(call check,test-wcsfunc,HAVE_WCSLCAT,wcslcat,$(LIB_BSD),-DWCSFUNC=wcslcat)

WCSLCPY:
	$(call check,test-wcsfunc,HAVE_WCSLCPY,wcslcpy,$(LIB_BSD),-DWCSFUNC=wcslcpy)

WCSLEN:
	$(call check,test-wcsfunc,HAVE_WCSLEN,wcslen,$(LIB_BSD),-DWCSFUNC=wcslen)

WCSNCASECMP:
	$(call check,test-wcsfunc,HAVE_WCSNCASECMP,wcsncasecmp,$(LIB_BSD),-DWCSFUNC=wcsncasecmp)

WCSNCAT:
	$(call check,test-wcsfunc,HAVE_WCSNCAT,wcsncat,$(LIB_BSD),-DWCSFUNC=wcsncat)

WCSNCMP:
	$(call check,test-wcsfunc,HAVE_WCSNCMP,wcsncmp,$(LIB_BSD),-DWCSFUNC=wcsncmp)

WCSRCHR:
	$(call check,test-wcsfunc,HAVE_WCSRCHR,wcsrchr,$(LIB_BSD),-DWCSFUNC=wcsrchr)

WCSXFRM:
	$(call check,test-wcsfunc,HAVE_WCSXFRM,wcsxfrm,$(LIB_BSD),-DWCSFUNC=wcsxfrm)

Y0:
	$(call check,test-mathfunc,HAVE_Y0,y0,$(LIB_M),-DMATHFUNC=y0)

Y1:
	$(call check,test-mathfunc,HAVE_Y1,y1,$(LIB_M),-DMATHFUNC=y1)

YN:
	$(call check,test-mathfunc,HAVE_YN,yn,$(LIB_M),-DMATHFUNC=yn)

Y0F:
	$(call check,test-mathfunc,HAVE_Y0F,y0f,$(LIB_M),-DMATHFUNC=y0f)

Y1F:
	$(call check,test-mathfunc,HAVE_Y1F,y1f,$(LIB_M),-DMATHFUNC=y1f)

YNF:
	$(call check,test-mathfunc,HAVE_YNF,ynf,$(LIB_M),-DMATHFUNC=ynf)

Y0L:
	$(call check,test-mathfunc,HAVE_Y0L,y0l,$(LIB_M),-DMATHFUNC=y0l)

Y1L:
	$(call check,test-mathfunc,HAVE_Y1L,y1l,$(LIB_M),-DMATHFUNC=y1l)

YNL:
	$(call check,test-mathfunc,HAVE_YNL,ynl,$(LIB_M),-DMATHFUNC=ynl)