Makefile.config

#
# Copyright (C) 2013-2021 Canonical, Ltd.
# Copyright (C) 2021-2023 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.

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

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 += -lsocket -lnsl
endif
#
#  This must always come after -pthread so that static linking works
#
ifeq ($(shell uname -s),Haiku)
	CONFIG_LDFLAGS += -lnetwork
else
	CONFIG_LDFLAGS += -lc
endif

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 -lm 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

all: libraries headers cpufeatures types 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
	@echo CONFIG_LDFLAGS += $(CONFIG_LDFLAGS) > $(CONFIGS)/HAVE_LDFLAGS_TMP
	@cat $(CONFIGS)/* | grep -v "#" | sed '/^$$/d' | sort | uniq > config
	@rm -f $(CONFIGS)/HAVE_LDFLAGS_TMP

configdir:
	@mkdir -p $(CONFIGS)

#.NOTPARALLEL:

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

.PHONY: libraries
libraries: \
	configdir \
	LIB_AIO LIB_APPARMOR LIB_BSD LIB_CRYPT LIB_DL \
	LIB_EGL LIB_GBM LIB_GLES2 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_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:
	$(call check,test-libbsd,HAVE_LIB_BSD,$(LIB_BSD),$(LIB_BSD))

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_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_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: \
	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 \
	COMPLEX_H WCHAR CRYPT_H EGL_H EGL_EXT_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_BINDER_H LINUX_ANDROID_BINDERFS_H \
	LINUX_AUDIT_H LINUX_BLKZONED_H LINUX_CDROM_H LINUX_CN_PROC_H \
	LINUX_CONNECTOR_H LINUX_DM_IOCTL_H LINUX_FD_H LINUX_FIEMAP_H \
	LINUX_FILTER_H LINUX_FSVERITY_H LINUX_FUTEX_H LINUX_FS_H \
	LINUX_GENETLINK_H LINUX_HDREG_H LINUX_HIDRAW_H LINUX_HPET_H LINUX_IF_ALG_H \
	LINUX_IF_PACKET_H LINUX_IF_TUN_H LINUX_IO_URING_H LINUX_KD_H \
	LINUX_KVM_H LINUX_LANDLOCK_H LINUX_LIRC_H LINUX_LOOP_H LINUX_MAGIC_H LINUX_MEDIA_H \
	LINUX_MEMBARRIER_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_UNIX_DIAG_H LINUX_USBDEVICE_FS_H \
	LINUX_USB_CDC_WDM_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 POLL_H PTHREAD_NP_H \
	SCSI_SCSI_H SCSI_SCSI_IOCTL_H SCSI_SG_H SEARCH_H SEMAPHORE_H \
	STRINGS_H SOUND_ASOUND_H SPAWN_H SYSLOG_H SYS_APPARMOR_H SYS_AUXV_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 SYS_MOUNT_H SYS_MSG_H \
	SYS_PARAM_H SYS_PERSONALITY_H SYS_PIDFD_H SYS_PLATFORM_PPC_H SYS_PRCTL_H \
	SYS_RANDOM_H SYS_SYSCTL_H SYS_TREE_H SYS_QUEUE_H SYS_QUOTA_H \
	SYS_SELECT_H SYS_SENDFILE_H SYS_SHM_H SYS_SIGNALFD_H SYS_STATFS_H \
	SYS_STATVFS_H SYS_SWAP_H SYSCALL_H SYS_SYSINFO_H SYS_SYSMACROS_H \
	SYS_TIMERFD_H SYS_TIMEX_H SYS_UIO_H SYS_UCRED_H SYS_UN_H SYS_UTSNAME_H \
	SYS_VFS_H SYS_VMMETER_H SYS_XATTR_H TERMIO_H TERMIOS_H NET_IF_H \
	NETINET_IP_H NETINET_IP_ICMP_H NETINET_SCTP_H NETINET_TCP_H UCONTEXT_H \
	USTAT_H UTIME_H UVM_UVM_EXTERN_H X86INTRIN_H XMMINTRIN_H XXHASH_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:
	$(call check_header,bsd/wchar.h,HAVE_BSD_WCHAR)

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

WCHAR:
	$(call check_header,wchar.h,HAVE_WCHAR)

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_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_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_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_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_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_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_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_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_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)

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)

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_64 ALIGNED_128 ALIGNED_64K ATTRIBUTE_ALWAYS_INLINE \
	ATTRIBUTE_FAST_MATH ATTRIBUTE_HOT ATTRIBUTE_NOINLINE \
	ATTRIBUTE_NORETURN ATTRIBUTE_PURE ATTRIBUTE_WARN_UNUSED_RESULT \
	ATTRIBUTE_WEAK \
	ASM_ALPHA_DRAINA ASM_ALPHA_HALT ASM_ARM_YIELD ASM_ARM_TLBI \
	ASM_HPPA_DIAG ASM_HPPA_RFI ASM_M68K_EORI_SR ASM_MB ASM_MIPS_WAIT \
	ASM_NOP ASM_S390_PTLB ASM_SH4_RTE ASM_SH4_SLEEP ASM_SPARC_MEMBAR \
	ASM_SPARC_RDPR ASM_SPARC_TICK 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_X86_CLDEMOTE ASM_X86_CLFLUSH ASM_X86_CLFLUSHOPT ASM_X86_CLWB \
	ASM_X86_CLTS 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_PREFETCHT0 ASM_X86_PREFETCHT1 \
	ASM_X86_PREFETCHT2 ASM_X86_PREFETCHNTA ASM_X86_RDMSR ASM_X86_RDPMC \
	ASM_X86_RDRAND ASM_X86_RDSEED ASM_X86_REP_STOSB ASM_X86_REP_STOSW \
	ASM_X86_REP_STOSD ASM_X86_REP_STOSQ ASM_X86_SERIALIZE ASM_X86_SFENCE \
	ASM_X86_TPAUSE ASM_X86_WBINVD ASM_X86_WRMSR ASM_NOTHING \
	MM_ADD_EPI8 MM_DPBUSD_EPI32 MM_DPWSSD_EPI32 MM_LOADU_SI128 MM_STOREU_SI128 \
	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 \
	PRAGMA PRAGMA_INSIDE PRAGMA_NO_HARD_DFP RESTRICT LABEL_AS_VALUE \
	TARGET_CLONES TARGET_CLONES_MMX \
	TARGET_CLONES_AVX TARGET_CLONES_AVX2 TARGET_CLONES_SSE \
	TARGET_CLONES_SSE2 TARGET_CLONES_SSE3 TARGET_CLONES_SSSE3 \
	TARGET_CLONES_SSE4_1 TARGET_CLONES_SSE4_2 TARGET_CLONES_SKYLAKE_AVX512 \
	TARGET_CLONES_COOPERLAKE TARGET_CLONES_TIGERLAKE TARGET_CLONES_SAPPHIRERAPIDS \
	TARGET_CLONES_ALDERLAKE TARGET_CLONES_ROCKETLAKE TARGET_CLONES_GRANITERAPIDS \
	TARGET_CLONES_POWER9 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_HOT:
	$(call check,test-attr-hot,HAVE_ATTRIBUTE_HOT,__attribute__((hot)))

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_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_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_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_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,-lm,-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_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_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 \
	COMPLEX DATTR_T DVD_AUTHINFO DVD_STRUCT DECIMAL32 DECIMAL64 \
	DECIMAL128 FLOAT16 FLOAT32 FLOAT64 FLOAT80 FLOAT128 ITIMER_WHICH_T \
	INO64_T INT128_T KERNEL_LONG_T KERNEL_ULONG_T KEY_T LANDLOCK_RULE_TYPE \
	LOFF_T MODE_T OFF_T OFF64_T PID_TYPE PRIORITY_WHICH_T PTHREAD_MUTEX_T \
	PTHREAD_MUTEXATTR_T PTRACE_REQUEST RLIMIT_RESOURCE_T RUSAGE_WHO CDROM_BLK \
	CDROM_MCN CDROM_MSF CDROM_READ_AUDIO CDROM_SUBCHNL CDROM_TI CDROM_TOCENTRY \
	CDROM_TOCHDR CDROM_VOLCTRL CONSOLEFONTDESC DM_IOCTL FLOPPY_FDC_STATE \
	FLOPPY_DRIVE_STRUCT FLOPPY_STRUCT FLOPPY_WRITE_ERRORS FSVERITY_DIGEST \
	FSVERITY_ENABLE_ARG FSXATTR_STRUCT IFCONF IFREQ ICMPHDR IPHDR KBDIACRS KBENTRY \
	KBKEYCODE KBSENTRY LANDLOCK_RULESET_ATTR MEDIA_DEVICE_INFO MSGINFO \
	MTRR_GENTRY MTRR_SENTRY OPEN_HOW RTC_PARAM RUSAGE_RU_MAXRSS \
	RUSAGE_RU_MINFLT RUSAGE_RU_NVCSW SCTP_ASSOCIATION SCTP_ASSOC_STATS \
	SCTP_ASSOC_VALUE SCTP_ASSOCPARAMS SCTP_DEFAULT_PRINFO SCTP_EVENT_SUBSCRIBE \
	SCTP_INITMSG SCTP_GETADDRS SCTP_PADDRPARAMS SCTP_PADDRINFO 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 VT_CONSIZE VT_MODE VT_SIZES VT_STAT V4L2_AUDIO \
	V4L2_AUDIOOUT V4L2_CAPABILITY V4L2_DV_TIMINGS V4L2_ENC_IDX \
	V4L2_FRAMEBUFFER V4L2_JPEGCOMPRESSION V4L2_STD_ID V2DI 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)

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)

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)

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)

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: functions
functions: \
	configdir \
	ACCEPT4 ADJTIME ADJTIMEX AIO_CANCEL AIO_FSYNC AIO_READ \
	AIO_WRITE ALIGNED_ALLOC 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_BITREVERSE BUILTIN_BSWAP32 \
	BUILTIN_CABSL BUILTIN_CEXP BUILTIN_CCOS BUILTIN_CCOSF BUILTIN_CCOSL \
	BUILTIN_CLZ BUILTIN_CLZL BUILTIN_CLZLL BUILTIN_CONSTANT_P BUILTIN_COS \
	BUILTIN_COSF BUILTIN_COSHL BUILTIN_COSL BUILTIN_CPOW \
	BUILTIN_CPU_IS_POWER9 BUILTIN_CSIN BUILTIN_CSINF BUILTIN_CSINL \
	BUILTIN_CTZ BUILTIN_EXP BUILTIN_EXPECT BUILTIN_EXPL BUILTIN_FABS \
	BUILTIN_FABSF BUILTIN_FABSL BUILTIN_IA32_MOVNTDQ BUILTIN_IA32_MOVNTI \
	BUILTIN_IA32_MOVNTI64 BUILTIN_LGAMMAL BUILTIN_LLABS BUILTIN_LOG BUILTIN_LOGL \
	BUILTIN_MEMCPY BUILTIN_MEMCMP BUILTIN_MEMMOVE BUILTIN_MEMSET BUILTIN_NONTEMPORAL_LOAD \
	BUILTIN_NONTEMPORAL_STORE BUILTIN_PARITY BUILTIN_POPCOUNT BUILTIN_POPCOUNTL \
	BUILTIN_POPCOUNTLL BUILTIN_POW BUILTIN_PREFETCH BUILTIN_RINT \
	BUILTIN_RINTL BUILTIN_ROTATELEFT8 BUILTIN_ROTATELEFT16 BUILTIN_ROTATELEFT32 \
	BUILTIN_ROTATELEFT64 BUILTIN_ROTATERIGHT8 BUILTIN_ROTATERIGHT16 BUILTIN_ROTATERIGHT32 \
	BUILTIN_ROTATERIGHT64 BUILTIN_ROUNDL BUILTIN_SFENCE BUILTIN_SHUFFLE BUILTIN_SIN \
	BUILTIN_SINF BUILTIN_SINHL BUILTIN_SINL BUILTIN_SINCOS BUILTIN_SINCOSF \
	BUILTIN_SINCOSL BUILTIN_SQRT BUILTIN_SQRTL BUILTIN_SUPPORTS BUILTIN___CLEAR_CACHE \
	BUILTIN_TAN BUILTIN_TANF BUILTIN_TANL \
	INTRINSIC_ROLB INTRINSIC_ROLD INTRINSIC_ROLW INTRINSIC_ROLQ \
	INTRINSIC_RORB INTRINSIC_RORD INTRINSIC_RORW INTRINSIC_RORQ \
	CABSL CACHEFLUSH CCOS CCOSF CCOSL CHROOT CIMAG CIMAGF CIMAGL CLEARENV CLOCK_ADJTIME \
	CLOCK_GETRES CLOCK_GETTIME CLOCK_NANOSLEEP CLOCK_SETTIME CLONE COPY_FILE_RANGE \
	COSHL COSL CPOW CREAL CREALF CREALL CRYPT_R CSIN CSINF CSINL DUP3 DRAND48 DELETE_MODULE \
	EIGEN ENDMNTENT ENDPWENT EPOLL_CREATE \
	EPOLL_CREATE1 EVENTFD EXECUTABLE_START EXECVEAT EXPL FACCESSAT \
	FACCESSAT2 FALLOCATE FANOTIFY FCHMODAT FCHMODAT2 FCHOWNAT FDATASYNC \
	FGETXATTR FINIT_MODULE FLISTXATTR FLOCK FREMOVEXATTR FSETXATTR FSTATAT FSTAT \
	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 GETXATTR HSEARCH INOTIFY INOTIFY1 IOPL \
	IOPORT LGAMMAL LGETXATTR LINKAT LISTXATTR LLISTXATTR LSTAT LOCKF LOGL \
	LOOKUP_DCOOKIE LRAND48 LREMOVEXATTR LSEARCH LSEEK64 LSETXATTR \
	MADVISE MALLOC_TRIM MALLOPT MEMALIGN MEMBARRIER MEMFD_CREATE MINCORE MKDIRAT \
	MKNODAT MLOCK MLOCK2 MLOCKALL MM_STREAM_SI128 MM_STREAM_SI64 MM_STREAM_SI32 \
	MODIFY_LDT MPROTECT MQUERY MQ_POSIX MQ_SYSV MREMAP MSYNC 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 POWL PPC_GET_TIMEBASE \
	PPOLL PRCTL PREAD PREADV PREADV2 PRLIMIT PROCESS_VM_READV \
	PROCESS_VM_WRITEV PSELECT PTHREAD_ATTR_SETSTACK \
	PTHREAD_MUTEX_INIT PTHREAD_MUTEX_DESTROY PTHREAD_MUTEXATTR_DESTROY \
	PTHREAD_MUTEXATTR_INIT PTHREAD_MUTEXATTR_SETPRIOCEILING \
	PTHREAD_MUTEXATTR_SETPROTOCOL PTHREAD_SETAFFINITY_NP \
	PTHREAD_SETSCHEDPARAM PTHREAD_SIGQUEUE PTRACE PTSNAME PWRITE PWRITEV \
	PWRITEV2 QUOTACTL_FD READLINKAT RECVMMSG REMAP_FILE_PAGES \
	REMOVEXATTR RENAMEAT RENAMEAT2 RFORK RINTL SBRK SCHED_GETAFFINITY \
	SCHED_GETCPU SCHED_GET_PRIORITY_MAX SCHED_GET_PRIORITY_MIN \
	SCHED_RR_GET_INTERVAL SCHED_SETSCHEDULER SCHED_SETAFFINITY SCHED_YIELD \
	SELECT SEMTIMEDOP SEM_POSIX SEM_SYSV SENDFILE SENDMMSG SETDOMAINNAME SETFSGID \
	SETFSUID SETITIMER SETNS SETMNTENT SETPGID SETPGRP SETPRIORITY SETPROCTITLE \
	SETPWENT SETREGID SETRESGID SETRESUID SETREUID SETTIMEOFDAY \
	SETXATTR SHM_SYSV SIGALTSTACK SIGNALFD SIGQUEUE SIGWAITINFO SINCOS SINCOSF SINCOSL \
	SINHL SINL SPLICE SQRTL SRAND48 STATFS STAT STATX STIME SYMLINKAT SWAP SWAPCONTEXT \
	SYNCFS SYNC_BOOL_COMPARE_AND_SWAP SYNC_FILE_RANGE SYNC_SYNCHRONIZE \
	SYSINFO SYSCALL TCDRAIN TCFLOW TCFLUSH TCGETATTR TEE TGKILL_LIBC \
	TIMERFD_CREATE TIMERFD_GETTIME TIMERFD_SETTIME TIMER_CREATE \
	TIMER_DELETE TIMER_GETOVERRUN TIMER_GETTIME TIMER_SETTIME \
	TSEARCH TTYNAME UMOUNT2 UNAME UNLINKAT UNSHARE USTAT UTIME UTIMENSAT \
	VFORK VALLOC VHANGUP VMSPLICE WAIT3 WAIT4 WAITID WAITPID WCSCASECMP WCSCAT WCSCHR \
	WCSCMP WCSCOLL WCSCPY WCSLCAT WCSLCPY WCSLEN WCSNCASECMP WCSNCAT \
	WCSNCMP WCSRCHR WCSXFRM

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)

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_BITREVERSE:
	$(call check,test-builtin-bitreverse,HAVE_BUILTIN_BITREVERSE,__builtin_bitreverse)

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

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

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

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

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

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

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,-lm,-DMATHFUNC=__builtin_cos)

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

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

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

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

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

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

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

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,-lm,-DMATHFUNC=__builtin_exp)

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

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

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_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_LGAMMAL:
	$(call check,test-mathfunc,HAVE_BUILTIN_LGAMMAL,__builtin_lgammal,-lm,-DMATHFUNC=__builtin_lgammal)

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

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

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

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,-lm,-DMATHFUNC=__builtin_pow)

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,-lm,-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,-lm,-DMATHFUNC=__builtin_sin)

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

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

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

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

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

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

BUILTIN_SQRT:
	$(call check,test-builtin-sqrt,HAVE_BUILTIN_SQRT,__builtin_sqrt,-lm)

BUILTIN_SQRTL:
	$(call check,test-builtin-sqrtl,HAVE_BUILTIN_SQRTL,__builtin_sqrtl,-lm)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

CIMAGL:
	$(call check,test-mathfunc,HAVE_CIMAGL,cimagl,-lm,-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)

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

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

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

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

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

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

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

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

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

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

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

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)

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

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)

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)

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

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

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)

LGAMMAL:
	$(call check,test-mathfunc,HAVE_LGAMMAL,lgammal,-lm,-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)

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

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

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)

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)

MSYNC:
	$(call check,test-msync,HAVE_MSYNC,msync)

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)

POWL:
	$(call check,test-mathfunc,HAVE_POWL,powl,-lm,-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)

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_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)

RINTL:
	$(call check,test-mathfunc,HAVE_RINTL,rintl,-lm,-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,-lm,-DMATHFUNC=sincos)

SINCOSF:
	$(call check,test-mathfunc,HAVE_SINCOSF,sincosf,-lm,-DMATHFUNC=sincosf)

SINCOSL:
	$(call check,test-mathfunc,HAVE_SINCOSL,sincosl,-lm,-DMATHFUNC=sincosl)

SINHL:
	$(call check,test-mathfunc,HAVE_SINHL,sinhl,-lm,-DMATHFUNC=sinhl)

SINL:
	$(call check,test-mathfunc,HAVE_SINL,sinl,-lm,-DMATHFUNC=sin)

SPLICE:
	$(call check,test-splice,HAVE_SPLICE,splice)

SQRTL:
	$(call check,test-mathfunc,HAVE_SQRTL,sqrtl,-lm,-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)

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)