Index: libcfa/prelude/Makefile.am
===================================================================
--- libcfa/prelude/Makefile.am (revision bf71cfdb7285490eee552b461158846f626cc52f)
+++ libcfa/prelude/Makefile.am (revision bf71cfdb7285490eee552b461158846f626cc52f)
@@ -0,0 +1,69 @@
+######################## -*- Mode: Makefile-Automake -*- ######################
+##
+## Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+##
+## The contents of this file are covered under the licence agreement in the
+## file "LICENCE" distributed with Cforall.
+##
+## Makefile.am --
+##
+## Author : Peter A. Buhr
+## Created On : Sun May 31 08:54:01 2015
+## Last Modified By : Peter A. Buhr
+## Last Modified On : Wed Dec 14 15:00:35 2016
+## Update Count : 205
+###############################################################################
+
+# create object files in directory with source files
+AUTOMAKE_OPTIONS = subdir-objects
+
+# put into lib for now
+cfalibdir = ${CFA_LIBDIR}
+cfalib_DATA = gcc-builtins.cf builtins.cf extras.cf prelude.cf bootloader.c
+noinst_DATA = ../src/libcfa-prelude.c
+
+CC = @CFACC@
+
+$(DEPDIR) :
+ mkdir $(DEPDIR)
+
+$(DEPDIR)/builtins.Po : $(DEPDIR)
+ touch ${@}
+
+# create extra forward types/declarations to reduce inclusion of library files
+extras.cf : ${srcdir}/extras.regx ${srcdir}/extras.c
+ ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -E ${srcdir}/extras.c | grep -f ${srcdir}/extras.regx > extras.cf
+
+# create forward declarations for gcc builtins
+gcc-builtins.cf : gcc-builtins.c ${srcdir}/prototypes.sed
+ ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -I${srcdir} -E -P $< | sed -r -f ${srcdir}/prototypes.sed > $@
+
+gcc-builtins.c : ${srcdir}/builtins.def ${srcdir}/prototypes.awk ${srcdir}/sync-builtins.cf ${srcdir}/prototypes.c
+ ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -I${srcdir} -E ${srcdir}/prototypes.c | awk -f ${srcdir}/prototypes.awk > $@
+
+prelude.cf : prelude-gen.cc
+ ${AM_V_GEN}${CXX} ${AM_CXXFLAGS} ${CXXFLAGS} ${<} -o prelude-gen -Wall -Wextra -O2 -g -std=c++14
+ @./prelude-gen > $@
+ @rm ./prelude-gen
+
+builtins.def :
+
+prototypes.awk :
+
+# create forward declarations for cfa builtins
+builtins.cf : builtins.c ${CC}
+ ${AM_V_GEN}${CC} -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po
+ ${AM_V_at}sed -i 's/builtins.o/builtins.cf/g' $(DEPDIR)/builtins.Po
+
+include $(DEPDIR)/builtins.Po
+
+../src/libcfa-prelude.c : prelude.cf extras.cf gcc-builtins.cf builtins.cf @CFACPP@
+ ${AM_V_GEN}@CFACPP@ -l prelude.cf $@ # use src/cfa-cpp as not in lib until after install
+
+bootloader.c : ${srcdir}/bootloader.cf prelude.cf extras.cf gcc-builtins.cf builtins.cf @CFACPP@
+ ${AM_V_GEN}@CFACPP@ -tpm ${srcdir}/bootloader.cf $@ # use src/cfa-cpp as not in lib until after install
+
+maintainer-clean-local :
+ rm -rf $(DEPDIR)
+
+MAINTAINERCLEANFILES = gcc-builtins.c gcc-builtins.cf builtins.cf extras.cf bootloader.c prelude.cf ${addprefix ${libdir}/,${cfalib_DATA}} ${addprefix ${libdir}/,${lib_LIBRARIES}}
Index: libcfa/prelude/Makefile.in
===================================================================
--- libcfa/prelude/Makefile.in (revision bf71cfdb7285490eee552b461158846f626cc52f)
+++ libcfa/prelude/Makefile.in (revision bf71cfdb7285490eee552b461158846f626cc52f)
@@ -0,0 +1,544 @@
+# Makefile.in generated by automake 1.15 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2014 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+######################## -*- Mode: Makefile-Automake -*- ######################
+###############################################################################
+
+VPATH = @srcdir@
+am__is_gnu_make = { \
+ if test -z '$(MAKELEVEL)'; then \
+ false; \
+ elif test -n '$(MAKE_HOST)'; then \
+ true; \
+ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
+ true; \
+ else \
+ false; \
+ fi; \
+}
+am__make_running_with_option = \
+ case $${target_option-} in \
+ ?) ;; \
+ *) echo "am__make_running_with_option: internal error: invalid" \
+ "target option '$${target_option-}' specified" >&2; \
+ exit 1;; \
+ esac; \
+ has_opt=no; \
+ sane_makeflags=$$MAKEFLAGS; \
+ if $(am__is_gnu_make); then \
+ sane_makeflags=$$MFLAGS; \
+ else \
+ case $$MAKEFLAGS in \
+ *\\[\ \ ]*) \
+ bs=\\; \
+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
+ esac; \
+ fi; \
+ skip_next=no; \
+ strip_trailopt () \
+ { \
+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
+ }; \
+ for flg in $$sane_makeflags; do \
+ test $$skip_next = yes && { skip_next=no; continue; }; \
+ case $$flg in \
+ *=*|--*) continue;; \
+ -*I) strip_trailopt 'I'; skip_next=yes;; \
+ -*I?*) strip_trailopt 'I';; \
+ -*O) strip_trailopt 'O'; skip_next=yes;; \
+ -*O?*) strip_trailopt 'O';; \
+ -*l) strip_trailopt 'l'; skip_next=yes;; \
+ -*l?*) strip_trailopt 'l';; \
+ -[dEDm]) skip_next=yes;; \
+ -[JT]) skip_next=yes;; \
+ esac; \
+ case $$flg in \
+ *$$target_option*) has_opt=yes; break;; \
+ esac; \
+ done; \
+ test $$has_opt = yes
+am__make_dryrun = (target_option=n; $(am__make_running_with_option))
+am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = libcfa/prelude
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+ $(ACLOCAL_M4)
+DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+AM_V_P = $(am__v_P_@AM_V@)
+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
+am__v_P_0 = false
+am__v_P_1 = :
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo " GEN " $@;
+am__v_GEN_1 =
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+am__v_at_1 =
+SOURCES =
+DIST_SOURCES =
+am__can_run_installinfo = \
+ case $$AM_UPDATE_INFO_DIR in \
+ n|no|NO) false;; \
+ *) (install-info --version) >/dev/null 2>&1;; \
+ esac
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+ *) f=$$p;; \
+ esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+ for p in $$list; do echo "$$p $$p"; done | \
+ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+ if (++n[$$2] == $(am__install_max)) \
+ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+ END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+ test -z "$$files" \
+ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+ $(am__cd) "$$dir" && rm -f $$files; }; \
+ }
+am__installdirs = "$(DESTDIR)$(cfalibdir)"
+DATA = $(cfalib_DATA) $(noinst_DATA)
+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+am__DIST_COMMON = $(srcdir)/Makefile.in
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+ALLOCA = @ALLOCA@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+BACKEND_CC = @BACKEND_CC@
+BUILD_IN_TREE_FLAGS = @BUILD_IN_TREE_FLAGS@
+BUILD_IN_TREE_FLAGS_NOLIB = @BUILD_IN_TREE_FLAGS_NOLIB@
+CC = @CFACC@
+CCAS = @CCAS@
+CCASDEPMODE = @CCASDEPMODE@
+CCASFLAGS = @CCASFLAGS@
+CCDEPMODE = @CCDEPMODE@
+CFACC = @CFACC@
+CFACPP = @CFACPP@
+CFA_BACKEND_CC = @CFA_BACKEND_CC@
+CFA_BINDIR = @CFA_BINDIR@
+CFA_FLAGS = @CFA_FLAGS@
+CFA_INCDIR = @CFA_INCDIR@
+CFA_LIBDIR = @CFA_LIBDIR@
+CFA_NAME = @CFA_NAME@
+CFA_PREFIX = @CFA_PREFIX@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DRIVER_DIR = @DRIVER_DIR@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LDFLAGS = @LDFLAGS@
+LEX = @LEX@
+LEXLIB = @LEXLIB@
+LEX_OUTPUT_ROOT = @LEX_OUTPUT_ROOT@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LTLIBOBJS = @LTLIBOBJS@
+MACHINE_TYPE = @MACHINE_TYPE@
+MAKEINFO = @MAKEINFO@
+MKDIR_P = @MKDIR_P@
+OBJEXT = @OBJEXT@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+RANLIB = @RANLIB@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+YACC = @YACC@
+YFLAGS = @YFLAGS@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+runstatedir = @runstatedir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+
+# create object files in directory with source files
+AUTOMAKE_OPTIONS = subdir-objects
+
+# put into lib for now
+cfalibdir = ${CFA_LIBDIR}
+cfalib_DATA = gcc-builtins.cf builtins.cf extras.cf prelude.cf bootloader.c
+noinst_DATA = ../src/libcfa-prelude.c
+MAINTAINERCLEANFILES = gcc-builtins.c gcc-builtins.cf builtins.cf extras.cf bootloader.c prelude.cf ${addprefix ${libdir}/,${cfalib_DATA}} ${addprefix ${libdir}/,${lib_LIBRARIES}}
+all: all-am
+
+.SUFFIXES:
+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
+ @for dep in $?; do \
+ case '$(am__configure_deps)' in \
+ *$$dep*) \
+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+ && { if test -f $@; then exit 0; else break; fi; }; \
+ exit 1;; \
+ esac; \
+ done; \
+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign libcfa/prelude/Makefile'; \
+ $(am__cd) $(top_srcdir) && \
+ $(AUTOMAKE) --foreign libcfa/prelude/Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+ @case '$?' in \
+ *config.status*) \
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+ *) \
+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+ esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: $(am__configure_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): $(am__aclocal_m4_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+install-cfalibDATA: $(cfalib_DATA)
+ @$(NORMAL_INSTALL)
+ @list='$(cfalib_DATA)'; test -n "$(cfalibdir)" || list=; \
+ if test -n "$$list"; then \
+ echo " $(MKDIR_P) '$(DESTDIR)$(cfalibdir)'"; \
+ $(MKDIR_P) "$(DESTDIR)$(cfalibdir)" || exit 1; \
+ fi; \
+ for p in $$list; do \
+ if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+ echo "$$d$$p"; \
+ done | $(am__base_list) | \
+ while read files; do \
+ echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(cfalibdir)'"; \
+ $(INSTALL_DATA) $$files "$(DESTDIR)$(cfalibdir)" || exit $$?; \
+ done
+
+uninstall-cfalibDATA:
+ @$(NORMAL_UNINSTALL)
+ @list='$(cfalib_DATA)'; test -n "$(cfalibdir)" || list=; \
+ files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
+ dir='$(DESTDIR)$(cfalibdir)'; $(am__uninstall_files_from_dir)
+tags TAGS:
+
+ctags CTAGS:
+
+cscope cscopelist:
+
+
+distdir: $(DISTFILES)
+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ list='$(DISTFILES)'; \
+ dist_files=`for file in $$list; do echo $$file; done | \
+ sed -e "s|^$$srcdirstrip/||;t" \
+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+ case $$dist_files in \
+ */*) $(MKDIR_P) `echo "$$dist_files" | \
+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+ sort -u` ;; \
+ esac; \
+ for file in $$dist_files; do \
+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+ if test -d $$d/$$file; then \
+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+ if test -d "$(distdir)/$$file"; then \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+ else \
+ test -f "$(distdir)/$$file" \
+ || cp -p $$d/$$file "$(distdir)/$$file" \
+ || exit 1; \
+ fi; \
+ done
+check-am: all-am
+check: check-am
+all-am: Makefile $(DATA)
+installdirs:
+ for dir in "$(DESTDIR)$(cfalibdir)"; do \
+ test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+ done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+ if test -z '$(STRIP)'; then \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ install; \
+ else \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+ fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+ @echo "This command is intended for maintainers to use"
+ @echo "it deletes files that may require special tools to rebuild."
+ -test -z "$(MAINTAINERCLEANFILES)" || rm -f $(MAINTAINERCLEANFILES)
+clean: clean-am
+
+clean-am: clean-generic mostlyclean-am
+
+distclean: distclean-am
+ -rm -f Makefile
+distclean-am: clean-am distclean-generic
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am: install-cfalibDATA
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am:
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+ -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic \
+ maintainer-clean-local
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-generic
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-cfalibDATA
+
+.MAKE: install-am install-strip
+
+.PHONY: all all-am check check-am clean clean-generic cscopelist-am \
+ ctags-am distclean distclean-generic distdir dvi dvi-am html \
+ html-am info info-am install install-am install-cfalibDATA \
+ install-data install-data-am install-dvi install-dvi-am \
+ install-exec install-exec-am install-html install-html-am \
+ install-info install-info-am install-man install-pdf \
+ install-pdf-am install-ps install-ps-am install-strip \
+ installcheck installcheck-am installdirs maintainer-clean \
+ maintainer-clean-generic maintainer-clean-local mostlyclean \
+ mostlyclean-generic pdf pdf-am ps ps-am tags-am uninstall \
+ uninstall-am uninstall-cfalibDATA
+
+.PRECIOUS: Makefile
+
+
+$(DEPDIR) :
+ mkdir $(DEPDIR)
+
+$(DEPDIR)/builtins.Po : $(DEPDIR)
+ touch ${@}
+
+# create extra forward types/declarations to reduce inclusion of library files
+extras.cf : ${srcdir}/extras.regx ${srcdir}/extras.c
+ ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -E ${srcdir}/extras.c | grep -f ${srcdir}/extras.regx > extras.cf
+
+# create forward declarations for gcc builtins
+gcc-builtins.cf : gcc-builtins.c ${srcdir}/prototypes.sed
+ ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -I${srcdir} -E -P $< | sed -r -f ${srcdir}/prototypes.sed > $@
+
+gcc-builtins.c : ${srcdir}/builtins.def ${srcdir}/prototypes.awk ${srcdir}/sync-builtins.cf ${srcdir}/prototypes.c
+ ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -I${srcdir} -E ${srcdir}/prototypes.c | awk -f ${srcdir}/prototypes.awk > $@
+
+prelude.cf : prelude-gen.cc
+ ${AM_V_GEN}${CXX} ${AM_CXXFLAGS} ${CXXFLAGS} ${<} -o prelude-gen -Wall -Wextra -O2 -g -std=c++14
+ @./prelude-gen > $@
+ @rm ./prelude-gen
+
+builtins.def :
+
+prototypes.awk :
+
+# create forward declarations for cfa builtins
+builtins.cf : builtins.c ${CC}
+ ${AM_V_GEN}${CC} -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po
+ ${AM_V_at}sed -i 's/builtins.o/builtins.cf/g' $(DEPDIR)/builtins.Po
+
+include $(DEPDIR)/builtins.Po
+
+../src/libcfa-prelude.c : prelude.cf extras.cf gcc-builtins.cf builtins.cf @CFACPP@
+ ${AM_V_GEN}@CFACPP@ -l prelude.cf $@ # use src/cfa-cpp as not in lib until after install
+
+bootloader.c : ${srcdir}/bootloader.cf prelude.cf extras.cf gcc-builtins.cf builtins.cf @CFACPP@
+ ${AM_V_GEN}@CFACPP@ -tpm ${srcdir}/bootloader.cf $@ # use src/cfa-cpp as not in lib until after install
+
+maintainer-clean-local :
+ rm -rf $(DEPDIR)
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
Index: libcfa/prelude/bootloader.cf
===================================================================
--- libcfa/prelude/bootloader.cf (revision bf71cfdb7285490eee552b461158846f626cc52f)
+++ libcfa/prelude/bootloader.cf (revision bf71cfdb7285490eee552b461158846f626cc52f)
@@ -0,0 +1,5 @@
+extern "C" { static inline int invoke_main(int argc, char* argv[], char* envp[]); }
+
+int main(int argc, char* argv[], char* envp[]) {
+ return invoke_main(argc, argv, envp);
+}
Index: libcfa/prelude/builtins.c
===================================================================
--- libcfa/prelude/builtins.c (revision bf71cfdb7285490eee552b461158846f626cc52f)
+++ libcfa/prelude/builtins.c (revision bf71cfdb7285490eee552b461158846f626cc52f)
@@ -0,0 +1,116 @@
+//
+// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// builtins.c --
+//
+// Author : Peter A. Buhr
+// Created On : Fri Jul 21 16:21:03 2017
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Feb 8 12:47:59 2018
+// Update Count : 19
+//
+
+// exception implementation
+
+typedef unsigned long long __cfaabi_abi_exception_type_t;
+
+#include "../src/virtual.h"
+#include "../src/exception.h"
+
+void exit( int status, const char fmt[], ... ) __attribute__ (( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ ));
+void abort ( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ ));
+
+// increment/decrement unification
+
+static inline forall( dtype T | { T& ?+=?( T&, one_t ); } )
+T& ++? ( T& x ) { return x += 1; }
+
+static inline forall( dtype T | sized(T) | { void ?{}( T&, T ); void ^?{}( T& ); T& ?+=?( T&, one_t ); } )
+T& ?++ ( T& x ) { T tmp = x; x += 1; return tmp; }
+
+static inline forall( dtype T | { T& ?-=?( T&, one_t ); } )
+T& --? ( T& x ) { return x -= 1; }
+
+static inline forall( dtype T | sized(T) | { void ?{}( T&, T ); void ^?{}( T& ); T& ?-=?( T&, one_t ); } )
+T& ?-- ( T& x ) { T tmp = x; x -= 1; return tmp; }
+
+// exponentiation operator implementation
+
+extern "C" {
+ float powf( float x, float y );
+ double pow( double x, double y );
+ long double powl( long double x, long double y );
+ float _Complex cpowf( float _Complex x, _Complex float z );
+ double _Complex cpow( double _Complex x, _Complex double z );
+ long double _Complex cpowl( long double _Complex x, _Complex long double z );
+} // extern "C"
+
+static inline float ?\?( float x, float y ) { return powf( x, y ); }
+static inline double ?\?( double x, double y ) { return pow( x, y ); }
+static inline long double ?\?( long double x, long double y ) { return powl( x, y ); }
+static inline float _Complex ?\?( float _Complex x, _Complex float y ) { return cpowf(x, y ); }
+static inline double _Complex ?\?( double _Complex x, _Complex double y ) { return cpow( x, y ); }
+static inline long double _Complex ?\?( long double _Complex x, _Complex long double y ) { return cpowl( x, y ); }
+
+static inline long int ?\?( long int ep, unsigned long int y ) { // disallow negative exponent
+ if ( y == 0 ) return 1; // base case
+ if ( ep == 2 ) return ep << (y - 1); // special case, positive shifting only
+ typeof( ep ) op = 1; // accumulate odd product
+ for ( ; y > 1; y >>= 1 ) { // squaring exponentiation, O(log2 y)
+ if ( (y & 1) == 1 ) op *= ep; // odd ?
+ ep *= ep;
+ } // for
+ return ep * op;
+} // ?\?
+
+static inline forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); } )
+T ?\?( T ep, unsigned long int y ) {
+ if ( y == 0 ) return 1;
+ T op = 1;
+ for ( ; y > 1; y >>= 1 ) { // squaring exponentiation, O(log2 y)
+ if ( (y & 1) == 1 ) op = op * ep; // odd ?
+ ep = ep * ep;
+ } // for
+ return ep * op;
+} // ?\?
+
+// unsigned computation may be faster and larger
+static inline unsigned long int ?\?( unsigned long int ep, unsigned long int y ) { // disallow negative exponent
+ if ( y == 0 ) return 1; // base case
+ if ( ep == 2 ) return ep << (y - 1); // special case, positive shifting only
+ typeof( ep ) op = 1; // accumulate odd product
+ for ( ; y > 1; y >>= 1 ) { // squaring exponentiation, O(log2 y)
+ if ( (y & 1) == 1 ) op *= ep; // odd ?
+ ep *= ep;
+ } // for
+ return ep * op;
+} // ?\?
+
+static inline double ?\?( long int x, signed long int y ) { // allow negative exponent
+ if ( y >= 0 ) return (double)(x \ (unsigned long int)y);
+ else return 1.0 / x \ (unsigned int)(-y);
+} // ?\?
+
+// FIXME (x \ (unsigned long int)y) relies on X ?\?(T, unsigned long) a function that is neither
+// defined, nor passed as an assertion parameter. Without user-defined conversions, cannot specify
+// X as a type that casts to double, yet it doesn't make sense to write functions with that type
+// signature where X is double.
+
+// static inline forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); double ?/?( double, T ); } )
+// double ?\?( T x, signed long int y ) {
+// if ( y >= 0 ) return (double)(x \ (unsigned long int)y);
+// else return 1.0 / x \ (unsigned long int)(-y);
+// } // ?\?
+
+static inline long int ?\=?( long int & x, unsigned long int y ) { x = x \ y; return x; }
+static inline unsigned long int ?\=?( unsigned long int & x, unsigned long int y ) { x = x \ y; return x; }
+static inline int ?\=?( int & x, unsigned long int y ) { x = x \ y; return x; }
+static inline unsigned int ?\=?( unsigned int & x, unsigned long int y ) { x = x \ y; return x; }
+
+// Local Variables: //
+// mode: c //
+// tab-width: 4 //
+// End: //
Index: libcfa/prelude/builtins.def
===================================================================
--- libcfa/prelude/builtins.def (revision bf71cfdb7285490eee552b461158846f626cc52f)
+++ libcfa/prelude/builtins.def (revision bf71cfdb7285490eee552b461158846f626cc52f)
@@ -0,0 +1,953 @@
+/* This file contains the definitions and documentation for the
+ builtins used in the GNU compiler.
+ Copyright (C) 2000-2016 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC 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 3, or (at your option) any later
+version.
+
+GCC 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 GCC; see the file COPYING3. If not see
+. */
+
+/* Before including this file, you should define a macro:
+
+ DEF_BUILTIN (ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P,
+ FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT, COND)
+
+ This macro will be called once for each builtin function. The
+ ENUM will be of type `enum built_in_function', and will indicate
+ which builtin function is being processed. The NAME of the builtin
+ function (which will always start with `__builtin_') is a string
+ literal. The CLASS is of type `enum built_in_class' and indicates
+ what kind of builtin is being processed.
+
+ Some builtins are actually two separate functions. For example,
+ for `strcmp' there are two builtin functions; `__builtin_strcmp'
+ and `strcmp' itself. Both behave identically. Other builtins
+ define only the `__builtin' variant. If BOTH_P is TRUE, then this
+ builtin has both variants; otherwise, it is has only the first
+ variant.
+
+ TYPE indicates the type of the function. The symbols correspond to
+ enumerals from builtin-types.def. If BOTH_P is true, then LIBTYPE
+ is the type of the non-`__builtin_' variant. Otherwise, LIBTYPE
+ should be ignored.
+
+ If FALLBACK_P is true then, if for some reason, the compiler cannot
+ expand the builtin function directly, it will call the
+ corresponding library function (which does not have the
+ `__builtin_' prefix.
+
+ If NONANSI_P is true, then the non-`__builtin_' variant is not an
+ ANSI/ISO library function, and so we should pretend it does not
+ exist when compiling in ANSI conformant mode.
+
+ ATTRs is an attribute list as defined in builtin-attrs.def that
+ describes the attributes of this builtin function.
+
+ IMPLICIT specifies condition when the builtin can be produced by
+ compiler. For instance C90 reserves floorf function, but does not
+ define it's meaning. When user uses floorf we may assume that the
+ floorf has the meaning we expect, but we can't produce floorf by
+ simplifying floor((double)float) since the runtime need not implement
+ it.
+
+ The builtins is registered only if COND is true. */
+
+/* A macro for builtins where the
+ BUILT_IN_*_CHKP = BUILT_IN_* + BEGIN_CHKP_BUILTINS + 1
+ enums should be defined too. */
+#ifndef DEF_BUILTIN_CHKP
+#define DEF_BUILTIN_CHKP(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, \
+ FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT, COND) \
+ DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
+ NONANSI_P, ATTRS, IMPLICIT, COND)
+#endif
+
+/* A GCC builtin (like __builtin_saveregs) is provided by the
+ compiler, but does not correspond to a function in the standard
+ library. */
+#undef DEF_GCC_BUILTIN
+#define DEF_GCC_BUILTIN(ENUM, NAME, TYPE, ATTRS) \
+ DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, BT_LAST, \
+ false, false, false, ATTRS, true, true)
+
+/* Like DEF_GCC_BUILTIN, except we don't prepend "__builtin_". */
+#undef DEF_SYNC_BUILTIN
+#define DEF_SYNC_BUILTIN(ENUM, NAME, TYPE, ATTRS) \
+ DEF_BUILTIN (ENUM, NAME, BUILT_IN_NORMAL, TYPE, BT_LAST, \
+ false, false, false, ATTRS, true, true)
+
+/* A library builtin (like __builtin_strchr) is a builtin equivalent
+ of an ANSI/ISO standard library function. In addition to the
+ `__builtin' version, we will create an ordinary version (e.g,
+ `strchr') as well. If we cannot compute the answer using the
+ builtin function, we will fall back to the standard library
+ version. */
+#undef DEF_LIB_BUILTIN
+#define DEF_LIB_BUILTIN(ENUM, NAME, TYPE, ATTRS) \
+ DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
+ true, true, false, ATTRS, true, true)
+#undef DEF_LIB_BUILTIN_CHKP
+#define DEF_LIB_BUILTIN_CHKP(ENUM, NAME, TYPE, ATTRS) \
+ DEF_BUILTIN_CHKP (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, \
+ TYPE, true, true, false, ATTRS, true, true)
+
+/* Like DEF_LIB_BUILTIN, except that the function is not one that is
+ specified by ANSI/ISO C. So, when we're being fully conformant we
+ ignore the version of these builtins that does not begin with
+ __builtin. */
+#undef DEF_EXT_LIB_BUILTIN
+#define DEF_EXT_LIB_BUILTIN(ENUM, NAME, TYPE, ATTRS) \
+ DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
+ true, true, true, ATTRS, false, true)
+#undef DEF_EXT_LIB_BUILTIN_CHKP
+#define DEF_EXT_LIB_BUILTIN_CHKP(ENUM, NAME, TYPE, ATTRS) \
+ DEF_BUILTIN_CHKP (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, \
+ TYPE, true, true, true, ATTRS, false, true)
+
+/* Like DEF_LIB_BUILTIN, except that the function is only a part of
+ the standard in C94 or above. */
+#undef DEF_C94_BUILTIN
+#define DEF_C94_BUILTIN(ENUM, NAME, TYPE, ATTRS) \
+ DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
+ true, true, !flag_isoc94, ATTRS, targetm.libc_has_function (function_c94), true)
+
+/* Like DEF_LIB_BUILTIN, except that the function is only a part of
+ the standard in C99 or above. */
+#undef DEF_C99_BUILTIN
+#define DEF_C99_BUILTIN(ENUM, NAME, TYPE, ATTRS) \
+ DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
+ true, true, !flag_isoc99, ATTRS, targetm.libc_has_function (function_c99_misc), true)
+
+/* Like DEF_LIB_BUILTIN, except that the function is only a part of
+ the standard in C11 or above. */
+#undef DEF_C11_BUILTIN
+#define DEF_C11_BUILTIN(ENUM, NAME, TYPE, ATTRS) \
+ DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
+ true, true, !flag_isoc11, ATTRS, targetm.libc_has_function (function_c11_misc), true)
+
+/* Like DEF_C99_BUILTIN, but for complex math functions. */
+#undef DEF_C99_COMPL_BUILTIN
+#define DEF_C99_COMPL_BUILTIN(ENUM, NAME, TYPE, ATTRS) \
+ DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
+ true, true, !flag_isoc99, ATTRS, targetm.libc_has_function (function_c99_math_complex), true)
+
+/* Builtin that is specified by C99 and C90 reserve the name for future use.
+ We can still recognize the builtin in C90 mode but we can't produce it
+ implicitly. */
+#undef DEF_C99_C90RES_BUILTIN
+#define DEF_C99_C90RES_BUILTIN(ENUM, NAME, TYPE, ATTRS) \
+ DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
+ true, true, !flag_isoc99, ATTRS, targetm.libc_has_function (function_c99_misc), true)
+
+/* Builtin that C99 reserve the name for future use. We can still recognize
+ the builtin in C99 mode but we can't produce it implicitly. */
+#undef DEF_EXT_C99RES_BUILTIN
+#define DEF_EXT_C99RES_BUILTIN(ENUM, NAME, TYPE, ATTRS) \
+ DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
+ true, true, true, ATTRS, false, true)
+
+/* Allocate the enum and the name for a builtin, but do not actually
+ define it here at all. */
+#undef DEF_BUILTIN_STUB
+#define DEF_BUILTIN_STUB(ENUM, NAME) \
+ DEF_BUILTIN (ENUM, NAME, BUILT_IN_NORMAL, BT_LAST, BT_LAST, false, false, \
+ false, ATTR_LAST, false, false)
+
+/* Builtin used by the implementation of OpenACC and OpenMP. Few of these are
+ actually implemented in the compiler; most are in libgomp. */
+/* These builtins also need to be enabled in offloading compilers invoked from
+ mkoffload; for that purpose, we're checking the -foffload-abi flag here. */
+#undef DEF_GOACC_BUILTIN
+#define DEF_GOACC_BUILTIN(ENUM, NAME, TYPE, ATTRS) \
+ DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
+ false, true, true, ATTRS, false, \
+ (flag_openacc \
+ || flag_offload_abi != OFFLOAD_ABI_UNSET))
+#undef DEF_GOACC_BUILTIN_COMPILER
+#define DEF_GOACC_BUILTIN_COMPILER(ENUM, NAME, TYPE, ATTRS) \
+ DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
+ flag_openacc, true, true, ATTRS, false, true)
+#undef DEF_GOMP_BUILTIN
+#define DEF_GOMP_BUILTIN(ENUM, NAME, TYPE, ATTRS) \
+ DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
+ false, true, true, ATTRS, false, \
+ (flag_openacc \
+ || flag_openmp \
+ || flag_tree_parallelize_loops > 1 \
+ || flag_cilkplus \
+ || flag_offload_abi != OFFLOAD_ABI_UNSET))
+
+/* Builtin used by implementation of Cilk Plus. Most of these are decomposed
+ by the compiler but a few are implemented in libcilkrts. */
+#undef DEF_CILK_BUILTIN_STUB
+#define DEF_CILK_BUILTIN_STUB(ENUM, NAME) \
+ DEF_BUILTIN (ENUM, NAME, BUILT_IN_NORMAL, BT_LAST, BT_LAST, false, false, \
+ false, ATTR_LAST, false, false)
+
+/* Builtin used by the implementation of GNU TM. These
+ functions are mapped to the actual implementation of the STM library. */
+#undef DEF_TM_BUILTIN
+#define DEF_TM_BUILTIN(ENUM, NAME, TYPE, ATTRS) \
+ DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
+ true, true, true, ATTRS, false, flag_tm)
+
+/* Builtin used by the implementation of libsanitizer. These
+ functions are mapped to the actual implementation of the
+ libtsan library. */
+#undef DEF_SANITIZER_BUILTIN
+#define DEF_SANITIZER_BUILTIN(ENUM, NAME, TYPE, ATTRS) \
+ DEF_BUILTIN (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, TYPE, \
+ true, true, true, ATTRS, true, \
+ (flag_sanitize & (SANITIZE_ADDRESS | SANITIZE_THREAD \
+ | SANITIZE_UNDEFINED | SANITIZE_NONDEFAULT) \
+ || flag_sanitize_coverage))
+
+#undef DEF_CILKPLUS_BUILTIN
+#define DEF_CILKPLUS_BUILTIN(ENUM, NAME, TYPE, ATTRS) \
+ DEF_BUILTIN (ENUM, NAME, BUILT_IN_NORMAL, BT_FN_INT_VAR, BT_LAST, \
+ false, false, false, ATTRS, false, flag_cilkplus)
+
+/* Builtin used by the implementation of Pointer Bounds Checker. */
+#undef DEF_CHKP_BUILTIN
+#define DEF_CHKP_BUILTIN(ENUM, NAME, TYPE, ATTRS) \
+ DEF_BUILTIN_CHKP (ENUM, "__builtin_" NAME, BUILT_IN_NORMAL, TYPE, \
+ TYPE, true, true, false, ATTRS, true, true)
+
+/* Define an attribute list for math functions that are normally
+ "impure" because some of them may write into global memory for
+ `errno'. If !flag_errno_math they are instead "const". */
+#undef ATTR_MATHFN_ERRNO
+#define ATTR_MATHFN_ERRNO (flag_errno_math ? \
+ ATTR_NOTHROW_LEAF_LIST : ATTR_CONST_NOTHROW_LEAF_LIST)
+
+/* Define an attribute list for math functions that are normally
+ "const" but if flag_rounding_math is set they are instead "pure".
+ This distinction accounts for the fact that some math functions
+ check the rounding mode which is akin to examining global
+ memory. */
+#undef ATTR_MATHFN_FPROUNDING
+#define ATTR_MATHFN_FPROUNDING (flag_rounding_math ? \
+ ATTR_PURE_NOTHROW_LEAF_LIST : ATTR_CONST_NOTHROW_LEAF_LIST)
+
+/* Define an attribute list for math functions that are normally
+ "impure" because some of them may write into global memory for
+ `errno'. If !flag_errno_math, we can possibly use "pure" or
+ "const" depending on whether we care about FP rounding. */
+#undef ATTR_MATHFN_FPROUNDING_ERRNO
+#define ATTR_MATHFN_FPROUNDING_ERRNO (flag_errno_math ? \
+ ATTR_NOTHROW_LEAF_LIST : ATTR_MATHFN_FPROUNDING)
+
+/* Define an attribute list for math functions that need to mind FP
+ rounding, but because they store into memory they are never "const"
+ or "pure". Use of this macro is mainly for documentation and
+ maintenance purposes. */
+#undef ATTR_MATHFN_FPROUNDING_STORE
+#define ATTR_MATHFN_FPROUNDING_STORE ATTR_NOTHROW_LEAF_LIST
+
+/* Define an attribute list for leaf functions that do not throw
+ exceptions normally, but may throw exceptions when using
+ -fnon-call-exceptions. */
+#define ATTR_NOTHROWCALL_LEAF_LIST (flag_non_call_exceptions ? \
+ ATTR_LEAF_LIST : ATTR_NOTHROW_LEAF_LIST)
+
+/* Make sure 0 is not a legitimate builtin. */
+DEF_BUILTIN_STUB(BUILT_IN_NONE, (const char *)0)
+
+/* Category: math builtins. */
+DEF_LIB_BUILTIN (BUILT_IN_ACOS, "acos", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_ACOSF, "acosf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_ACOSH, "acosh", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_ACOSHF, "acoshf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_ACOSHL, "acoshl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_ACOSL, "acosl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C11_BUILTIN (BUILT_IN_ALIGNED_ALLOC, "aligned_alloc", BT_FN_PTR_SIZE_SIZE, ATTR_MALLOC_NOTHROW_LIST)
+DEF_LIB_BUILTIN (BUILT_IN_ASIN, "asin", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_ASINF, "asinf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_ASINH, "asinh", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_BUILTIN (BUILT_IN_ASINHF, "asinhf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_BUILTIN (BUILT_IN_ASINHL, "asinhl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_ASINL, "asinl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_LIB_BUILTIN (BUILT_IN_ATAN, "atan", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_LIB_BUILTIN (BUILT_IN_ATAN2, "atan2", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_ATAN2F, "atan2f", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_ATAN2L, "atan2l", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_ATANF, "atanf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_BUILTIN (BUILT_IN_ATANH, "atanh", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_ATANHF, "atanhf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_ATANHL, "atanhl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_ATANL, "atanl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_BUILTIN (BUILT_IN_CBRT, "cbrt", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_BUILTIN (BUILT_IN_CBRTF, "cbrtf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_BUILTIN (BUILT_IN_CBRTL, "cbrtl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_LIB_BUILTIN (BUILT_IN_CEIL, "ceil", BT_FN_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_CEILF, "ceilf", BT_FN_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_CEILL, "ceill", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_BUILTIN (BUILT_IN_COPYSIGN, "copysign", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_BUILTIN (BUILT_IN_COPYSIGNF, "copysignf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_BUILTIN (BUILT_IN_COPYSIGNL, "copysignl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_LIB_BUILTIN (BUILT_IN_COS, "cos", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_COSF, "cosf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_LIB_BUILTIN (BUILT_IN_COSH, "cosh", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_COSHF, "coshf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_COSHL, "coshl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_COSL, "cosl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_DREM, "drem", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_DREMF, "dremf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_DREML, "dreml", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_ERF, "erf", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_BUILTIN (BUILT_IN_ERFC, "erfc", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_ERFCF, "erfcf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_ERFCL, "erfcl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_ERFF, "erff", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_BUILTIN (BUILT_IN_ERFL, "erfl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_LIB_BUILTIN (BUILT_IN_EXP, "exp", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_EXP10, "exp10", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_EXP10F, "exp10f", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_EXP10L, "exp10l", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_EXP2, "exp2", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_EXP2F, "exp2f", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_EXP2L, "exp2l", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_EXPF, "expf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_EXPL, "expl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_EXPM1, "expm1", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_EXPM1F, "expm1f", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_EXPM1L, "expm1l", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_LIB_BUILTIN (BUILT_IN_FABS, "fabs", BT_FN_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_FABSF, "fabsf", BT_FN_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_FABSL, "fabsl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_FABSD32, "fabsd32", BT_FN_DFLOAT32_DFLOAT32, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_FABSD64, "fabsd64", BT_FN_DFLOAT64_DFLOAT64, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_FABSD128, "fabsd128", BT_FN_DFLOAT128_DFLOAT128, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_BUILTIN (BUILT_IN_FDIM, "fdim", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_FDIMF, "fdimf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_FDIML, "fdiml", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_LIB_BUILTIN (BUILT_IN_FLOOR, "floor", BT_FN_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_FLOORF, "floorf", BT_FN_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_FLOORL, "floorl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_BUILTIN (BUILT_IN_FMA, "fma", BT_FN_DOUBLE_DOUBLE_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_BUILTIN (BUILT_IN_FMAF, "fmaf", BT_FN_FLOAT_FLOAT_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_BUILTIN (BUILT_IN_FMAL, "fmal", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_BUILTIN (BUILT_IN_FMAX, "fmax", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_BUILTIN (BUILT_IN_FMAXF, "fmaxf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_BUILTIN (BUILT_IN_FMAXL, "fmaxl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_BUILTIN (BUILT_IN_FMIN, "fmin", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_BUILTIN (BUILT_IN_FMINF, "fminf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_BUILTIN (BUILT_IN_FMINL, "fminl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_LIB_BUILTIN (BUILT_IN_FMOD, "fmod", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_FMODF, "fmodf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_FMODL, "fmodl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_LIB_BUILTIN (BUILT_IN_FREXP, "frexp", BT_FN_DOUBLE_DOUBLE_INTPTR, ATTR_MATHFN_FPROUNDING_STORE)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_FREXPF, "frexpf", BT_FN_FLOAT_FLOAT_INTPTR, ATTR_MATHFN_FPROUNDING_STORE)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_FREXPL, "frexpl", BT_FN_LONGDOUBLE_LONGDOUBLE_INTPTR, ATTR_MATHFN_FPROUNDING_STORE)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_GAMMA, "gamma", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_STORE)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_GAMMAF, "gammaf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_STORE)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_GAMMAL, "gammal", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_STORE)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_GAMMA_R, "gamma_r", BT_FN_DOUBLE_DOUBLE_INTPTR, ATTR_MATHFN_FPROUNDING_STORE)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_GAMMAF_R, "gammaf_r", BT_FN_FLOAT_FLOAT_INTPTR, ATTR_MATHFN_FPROUNDING_STORE)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_GAMMAL_R, "gammal_r", BT_FN_LONGDOUBLE_LONGDOUBLE_INTPTR, ATTR_MATHFN_FPROUNDING_STORE)
+DEF_GCC_BUILTIN (BUILT_IN_HUGE_VAL, "huge_val", BT_FN_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_HUGE_VALF, "huge_valf", BT_FN_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_HUGE_VALL, "huge_vall", BT_FN_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_BUILTIN (BUILT_IN_HYPOT, "hypot", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_HYPOTF, "hypotf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_HYPOTL, "hypotl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_GCC_BUILTIN (BUILT_IN_ICEIL, "iceil", BT_FN_INT_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_ICEILF, "iceilf", BT_FN_INT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_ICEILL, "iceill", BT_FN_INT_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_IFLOOR, "ifloor", BT_FN_INT_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_IFLOORF, "ifloorf", BT_FN_INT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_IFLOORL, "ifloorl", BT_FN_INT_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_BUILTIN (BUILT_IN_ILOGB, "ilogb", BT_FN_INT_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_ILOGBF, "ilogbf", BT_FN_INT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_ILOGBL, "ilogbl", BT_FN_INT_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_GCC_BUILTIN (BUILT_IN_INF, "inf", BT_FN_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_INFF, "inff", BT_FN_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_INFL, "infl", BT_FN_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_INFD32, "infd32", BT_FN_DFLOAT32, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_INFD64, "infd64", BT_FN_DFLOAT64, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_INFD128, "infd128", BT_FN_DFLOAT128, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_IRINT, "irint", BT_FN_INT_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_GCC_BUILTIN (BUILT_IN_IRINTF, "irintf", BT_FN_INT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_GCC_BUILTIN (BUILT_IN_IRINTL, "irintl", BT_FN_INT_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_GCC_BUILTIN (BUILT_IN_IROUND, "iround", BT_FN_INT_DOUBLE, ATTR_MATHFN_ERRNO)
+DEF_GCC_BUILTIN (BUILT_IN_IROUNDF, "iroundf", BT_FN_INT_FLOAT, ATTR_MATHFN_ERRNO)
+DEF_GCC_BUILTIN (BUILT_IN_IROUNDL, "iroundl", BT_FN_INT_LONGDOUBLE, ATTR_MATHFN_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_J0, "j0", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_J0F, "j0f", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_J0L, "j0l", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_J1, "j1", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_J1F, "j1f", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_J1L, "j1l", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_JN, "jn", BT_FN_DOUBLE_INT_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_JNF, "jnf", BT_FN_FLOAT_INT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_JNL, "jnl", BT_FN_LONGDOUBLE_INT_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_GCC_BUILTIN (BUILT_IN_LCEIL, "lceil", BT_FN_LONG_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_LCEILF, "lceilf", BT_FN_LONG_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_LCEILL, "lceill", BT_FN_LONG_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_LIB_BUILTIN (BUILT_IN_LDEXP, "ldexp", BT_FN_DOUBLE_DOUBLE_INT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_LDEXPF, "ldexpf", BT_FN_FLOAT_FLOAT_INT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_LDEXPL, "ldexpl", BT_FN_LONGDOUBLE_LONGDOUBLE_INT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_GCC_BUILTIN (BUILT_IN_LFLOOR, "lfloor", BT_FN_LONG_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_LFLOORF, "lfloorf", BT_FN_LONG_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_LFLOORL, "lfloorl", BT_FN_LONG_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_BUILTIN (BUILT_IN_LGAMMA, "lgamma", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_STORE)
+DEF_C99_BUILTIN (BUILT_IN_LGAMMAF, "lgammaf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_STORE)
+DEF_C99_BUILTIN (BUILT_IN_LGAMMAL, "lgammal", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_STORE)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_LGAMMA_R, "lgamma_r", BT_FN_DOUBLE_DOUBLE_INTPTR, ATTR_MATHFN_FPROUNDING_STORE)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_LGAMMAF_R, "lgammaf_r", BT_FN_FLOAT_FLOAT_INTPTR, ATTR_MATHFN_FPROUNDING_STORE)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_LGAMMAL_R, "lgammal_r", BT_FN_LONGDOUBLE_LONGDOUBLE_INTPTR, ATTR_MATHFN_FPROUNDING_STORE)
+DEF_GCC_BUILTIN (BUILT_IN_LLCEIL, "llceil", BT_FN_LONGLONG_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_LLCEILF, "llceilf", BT_FN_LONGLONG_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_LLCEILL, "llceill", BT_FN_LONGLONG_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_LLFLOOR, "llfloor", BT_FN_LONGLONG_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_LLFLOORF, "llfloorf", BT_FN_LONGLONG_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_LLFLOORL, "llfloorl", BT_FN_LONGLONG_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_BUILTIN (BUILT_IN_LLRINT, "llrint", BT_FN_LONGLONG_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_LLRINTF, "llrintf", BT_FN_LONGLONG_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_LLRINTL, "llrintl", BT_FN_LONGLONG_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_LLROUND, "llround", BT_FN_LONGLONG_DOUBLE, ATTR_MATHFN_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_LLROUNDF, "llroundf", BT_FN_LONGLONG_FLOAT, ATTR_MATHFN_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_LLROUNDL, "llroundl", BT_FN_LONGLONG_LONGDOUBLE, ATTR_MATHFN_ERRNO)
+DEF_LIB_BUILTIN (BUILT_IN_LOG, "log", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_LIB_BUILTIN (BUILT_IN_LOG10, "log10", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_LOG10F, "log10f", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_LOG10L, "log10l", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_LOG1P, "log1p", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_LOG1PF, "log1pf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_LOG1PL, "log1pl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_LOG2, "log2", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_LOG2F, "log2f", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_LOG2L, "log2l", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_LOGB, "logb", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_LOGBF, "logbf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_LOGBL, "logbl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_LOGF, "logf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_LOGL, "logl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_LRINT, "lrint", BT_FN_LONG_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_LRINTF, "lrintf", BT_FN_LONG_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_LRINTL, "lrintl", BT_FN_LONG_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_LROUND, "lround", BT_FN_LONG_DOUBLE, ATTR_MATHFN_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_LROUNDF, "lroundf", BT_FN_LONG_FLOAT, ATTR_MATHFN_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_LROUNDL, "lroundl", BT_FN_LONG_LONGDOUBLE, ATTR_MATHFN_ERRNO)
+DEF_LIB_BUILTIN (BUILT_IN_MODF, "modf", BT_FN_DOUBLE_DOUBLE_DOUBLEPTR, ATTR_MATHFN_FPROUNDING_STORE)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_MODFF, "modff", BT_FN_FLOAT_FLOAT_FLOATPTR, ATTR_MATHFN_FPROUNDING_STORE)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_MODFL, "modfl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLEPTR, ATTR_MATHFN_FPROUNDING_STORE)
+DEF_C99_BUILTIN (BUILT_IN_NAN, "nan", BT_FN_DOUBLE_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL)
+DEF_C99_BUILTIN (BUILT_IN_NANF, "nanf", BT_FN_FLOAT_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL)
+DEF_C99_BUILTIN (BUILT_IN_NANL, "nanl", BT_FN_LONGDOUBLE_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL)
+DEF_GCC_BUILTIN (BUILT_IN_NAND32, "nand32", BT_FN_DFLOAT32_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL)
+DEF_GCC_BUILTIN (BUILT_IN_NAND64, "nand64", BT_FN_DFLOAT64_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL)
+DEF_GCC_BUILTIN (BUILT_IN_NAND128, "nand128", BT_FN_DFLOAT128_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL)
+DEF_GCC_BUILTIN (BUILT_IN_NANS, "nans", BT_FN_DOUBLE_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL)
+DEF_GCC_BUILTIN (BUILT_IN_NANSF, "nansf", BT_FN_FLOAT_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL)
+DEF_GCC_BUILTIN (BUILT_IN_NANSL, "nansl", BT_FN_LONGDOUBLE_CONST_STRING, ATTR_CONST_NOTHROW_NONNULL)
+DEF_C99_BUILTIN (BUILT_IN_NEARBYINT, "nearbyint", BT_FN_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_BUILTIN (BUILT_IN_NEARBYINTF, "nearbyintf", BT_FN_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_BUILTIN (BUILT_IN_NEARBYINTL, "nearbyintl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_BUILTIN (BUILT_IN_NEXTAFTER, "nextafter", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_NEXTAFTERF, "nextafterf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_NEXTAFTERL, "nextafterl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_NEXTTOWARD, "nexttoward", BT_FN_DOUBLE_DOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_NEXTTOWARDF, "nexttowardf", BT_FN_FLOAT_FLOAT_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_NEXTTOWARDL, "nexttowardl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_LIB_BUILTIN (BUILT_IN_POW, "pow", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_POW10, "pow10", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_POW10F, "pow10f", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_POW10L, "pow10l", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_POWF, "powf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_GCC_BUILTIN (BUILT_IN_POWI, "powi", BT_FN_DOUBLE_DOUBLE_INT, ATTR_MATHFN_FPROUNDING)
+DEF_GCC_BUILTIN (BUILT_IN_POWIF, "powif", BT_FN_FLOAT_FLOAT_INT, ATTR_MATHFN_FPROUNDING)
+DEF_GCC_BUILTIN (BUILT_IN_POWIL, "powil", BT_FN_LONGDOUBLE_LONGDOUBLE_INT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_POWL, "powl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_REMAINDER, "remainder", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_REMAINDERF, "remainderf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_REMAINDERL, "remainderl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_REMQUO, "remquo", BT_FN_DOUBLE_DOUBLE_DOUBLE_INTPTR, ATTR_MATHFN_FPROUNDING_STORE)
+DEF_C99_BUILTIN (BUILT_IN_REMQUOF, "remquof", BT_FN_FLOAT_FLOAT_FLOAT_INTPTR, ATTR_MATHFN_FPROUNDING_STORE)
+DEF_C99_BUILTIN (BUILT_IN_REMQUOL, "remquol", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE_INTPTR, ATTR_MATHFN_FPROUNDING_STORE)
+DEF_C99_BUILTIN (BUILT_IN_RINT, "rint", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_BUILTIN (BUILT_IN_RINTF, "rintf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_BUILTIN (BUILT_IN_RINTL, "rintl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_BUILTIN (BUILT_IN_ROUND, "round", BT_FN_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_BUILTIN (BUILT_IN_ROUNDF, "roundf", BT_FN_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_BUILTIN (BUILT_IN_ROUNDL, "roundl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_SCALB, "scalb", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_SCALBF, "scalbf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_SCALBL, "scalbl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_SCALBLN, "scalbln", BT_FN_DOUBLE_DOUBLE_LONG, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_SCALBLNF, "scalblnf", BT_FN_FLOAT_FLOAT_LONG, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_SCALBLNL, "scalblnl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONG, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_SCALBN, "scalbn", BT_FN_DOUBLE_DOUBLE_INT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_SCALBNF, "scalbnf", BT_FN_FLOAT_FLOAT_INT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_SCALBNL, "scalbnl", BT_FN_LONGDOUBLE_LONGDOUBLE_INT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_SIGNBIT, "signbit", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_SIGNBITF, "signbitf", BT_FN_INT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_SIGNBITL, "signbitl", BT_FN_INT_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_SIGNBITD32, "signbitd32", BT_FN_INT_DFLOAT32, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_SIGNBITD64, "signbitd64", BT_FN_INT_DFLOAT64, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_SIGNBITD128, "signbitd128", BT_FN_INT_DFLOAT128, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_SIGNIFICAND, "significand", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_SIGNIFICANDF, "significandf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_SIGNIFICANDL, "significandl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_LIB_BUILTIN (BUILT_IN_SIN, "sin", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_SINCOS, "sincos", BT_FN_VOID_DOUBLE_DOUBLEPTR_DOUBLEPTR, ATTR_MATHFN_FPROUNDING_STORE)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_SINCOSF, "sincosf", BT_FN_VOID_FLOAT_FLOATPTR_FLOATPTR, ATTR_MATHFN_FPROUNDING_STORE)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_SINCOSL, "sincosl", BT_FN_VOID_LONGDOUBLE_LONGDOUBLEPTR_LONGDOUBLEPTR, ATTR_MATHFN_FPROUNDING_STORE)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_SINF, "sinf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_LIB_BUILTIN (BUILT_IN_SINH, "sinh", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_SINHF, "sinhf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_SINHL, "sinhl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_SINL, "sinl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_LIB_BUILTIN (BUILT_IN_SQRT, "sqrt", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_SQRTF, "sqrtf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_SQRTL, "sqrtl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_LIB_BUILTIN (BUILT_IN_TAN, "tan", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_TANF, "tanf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_LIB_BUILTIN (BUILT_IN_TANH, "tanh", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_TANHF, "tanhf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_TANHL, "tanhl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_TANL, "tanl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_BUILTIN (BUILT_IN_TGAMMA, "tgamma", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_TGAMMAF, "tgammaf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_TGAMMAL, "tgammal", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_C99_BUILTIN (BUILT_IN_TRUNC, "trunc", BT_FN_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_BUILTIN (BUILT_IN_TRUNCF, "truncf", BT_FN_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_BUILTIN (BUILT_IN_TRUNCL, "truncl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_Y0, "y0", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_Y0F, "y0f", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_Y0L, "y0l", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_Y1, "y1", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_Y1F, "y1f", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_Y1L, "y1l", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_YN, "yn", BT_FN_DOUBLE_INT_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_YNF, "ynf", BT_FN_FLOAT_INT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_YNL, "ynl", BT_FN_LONGDOUBLE_INT_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
+
+/* Category: _Complex math builtins. */
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CABS, "cabs", BT_FN_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CABSF, "cabsf", BT_FN_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CABSL, "cabsl", BT_FN_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CACOS, "cacos", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CACOSF, "cacosf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CACOSH, "cacosh", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CACOSHF, "cacoshf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CACOSHL, "cacoshl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CACOSL, "cacosl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CARG, "carg", BT_FN_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CARGF, "cargf", BT_FN_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CARGL, "cargl", BT_FN_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CASIN, "casin", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CASINF, "casinf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CASINH, "casinh", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CASINHF, "casinhf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CASINHL, "casinhl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CASINL, "casinl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CATAN, "catan", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CATANF, "catanf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CATANH, "catanh", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CATANHF, "catanhf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CATANHL, "catanhl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CATANL, "catanl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CCOS, "ccos", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CCOSF, "ccosf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CCOSH, "ccosh", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CCOSHF, "ccoshf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CCOSHL, "ccoshl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CCOSL, "ccosl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CEXP, "cexp", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CEXPF, "cexpf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CEXPL, "cexpl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_GCC_BUILTIN (BUILT_IN_CEXPI, "cexpi", BT_FN_COMPLEX_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_GCC_BUILTIN (BUILT_IN_CEXPIF, "cexpif", BT_FN_COMPLEX_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_GCC_BUILTIN (BUILT_IN_CEXPIL, "cexpil", BT_FN_COMPLEX_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CIMAG, "cimag", BT_FN_DOUBLE_COMPLEX_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CIMAGF, "cimagf", BT_FN_FLOAT_COMPLEX_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CIMAGL, "cimagl", BT_FN_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CLOG, "clog", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CLOGF, "clogf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CLOGL, "clogl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_EXT_C99RES_BUILTIN (BUILT_IN_CLOG10, "clog10", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_EXT_C99RES_BUILTIN (BUILT_IN_CLOG10F, "clog10f", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_EXT_C99RES_BUILTIN (BUILT_IN_CLOG10L, "clog10l", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CONJ, "conj", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CONJF, "conjf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CONJL, "conjl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CPOW, "cpow", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CPOWF, "cpowf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CPOWL, "cpowl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CPROJ, "cproj", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CPROJF, "cprojf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CPROJL, "cprojl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CREAL, "creal", BT_FN_DOUBLE_COMPLEX_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CREALF, "crealf", BT_FN_FLOAT_COMPLEX_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CREALL, "creall", BT_FN_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CSIN, "csin", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CSINF, "csinf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CSINH, "csinh", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CSINHF, "csinhf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CSINHL, "csinhl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CSINL, "csinl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CSQRT, "csqrt", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CSQRTF, "csqrtf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CSQRTL, "csqrtl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CTAN, "ctan", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CTANF, "ctanf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CTANH, "ctanh", BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CTANHF, "ctanhf", BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CTANHL, "ctanhl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+DEF_C99_COMPL_BUILTIN (BUILT_IN_CTANL, "ctanl", BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
+
+/* Category: string/memory builtins. */
+/* bcmp, bcopy and bzero have traditionally accepted NULL pointers
+ when the length parameter is zero, so don't apply attribute "nonnull". */
+DEF_EXT_LIB_BUILTIN (BUILT_IN_BCMP, "bcmp", BT_FN_INT_CONST_PTR_CONST_PTR_SIZE, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_BCOPY, "bcopy", BT_FN_VOID_CONST_PTR_PTR_SIZE, ATTR_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_BZERO, "bzero", BT_FN_VOID_PTR_SIZE, ATTR_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_INDEX, "index", BT_FN_STRING_CONST_STRING_INT, ATTR_PURE_NOTHROW_NONNULL_LEAF)
+DEF_LIB_BUILTIN (BUILT_IN_MEMCHR, "memchr", BT_FN_PTR_CONST_PTR_INT_SIZE, ATTR_PURE_NOTHROW_NONNULL_LEAF)
+DEF_LIB_BUILTIN (BUILT_IN_MEMCMP, "memcmp", BT_FN_INT_CONST_PTR_CONST_PTR_SIZE, ATTR_PURE_NOTHROW_NONNULL_LEAF)
+DEF_LIB_BUILTIN_CHKP (BUILT_IN_MEMCPY, "memcpy", BT_FN_PTR_PTR_CONST_PTR_SIZE, ATTR_RET1_NOTHROW_NONNULL_LEAF)
+DEF_LIB_BUILTIN_CHKP (BUILT_IN_MEMMOVE, "memmove", BT_FN_PTR_PTR_CONST_PTR_SIZE, ATTR_RET1_NOTHROW_NONNULL_LEAF)
+DEF_EXT_LIB_BUILTIN_CHKP (BUILT_IN_MEMPCPY, "mempcpy", BT_FN_PTR_PTR_CONST_PTR_SIZE, ATTR_NOTHROW_NONNULL_LEAF)
+DEF_LIB_BUILTIN_CHKP (BUILT_IN_MEMSET, "memset", BT_FN_PTR_PTR_INT_SIZE, ATTR_RET1_NOTHROW_NONNULL_LEAF)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_RINDEX, "rindex", BT_FN_STRING_CONST_STRING_INT, ATTR_PURE_NOTHROW_NONNULL_LEAF)
+DEF_EXT_LIB_BUILTIN_CHKP (BUILT_IN_STPCPY, "stpcpy", BT_FN_STRING_STRING_CONST_STRING, ATTR_NOTHROW_NONNULL_LEAF)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_STPNCPY, "stpncpy", BT_FN_STRING_STRING_CONST_STRING_SIZE, ATTR_NOTHROW_NONNULL_LEAF)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_STRCASECMP, "strcasecmp", BT_FN_INT_CONST_STRING_CONST_STRING, ATTR_PURE_NOTHROW_NONNULL_LEAF)
+DEF_LIB_BUILTIN_CHKP (BUILT_IN_STRCAT, "strcat", BT_FN_STRING_STRING_CONST_STRING, ATTR_NOTHROW_NONNULL_LEAF)
+DEF_LIB_BUILTIN_CHKP (BUILT_IN_STRCHR, "strchr", BT_FN_STRING_CONST_STRING_INT, ATTR_PURE_NOTHROW_NONNULL_LEAF)
+DEF_LIB_BUILTIN (BUILT_IN_STRCMP, "strcmp", BT_FN_INT_CONST_STRING_CONST_STRING, ATTR_PURE_NOTHROW_NONNULL_LEAF)
+DEF_LIB_BUILTIN_CHKP (BUILT_IN_STRCPY, "strcpy", BT_FN_STRING_STRING_CONST_STRING, ATTR_RET1_NOTHROW_NONNULL_LEAF)
+DEF_LIB_BUILTIN (BUILT_IN_STRCSPN, "strcspn", BT_FN_SIZE_CONST_STRING_CONST_STRING, ATTR_PURE_NOTHROW_NONNULL_LEAF)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_STRDUP, "strdup", BT_FN_STRING_CONST_STRING, ATTR_MALLOC_NOTHROW_NONNULL_LEAF)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_STRNDUP, "strndup", BT_FN_STRING_CONST_STRING_SIZE, ATTR_MALLOC_NOTHROW_NONNULL_LEAF)
+DEF_LIB_BUILTIN_CHKP (BUILT_IN_STRLEN, "strlen", BT_FN_SIZE_CONST_STRING, ATTR_PURE_NOTHROW_NONNULL_LEAF)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_STRNCASECMP, "strncasecmp", BT_FN_INT_CONST_STRING_CONST_STRING_SIZE, ATTR_PURE_NOTHROW_NONNULL_LEAF)
+DEF_LIB_BUILTIN (BUILT_IN_STRNCAT, "strncat", BT_FN_STRING_STRING_CONST_STRING_SIZE, ATTR_NOTHROW_NONNULL_LEAF)
+DEF_LIB_BUILTIN (BUILT_IN_STRNCMP, "strncmp", BT_FN_INT_CONST_STRING_CONST_STRING_SIZE, ATTR_PURE_NOTHROW_NONNULL_LEAF)
+DEF_LIB_BUILTIN (BUILT_IN_STRNCPY, "strncpy", BT_FN_STRING_STRING_CONST_STRING_SIZE, ATTR_NOTHROW_NONNULL_LEAF)
+DEF_LIB_BUILTIN (BUILT_IN_STRPBRK, "strpbrk", BT_FN_STRING_CONST_STRING_CONST_STRING, ATTR_PURE_NOTHROW_NONNULL_LEAF)
+DEF_LIB_BUILTIN (BUILT_IN_STRRCHR, "strrchr", BT_FN_STRING_CONST_STRING_INT, ATTR_PURE_NOTHROW_NONNULL_LEAF)
+DEF_LIB_BUILTIN (BUILT_IN_STRSPN, "strspn", BT_FN_SIZE_CONST_STRING_CONST_STRING, ATTR_PURE_NOTHROW_NONNULL_LEAF)
+DEF_LIB_BUILTIN (BUILT_IN_STRSTR, "strstr", BT_FN_STRING_CONST_STRING_CONST_STRING, ATTR_PURE_NOTHROW_NONNULL_LEAF)
+
+/* Category: stdio builtins. */
+DEF_LIB_BUILTIN (BUILT_IN_FPRINTF, "fprintf", BT_FN_INT_FILEPTR_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_2_3)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_FPRINTF_UNLOCKED, "fprintf_unlocked", BT_FN_INT_FILEPTR_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_2_3)
+DEF_LIB_BUILTIN (BUILT_IN_PUTC, "putc", BT_FN_INT_INT_FILEPTR, ATTR_NONNULL_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_PUTC_UNLOCKED, "putc_unlocked", BT_FN_INT_INT_FILEPTR, ATTR_NONNULL_LIST)
+DEF_LIB_BUILTIN (BUILT_IN_FPUTC, "fputc", BT_FN_INT_INT_FILEPTR, ATTR_NONNULL_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_FPUTC_UNLOCKED, "fputc_unlocked", BT_FN_INT_INT_FILEPTR, ATTR_NONNULL_LIST)
+DEF_LIB_BUILTIN (BUILT_IN_FPUTS, "fputs", BT_FN_INT_CONST_STRING_FILEPTR, ATTR_NONNULL_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_FPUTS_UNLOCKED, "fputs_unlocked", BT_FN_INT_CONST_STRING_FILEPTR, ATTR_NONNULL_LIST)
+DEF_LIB_BUILTIN (BUILT_IN_FSCANF, "fscanf", BT_FN_INT_FILEPTR_CONST_STRING_VAR, ATTR_FORMAT_SCANF_2_3)
+DEF_LIB_BUILTIN (BUILT_IN_FWRITE, "fwrite", BT_FN_SIZE_CONST_PTR_SIZE_SIZE_FILEPTR, ATTR_NONNULL_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_FWRITE_UNLOCKED, "fwrite_unlocked", BT_FN_SIZE_CONST_PTR_SIZE_SIZE_FILEPTR, ATTR_NONNULL_LIST)
+DEF_LIB_BUILTIN (BUILT_IN_PRINTF, "printf", BT_FN_INT_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_1_2)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_PRINTF_UNLOCKED, "printf_unlocked", BT_FN_INT_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_1_2)
+DEF_LIB_BUILTIN (BUILT_IN_PUTCHAR, "putchar", BT_FN_INT_INT, ATTR_NULL)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_PUTCHAR_UNLOCKED, "putchar_unlocked", BT_FN_INT_INT, ATTR_NULL)
+DEF_LIB_BUILTIN (BUILT_IN_PUTS, "puts", BT_FN_INT_CONST_STRING, ATTR_NONNULL_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_PUTS_UNLOCKED, "puts_unlocked", BT_FN_INT_CONST_STRING, ATTR_NONNULL_LIST)
+DEF_LIB_BUILTIN (BUILT_IN_SCANF, "scanf", BT_FN_INT_CONST_STRING_VAR, ATTR_FORMAT_SCANF_1_2)
+DEF_C99_BUILTIN (BUILT_IN_SNPRINTF, "snprintf", BT_FN_INT_STRING_SIZE_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_NOTHROW_3_4)
+DEF_LIB_BUILTIN (BUILT_IN_SPRINTF, "sprintf", BT_FN_INT_STRING_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_NOTHROW_2_3)
+DEF_LIB_BUILTIN (BUILT_IN_SSCANF, "sscanf", BT_FN_INT_CONST_STRING_CONST_STRING_VAR, ATTR_FORMAT_SCANF_NOTHROW_2_3)
+DEF_LIB_BUILTIN (BUILT_IN_VFPRINTF, "vfprintf", BT_FN_INT_FILEPTR_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_2_0)
+DEF_C99_BUILTIN (BUILT_IN_VFSCANF, "vfscanf", BT_FN_INT_FILEPTR_CONST_STRING_VALIST_ARG, ATTR_FORMAT_SCANF_2_0)
+DEF_LIB_BUILTIN (BUILT_IN_VPRINTF, "vprintf", BT_FN_INT_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_1_0)
+DEF_C99_BUILTIN (BUILT_IN_VSCANF, "vscanf", BT_FN_INT_CONST_STRING_VALIST_ARG, ATTR_FORMAT_SCANF_1_0)
+DEF_C99_BUILTIN (BUILT_IN_VSNPRINTF, "vsnprintf", BT_FN_INT_STRING_SIZE_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_NOTHROW_3_0)
+DEF_LIB_BUILTIN (BUILT_IN_VSPRINTF, "vsprintf", BT_FN_INT_STRING_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_NOTHROW_2_0)
+DEF_C99_BUILTIN (BUILT_IN_VSSCANF, "vsscanf", BT_FN_INT_CONST_STRING_CONST_STRING_VALIST_ARG, ATTR_FORMAT_SCANF_NOTHROW_2_0)
+
+/* Category: ctype builtins. */
+DEF_LIB_BUILTIN (BUILT_IN_ISALNUM, "isalnum", BT_FN_INT_INT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_LIB_BUILTIN (BUILT_IN_ISALPHA, "isalpha", BT_FN_INT_INT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_ISASCII, "isascii", BT_FN_INT_INT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_BUILTIN (BUILT_IN_ISBLANK, "isblank", BT_FN_INT_INT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_LIB_BUILTIN (BUILT_IN_ISCNTRL, "iscntrl", BT_FN_INT_INT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_LIB_BUILTIN (BUILT_IN_ISDIGIT, "isdigit", BT_FN_INT_INT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_LIB_BUILTIN (BUILT_IN_ISGRAPH, "isgraph", BT_FN_INT_INT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_LIB_BUILTIN (BUILT_IN_ISLOWER, "islower", BT_FN_INT_INT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_LIB_BUILTIN (BUILT_IN_ISPRINT, "isprint", BT_FN_INT_INT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_LIB_BUILTIN (BUILT_IN_ISPUNCT, "ispunct", BT_FN_INT_INT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_LIB_BUILTIN (BUILT_IN_ISSPACE, "isspace", BT_FN_INT_INT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_LIB_BUILTIN (BUILT_IN_ISUPPER, "isupper", BT_FN_INT_INT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_LIB_BUILTIN (BUILT_IN_ISXDIGIT, "isxdigit", BT_FN_INT_INT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_TOASCII, "toascii", BT_FN_INT_INT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_LIB_BUILTIN (BUILT_IN_TOLOWER, "tolower", BT_FN_INT_INT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_LIB_BUILTIN (BUILT_IN_TOUPPER, "toupper", BT_FN_INT_INT, ATTR_PURE_NOTHROW_LEAF_LIST)
+
+/* Category: wctype builtins. */
+DEF_C94_BUILTIN (BUILT_IN_ISWALNUM, "iswalnum", BT_FN_INT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_C94_BUILTIN (BUILT_IN_ISWALPHA, "iswalpha", BT_FN_INT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_C99_BUILTIN (BUILT_IN_ISWBLANK, "iswblank", BT_FN_INT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_C94_BUILTIN (BUILT_IN_ISWCNTRL, "iswcntrl", BT_FN_INT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_C94_BUILTIN (BUILT_IN_ISWDIGIT, "iswdigit", BT_FN_INT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_C94_BUILTIN (BUILT_IN_ISWGRAPH, "iswgraph", BT_FN_INT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_C94_BUILTIN (BUILT_IN_ISWLOWER, "iswlower", BT_FN_INT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_C94_BUILTIN (BUILT_IN_ISWPRINT, "iswprint", BT_FN_INT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_C94_BUILTIN (BUILT_IN_ISWPUNCT, "iswpunct", BT_FN_INT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_C94_BUILTIN (BUILT_IN_ISWSPACE, "iswspace", BT_FN_INT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_C94_BUILTIN (BUILT_IN_ISWUPPER, "iswupper", BT_FN_INT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_C94_BUILTIN (BUILT_IN_ISWXDIGIT, "iswxdigit", BT_FN_INT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_C94_BUILTIN (BUILT_IN_TOWLOWER, "towlower", BT_FN_WINT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_C94_BUILTIN (BUILT_IN_TOWUPPER, "towupper", BT_FN_WINT_WINT, ATTR_PURE_NOTHROW_LEAF_LIST)
+
+/* Category: integer overflow checking builtins. */
+DEF_GCC_BUILTIN (BUILT_IN_ADD_OVERFLOW, "add_overflow", BT_FN_BOOL_VAR, ATTR_NOTHROW_TYPEGENERIC_LEAF)
+DEF_GCC_BUILTIN (BUILT_IN_SUB_OVERFLOW, "sub_overflow", BT_FN_BOOL_VAR, ATTR_NOTHROW_TYPEGENERIC_LEAF)
+DEF_GCC_BUILTIN (BUILT_IN_MUL_OVERFLOW, "mul_overflow", BT_FN_BOOL_VAR, ATTR_NOTHROW_TYPEGENERIC_LEAF)
+/* Clang compatibility. */
+DEF_GCC_BUILTIN (BUILT_IN_SADD_OVERFLOW, "sadd_overflow", BT_FN_BOOL_INT_INT_INTPTR, ATTR_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_SADDL_OVERFLOW, "saddl_overflow", BT_FN_BOOL_LONG_LONG_LONGPTR, ATTR_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_SADDLL_OVERFLOW, "saddll_overflow", BT_FN_BOOL_LONGLONG_LONGLONG_LONGLONGPTR, ATTR_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_SSUB_OVERFLOW, "ssub_overflow", BT_FN_BOOL_INT_INT_INTPTR, ATTR_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_SSUBL_OVERFLOW, "ssubl_overflow", BT_FN_BOOL_LONG_LONG_LONGPTR, ATTR_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_SSUBLL_OVERFLOW, "ssubll_overflow", BT_FN_BOOL_LONGLONG_LONGLONG_LONGLONGPTR, ATTR_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_SMUL_OVERFLOW, "smul_overflow", BT_FN_BOOL_INT_INT_INTPTR, ATTR_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_SMULL_OVERFLOW, "smull_overflow", BT_FN_BOOL_LONG_LONG_LONGPTR, ATTR_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_SMULLL_OVERFLOW, "smulll_overflow", BT_FN_BOOL_LONGLONG_LONGLONG_LONGLONGPTR, ATTR_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_UADD_OVERFLOW, "uadd_overflow", BT_FN_BOOL_UINT_UINT_UINTPTR, ATTR_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_UADDL_OVERFLOW, "uaddl_overflow", BT_FN_BOOL_ULONG_ULONG_ULONGPTR, ATTR_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_UADDLL_OVERFLOW, "uaddll_overflow", BT_FN_BOOL_ULONGLONG_ULONGLONG_ULONGLONGPTR, ATTR_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_USUB_OVERFLOW, "usub_overflow", BT_FN_BOOL_UINT_UINT_UINTPTR, ATTR_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_USUBL_OVERFLOW, "usubl_overflow", BT_FN_BOOL_ULONG_ULONG_ULONGPTR, ATTR_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_USUBLL_OVERFLOW, "usubll_overflow", BT_FN_BOOL_ULONGLONG_ULONGLONG_ULONGLONGPTR, ATTR_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_UMUL_OVERFLOW, "umul_overflow", BT_FN_BOOL_UINT_UINT_UINTPTR, ATTR_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_UMULL_OVERFLOW, "umull_overflow", BT_FN_BOOL_ULONG_ULONG_ULONGPTR, ATTR_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_UMULLL_OVERFLOW, "umulll_overflow", BT_FN_BOOL_ULONGLONG_ULONGLONG_ULONGLONGPTR, ATTR_NOTHROW_LEAF_LIST)
+
+/* Category: miscellaneous builtins. */
+DEF_LIB_BUILTIN (BUILT_IN_ABORT, "abort", BT_FN_VOID, ATTR_TMPURE_NORETURN_NOTHROW_LEAF_LIST)
+DEF_LIB_BUILTIN (BUILT_IN_ABS, "abs", BT_FN_INT_INT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_AGGREGATE_INCOMING_ADDRESS, "aggregate_incoming_address", BT_FN_PTR_VAR, ATTR_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_ALLOCA, "alloca", BT_FN_PTR_SIZE, ATTR_MALLOC_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_APPLY, "apply", BT_FN_PTR_PTR_FN_VOID_VAR_PTR_SIZE, ATTR_NULL)
+DEF_GCC_BUILTIN (BUILT_IN_APPLY_ARGS, "apply_args", BT_FN_PTR_VAR, ATTR_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_BSWAP16, "bswap16", BT_FN_UINT16_UINT16, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_BSWAP32, "bswap32", BT_FN_UINT32_UINT32, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_BSWAP64, "bswap64", BT_FN_UINT64_UINT64, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_CLEAR_CACHE, "__clear_cache", BT_FN_VOID_PTR_PTR, ATTR_NOTHROW_LEAF_LIST)
+/* [trans-mem]: Adjust BUILT_IN_TM_CALLOC if BUILT_IN_CALLOC is changed. */
+DEF_LIB_BUILTIN (BUILT_IN_CALLOC, "calloc", BT_FN_PTR_SIZE_SIZE, ATTR_MALLOC_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_CLASSIFY_TYPE, "classify_type", BT_FN_INT_VAR, ATTR_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_CLZ, "clz", BT_FN_INT_UINT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_CLZIMAX, "clzimax", BT_FN_INT_UINTMAX, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_CLZL, "clzl", BT_FN_INT_ULONG, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_CLZLL, "clzll", BT_FN_INT_ULONGLONG, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_CONSTANT_P, "constant_p", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_CTZ, "ctz", BT_FN_INT_UINT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_CTZIMAX, "ctzimax", BT_FN_INT_UINTMAX, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_CTZL, "ctzl", BT_FN_INT_ULONG, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_CTZLL, "ctzll", BT_FN_INT_ULONGLONG, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_CLRSB, "clrsb", BT_FN_INT_INT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_CLRSBIMAX, "clrsbimax", BT_FN_INT_INTMAX, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_CLRSBL, "clrsbl", BT_FN_INT_LONG, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_CLRSBLL, "clrsbll", BT_FN_INT_LONGLONG, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_DCGETTEXT, "dcgettext", BT_FN_STRING_CONST_STRING_CONST_STRING_INT, ATTR_FORMAT_ARG_2)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_DGETTEXT, "dgettext", BT_FN_STRING_CONST_STRING_CONST_STRING, ATTR_FORMAT_ARG_2)
+DEF_GCC_BUILTIN (BUILT_IN_DWARF_CFA, "dwarf_cfa", BT_FN_PTR, ATTR_NULL)
+DEF_GCC_BUILTIN (BUILT_IN_DWARF_SP_COLUMN, "dwarf_sp_column", BT_FN_UINT, ATTR_NULL)
+DEF_GCC_BUILTIN (BUILT_IN_EH_RETURN, "eh_return", BT_FN_VOID_PTRMODE_PTR, ATTR_NORETURN_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_EH_RETURN_DATA_REGNO, "eh_return_data_regno", BT_FN_INT_INT, ATTR_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_EXECL, "execl", BT_FN_INT_CONST_STRING_CONST_STRING_VAR, ATTR_SENTINEL_NOTHROW_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_EXECLP, "execlp", BT_FN_INT_CONST_STRING_CONST_STRING_VAR, ATTR_SENTINEL_NOTHROW_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_EXECLE, "execle", BT_FN_INT_CONST_STRING_CONST_STRING_VAR, ATTR_NOTHROW_SENTINEL_1)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_EXECV, "execv", BT_FN_INT_CONST_STRING_PTR_CONST_STRING, ATTR_NOTHROW_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_EXECVP, "execvp", BT_FN_INT_CONST_STRING_PTR_CONST_STRING, ATTR_NOTHROW_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_EXECVE, "execve", BT_FN_INT_CONST_STRING_PTR_CONST_STRING_PTR_CONST_STRING, ATTR_NOTHROW_LIST)
+DEF_LIB_BUILTIN (BUILT_IN_EXIT, "exit", BT_FN_VOID_INT, ATTR_NORETURN_NOTHROW_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_EXPECT, "expect", BT_FN_LONG_LONG_LONG, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_ASSUME_ALIGNED, "assume_aligned", BT_FN_PTR_CONST_PTR_SIZE_VAR, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_EXTEND_POINTER, "extend_pointer", BT_FN_UNWINDWORD_PTR, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_EXTRACT_RETURN_ADDR, "extract_return_addr", BT_FN_PTR_PTR, ATTR_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_FFS, "ffs", BT_FN_INT_INT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_FFSIMAX, "ffsimax", BT_FN_INT_INTMAX, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_FFSL, "ffsl", BT_FN_INT_LONG, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_FFSLL, "ffsll", BT_FN_INT_LONGLONG, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_FORK, "fork", BT_FN_PID, ATTR_NOTHROW_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_FRAME_ADDRESS, "frame_address", BT_FN_PTR_UINT, ATTR_NULL)
+/* [trans-mem]: Adjust BUILT_IN_TM_FREE if BUILT_IN_FREE is changed. */
+DEF_LIB_BUILTIN (BUILT_IN_FREE, "free", BT_FN_VOID_PTR, ATTR_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_FROB_RETURN_ADDR, "frob_return_addr", BT_FN_PTR_PTR, ATTR_NULL)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_GETTEXT, "gettext", BT_FN_STRING_CONST_STRING, ATTR_FORMAT_ARG_1)
+DEF_C99_BUILTIN (BUILT_IN_IMAXABS, "imaxabs", BT_FN_INTMAX_INTMAX, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_INIT_DWARF_REG_SIZES, "init_dwarf_reg_size_table", BT_FN_VOID_PTR, ATTR_NULL)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_FINITE, "finite", BT_FN_INT_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_FINITEF, "finitef", BT_FN_INT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_FINITEL, "finitel", BT_FN_INT_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_FINITED32, "finited32", BT_FN_INT_DFLOAT32, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_FINITED64, "finited64", BT_FN_INT_DFLOAT64, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_FINITED128, "finited128", BT_FN_INT_DFLOAT128, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_FPCLASSIFY, "fpclassify", BT_FN_INT_INT_INT_INT_INT_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF)
+DEF_GCC_BUILTIN (BUILT_IN_ISFINITE, "isfinite", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF)
+DEF_GCC_BUILTIN (BUILT_IN_ISINF_SIGN, "isinf_sign", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_ISINF, "isinf", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_ISINFF, "isinff", BT_FN_INT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_ISINFL, "isinfl", BT_FN_INT_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_ISINFD32, "isinfd32", BT_FN_INT_DFLOAT32, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_ISINFD64, "isinfd64", BT_FN_INT_DFLOAT64, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_ISINFD128, "isinfd128", BT_FN_INT_DFLOAT128, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_C90RES_BUILTIN (BUILT_IN_ISNAN, "isnan", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_ISNANF, "isnanf", BT_FN_INT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_ISNANL, "isnanl", BT_FN_INT_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_ISNAND32, "isnand32", BT_FN_INT_DFLOAT32, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_ISNAND64, "isnand64", BT_FN_INT_DFLOAT64, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_ISNAND128, "isnand128", BT_FN_INT_DFLOAT128, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_ISNORMAL, "isnormal", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF)
+DEF_GCC_BUILTIN (BUILT_IN_ISGREATER, "isgreater", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF)
+DEF_GCC_BUILTIN (BUILT_IN_ISGREATEREQUAL, "isgreaterequal", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF)
+DEF_GCC_BUILTIN (BUILT_IN_ISLESS, "isless", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF)
+DEF_GCC_BUILTIN (BUILT_IN_ISLESSEQUAL, "islessequal", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF)
+DEF_GCC_BUILTIN (BUILT_IN_ISLESSGREATER, "islessgreater", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF)
+DEF_GCC_BUILTIN (BUILT_IN_ISUNORDERED, "isunordered", BT_FN_INT_VAR, ATTR_CONST_NOTHROW_TYPEGENERIC_LEAF)
+DEF_LIB_BUILTIN (BUILT_IN_LABS, "labs", BT_FN_LONG_LONG, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_C99_BUILTIN (BUILT_IN_LLABS, "llabs", BT_FN_LONGLONG_LONGLONG, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_LONGJMP, "longjmp", BT_FN_VOID_PTR_INT, ATTR_NORETURN_NOTHROW_LIST)
+/* [trans-mem]: Adjust BUILT_IN_TM_MALLOC if BUILT_IN_MALLOC is changed. */
+DEF_LIB_BUILTIN (BUILT_IN_MALLOC, "malloc", BT_FN_PTR_SIZE, ATTR_MALLOC_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_NEXT_ARG, "next_arg", BT_FN_PTR_VAR, ATTR_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_PARITY, "parity", BT_FN_INT_UINT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_PARITYIMAX, "parityimax", BT_FN_INT_UINTMAX, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_PARITYL, "parityl", BT_FN_INT_ULONG, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_PARITYLL, "parityll", BT_FN_INT_ULONGLONG, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_POPCOUNT, "popcount", BT_FN_INT_UINT, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_POPCOUNTIMAX, "popcountimax", BT_FN_INT_UINTMAX, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_POPCOUNTL, "popcountl", BT_FN_INT_ULONG, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_POPCOUNTLL, "popcountll", BT_FN_INT_ULONGLONG, ATTR_CONST_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_POSIX_MEMALIGN, "posix_memalign", BT_FN_INT_PTRPTR_SIZE_SIZE, ATTR_NOTHROW_NONNULL_LEAF)
+DEF_GCC_BUILTIN (BUILT_IN_PREFETCH, "prefetch", BT_FN_VOID_CONST_PTR_VAR, ATTR_NOVOPS_LEAF_LIST)
+DEF_LIB_BUILTIN (BUILT_IN_REALLOC, "realloc", BT_FN_PTR_PTR_SIZE, ATTR_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_RETURN, "return", BT_FN_VOID_PTR, ATTR_NORETURN_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_RETURN_ADDRESS, "return_address", BT_FN_PTR_UINT, ATTR_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_SAVEREGS, "saveregs", BT_FN_PTR_VAR, ATTR_NULL)
+DEF_GCC_BUILTIN (BUILT_IN_SETJMP, "setjmp", BT_FN_INT_PTR, ATTR_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_STRFMON, "strfmon", BT_FN_SSIZE_STRING_SIZE_CONST_STRING_VAR, ATTR_FORMAT_STRFMON_NOTHROW_3_4)
+DEF_LIB_BUILTIN (BUILT_IN_STRFTIME, "strftime", BT_FN_SIZE_STRING_SIZE_CONST_STRING_CONST_PTR, ATTR_FORMAT_STRFTIME_NOTHROW_3_0)
+DEF_GCC_BUILTIN (BUILT_IN_TRAP, "trap", BT_FN_VOID, ATTR_NORETURN_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_UNREACHABLE, "unreachable", BT_FN_VOID, ATTR_CONST_NORETURN_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_UNWIND_INIT, "unwind_init", BT_FN_VOID, ATTR_NULL)
+DEF_GCC_BUILTIN (BUILT_IN_UPDATE_SETJMP_BUF, "update_setjmp_buf", BT_FN_VOID_PTR_INT, ATTR_NULL)
+DEF_GCC_BUILTIN (BUILT_IN_VA_COPY, "va_copy", BT_FN_VOID_VALIST_REF_VALIST_ARG, ATTR_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_VA_END, "va_end", BT_FN_VOID_VALIST_REF, ATTR_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_VA_START, "va_start", BT_FN_VOID_VALIST_REF_VAR, ATTR_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_VA_ARG_PACK, "va_arg_pack", BT_FN_INT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_VA_ARG_PACK_LEN, "va_arg_pack_len", BT_FN_INT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN (BUILT_IN__EXIT, "_exit", BT_FN_VOID_INT, ATTR_NORETURN_NOTHROW_LEAF_LIST)
+DEF_C99_BUILTIN (BUILT_IN__EXIT2, "_Exit", BT_FN_VOID_INT, ATTR_NORETURN_NOTHROW_LEAF_LIST)
+
+/* Implementing nested functions. */
+DEF_BUILTIN_STUB (BUILT_IN_INIT_TRAMPOLINE, "__builtin_init_trampoline")
+DEF_BUILTIN_STUB (BUILT_IN_INIT_HEAP_TRAMPOLINE, "__builtin_init_heap_trampoline")
+DEF_BUILTIN_STUB (BUILT_IN_ADJUST_TRAMPOLINE, "__builtin_adjust_trampoline")
+DEF_BUILTIN_STUB (BUILT_IN_NONLOCAL_GOTO, "__builtin_nonlocal_goto")
+
+/* Implementing __builtin_setjmp. */
+DEF_BUILTIN_STUB (BUILT_IN_SETJMP_SETUP, "__builtin_setjmp_setup")
+DEF_BUILTIN_STUB (BUILT_IN_SETJMP_RECEIVER, "__builtin_setjmp_receiver")
+
+/* Implementing variable sized local variables. */
+DEF_BUILTIN_STUB (BUILT_IN_STACK_SAVE, "__builtin_stack_save")
+DEF_BUILTIN_STUB (BUILT_IN_STACK_RESTORE, "__builtin_stack_restore")
+DEF_BUILTIN_STUB (BUILT_IN_ALLOCA_WITH_ALIGN, "__builtin_alloca_with_align")
+
+/* Object size checking builtins. */
+DEF_GCC_BUILTIN (BUILT_IN_OBJECT_SIZE, "object_size", BT_FN_SIZE_CONST_PTR_INT, ATTR_PURE_NOTHROW_LEAF_LIST)
+DEF_EXT_LIB_BUILTIN_CHKP (BUILT_IN_MEMCPY_CHK, "__memcpy_chk", BT_FN_PTR_PTR_CONST_PTR_SIZE_SIZE, ATTR_RET1_NOTHROW_NONNULL_LEAF)
+DEF_EXT_LIB_BUILTIN_CHKP (BUILT_IN_MEMMOVE_CHK, "__memmove_chk", BT_FN_PTR_PTR_CONST_PTR_SIZE_SIZE, ATTR_RET1_NOTHROW_NONNULL_LEAF)
+DEF_EXT_LIB_BUILTIN_CHKP (BUILT_IN_MEMPCPY_CHK, "__mempcpy_chk", BT_FN_PTR_PTR_CONST_PTR_SIZE_SIZE, ATTR_NOTHROW_NONNULL_LEAF)
+DEF_EXT_LIB_BUILTIN_CHKP (BUILT_IN_MEMSET_CHK, "__memset_chk", BT_FN_PTR_PTR_INT_SIZE_SIZE, ATTR_NOTHROW_NONNULL_LEAF)
+DEF_EXT_LIB_BUILTIN_CHKP (BUILT_IN_STPCPY_CHK, "__stpcpy_chk", BT_FN_STRING_STRING_CONST_STRING_SIZE, ATTR_NOTHROW_NONNULL_LEAF)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_STPNCPY_CHK, "__stpncpy_chk", BT_FN_STRING_STRING_CONST_STRING_SIZE_SIZE, ATTR_NOTHROW_NONNULL_LEAF)
+DEF_EXT_LIB_BUILTIN_CHKP (BUILT_IN_STRCAT_CHK, "__strcat_chk", BT_FN_STRING_STRING_CONST_STRING_SIZE, ATTR_NOTHROW_NONNULL_LEAF)
+DEF_EXT_LIB_BUILTIN_CHKP (BUILT_IN_STRCPY_CHK, "__strcpy_chk", BT_FN_STRING_STRING_CONST_STRING_SIZE, ATTR_NOTHROW_NONNULL_LEAF)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_STRNCAT_CHK, "__strncat_chk", BT_FN_STRING_STRING_CONST_STRING_SIZE_SIZE, ATTR_NOTHROW_NONNULL_LEAF)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_STRNCPY_CHK, "__strncpy_chk", BT_FN_STRING_STRING_CONST_STRING_SIZE_SIZE, ATTR_NOTHROW_NONNULL_LEAF)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_SNPRINTF_CHK, "__snprintf_chk", BT_FN_INT_STRING_SIZE_INT_SIZE_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_NOTHROW_5_6)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_SPRINTF_CHK, "__sprintf_chk", BT_FN_INT_STRING_INT_SIZE_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_NOTHROW_4_5)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_VSNPRINTF_CHK, "__vsnprintf_chk", BT_FN_INT_STRING_SIZE_INT_SIZE_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_NOTHROW_5_0)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_VSPRINTF_CHK, "__vsprintf_chk", BT_FN_INT_STRING_INT_SIZE_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_NOTHROW_4_0)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_FPRINTF_CHK, "__fprintf_chk", BT_FN_INT_FILEPTR_INT_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_3_4)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_PRINTF_CHK, "__printf_chk", BT_FN_INT_INT_CONST_STRING_VAR, ATTR_FORMAT_PRINTF_2_3)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_VFPRINTF_CHK, "__vfprintf_chk", BT_FN_INT_FILEPTR_INT_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_3_0)
+DEF_EXT_LIB_BUILTIN (BUILT_IN_VPRINTF_CHK, "__vprintf_chk", BT_FN_INT_INT_CONST_STRING_VALIST_ARG, ATTR_FORMAT_PRINTF_2_0)
+
+/* Profiling hooks. */
+DEF_BUILTIN (BUILT_IN_PROFILE_FUNC_ENTER, "__cyg_profile_func_enter", BUILT_IN_NORMAL, BT_FN_VOID_PTR_PTR, BT_LAST,
+ false, false, false, ATTR_NULL, true, true)
+DEF_BUILTIN (BUILT_IN_PROFILE_FUNC_EXIT, "__cyg_profile_func_exit", BUILT_IN_NORMAL, BT_FN_VOID_PTR_PTR, BT_LAST,
+ false, false, false, ATTR_NULL, true, true)
+
+/* TLS thread pointer related builtins. */
+DEF_BUILTIN (BUILT_IN_THREAD_POINTER, "__builtin_thread_pointer",
+ BUILT_IN_NORMAL, BT_FN_PTR, BT_LAST,
+ false, false, true, ATTR_CONST_NOTHROW_LIST, true,
+ targetm.have_tls)
+
+DEF_BUILTIN (BUILT_IN_SET_THREAD_POINTER, "__builtin_set_thread_pointer",
+ BUILT_IN_NORMAL, BT_FN_VOID_PTR, BT_LAST,
+ false, false, true, ATTR_NOTHROW_LIST, true,
+ targetm.have_tls)
+
+/* TLS emulation. */
+DEF_BUILTIN (BUILT_IN_EMUTLS_GET_ADDRESS, targetm.emutls.get_address,
+ BUILT_IN_NORMAL,
+ BT_FN_PTR_PTR, BT_FN_PTR_PTR,
+ true, true, true, ATTR_CONST_NOTHROW_NONNULL_LEAF, false,
+ !targetm.have_tls)
+DEF_BUILTIN (BUILT_IN_EMUTLS_REGISTER_COMMON,
+ targetm.emutls.register_common, BUILT_IN_NORMAL,
+ BT_FN_VOID_PTR_WORD_WORD_PTR, BT_FN_VOID_PTR_WORD_WORD_PTR,
+ true, true, true, ATTR_NOTHROW_LEAF_LIST, false,
+ !targetm.have_tls)
+
+/* Exception support. */
+DEF_BUILTIN_STUB (BUILT_IN_UNWIND_RESUME, "__builtin_unwind_resume")
+DEF_BUILTIN_STUB (BUILT_IN_CXA_END_CLEANUP, "__builtin_cxa_end_cleanup")
+DEF_BUILTIN_STUB (BUILT_IN_EH_POINTER, "__builtin_eh_pointer")
+DEF_BUILTIN_STUB (BUILT_IN_EH_FILTER, "__builtin_eh_filter")
+DEF_BUILTIN_STUB (BUILT_IN_EH_COPY_VALUES, "__builtin_eh_copy_values")
+
+/* __FILE__, __LINE__, __FUNCTION__ as builtins. */
+DEF_GCC_BUILTIN (BUILT_IN_FILE, "FILE", BT_FN_CONST_STRING, ATTR_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_FUNCTION, "FUNCTION", BT_FN_CONST_STRING, ATTR_NOTHROW_LEAF_LIST)
+DEF_GCC_BUILTIN (BUILT_IN_LINE, "LINE", BT_FN_INT, ATTR_NOTHROW_LEAF_LIST)
+
+#if 0 //Ifdefed out because we hard-coded the proper overloadings of the atomic built-ins
+/* Synchronization Primitives. */
+#include "sync-builtins.def"
+
+/* Offloading and Multi Processing builtins. */
+#include "omp-builtins.def"
+
+/* Cilk keywords builtins. */
+#include "cilk-builtins.def"
+
+/* GTM builtins. */
+#include "gtm-builtins.def"
+
+/* Sanitizer builtins. */
+#include "sanitizer.def"
+
+/* Cilk Plus builtins. */
+#include "cilkplus.def"
+
+/* Pointer Bounds Checker builtins. */
+#include "chkp-builtins.def"
+#endif
+
+#undef DEF_BUILTIN_CHKP
+#undef DEF_BUILTIN
Index: libcfa/prelude/extras.c
===================================================================
--- libcfa/prelude/extras.c (revision bf71cfdb7285490eee552b461158846f626cc52f)
+++ libcfa/prelude/extras.c (revision bf71cfdb7285490eee552b461158846f626cc52f)
@@ -0,0 +1,6 @@
+#include // size_t, ptrdiff_t
+#include // intX_t, uintX_t, where X is 8, 16, 32, 64
+#include // char16_t, char32_t
+#include // wchar_t
+#include // malloc, free, exit, atexit, abort
+#include // printf
Index: libcfa/prelude/extras.regx
===================================================================
--- libcfa/prelude/extras.regx (revision bf71cfdb7285490eee552b461158846f626cc52f)
+++ libcfa/prelude/extras.regx (revision bf71cfdb7285490eee552b461158846f626cc52f)
@@ -0,0 +1,27 @@
+typedef.* size_t;
+typedef.* ptrdiff_t;
+typedef.* __int8_t;
+typedef.* __int16_t;
+typedef.* __int32_t;
+typedef.* __int64_t;
+typedef.* __uint8_t;
+typedef.* __uint16_t;
+typedef.* __uint32_t;
+typedef.* __uint64_t;
+typedef.* int8_t;
+typedef.* int16_t;
+typedef.* int32_t;
+typedef.* int64_t;
+typedef.* uint8_t;
+typedef.* uint16_t;
+typedef.* uint32_t;
+typedef.* uint64_t;
+typedef.* char16_t;
+typedef.* char32_t;
+typedef.* wchar_t;
+extern.*\*malloc\(.*\).*
+extern.* free\(.*\).*
+extern.* exit\(.*\).*
+extern.* atexit\(.*\).*
+extern.* abort\(.*\).*
+extern.* printf\(.*\).*
Index: libcfa/prelude/prelude-gen.cc
===================================================================
--- libcfa/prelude/prelude-gen.cc (revision bf71cfdb7285490eee552b461158846f626cc52f)
+++ libcfa/prelude/prelude-gen.cc (revision bf71cfdb7285490eee552b461158846f626cc52f)
@@ -0,0 +1,388 @@
+#include
+#include
+#include
+#include
+#include
+using namespace std;
+
+static struct{
+ const string name;
+ bool isFloat;
+ bool hasComparison;
+} basicTypes[] = {
+ // { "char" , false, true , },
+ // { "signed char" , false, true , },
+ // { "unsigned char" , false, true , },
+ { "signed short" , false, true , },
+ { "unsigned short" , false, true , },
+ { "signed int" , false, true , },
+ { "unsigned int" , false, true , },
+ { "signed long int" , false, true , },
+ { "unsigned long int" , false, true , },
+ { "signed long long int" , false, true , },
+ { "unsigned long long int", false, true , },
+ { "float" , true , true , },
+ { "double" , true , true , },
+ { "long double" , true , true , },
+ { "float _Complex" , true , false, },
+ { "double _Complex" , true , false, },
+ { "long double _Complex" , true , false, },
+#if defined(__SIZEOF_INT128__)
+ { "__int128" , false, true , },
+ { "unsigned __int128" , false, true , },
+#endif
+#if defined(__i386__) || defined(__ia64__) || defined(__x86_64__)
+ { "__float80" , true , true , },
+ { "_Float128" , true , true , },
+#endif
+};
+
+struct {
+ const string name;
+ bool assignment = false;
+ bool floatCompat = true;
+ bool isComparison = false;
+ bool isEqual = false;
+} arithmeticOperators[] = {
+ { "?++" , true , true, false, false },
+ { "?--" , true , true, false, false },
+ { "++?" , true , true, false, false },
+ { "--?" , true , true, false, false },
+ { "+?" , false, true , false, false },
+ { "-?" , false, true , false, false },
+ { "~?" , false, false, false, false },
+ { "!?" , false, true , false, true },
+ { "?*?" , false, true , false, false },
+ { "?/?" , false, true , false, false },
+ { "?%?" , false, false, false, false },
+ { "?+?" , false, true , false, false },
+ { "?-?" , false, true , false, false },
+ { "?<>?" , false, false, false, false },
+ { "??" , false, true , true , false },
+ { "?>=?" , false, true , true , true },
+ { "?==?" , false, true , false, true },
+ { "?!=?" , false, true , false, true },
+ { "?&?" , false, false, false, false },
+ { "?^?" , false, false, false, false },
+ { "?|?" , false, false, false, false },
+ { "?=?" , true , true , false, false },
+ { "?+=?" , true , true , false, false },
+ { "?-=?" , true , true , false, false },
+ { "?*=?" , true , true , false, false },
+ { "?/=?" , true , true , false, false },
+ { "?%=?" , true , false, false, false },
+ { "?<<=?", true , false, false, false },
+ { "?>>=?", true , false, false, false },
+ { "?&=?" , true , false, false, false },
+ { "?|=?" , true , false, false, false },
+ { "?^=?" , true , false, false, false },
+};
+
+enum ArgType { Normal, PtrDiff, CommPtrDiff };
+
+struct {
+ const string name;
+ bool assignment = false;
+ string diffReturn;
+ ArgType diffArg2 = Normal;
+ string sized;
+} pointerOperators[] = {
+ { "?++", true, "", Normal, " | sized(DT)" },
+ { "?--", true, "", Normal, " | sized(DT)" },
+ { "++?", true, "", Normal, " | sized(DT)" },
+ { "--?", true, "", Normal, " | sized(DT)" },
+ { "!?" , false, "int", Normal, "" },
+ { "??", false, "signed int", Normal, "" },
+ { "?>=?", false, "signed int", Normal, "" },
+ { "?==?", false, "signed int", Normal, "" },
+ { "?!=?", false, "signed int", Normal, "" },
+ { "?=?", true, "", Normal, "" }, // void * LHS, zero_t RHS ???
+ { "*?", false, "&", Normal, " | sized(DT)" }, // & ???
+
+ { "?-?", false, "ptrdiff_t", Normal, " | sized(DT)" },
+ { "?-?", false, "", PtrDiff, " | sized(DT)" },
+ { "?-=?", true, "", PtrDiff, " | sized(DT)" },
+
+ { "?+?", false, "", CommPtrDiff, " | sized(DT)" },
+ { "?[?]", false, "&", CommPtrDiff, " | sized(DT)" }, // & ???
+ { "?+=?" , true, "", PtrDiff, " | sized(DT)" },
+};
+
+template
+string mask2string(unsigned int mask, array names) {
+ string result = "";
+ int i = 0;
+ for(auto name : names) {
+ if(mask & (1 << i)) {
+ result += name;
+ } else {
+ result.append(name.size(), ' ');
+ }
+ i++;
+ }
+ return result;
+}
+
+template
+constexpr auto make_array(T&&... values) ->
+ std::array<
+ typename std::decay::type>::type,
+ sizeof...(T)>
+{
+ return std::array<
+ typename std::decay<
+ typename std::common_type::type>::type,
+ sizeof...(T)>{{std::forward(values)...}};
+}
+
+int main() {
+ cout << "# 2 \"prelude.cf\" // needed for error messages from this file" << endl;
+ cout << "trait sized(dtype T) {};" << endl;
+
+ cout << "//////////////////////////" << endl;
+ cout << "// Arithmetic Operators //" << endl;
+ cout << "//////////////////////////" << endl;
+ cout << endl;
+
+ cout << "signed int ?==?( zero_t, zero_t ), ?!=?( zero_t, zero_t );" << endl;
+ cout << "signed int ?==?( one_t, one_t ), ?!=?( one_t, one_t );" << endl;
+ cout << "signed int ?==?( _Bool, _Bool ), ?!=?( _Bool, _Bool );" << endl;
+ cout << "signed int !?( _Bool );" << endl;
+
+ for (auto op : arithmeticOperators) {
+ for (auto type : basicTypes ) {
+ auto operands = count(op.name.begin(), op.name.end(), '?');
+ if (! op.floatCompat && type.isFloat) continue;
+ if (op.isComparison && ! type.hasComparison) continue;
+ if (op.assignment) {
+ const char * qualifiers[] = { "", "volatile " };
+ for (auto q : qualifiers){
+ cout << type.name << " " << op.name << "(";
+ cout << q << type.name << " &";
+ for (int i = 1; i < operands; ++i) {
+ cout << ", " << type.name;
+ }
+ cout << ");" << endl;
+ }
+ } else {
+ if (op.isComparison || op.isEqual) cout << "signed int";
+ else cout << type.name;
+ cout << " " << op.name << "(";
+ for (int i = 0; i < operands; ++i) {
+ cout << type.name;
+ if ((i+1) != operands) cout << ", ";
+ }
+ cout << ");" << endl;
+ }
+ }
+ cout << endl;
+ }
+ cout << endl;
+
+ cout << "/////////////////////////////" << endl;
+ cout << "// Arithmetic Constructors //" << endl;
+ cout << "/////////////////////////////" << endl;
+ auto otype = [](const std::string & type, bool do_volatile = false) {
+ cout << "void \t?{} ( " << type << " & );" << endl;
+ cout << "void \t?{} ( " << type << " &, " << type << " );" << endl;
+ cout << type << " \t?=? ( " << type << " &, " << type << " )";
+ if( do_volatile ) {
+ cout << ", \t?=?( volatile " << type << " &, " << type << " )";
+ }
+ cout << ";" << endl;
+ cout << "void \t^?{}( " << type << " & );" << endl;
+ };
+
+ otype("zero_t");
+ otype("one_t");
+ otype("_Bool", true);
+ otype("char", true);
+ otype("signed char", true);
+ otype("unsigned char", true);
+
+ for (auto type : basicTypes) {
+ cout << "void ?{}(" << type.name << " &);" << endl;
+ cout << "void ?{}(" << type.name << " &, " << type.name << ");" << endl;
+ cout << "void ^?{}(" << type.name << " &);" << endl;
+ cout << endl;
+ }
+ cout << endl;
+
+ cout << "//////////////////////////" << endl;
+ cout << "// Pointer Constructors //" << endl;
+ cout << "//////////////////////////" << endl;
+ cout << "forall(ftype FT) void ?{}( FT *&, FT * );" << endl;
+ cout << "forall(ftype FT) void ?{}( FT * volatile &, FT * );" << endl;
+
+ // generate qualifiers
+ vector qualifiersSingle;
+ vector> qualifiersPair;
+ const unsigned int NQ = 2;
+ for(unsigned int lhs = 0; lhs < (1<>?( signed int, signed int );
+unsigned int ?<>?( unsigned int, unsigned int );
+signed long int ?<>?( signed long int, signed long int );
+unsigned long int ?<>?( unsigned long int, unsigned long int );
+signed long long int ?<>?( signed long long int, signed long long int );
+unsigned long long int ?<>?( unsigned long long int, unsigned long long int );
+
+// ------------------------------------------------------------
+//
+// Section 4.8 Relational Operators
+//
+// ------------------------------------------------------------
+
+signed int ??( _Bool, _Bool ), ?>=?( _Bool, _Bool );
+signed int ??( char, char ), ?>=?( char, char );
+signed int ??( signed char, signed char ), ?>=?( signed char, signed char );
+signed int ??( unsigned char, unsigned char ), ?>=?( unsigned char, unsigned char );
+signed int ??( signed short, signed short ), ?>=?( signed short, signed short );
+signed int ??( unsigned short, unsigned short ), ?>=?( unsigned short, unsigned short );
+signed int ??( signed int, signed int ), ?>=?( signed int, signed int );
+signed int ??( unsigned int, unsigned int ), ?>=?( unsigned int, unsigned int );
+signed int ??( signed long int, signed long int ), ?>=?( signed long int, signed long int );
+signed int ??( unsigned long int, unsigned long int ), ?>=?( unsigned long int, unsigned long int );
+signed int ??( signed long long int, signed long long int ), ?>=?( signed long long int, signed long long int );
+signed int ??( unsigned long long int, unsigned long long int ), ?>=?( unsigned long long int, unsigned long long int );
+signed int ??( float, float ), ?>=?( float, float );
+signed int ??( double, double ), ?>=?( double, double );
+signed int ??( long double, long double ), ?>=?( long double, long double );
+
+forall( dtype DT ) signed int ??( DT *, DT * );
+forall( dtype DT ) signed int ?>?( const DT *, const DT * );
+forall( dtype DT ) signed int ?>?( volatile DT *, volatile DT * );
+forall( dtype DT ) signed int ?>?( const volatile DT *, const volatile DT * );
+
+forall( dtype DT ) signed int ?<=?( DT *, DT * );
+forall( dtype DT ) signed int ?<=?( const DT *, const DT * );
+forall( dtype DT ) signed int ?<=?( volatile DT *, volatile DT * );
+forall( dtype DT ) signed int ?<=?( const volatile DT *, const volatile DT * );
+
+forall( dtype DT ) signed int ?>=?( DT *, DT * );
+forall( dtype DT ) signed int ?>=?( const DT *, const DT * );
+forall( dtype DT ) signed int ?>=?( volatile DT *, volatile DT * );
+forall( dtype DT ) signed int ?>=?( const volatile DT *, const volatile DT * );
+
+// ------------------------------------------------------------
+//
+// Section 4.9 Equality Operators
+//
+// ------------------------------------------------------------
+
+signed int ?==?( _Bool, _Bool ), ?!=?( _Bool, _Bool );
+signed int ?==?( char, char ), ?!=?( char, char );
+signed int ?==?( signed char, signed char ), ?!=?( signed char, signed char );
+signed int ?==?( unsigned char, unsigned char ), ?!=?( unsigned char, unsigned char );
+signed int ?==?( signed short, signed short ), ?!=?( signed short, signed short );
+signed int ?==?( unsigned short, unsigned short ), ?!=?( unsigned short, unsigned short );
+signed int ?==?( signed int, signed int ), ?!=?( signed int, signed int );
+signed int ?==?( unsigned int, unsigned int ), ?!=?( unsigned int, unsigned int );
+signed int ?==?( signed long int, signed long int ), ?!=?( signed long int, signed long int );
+signed int ?==?( unsigned long int, unsigned long int ), ?!=?( unsigned long int, unsigned long int );
+signed int ?==?( signed long long int, long long int signed), ?!=?( signed long long int, signed long long int );
+signed int ?==?( unsigned long long int, unsigned long long int ), ?!=?( unsigned long long int, unsigned long long int );
+signed int ?==?( float, float ), ?!=?( float, float );
+signed int ?==?( double, double ), ?!=?( double, double );
+signed int ?==?( long double, long double ), ?!=?( long double, long double );
+signed int ?==?( float _Complex, float _Complex ), ?!=?( float _Complex, float _Complex );
+signed int ?==?( double _Complex, double _Complex ), ?!=?( double _Complex, double _Complex );
+signed int ?==?( long double _Complex, long double _Complex ), ?!=?( long double _Complex, long double _Complex );
+signed int ?==?( zero_t, zero_t ), ?!=?( zero_t, zero_t );
+signed int ?==?( one_t, one_t ), ?!=?( one_t, one_t );
+
+forall( dtype DT ) signed int ?==?( DT *, DT * );
+forall( dtype DT ) signed int ?==?( const DT *, const DT * );
+forall( dtype DT ) signed int ?==?( volatile DT *, volatile DT * );
+forall( dtype DT ) signed int ?==?( const volatile DT *, const volatile DT * );
+forall( ftype FT ) signed int ?==?( FT *, FT * );
+forall( dtype DT ) signed int ?!=?( DT *, DT * );
+forall( dtype DT ) signed int ?!=?( const DT *, const DT * );
+forall( dtype DT ) signed int ?!=?( volatile DT *, volatile DT * );
+forall( dtype DT ) signed int ?!=?( const volatile DT *, const volatile DT * );
+forall( ftype FT ) signed int ?!=?( FT *, FT * );
+
+// forall( dtype DT ) signed int ?==?( const volatile DT *, const volatile void * );
+// forall( dtype DT ) signed int ?==?( const volatile void *, const volatile DT * );
+// forall( dtype DT ) signed int ?!=?( const volatile DT *, const volatile void * );
+// forall( dtype DT ) signed int ?!=?( const volatile void *, const volatile DT * );
+
+// forall( dtype DT ) signed int ?==?( const volatile DT *, zero_t );
+// forall( dtype DT ) signed int ?==?( zero_t, const volatile DT * );
+// forall( ftype FT ) signed int ?==?( FT *, zero_t );
+// forall( ftype FT ) signed int ?==?( zero_t, FT * );
+// forall( dtype DT ) signed int ?!=?( const volatile DT *, zero_t );
+// forall( dtype DT ) signed int ?!=?( zero_t, const volatile DT * );
+// forall( ftype FT ) signed int ?!=?( FT *, zero_t );
+// forall( ftype FT ) signed int ?!=?( zero_t, FT * );
+
+// ------------------------------------------------------------
+//
+// Section 4.10 Bitwise AND Operators
+//
+// ------------------------------------------------------------
+
+_Bool ?&?( _Bool, _Bool );
+signed int ?&?( signed int, signed int );
+unsigned int ?&?( unsigned int, unsigned int );
+signed long int ?&?( signed long int, signed long int );
+unsigned long int ?&?( unsigned long int, unsigned long int );
+signed long long int ?&?( signed long long int, signed long long int );
+unsigned long long int ?&?( unsigned long long int, unsigned long long int );
+
+// ------------------------------------------------------------
+//
+// Section 4.11 Bitwise XOR Operators
+//
+// ------------------------------------------------------------
+
+_Bool ?^?( _Bool, _Bool );
+signed int ?^?( signed int, signed int );
+unsigned int ?^?( unsigned int, unsigned int );
+signed long int ?^?( signed long int, signed long int );
+unsigned long int ?^?( unsigned long int, unsigned long int );
+signed long long int ?^?( signed long long int, signed long long int );
+unsigned long long int ?^?( unsigned long long int, unsigned long long int );
+
+// ------------------------------------------------------------
+//
+// Section 4.12 Bitwise OR Operators
+//
+// ------------------------------------------------------------
+
+_Bool ?|?( _Bool, _Bool );
+signed int ?|?( signed int, signed int );
+unsigned int ?|?( unsigned int, unsigned int );
+signed long int ?|?( signed long int, signed long int );
+unsigned long int ?|?( unsigned long int, unsigned long int );
+signed long long int ?|?( signed long long int, signed long long int );
+unsigned long long int ?|?( unsigned long long int, unsigned long long int );
+
+// ------------------------------------------------------------
+//
+// Section 4.16 Assignment Operator
+//
+// ------------------------------------------------------------
+
+forall( ftype FT ) FT * ?=?( FT *&, FT * );
+forall( ftype FT ) FT * ?=?( FT * volatile &, FT * );
+
+forall( dtype DT ) DT * ?=?( DT * &, DT * );
+forall( dtype DT ) DT * ?=?( DT * volatile &, DT * );
+forall( dtype DT ) const DT * ?=?( const DT * &, DT * );
+forall( dtype DT ) const DT * ?=?( const DT * volatile &, DT * );
+forall( dtype DT ) const DT * ?=?( const DT * &, const DT * );
+forall( dtype DT ) const DT * ?=?( const DT * volatile &, const DT * );
+forall( dtype DT ) volatile DT * ?=?( volatile DT * &, DT * );
+forall( dtype DT ) volatile DT * ?=?( volatile DT * volatile &, DT * );
+forall( dtype DT ) volatile DT * ?=?( volatile DT * &, volatile DT * );
+forall( dtype DT ) volatile DT * ?=?( volatile DT * volatile &, volatile DT * );
+
+forall( dtype DT ) const volatile DT * ?=?( const volatile DT * &, DT * );
+forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile &, DT * );
+forall( dtype DT ) const volatile DT * ?=?( const volatile DT * &, const DT * );
+forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile &, const DT * );
+forall( dtype DT ) const volatile DT * ?=?( const volatile DT * &, volatile DT * );
+forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile &, volatile DT * );
+forall( dtype DT ) const volatile DT * ?=?( const volatile DT * &, const volatile DT * );
+forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile &, const volatile DT * );
+
+forall( dtype DT ) void * ?=?( void * &, DT * );
+forall( dtype DT ) void * ?=?( void * volatile &, DT * );
+forall( dtype DT ) const void * ?=?( const void * &, DT * );
+forall( dtype DT ) const void * ?=?( const void * volatile &, DT * );
+forall( dtype DT ) const void * ?=?( const void * &, const DT * );
+forall( dtype DT ) const void * ?=?( const void * volatile &, const DT * );
+forall( dtype DT ) volatile void * ?=?( volatile void * &, DT * );
+forall( dtype DT ) volatile void * ?=?( volatile void * volatile &, DT * );
+forall( dtype DT ) volatile void * ?=?( volatile void * &, volatile DT * );
+forall( dtype DT ) volatile void * ?=?( volatile void * volatile &, volatile DT * );
+forall( dtype DT ) const volatile void * ?=?( const volatile void * &, DT * );
+forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &, DT * );
+forall( dtype DT ) const volatile void * ?=?( const volatile void * &, const DT * );
+forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &, const DT * );
+forall( dtype DT ) const volatile void * ?=?( const volatile void * &, volatile DT * );
+forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &, volatile DT * );
+forall( dtype DT ) const volatile void * ?=?( const volatile void * &, const volatile DT * );
+forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &, const volatile DT * );
+
+//forall( dtype DT ) DT * ?=?( DT * &, zero_t );
+//forall( dtype DT ) DT * ?=?( DT * volatile &, zero_t );
+forall( dtype DT ) const DT * ?=?( const DT * &, zero_t );
+forall( dtype DT ) const DT * ?=?( const DT * volatile &, zero_t );
+//forall( dtype DT ) volatile DT * ?=?( volatile DT * &, zero_t );
+//forall( dtype DT ) volatile DT * ?=?( volatile DT * volatile &, zero_t );
+forall( dtype DT ) const volatile DT * ?=?( const volatile DT * &, zero_t );
+forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile &, zero_t );
+
+forall( ftype FT ) FT * ?=?( FT * &, zero_t );
+forall( ftype FT ) FT * ?=?( FT * volatile &, zero_t );
+
+forall( dtype T | sized(T) ) T * ?+=?( T * &, ptrdiff_t );
+forall( dtype T | sized(T) ) T * ?+=?( T * volatile &, ptrdiff_t );
+forall( dtype T | sized(T) ) const T * ?+=?( const T * &, ptrdiff_t );
+forall( dtype T | sized(T) ) const T * ?+=?( const T * volatile &, ptrdiff_t );
+forall( dtype T | sized(T) ) volatile T * ?+=?( volatile T * &, ptrdiff_t );
+forall( dtype T | sized(T) ) volatile T * ?+=?( volatile T * volatile &, ptrdiff_t );
+forall( dtype T | sized(T) ) const volatile T * ?+=?( const volatile T * &, ptrdiff_t );
+forall( dtype T | sized(T) ) const volatile T * ?+=?( const volatile T * volatile &, ptrdiff_t );
+forall( dtype T | sized(T) ) T * ?-=?( T * &, ptrdiff_t );
+forall( dtype T | sized(T) ) T * ?-=?( T * volatile &, ptrdiff_t );
+forall( dtype T | sized(T) ) const T * ?-=?( const T * &, ptrdiff_t );
+forall( dtype T | sized(T) ) const T * ?-=?( const T * volatile &, ptrdiff_t );
+forall( dtype T | sized(T) ) volatile T * ?-=?( volatile T * &, ptrdiff_t );
+forall( dtype T | sized(T) ) volatile T * ?-=?( volatile T * volatile &, ptrdiff_t );
+forall( dtype T | sized(T) ) const volatile T * ?-=?( const volatile T * &, ptrdiff_t );
+forall( dtype T | sized(T) ) const volatile T * ?-=?( const volatile T * volatile &, ptrdiff_t );
+
+_Bool ?=?( _Bool &, _Bool ), ?=?( volatile _Bool &, _Bool );
+char ?=?( char &, char ), ?=?( volatile char &, char );
+char signed ?=?( char signed &, char signed ), ?=?( volatile char signed &, char signed );
+char unsigned ?=?( char unsigned &, char unsigned ), ?=?( volatile char unsigned &, char unsigned );
+int short ?=?( int short &, int short ), ?=?( volatile int short &, int short );
+int short unsigned ?=?( int short unsigned &, int short unsigned ), ?=?( volatile int short unsigned &, int short unsigned );
+signed int ?=?( signed int &, signed int ), ?=?( volatile signed int &, signed int );
+unsigned int ?=?( unsigned &, unsigned ), ?=?( volatile unsigned &, unsigned );
+signed long int ?=?( signed long int &, signed long int ), ?=?( volatile signed long int &, signed long int );
+unsigned long int ?=?( unsigned long int &, unsigned long int ), ?=?( volatile unsigned long int &, unsigned long int );
+signed long long int ?=?( signed long long int &, signed long long int ), ?=?( volatile signed long long int &, signed long long int );
+unsigned long long int ?=?( unsigned long long int &, unsigned long long int ), ?=?( volatile unsigned long long int &, unsigned long long int );
+zero_t ?=?( zero_t &, zero_t );
+one_t ?=?( one_t &, one_t );
+
+
+char ?*=?( char &, char ), ?*=?( volatile char &, char );
+char signed ?*=?( char signed &, char signed ), ?*=?( volatile char signed &, char signed );
+char unsigned ?*=?( char unsigned &, char unsigned ), ?*=?( volatile char unsigned &, char unsigned );
+int short ?*=?( int short &, int short ), ?*=?( volatile int short &, int short );
+int short unsigned ?*=?( int short unsigned &, int short unsigned ), ?*=?( volatile int short unsigned &, int short unsigned );
+signed int ?*=?( signed int &, signed int ), ?*=?( volatile signed int &, signed int );
+unsigned int ?*=?( unsigned &, unsigned ), ?*=?( volatile unsigned &, unsigned );
+signed long int ?*=?( signed long int &, signed long int ), ?*=?( volatile signed long int &, signed long int );
+unsigned long int ?*=?( unsigned long int &, unsigned long int ), ?*=?( volatile unsigned long int &, unsigned long int );
+signed long long int ?*=?( signed long long int &, signed long long int ), ?*=?( volatile signed long long int &, signed long long int );
+unsigned long long int ?*=?( unsigned long long int &, unsigned long long int ), ?*=?( volatile unsigned long long int &, unsigned long long int );
+
+_Bool ?/=?( _Bool &, _Bool ), ?/=?( volatile _Bool &, _Bool );
+char ?/=?( char &, char ), ?/=?( volatile char &, char );
+char signed ?/=?( char signed &, char signed ), ?/=?( volatile char signed &, char signed );
+char unsigned ?/=?( char unsigned &, char unsigned ), ?/=?( volatile char unsigned &, char unsigned );
+int short ?/=?( int short &, int short ), ?/=?( volatile int short &, int short );
+int short unsigned ?/=?( int short unsigned &, int short unsigned ), ?/=?( volatile int short unsigned &, int short unsigned );
+signed int ?/=?( signed int &, signed int ), ?/=?( volatile signed int &, signed int );
+unsigned int ?/=?( unsigned &, unsigned ), ?/=?( volatile unsigned &, unsigned );
+signed long int ?/=?( signed long int &, signed long int ), ?/=?( volatile signed long int &, signed long int );
+unsigned long int ?/=?( unsigned long int &, unsigned long int ), ?/=?( volatile unsigned long int &, unsigned long int );
+signed long long int ?/=?( signed long long int &, signed long long int ), ?/=?( volatile signed long long int &, signed long long int );
+unsigned long long int ?/=?( unsigned long long int &, unsigned long long int ), ?/=?( volatile unsigned long long int &, unsigned long long int );
+
+_Bool ?%=?( _Bool &, _Bool ), ?%=?( volatile _Bool &, _Bool );
+char ?%=?( char &, char ), ?%=?( volatile char &, char );
+char signed ?%=?( char signed &, char signed ), ?%=?( volatile char signed &, char signed );
+char unsigned ?%=?( char unsigned &, char unsigned ), ?%=?( volatile char unsigned &, char unsigned );
+int short ?%=?( int short &, int short ), ?%=?( volatile int short &, int short );
+int short unsigned ?%=?( int short unsigned &, int short unsigned ), ?%=?( volatile int short unsigned &, int short unsigned );
+signed int ?%=?( signed int &, signed int ), ?%=?( volatile signed int &, signed int );
+unsigned int ?%=?( unsigned &, unsigned ), ?%=?( volatile unsigned &, unsigned );
+signed long int ?%=?( signed long int &, signed long int ), ?%=?( volatile signed long int &, signed long int );
+unsigned long int ?%=?( unsigned long int &, unsigned long int ), ?%=?( volatile unsigned long int &, unsigned long int );
+signed long long int ?%=?( signed long long int &, signed long long int ), ?%=?( volatile signed long long int &, signed long long int );
+unsigned long long int ?%=?( unsigned long long int &, unsigned long long int ), ?%=?( volatile unsigned long long int &, unsigned long long int );
+
+_Bool ?+=?( _Bool &, _Bool ), ?+=?( volatile _Bool &, _Bool );
+char ?+=?( char &, char ), ?+=?( volatile char &, char );
+char signed ?+=?( char signed &, char signed ), ?+=?( volatile char signed &, char signed );
+char unsigned ?+=?( char unsigned &, char unsigned ), ?+=?( volatile char unsigned &, char unsigned );
+int short ?+=?( int short &, int short ), ?+=?( volatile int short &, int short );
+int short unsigned ?+=?( int short unsigned &, int short unsigned ), ?+=?( volatile int short unsigned &, int short unsigned );
+signed int ?+=?( signed int &, signed int ), ?+=?( volatile signed int &, signed int );
+unsigned int ?+=?( unsigned &, unsigned ), ?+=?( volatile unsigned &, unsigned );
+signed long int ?+=?( signed long int &, signed long int ), ?+=?( volatile signed long int &, signed long int );
+unsigned long int ?+=?( unsigned long int &, unsigned long int ), ?+=?( volatile unsigned long int &, unsigned long int );
+signed long long int ?+=?( signed long long int &, signed long long int ), ?+=?( volatile signed long long int &, signed long long int );
+unsigned long long int ?+=?( unsigned long long int &, unsigned long long int ), ?+=?( volatile unsigned long long int &, unsigned long long int );
+//signed int128 ?+=?( signed int128 &, signed int128 ), ?+=?( volatile signed int128 &, signed int128 );
+//unsigned int128 ?+=?( unsigned int128 &, unsigned int128 ), ?+=?( volatile unsigned int128 &, unsigned int128 );
+
+_Bool ?-=?( _Bool &, _Bool ), ?-=?( volatile _Bool &, _Bool );
+char ?-=?( char &, char ), ?-=?( volatile char &, char );
+char signed ?-=?( char signed &, char signed ), ?-=?( volatile char signed &, char signed );
+char unsigned ?-=?( char unsigned &, char unsigned ), ?-=?( volatile char unsigned &, char unsigned );
+int short ?-=?( int short &, int short ), ?-=?( volatile int short &, int short );
+int short unsigned ?-=?( int short unsigned &, int short unsigned ), ?-=?( volatile int short unsigned &, int short unsigned );
+signed int ?-=?( signed int &, signed int ), ?-=?( volatile signed int &, signed int );
+unsigned int ?-=?( unsigned &, unsigned ), ?-=?( volatile unsigned &, unsigned );
+signed long int ?-=?( signed long int &, signed long int ), ?-=?( volatile signed long int &, signed long int );
+unsigned long int ?-=?( unsigned long int &, unsigned long int ), ?-=?( volatile unsigned long int &, unsigned long int );
+signed long long int ?-=?( signed long long int &, signed long long int ), ?-=?( volatile signed long long int &, signed long long int );
+unsigned long long int ?-=?( unsigned long long int &, unsigned long long int ), ?-=?( volatile unsigned long long int &, unsigned long long int );
+
+char ?<<=?( char &, char ), ?<<=?( volatile char &, char );
+char signed ?<<=?( char signed &, char signed ), ?<<=?( volatile char signed &, char signed );
+char unsigned ?<<=?( char unsigned &, char unsigned ), ?<<=?( volatile char unsigned &, char unsigned );
+int short ?<<=?( int short &, int short ), ?<<=?( volatile int short &, int short );
+int short unsigned ?<<=?( int short unsigned &, int short unsigned ), ?<<=?( volatile int short unsigned &, int short unsigned );
+signed int ?<<=?( signed int &, signed int ), ?<<=?( volatile signed int &, signed int );
+unsigned int ?<<=?( unsigned &, unsigned ), ?<<=?( volatile unsigned &, unsigned );
+signed long int ?<<=?( signed long int &, signed long int ), ?<<=?( volatile signed long int &, signed long int );
+unsigned long int ?<<=?( unsigned long int &, unsigned long int ), ?<<=?( volatile unsigned long int &, unsigned long int );
+signed long long int ?<<=?( signed long long int &, signed long long int ), ?<<=?( volatile signed long long int &, signed long long int );
+unsigned long long int ?<<=?( unsigned long long int &, unsigned long long int ), ?<<=?( volatile unsigned long long int &, unsigned long long int );
+
+char ?>>=?( char &, char ), ?>>=?( volatile char &, char );
+char signed ?>>=?( char signed &, char signed ), ?>>=?( volatile char signed &, char signed );
+char unsigned ?>>=?( char unsigned &, char unsigned ), ?>>=?( volatile char unsigned &, char unsigned );
+int short ?>>=?( int short &, int short ), ?>>=?( volatile int short &, int short );
+int short unsigned ?>>=?( int short unsigned &, int short unsigned ), ?>>=?( volatile int short unsigned &, int short unsigned );
+signed int ?>>=?( signed int &, signed int ), ?>>=?( volatile signed int &, signed int );
+unsigned int ?>>=?( unsigned &, unsigned ), ?>>=?( volatile unsigned &, unsigned );
+signed long int ?>>=?( signed long int &, signed long int ), ?>>=?( volatile signed long int &, signed long int );
+unsigned long int ?>>=?( unsigned long int &, unsigned long int ), ?>>=?( volatile unsigned long int &, unsigned long int );
+signed long long int ?>>=?( signed long long int &, signed long long int ), ?>>=?( volatile signed long long int &, signed long long int );
+unsigned long long int ?>>=?( unsigned long long int &, unsigned long long int ), ?>>=?( volatile unsigned long long int &, unsigned long long int );
+
+_Bool ?&=?( _Bool &, _Bool ), ?&=?( volatile _Bool &, _Bool );
+char ?&=?( char &, char ), ?&=?( volatile char &, char );
+char signed ?&=?( char signed &, char signed ), ?&=?( volatile char signed &, char signed );
+char unsigned ?&=?( char unsigned &, char unsigned ), ?&=?( volatile char unsigned &, char unsigned );
+int short ?&=?( int short &, int short ), ?&=?( volatile int short &, int short );
+int short unsigned ?&=?( int short unsigned &, int short unsigned ), ?&=?( volatile int short unsigned &, int short unsigned );
+signed int ?&=?( signed int &, signed int ), ?&=?( volatile signed int &, signed int );
+unsigned int ?&=?( unsigned &, unsigned ), ?&=?( volatile unsigned &, unsigned );
+signed long int ?&=?( signed long int &, signed long int ), ?&=?( volatile signed long int &, signed long int );
+unsigned long int ?&=?( unsigned long int &, unsigned long int ), ?&=?( volatile unsigned long int &, unsigned long int );
+signed long long int ?&=?( signed long long int &, signed long long int ), ?&=?( volatile signed long long int &, signed long long int );
+unsigned long long int ?&=?( unsigned long long int &, unsigned long long int ), ?&=?( volatile unsigned long long int &, unsigned long long int );
+
+_Bool ?|=?( _Bool &, _Bool ), ?|=?( volatile _Bool &, _Bool );
+char ?|=?( char &, char ), ?|=?( volatile char &, char );
+char signed ?|=?( char signed &, char signed ), ?|=?( volatile char signed &, char signed );
+char unsigned ?|=?( char unsigned &, char unsigned ), ?|=?( volatile char unsigned &, char unsigned );
+int short ?|=?( int short &, int short ), ?|=?( volatile int short &, int short );
+int short unsigned ?|=?( int short unsigned &, int short unsigned ), ?|=?( volatile int short unsigned &, int short unsigned );
+signed int ?|=?( signed int &, signed int ), ?|=?( volatile signed int &, signed int );
+unsigned int ?|=?( unsigned &, unsigned ), ?|=?( volatile unsigned &, unsigned );
+signed long int ?|=?( signed long int &, signed long int ), ?|=?( volatile signed long int &, signed long int );
+unsigned long int ?|=?( unsigned long int &, unsigned long int ), ?|=?( volatile unsigned long int &, unsigned long int );
+signed long long int ?|=?( signed long long int &, signed long long int ), ?|=?( volatile signed long long int &, signed long long int );
+unsigned long long int ?|=?( unsigned long long int &, unsigned long long int ), ?|=?( volatile unsigned long long int &, unsigned long long int );
+
+_Bool ?^=?( _Bool &, _Bool ), ?^=?( volatile _Bool &, _Bool );
+char ?^=?( char &, char ), ?^=?( volatile char &, char );
+char signed ?^=?( char signed &, char signed ), ?^=?( volatile char signed &, char signed );
+char unsigned ?^=?( char unsigned &, char unsigned ), ?^=?( volatile char unsigned &, char unsigned );
+int short ?^=?( int short &, int short ), ?^=?( volatile int short &, int short );
+int short unsigned ?^=?( int short unsigned &, int short unsigned ), ?^=?( volatile int short unsigned &, int short unsigned );
+signed int ?^=?( signed int &, signed int ), ?^=?( volatile signed int &, signed int );
+unsigned int ?^=?( unsigned &, unsigned ), ?^=?( volatile unsigned &, unsigned );
+signed long int ?^=?( signed long int &, signed long int ), ?^=?( volatile signed long int &, signed long int );
+unsigned long int ?^=?( unsigned long int &, unsigned long int ), ?^=?( volatile unsigned long int &, unsigned long int );
+signed long long int ?^=?( signed long long int &, signed long long int ), ?^=?( volatile signed long long int &, signed long long int );
+unsigned long long int ?^=?( unsigned long long int &, unsigned long long int ), ?^=?( volatile unsigned long long int &, unsigned long long int );
+
+float ?=?( float &, float ), ?=?( volatile float &, float ),
+ ?*=?( float &, float ), ?*=?( volatile float &, float ),
+ ?/=?( float &, float ), ?/=?( volatile float &, float ),
+ ?+=?( float &, float ), ?+=?( volatile float &, float ),
+ ?-=?( float &, float ), ?-=?( volatile float &, float );
+
+double ?=?( double &, double ), ?=?( volatile double &, double ),
+ ?*=?( double &, double ), ?*=?( volatile double &, double ),
+ ?/=?( double &, double ), ?/=?( volatile double &, double ),
+ ?+=?( double &, double ), ?+=?( volatile double &, double ),
+ ?-=?( double &, double ), ?-=?( volatile double &, double );
+
+long double ?=?( long double &, long double ), ?=?( volatile long double &, long double ),
+ ?*=?( long double &, long double ), ?*=?( volatile long double &, long double ),
+ ?/=?( long double &, long double ), ?/=?( volatile long double &, long double ),
+ ?+=?( long double &, long double ), ?+=?( volatile long double &, long double ),
+ ?-=?( long double &, long double ), ?-=?( volatile long double &, long double );
+
+float _Complex ?=?( float _Complex &, float _Complex ), ?=?( volatile float _Complex &, float _Complex ),
+ ?*=?( float _Complex &, float _Complex ), ?*=?( volatile float _Complex &, float _Complex ),
+ ?/=?( float _Complex &, float _Complex ), ?/=?( volatile float _Complex &, float _Complex ),
+ ?+=?( float _Complex &, float _Complex ), ?+=?( volatile float _Complex &, float _Complex ),
+ ?-=?( float _Complex &, float _Complex ), ?-=?( volatile float _Complex &, float _Complex );
+
+double _Complex ?=?( double _Complex &, double _Complex ), ?=?( volatile double _Complex &, double _Complex ),
+ ?*=?( double _Complex &, double _Complex ), ?*=?( volatile double _Complex &, double _Complex ),
+ ?/=?( double _Complex &, double _Complex ), ?/=?( volatile double _Complex &, double _Complex ),
+ ?+=?( double _Complex &, double _Complex ), ?+=?( volatile double _Complex &, double _Complex ),
+ ?-=?( double _Complex &, double _Complex ), ?-=?( volatile double _Complex &, double _Complex );
+
+long double _Complex ?=?( long double _Complex &, long double _Complex ), ?=?( volatile long double _Complex &, long double _Complex ),
+ ?*=?( long double _Complex &, long double _Complex ), ?*=?( volatile long double _Complex &, long double _Complex ),
+ ?/=?( long double _Complex &, long double _Complex ), ?/=?( volatile long double _Complex &, long double _Complex ),
+ ?+=?( long double _Complex &, long double _Complex ), ?+=?( volatile long double _Complex &, long double _Complex ),
+ ?-=?( long double _Complex &, long double _Complex ), ?-=?( volatile long double _Complex &, long double _Complex );
+
+
+// ------------------------------------------------------------
+//
+// Section ??? Constructors and Destructors
+//
+// ------------------------------------------------------------
+
+// default ctor
+void ?{}( _Bool & );
+void ?{}( char & );
+void ?{}( unsigned char & );
+void ?{}( char signed & );
+void ?{}( int short & );
+void ?{}( int short unsigned & );
+void ?{}( signed int & );
+void ?{}( unsigned int & );
+void ?{}( signed long int & );
+void ?{}( unsigned long int & );
+void ?{}( signed long long int & );
+void ?{}( unsigned long long int & );
+void ?{}( float & );
+void ?{}( double & );
+void ?{}( long double & );
+void ?{}( float _Complex & );
+void ?{}( double _Complex & );
+void ?{}( long double _Complex & );
+void ?{}( zero_t & );
+void ?{}( one_t & );
+
+// copy ctor
+void ?{}( _Bool &, _Bool );
+void ?{}( char &, char );
+void ?{}( unsigned char &, unsigned char );
+void ?{}( char signed &, char signed );
+void ?{}( int short &, int short );
+void ?{}( int short unsigned &, int short unsigned );
+void ?{}( signed int &, signed int);
+void ?{}( unsigned int &, unsigned int);
+void ?{}( signed long int &, signed long int);
+void ?{}( unsigned long int &, unsigned long int);
+void ?{}( signed long long int &, signed long long int);
+void ?{}( unsigned long long int &, unsigned long long int);
+void ?{}( float &, float);
+void ?{}( double &, double);
+void ?{}( long double &, long double);
+void ?{}( float _Complex &, float _Complex);
+void ?{}( double _Complex &, double _Complex);
+void ?{}( long double _Complex &, long double _Complex);
+void ?{}( zero_t &, zero_t );
+void ?{}( one_t &, one_t );
+
+// dtor
+void ^?{}( _Bool & );
+void ^?{}( char & );
+void ^?{}( char unsigned & );
+void ^?{}( char signed & );
+void ^?{}( int short & );
+void ^?{}( int short unsigned & );
+void ^?{}( signed int & );
+void ^?{}( unsigned int & );
+void ^?{}( signed long int & );
+void ^?{}( unsigned long int & );
+void ^?{}( signed long long int & );
+void ^?{}( unsigned long long int & );
+void ^?{}( float & );
+void ^?{}( double & );
+void ^?{}( long double & );
+void ^?{}( float _Complex & );
+void ^?{}( double _Complex & );
+void ^?{}( long double _Complex & );
+void ^?{}( zero_t & );
+void ^?{}( one_t & );
+
+// // default ctor
+// forall( dtype DT ) void ?{}( DT ** );
+// forall( dtype DT ) void ?{}( const DT ** );
+// forall( dtype DT ) void ?{}( volatile DT ** );
+// forall( dtype DT ) void ?{}( const volatile DT ** );
+
+// // copy ctor
+// forall( dtype DT ) void ?{}( DT **, DT* );
+// forall( dtype DT ) void ?{}( const DT **, DT* );
+// forall( dtype DT ) void ?{}( volatile DT **, DT* );
+// forall( dtype DT ) void ?{}( const volatile DT **, DT* );
+
+// // dtor
+// forall( dtype DT ) void ^?{}( DT ** );
+// forall( dtype DT ) void ^?{}( const DT ** );
+// forall( dtype DT ) void ^?{}( volatile DT ** );
+// forall( dtype DT ) void ^?{}( const volatile DT ** );
+
+// copied from assignment section
+// copy constructors
+forall( ftype FT ) void ?{}( FT *&, FT * );
+forall( ftype FT ) void ?{}( FT * volatile &, FT * );
+
+forall( dtype DT ) void ?{}( DT * &, DT * );
+forall( dtype DT ) void ?{}( const DT * &, DT * );
+forall( dtype DT ) void ?{}( const DT * &, const DT * );
+forall( dtype DT ) void ?{}( volatile DT * &, DT * );
+forall( dtype DT ) void ?{}( volatile DT * &, volatile DT * );
+forall( dtype DT ) void ?{}( const volatile DT * &, DT * );
+forall( dtype DT ) void ?{}( const volatile DT * &, const DT * );
+forall( dtype DT ) void ?{}( const volatile DT * &, volatile DT * );
+forall( dtype DT ) void ?{}( const volatile DT * &, const volatile DT * );
+
+forall( dtype DT ) void ?{}( void * &, DT * );
+forall( dtype DT ) void ?{}( const void * &, DT * );
+forall( dtype DT ) void ?{}( const void * &, const DT * );
+forall( dtype DT ) void ?{}( volatile void * &, DT * );
+forall( dtype DT ) void ?{}( volatile void * &, volatile DT * );
+forall( dtype DT ) void ?{}( const volatile void * &, DT * );
+forall( dtype DT ) void ?{}( const volatile void * &, const DT * );
+forall( dtype DT ) void ?{}( const volatile void * &, volatile DT * );
+forall( dtype DT ) void ?{}( const volatile void * &, const volatile DT * );
+
+//forall( dtype DT ) void ?{}( DT * &, zero_t );
+//forall( dtype DT ) void ?{}( DT * volatile &, zero_t );
+forall( dtype DT ) void ?{}( const DT * &, zero_t );
+//forall( dtype DT ) void ?{}( volatile DT * &, zero_t );
+//forall( dtype DT ) void ?{}( volatile DT * volatile &, zero_t );
+forall( dtype DT ) void ?{}( const volatile DT * &, zero_t );
+
+forall( ftype FT ) void ?{}( FT * &, zero_t );
+
+// default ctors
+forall( ftype FT ) void ?{}( FT * & );
+
+forall( dtype DT ) void ?{}( DT * &);
+forall( dtype DT ) void ?{}( const DT * &);
+forall( dtype DT ) void ?{}( volatile DT * &);
+forall( dtype DT ) void ?{}( const volatile DT * &);
+
+void ?{}( void * &);
+void ?{}( const void * &);
+void ?{}( volatile void * &);
+void ?{}( const volatile void * &);
+
+// dtors
+forall( ftype FT ) void ^?{}( FT * & );
+
+forall( dtype DT ) void ^?{}( DT * &);
+forall( dtype DT ) void ^?{}( const DT * &);
+forall( dtype DT ) void ^?{}( volatile DT * &);
+forall( dtype DT ) void ^?{}( const volatile DT * &);
+
+void ^?{}( void * &);
+void ^?{}( const void * &);
+void ^?{}( volatile void * &);
+void ^?{}( const volatile void * &);
+
+// Local Variables: //
+// mode: c //
+// tab-width: 8 //
+// End: //
Index: libcfa/prelude/prototypes.awk
===================================================================
--- libcfa/prelude/prototypes.awk (revision bf71cfdb7285490eee552b461158846f626cc52f)
+++ libcfa/prelude/prototypes.awk (revision bf71cfdb7285490eee552b461158846f626cc52f)
@@ -0,0 +1,160 @@
+#
+# Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+#
+# The contents of this file are covered under the licence agreement in the
+# file "LICENCE" distributed with Cforall.
+#
+# prototypes.awk --
+#
+# Author : Peter A. Buhr
+# Created On : Sat May 16 07:57:37 2015
+# Last Modified By : Peter A. Buhr
+# Last Modified On : Tue Jul 5 14:32:52 2016
+# Update Count : 32
+#
+
+# http://llvm.org/svn/llvm-project/cfe/trunk/include/clang/Basic/Builtins.def
+
+BEGIN {
+ FS = "[( )]"
+ # order so string search is longest string
+ i=-1
+ types[i+=1] = "BOOL"; vtypes[i] = "_Bool"
+ types[i+=1] = "UINTMAX"; vtypes[i] = "unsigned long int"
+ types[i+=1] = "UINT16"; vtypes[i] = "short int"
+ types[i+=1] = "UINT32"; vtypes[i] = "int"
+ types[i+=1] = "UINT64"; vtypes[i] = "long long int"
+ types[i+=1] = "UINT"; vtypes[i] = "unsigned int"
+ types[i+=1] = "INTMAX"; vtypes[i] = "long int"
+ types[i+=1] = "INTPTR"; vtypes[i] = "int *"
+ types[i+=1] = "WINT"; vtypes[i] = "unsigned int"
+ types[i+=1] = "INT"; vtypes[i] = "int"
+ types[i+=1] = "ULONGLONG"; vtypes[i] = "unsigned long long"
+ types[i+=1] = "ULONG"; vtypes[i] = "unsigned long"
+ types[i+=1] = "UNSIGNED"; vtypes[i] = "unsigned"
+ types[i+=1] = "COMPLEX_LONGDOUBLE"; vtypes[i] = "_Complex long double"
+ types[i+=1] = "COMPLEX_DOUBLE"; vtypes[i] = "_Complex double"
+ types[i+=1] = "COMPLEX_FLOAT"; vtypes[i] = "_Complex float"
+ types[i+=1] = "LONGDOUBLEPTR"; vtypes[i] = "long double *"
+ types[i+=1] = "LONGDOUBLE"; vtypes[i] = "long double"
+ types[i+=1] = "LONGLONG"; vtypes[i] = "long long"
+ types[i+=1] = "LONG"; vtypes[i] = "long"
+ types[i+=1] = "DFLOAT32"; vtypes[i] = "__Unsupported"
+ types[i+=1] = "DFLOAT64"; vtypes[i] = "__Unsupported"
+ types[i+=1] = "DFLOAT128"; vtypes[i] = "__Unsupported"
+ types[i+=1] = "DOUBLEPTR"; vtypes[i] = "double *"
+ types[i+=1] = "DOUBLE"; vtypes[i] = "double"
+ types[i+=1] = "FLOATPTR"; vtypes[i] = "float *"
+ types[i+=1] = "FLOAT128X"; vtypes[i] = "__Unsupported"
+ types[i+=1] = "FLOAT128"; vtypes[i] = "__Unsupported"
+ types[i+=1] = "FLOAT64X"; vtypes[i] = "__Unsupported"
+ types[i+=1] = "FLOAT64"; vtypes[i] = "__Unsupported"
+ types[i+=1] = "FLOAT32X"; vtypes[i] = "__Unsupported"
+ types[i+=1] = "FLOAT32"; vtypes[i] = "__Unsupported"
+ types[i+=1] = "FLOAT16"; vtypes[i] = "__Unsupported"
+ types[i+=1] = "FLOAT"; vtypes[i] = "float"
+ types[i+=1] = "CONST_VPTR"; vtypes[i] = "const volatile void *"
+ types[i+=1] = "CONST_PTR"; vtypes[i] = "const void *"
+ types[i+=1] = "CONST_STRING"; vtypes[i] = "const char *"
+ types[i+=1] = "CONST_TM_PTR"; vtypes[i] = "const struct tm *"
+ types[i+=1] = "PTR_FN_VOID_VAR_PTR_SIZE"; vtypes[i] = ""
+ types[i+=1] = "PTR_CONST_STRING"; vtypes[i] = "char *const"
+ types[i+=1] = "PTRMODE_PTR"; vtypes[i] = ""
+ types[i+=1] = "PTRPTR"; vtypes[i] = "void **"
+ types[i+=1] = "VPTR"; vtypes[i] = "volatile void *"
+ types[i+=1] = "PTR"; vtypes[i] = "void *"
+ types[i+=1] = "VOID"; vtypes[i] = "void"
+ types[i+=1] = "STRING"; vtypes[i] = "char *"
+ types[i+=1] = "FILEPTR"; vtypes[i] = "struct _IO_FILE *"
+ types[i+=1] = "SIZE"; vtypes[i] = "unsigned long"
+ types[i+=1] = "VAR"; vtypes[i] = "..."
+ types[i+=1] = "VALIST_ARG"; vtypes[i] = "__builtin_va_list"
+ types[i+=1] = "VALIST_REF"; vtypes[i] = "__builtin_va_list"
+ types[i+=1] = "UNWINDWORD"; vtypes[i] = "void *"
+ types[i+=1] = "WORD"; vtypes[i] = ""
+ types[i+=1] = "SSIZE"; vtypes[i] = "long int"
+ types[i+=1] = "PID"; vtypes[i] = "int"
+ types[i+=1] = "I16"; vtypes[i] = "__int128"
+ types[i+=1] = "I8"; vtypes[i] = "long long int"
+ types[i+=1] = "I4"; vtypes[i] = "int"
+ types[i+=1] = "I2"; vtypes[i] = "short"
+ types[i+=1] = "I1"; vtypes[i] = "char"
+ N = i + 1
+} # BEGIN
+
+/BT_FN/ {
+ for (i = 1; i <= NF; i++) {
+ if( match($i, "BT_FN") != 0 ) {
+ prototypes[$i] = $i
+ }
+ }
+ }
+
+END {
+ printf( "#define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT, COND) TYPE(NAME)\n" );
+ printf( "#define FUNC_SIMPLE(RETURN, NAME, ARGS...) RETURN NAME(ARGS);\n" );
+ printf( "#define BT_LAST(NAME) FUNC_SIMPLE(void, NAME)\n\n" );
+
+ # generate C types for macros names
+ for ( i = 0; i < N; i += 1 ) {
+ printf( "#define BT_%s %s\n", types[i], vtypes[i] )
+ } # for
+ printf( "\n" )
+
+ for ( prototype in prototypes ) {
+ # printf( "//\"%s\"\n", prototype )
+ if ( index( "BT_LAST", prototype ) == 1 ) {
+ continue
+ } # if
+
+ printf( "#define %s(NAME) FUNC_SIMPLE(", prototype )
+
+ if ( sub( "BT_FN_", "", prototype ) == 0 ) {
+ printf( "\n********** BAD MACRO NAME \"%s\" **********\n", prototype )
+ exit 0
+ } # if
+
+ # generate function return type as macro
+ for ( t = 0; t < N; t += 1 ) { # find longest match
+ type = types[t];
+ if ( index( prototype, type ) == 1 ) { # found match
+ printf( "BT_%s, NAME", type )
+ sub( type, "", prototype )
+ break;
+ } # if
+ } # for
+
+ # generate function parameter types as macro
+ if ( index( prototype, "VAR" ) != 2 ) { # C-style empty parameters ?
+ for ( p = 0; length( prototype ) > 0; p += 1 ) { # until all parameters types are removed
+ sub( "_", "", prototype) # remove "_"
+ printf( ", ", type )
+ temp = prototype
+ for ( t = 0; t < N; t += 1 ) { # find longest match
+ type = types[t];
+ if ( index( prototype, type ) == 1 ) { # found match
+ printf( "BT_%s", type )
+ sub( type, "", prototype )
+ break;
+ } # if
+ } # for
+ if ( temp == prototype ) { # no match found for parameter in macro table
+ printf( "\n********** MISSING TYPE \"%s\" **********\n", prototype )
+ exit 0
+ } # if
+ } # for
+ } # if
+ printf( ")\n" )
+ } # for
+
+ # extras
+ printf( "\n#include \"builtins.def\"\n\n" );
+ printf( "\n#include \"sync-builtins.cf\"\n\n" );
+ printf( "extern const char *__PRETTY_FUNCTION__;\n" );
+} # END
+
+# Local Variables: #
+# tab-width: 4 #
+# mode: awk #
+# compile-command: "make install" #
+# End: #
Index: libcfa/prelude/prototypes.c
===================================================================
--- libcfa/prelude/prototypes.c (revision bf71cfdb7285490eee552b461158846f626cc52f)
+++ libcfa/prelude/prototypes.c (revision bf71cfdb7285490eee552b461158846f626cc52f)
@@ -0,0 +1,2 @@
+#define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT, COND) TYPE(NAME)
+#include "builtins.def"
Index: libcfa/prelude/prototypes.sed
===================================================================
--- libcfa/prelude/prototypes.sed (revision bf71cfdb7285490eee552b461158846f626cc52f)
+++ libcfa/prelude/prototypes.sed (revision bf71cfdb7285490eee552b461158846f626cc52f)
@@ -0,0 +1,22 @@
+s/; /;\n/g #Make multi declaration lines into multiple lines
+/targetm/s/.*// #Remove targetm declarations
+/__Unsupported/s/.*// #Remove Unsupported types declarations
+s/void \(const char \*\)0\(\);// #Remove void (const char \*)0();
+s/\"//g #Remove extraenous quotes in declarations
+/__builtin_/s/_ /_/g #Remove extraenous spaces in declarations
+
+#Fix gcc overloading
+# various sed rules for the gcc sync builtins which are overloaded
+# kept here because they generate an acceptable approximate of the correct prototypes
+
+#/__sync_/s/_[0-9][0-9]*\(.*\)/\(\);/g #hack since it will accept any parameters
+#/__atomic_/s/_[0-9][0-9]*\(.*\)/\(\);/g #hack since it will accept any parameters
+
+#/_16/s/void \*/__int128 \*/g
+#/_8/s/void \*/long long int \*/g
+#/_4/s/void \*/int \*/g
+#/_2/s/void \*/short \*/g
+#/_1/s/void \*/char \*/g
+
+#s/([a-zA-Z0-9_ ]+)\s+__sync([a-z_]+)_([0-9]+)\((.*)\);/\1 __sync\2\(\4\,...); \1 __sync\2_\3\(\4\,...);/
+#s/([a-zA-Z0-9_ ]+)\s+__atomic([a-z_]+)_([0-9]+)\((.*)\);/\1 __atomic\2\(\4\); \1 __atomic\2_\3\(\4\);/
Index: libcfa/prelude/sync-builtins.cf
===================================================================
--- libcfa/prelude/sync-builtins.cf (revision bf71cfdb7285490eee552b461158846f626cc52f)
+++ libcfa/prelude/sync-builtins.cf (revision bf71cfdb7285490eee552b461158846f626cc52f)
@@ -0,0 +1,889 @@
+char __sync_fetch_and_add(volatile char *, char,...);
+char __sync_fetch_and_add_1(volatile char *, char,...);
+signed char __sync_fetch_and_add(volatile signed char *, signed char,...);
+signed char __sync_fetch_and_add_1(volatile signed char *, signed char,...);
+unsigned char __sync_fetch_and_add(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_fetch_and_add_1(volatile unsigned char *, unsigned char,...);
+signed short __sync_fetch_and_add(volatile signed short *, signed short,...);
+signed short __sync_fetch_and_add_2(volatile signed short *, signed short,...);
+unsigned short __sync_fetch_and_add(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_fetch_and_add_2(volatile unsigned short *, unsigned short,...);
+signed int __sync_fetch_and_add(volatile signed int *, signed int,...);
+signed int __sync_fetch_and_add_4(volatile signed int *, signed int,...);
+unsigned int __sync_fetch_and_add(volatile unsigned int *, unsigned int,...);
+unsigned int __sync_fetch_and_add_4(volatile unsigned int *, unsigned int,...);
+signed long long int __sync_fetch_and_add(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_fetch_and_add_8(volatile signed long long int *, signed long long int,...);
+unsigned long long int __sync_fetch_and_add(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_fetch_and_add_8(volatile unsigned long long int *, unsigned long long int,...);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __sync_fetch_and_add(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_fetch_and_add_16(volatile signed __int128 *, signed __int128,...);
+unsigned __int128 __sync_fetch_and_add(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_fetch_and_add_16(volatile unsigned __int128 *, unsigned __int128,...);
+#endif
+
+char __sync_fetch_and_sub(volatile char *, char,...);
+char __sync_fetch_and_sub_1(volatile char *, char,...);
+signed char __sync_fetch_and_sub(volatile signed char *, signed char,...);
+signed char __sync_fetch_and_sub_1(volatile signed char *, signed char,...);
+unsigned char __sync_fetch_and_sub(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_fetch_and_sub_1(volatile unsigned char *, unsigned char,...);
+signed short __sync_fetch_and_sub(volatile signed short *, signed short,...);
+signed short __sync_fetch_and_sub_2(volatile signed short *, signed short,...);
+unsigned short __sync_fetch_and_sub(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_fetch_and_sub_2(volatile unsigned short *, unsigned short,...);
+signed int __sync_fetch_and_sub(volatile signed int *, signed int,...);
+signed int __sync_fetch_and_sub_4(volatile signed int *, signed int,...);
+unsigned int __sync_fetch_and_sub(volatile unsigned int *, unsigned int,...);
+unsigned int __sync_fetch_and_sub_4(volatile unsigned int *, unsigned int,...);
+signed long long int __sync_fetch_and_sub(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_fetch_and_sub_8(volatile signed long long int *, signed long long int,...);
+unsigned long long int __sync_fetch_and_sub(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_fetch_and_sub_8(volatile unsigned long long int *, unsigned long long int,...);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __sync_fetch_and_sub(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_fetch_and_sub_16(volatile signed __int128 *, signed __int128,...);
+unsigned __int128 __sync_fetch_and_sub(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_fetch_and_sub_16(volatile unsigned __int128 *, unsigned __int128,...);
+#endif
+
+char __sync_fetch_and_or(volatile char *, char,...);
+char __sync_fetch_and_or_1(volatile char *, char,...);
+signed char __sync_fetch_and_or(volatile signed char *, signed char,...);
+signed char __sync_fetch_and_or_1(volatile signed char *, signed char,...);
+unsigned char __sync_fetch_and_or(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_fetch_and_or_1(volatile unsigned char *, unsigned char,...);
+signed short __sync_fetch_and_or(volatile signed short *, signed short,...);
+signed short __sync_fetch_and_or_2(volatile signed short *, signed short,...);
+unsigned short __sync_fetch_and_or(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_fetch_and_or_2(volatile unsigned short *, unsigned short,...);
+signed int __sync_fetch_and_or(volatile signed int *, signed int,...);
+signed int __sync_fetch_and_or_4(volatile signed int *, signed int,...);
+unsigned int __sync_fetch_and_or(volatile unsigned int *, unsigned int,...);
+unsigned int __sync_fetch_and_or_4(volatile unsigned int *, unsigned int,...);
+signed long long int __sync_fetch_and_or(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_fetch_and_or_8(volatile signed long long int *, signed long long int,...);
+unsigned long long int __sync_fetch_and_or(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_fetch_and_or_8(volatile unsigned long long int *, unsigned long long int,...);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __sync_fetch_and_or(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_fetch_and_or_16(volatile signed __int128 *, signed __int128,...);
+unsigned __int128 __sync_fetch_and_or(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_fetch_and_or_16(volatile unsigned __int128 *, unsigned __int128,...);
+#endif
+
+char __sync_fetch_and_and(volatile char *, char,...);
+char __sync_fetch_and_and_1(volatile char *, char,...);
+signed char __sync_fetch_and_and(volatile signed char *, signed char,...);
+signed char __sync_fetch_and_and_1(volatile signed char *, signed char,...);
+unsigned char __sync_fetch_and_and(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_fetch_and_and_1(volatile unsigned char *, unsigned char,...);
+signed short __sync_fetch_and_and(volatile signed short *, signed short,...);
+signed short __sync_fetch_and_and_2(volatile signed short *, signed short,...);
+unsigned short __sync_fetch_and_and(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_fetch_and_and_2(volatile unsigned short *, unsigned short,...);
+signed int __sync_fetch_and_and(volatile signed int *, signed int,...);
+signed int __sync_fetch_and_and_4(volatile signed int *, signed int,...);
+unsigned int __sync_fetch_and_and(volatile unsigned int *, unsigned int,...);
+unsigned int __sync_fetch_and_and_4(volatile unsigned int *, unsigned int,...);
+signed long long int __sync_fetch_and_and(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_fetch_and_and_8(volatile signed long long int *, signed long long int,...);
+unsigned long long int __sync_fetch_and_and(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_fetch_and_and_8(volatile unsigned long long int *, unsigned long long int,...);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __sync_fetch_and_and(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_fetch_and_and_16(volatile signed __int128 *, signed __int128,...);
+unsigned __int128 __sync_fetch_and_and(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_fetch_and_and_16(volatile unsigned __int128 *, unsigned __int128,...);
+#endif
+
+char __sync_fetch_and_xor(volatile char *, char,...);
+char __sync_fetch_and_xor_1(volatile char *, char,...);
+signed char __sync_fetch_and_xor(volatile signed char *, signed char,...);
+signed char __sync_fetch_and_xor_1(volatile signed char *, signed char,...);
+unsigned char __sync_fetch_and_xor(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_fetch_and_xor_1(volatile unsigned char *, unsigned char,...);
+signed short __sync_fetch_and_xor(volatile signed short *, signed short,...);
+signed short __sync_fetch_and_xor_2(volatile signed short *, signed short,...);
+unsigned short __sync_fetch_and_xor(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_fetch_and_xor_2(volatile unsigned short *, unsigned short,...);
+signed int __sync_fetch_and_xor(volatile signed int *, signed int,...);
+signed int __sync_fetch_and_xor_4(volatile signed int *, signed int,...);
+unsigned int __sync_fetch_and_xor(volatile unsigned int *, unsigned int,...);
+unsigned int __sync_fetch_and_xor_4(volatile unsigned int *, unsigned int,...);
+signed long long int __sync_fetch_and_xor(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_fetch_and_xor_8(volatile signed long long int *, signed long long int,...);
+unsigned long long int __sync_fetch_and_xor(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_fetch_and_xor_8(volatile unsigned long long int *, unsigned long long int,...);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __sync_fetch_and_xor(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_fetch_and_xor_16(volatile signed __int128 *, signed __int128,...);
+unsigned __int128 __sync_fetch_and_xor(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_fetch_and_xor_16(volatile unsigned __int128 *, unsigned __int128,...);
+#endif
+
+char __sync_fetch_and_nand(volatile char *, char,...);
+char __sync_fetch_and_nand_1(volatile char *, char,...);
+signed char __sync_fetch_and_nand(volatile signed char *, signed char,...);
+signed char __sync_fetch_and_nand_1(volatile signed char *, signed char,...);
+unsigned char __sync_fetch_and_nand(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_fetch_and_nand_1(volatile unsigned char *, unsigned char,...);
+signed short __sync_fetch_and_nand(volatile signed short *, signed short,...);
+signed short __sync_fetch_and_nand_2(volatile signed short *, signed short,...);
+unsigned short __sync_fetch_and_nand(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_fetch_and_nand_2(volatile unsigned short *, unsigned short,...);
+signed int __sync_fetch_and_nand(volatile signed int *, signed int,...);
+signed int __sync_fetch_and_nand_4(volatile signed int *, signed int,...);
+unsigned int __sync_fetch_and_nand(volatile unsigned int *, unsigned int,...);
+unsigned int __sync_fetch_and_nand_4(volatile unsigned int *, unsigned int,...);
+signed long long int __sync_fetch_and_nand(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_fetch_and_nand_8(volatile signed long long int *, signed long long int,...);
+unsigned long long int __sync_fetch_and_nand(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_fetch_and_nand_8(volatile unsigned long long int *, unsigned long long int,...);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __sync_fetch_and_nand(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_fetch_and_nand_16(volatile signed __int128 *, signed __int128,...);
+unsigned __int128 __sync_fetch_and_nand(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_fetch_and_nand_16(volatile unsigned __int128 *, unsigned __int128,...);
+#endif
+
+char __sync_add_and_fetch(volatile char *, char,...);
+char __sync_add_and_fetch_1(volatile char *, char,...);
+signed char __sync_add_and_fetch(volatile signed char *, signed char,...);
+signed char __sync_add_and_fetch_1(volatile signed char *, signed char,...);
+unsigned char __sync_add_and_fetch(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_add_and_fetch_1(volatile unsigned char *, unsigned char,...);
+signed short __sync_add_and_fetch(volatile signed short *, signed short,...);
+signed short __sync_add_and_fetch_2(volatile signed short *, signed short,...);
+unsigned short __sync_add_and_fetch(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_add_and_fetch_2(volatile unsigned short *, unsigned short,...);
+signed int __sync_add_and_fetch(volatile signed int *, signed int,...);
+signed int __sync_add_and_fetch_4(volatile signed int *, signed int,...);
+signed int __sync_add_and_fetch(volatile signed int *, signed int,...);
+signed int __sync_add_and_fetch_4(volatile signed int *, signed int,...);
+signed long long int __sync_add_and_fetch(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_add_and_fetch_8(volatile signed long long int *, signed long long int,...);
+unsigned long long int __sync_add_and_fetch(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_add_and_fetch_8(volatile unsigned long long int *, unsigned long long int,...);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __sync_add_and_fetch(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_add_and_fetch_16(volatile signed __int128 *, signed __int128,...);
+unsigned __int128 __sync_add_and_fetch(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_add_and_fetch_16(volatile unsigned __int128 *, unsigned __int128,...);
+#endif
+
+char __sync_sub_and_fetch(volatile char *, char,...);
+char __sync_sub_and_fetch_1(volatile char *, char,...);
+signed char __sync_sub_and_fetch(volatile signed char *, signed char,...);
+signed char __sync_sub_and_fetch_1(volatile signed char *, signed char,...);
+unsigned char __sync_sub_and_fetch(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_sub_and_fetch_1(volatile unsigned char *, unsigned char,...);
+signed short __sync_sub_and_fetch(volatile signed short *, signed short,...);
+signed short __sync_sub_and_fetch_2(volatile signed short *, signed short,...);
+unsigned short __sync_sub_and_fetch(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_sub_and_fetch_2(volatile unsigned short *, unsigned short,...);
+signed int __sync_sub_and_fetch(volatile signed int *, signed int,...);
+signed int __sync_sub_and_fetch_4(volatile signed int *, signed int,...);
+unsigned int __sync_sub_and_fetch(volatile unsigned int *, unsigned int,...);
+unsigned int __sync_sub_and_fetch_4(volatile unsigned int *, unsigned int,...);
+signed long long int __sync_sub_and_fetch(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_sub_and_fetch_8(volatile signed long long int *, signed long long int,...);
+unsigned long long int __sync_sub_and_fetch(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_sub_and_fetch_8(volatile unsigned long long int *, unsigned long long int,...);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __sync_sub_and_fetch(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_sub_and_fetch_16(volatile signed __int128 *, signed __int128,...);
+unsigned __int128 __sync_sub_and_fetch(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_sub_and_fetch_16(volatile unsigned __int128 *, unsigned __int128,...);
+#endif
+
+char __sync_or_and_fetch(volatile char *, char,...);
+char __sync_or_and_fetch_1(volatile char *, char,...);
+signed char __sync_or_and_fetch(volatile signed char *, signed char,...);
+signed char __sync_or_and_fetch_1(volatile signed char *, signed char,...);
+unsigned char __sync_or_and_fetch(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_or_and_fetch_1(volatile unsigned char *, unsigned char,...);
+signed short __sync_or_and_fetch(volatile signed short *, signed short,...);
+signed short __sync_or_and_fetch_2(volatile signed short *, signed short,...);
+unsigned short __sync_or_and_fetch(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_or_and_fetch_2(volatile unsigned short *, unsigned short,...);
+signed int __sync_or_and_fetch(volatile signed int *, signed int,...);
+signed int __sync_or_and_fetch_4(volatile signed int *, signed int,...);
+unsigned int __sync_or_and_fetch(volatile unsigned int *, unsigned int,...);
+unsigned int __sync_or_and_fetch_4(volatile unsigned int *, unsigned int,...);
+signed long long int __sync_or_and_fetch(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_or_and_fetch_8(volatile signed long long int *, signed long long int,...);
+unsigned long long int __sync_or_and_fetch(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_or_and_fetch_8(volatile unsigned long long int *, unsigned long long int,...);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __sync_or_and_fetch(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_or_and_fetch_16(volatile signed __int128 *, signed __int128,...);
+unsigned __int128 __sync_or_and_fetch(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_or_and_fetch_16(volatile unsigned __int128 *, unsigned __int128,...);
+#endif
+
+char __sync_and_and_fetch(volatile char *, char,...);
+char __sync_and_and_fetch_1(volatile char *, char,...);
+signed char __sync_and_and_fetch(volatile signed char *, signed char,...);
+signed char __sync_and_and_fetch_1(volatile signed char *, signed char,...);
+unsigned char __sync_and_and_fetch(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_and_and_fetch_1(volatile unsigned char *, unsigned char,...);
+signed short __sync_and_and_fetch(volatile signed short *, signed short,...);
+signed short __sync_and_and_fetch_2(volatile signed short *, signed short,...);
+unsigned short __sync_and_and_fetch(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_and_and_fetch_2(volatile unsigned short *, unsigned short,...);
+signed int __sync_and_and_fetch(volatile signed int *, signed int,...);
+signed int __sync_and_and_fetch_4(volatile signed int *, signed int,...);
+unsigned int __sync_and_and_fetch(volatile unsigned int *, unsigned int,...);
+unsigned int __sync_and_and_fetch_4(volatile unsigned int *, unsigned int,...);
+signed long long int __sync_and_and_fetch(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_and_and_fetch_8(volatile signed long long int *, signed long long int,...);
+unsigned long long int __sync_and_and_fetch(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_and_and_fetch_8(volatile unsigned long long int *, unsigned long long int,...);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __sync_and_and_fetch(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_and_and_fetch_16(volatile signed __int128 *, signed __int128,...);
+unsigned __int128 __sync_and_and_fetch(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_and_and_fetch_16(volatile unsigned __int128 *, unsigned __int128,...);
+#endif
+
+char __sync_xor_and_fetch(volatile char *, char,...);
+char __sync_xor_and_fetch_1(volatile char *, char,...);
+signed char __sync_xor_and_fetch(volatile signed char *, signed char,...);
+signed char __sync_xor_and_fetch_1(volatile signed char *, signed char,...);
+unsigned char __sync_xor_and_fetch(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_xor_and_fetch_1(volatile unsigned char *, unsigned char,...);
+signed short __sync_xor_and_fetch(volatile signed short *, signed short,...);
+signed short __sync_xor_and_fetch_2(volatile signed short *, signed short,...);
+unsigned short __sync_xor_and_fetch(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_xor_and_fetch_2(volatile unsigned short *, unsigned short,...);
+signed int __sync_xor_and_fetch(volatile signed int *, signed int,...);
+signed int __sync_xor_and_fetch_4(volatile signed int *, signed int,...);
+unsigned int __sync_xor_and_fetch(volatile unsigned int *, unsigned int,...);
+unsigned int __sync_xor_and_fetch_4(volatile unsigned int *, unsigned int,...);
+signed long long int __sync_xor_and_fetch(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_xor_and_fetch_8(volatile signed long long int *, signed long long int,...);
+unsigned long long int __sync_xor_and_fetch(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_xor_and_fetch_8(volatile unsigned long long int *, unsigned long long int,...);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __sync_xor_and_fetch(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_xor_and_fetch_16(volatile signed __int128 *, signed __int128,...);
+unsigned __int128 __sync_xor_and_fetch(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_xor_and_fetch_16(volatile unsigned __int128 *, unsigned __int128,...);
+#endif
+
+char __sync_nand_and_fetch(volatile char *, char,...);
+char __sync_nand_and_fetch_1(volatile char *, char,...);
+signed char __sync_nand_and_fetch(volatile signed char *, signed char,...);
+signed char __sync_nand_and_fetch_1(volatile signed char *, signed char,...);
+unsigned char __sync_nand_and_fetch(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_nand_and_fetch_1(volatile unsigned char *, unsigned char,...);
+signed short __sync_nand_and_fetch(volatile signed short *, signed short,...);
+signed short __sync_nand_and_fetch_2(volatile signed short *, signed short,...);
+unsigned short __sync_nand_and_fetch(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_nand_and_fetch_2(volatile unsigned short *, unsigned short,...);
+signed int __sync_nand_and_fetch(volatile signed int *, signed int,...);
+signed int __sync_nand_and_fetch_4(volatile signed int *, signed int,...);
+unsigned int __sync_nand_and_fetch(volatile unsigned int *, unsigned int,...);
+unsigned int __sync_nand_and_fetch_4(volatile unsigned int *, unsigned int,...);
+signed long long int __sync_nand_and_fetch(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_nand_and_fetch_8(volatile signed long long int *, signed long long int,...);
+unsigned long long int __sync_nand_and_fetch(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_nand_and_fetch_8(volatile unsigned long long int *, unsigned long long int,...);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __sync_nand_and_fetch(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_nand_and_fetch_16(volatile signed __int128 *, signed __int128,...);
+unsigned __int128 __sync_nand_and_fetch(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_nand_and_fetch_16(volatile unsigned __int128 *, unsigned __int128,...);
+#endif
+
+_Bool __sync_bool_compare_and_swap(volatile char *, char, char,...);
+_Bool __sync_bool_compare_and_swap_1(volatile char *, char, char,...);
+_Bool __sync_bool_compare_and_swap(volatile signed char *, signed char, signed char,...);
+_Bool __sync_bool_compare_and_swap_1(volatile signed char *, signed char, signed char,...);
+_Bool __sync_bool_compare_and_swap(volatile unsigned char *, unsigned char, unsigned char,...);
+_Bool __sync_bool_compare_and_swap_1(volatile unsigned char *, unsigned char, unsigned char,...);
+_Bool __sync_bool_compare_and_swap(volatile short *, signed short, signed short,...);
+_Bool __sync_bool_compare_and_swap_2(volatile short *, signed short, signed short,...);
+_Bool __sync_bool_compare_and_swap(volatile short *, unsigned short, unsigned short,...);
+_Bool __sync_bool_compare_and_swap_2(volatile short *, unsigned short, unsigned short,...);
+_Bool __sync_bool_compare_and_swap(volatile signed int *, signed int, signed int,...);
+_Bool __sync_bool_compare_and_swap_4(volatile signed int *, signed int, signed int,...);
+_Bool __sync_bool_compare_and_swap(volatile unsigned int *, unsigned int, unsigned int,...);
+_Bool __sync_bool_compare_and_swap_4(volatile unsigned int *, unsigned int, unsigned int,...);
+_Bool __sync_bool_compare_and_swap(volatile signed long long int *, signed long long int, signed long long int,...);
+_Bool __sync_bool_compare_and_swap_8(volatile signed long long int *, signed long long int, signed long long int,...);
+_Bool __sync_bool_compare_and_swap(volatile unsigned long long int *, unsigned long long int, unsigned long long int,...);
+_Bool __sync_bool_compare_and_swap_8(volatile unsigned long long int *, unsigned long long int, unsigned long long int,...);
+#if defined(__SIZEOF_INT128__)
+_Bool __sync_bool_compare_and_swap(volatile signed __int128 *, signed __int128, signed __int128,...);
+_Bool __sync_bool_compare_and_swap_16(volatile signed __int128 *, signed __int128, signed __int128,...);
+_Bool __sync_bool_compare_and_swap(volatile unsigned __int128 *, unsigned __int128, unsigned __int128,...);
+_Bool __sync_bool_compare_and_swap_16(volatile unsigned __int128 *, unsigned __int128, unsigned __int128,...);
+#endif
+
+char __sync_val_compare_and_swap(volatile char *, char, char,...);
+char __sync_val_compare_and_swap_1(volatile char *, char, char,...);
+signed char __sync_val_compare_and_swap(volatile signed char *, signed char, signed char,...);
+signed char __sync_val_compare_and_swap_1(volatile signed char *, signed char, signed char,...);
+unsigned char __sync_val_compare_and_swap(volatile unsigned char *, unsigned char, unsigned char,...);
+unsigned char __sync_val_compare_and_swap_1(volatile unsigned char *, unsigned char, unsigned char,...);
+signed short __sync_val_compare_and_swap(volatile signed short *, signed short, signed short,...);
+signed short __sync_val_compare_and_swap_2(volatile signed short *, signed short, signed short,...);
+unsigned short __sync_val_compare_and_swap(volatile unsigned short *, unsigned short, unsigned short,...);
+unsigned short __sync_val_compare_and_swap_2(volatile unsigned short *, unsigned short, unsigned short,...);
+signed int __sync_val_compare_and_swap(volatile signed int *, signed int, signed int,...);
+signed int __sync_val_compare_and_swap_4(volatile signed int *, signed int, signed int,...);
+unsigned int __sync_val_compare_and_swap(volatile unsigned int *, unsigned int, unsigned int,...);
+unsigned int __sync_val_compare_and_swap_4(volatile unsigned int *, unsigned int, unsigned int,...);
+signed long long int __sync_val_compare_and_swap(volatile signed long long int *, signed long long int, signed long long int,...);
+signed long long int __sync_val_compare_and_swap_8(volatile signed long long int *, signed long long int, signed long long int,...);
+unsigned long long int __sync_val_compare_and_swap(volatile unsigned long long int *, unsigned long long int, unsigned long long int,...);
+unsigned long long int __sync_val_compare_and_swap_8(volatile unsigned long long int *, unsigned long long int, unsigned long long int,...);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __sync_val_compare_and_swap(volatile signed __int128 *, signed __int128, signed __int128,...);
+signed __int128 __sync_val_compare_and_swap_16(volatile signed __int128 *, signed __int128, signed __int128,...);
+unsigned __int128 __sync_val_compare_and_swap(volatile unsigned __int128 *, unsigned __int128, unsigned __int128,...);
+unsigned __int128 __sync_val_compare_and_swap_16(volatile unsigned __int128 *, unsigned __int128, unsigned __int128,...);
+#endif
+
+char __sync_lock_test_and_set(volatile char *, char,...);
+char __sync_lock_test_and_set_1(volatile char *, char,...);
+signed char __sync_lock_test_and_set(volatile signed char *, signed char,...);
+signed char __sync_lock_test_and_set_1(volatile signed char *, signed char,...);
+unsigned char __sync_lock_test_and_set(volatile unsigned char *, unsigned char,...);
+unsigned char __sync_lock_test_and_set_1(volatile unsigned char *, unsigned char,...);
+signed short __sync_lock_test_and_set(volatile signed short *, signed short,...);
+signed short __sync_lock_test_and_set_2(volatile signed short *, signed short,...);
+unsigned short __sync_lock_test_and_set(volatile unsigned short *, unsigned short,...);
+unsigned short __sync_lock_test_and_set_2(volatile unsigned short *, unsigned short,...);
+signed int __sync_lock_test_and_set(volatile signed int *, signed int,...);
+signed int __sync_lock_test_and_set_4(volatile signed int *, signed int,...);
+unsigned int __sync_lock_test_and_set(volatile unsigned int *, unsigned int,...);
+unsigned int __sync_lock_test_and_set_4(volatile unsigned int *, unsigned int,...);
+signed long long int __sync_lock_test_and_set(volatile signed long long int *, signed long long int,...);
+signed long long int __sync_lock_test_and_set_8(volatile signed long long int *, signed long long int,...);
+unsigned long long int __sync_lock_test_and_set(volatile unsigned long long int *, unsigned long long int,...);
+unsigned long long int __sync_lock_test_and_set_8(volatile unsigned long long int *, unsigned long long int,...);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __sync_lock_test_and_set(volatile signed __int128 *, signed __int128,...);
+signed __int128 __sync_lock_test_and_set_16(volatile signed __int128 *, signed __int128,...);
+unsigned __int128 __sync_lock_test_and_set(volatile unsigned __int128 *, unsigned __int128,...);
+unsigned __int128 __sync_lock_test_and_set_16(volatile unsigned __int128 *, unsigned __int128,...);
+#endif
+
+void __sync_lock_release(volatile char *,...);
+void __sync_lock_release_1(volatile char *,...);
+void __sync_lock_release(volatile signed char *,...);
+void __sync_lock_release_1(volatile signed char *,...);
+void __sync_lock_release(volatile unsigned char *,...);
+void __sync_lock_release_1(volatile unsigned char *,...);
+void __sync_lock_release(volatile signed short *,...);
+void __sync_lock_release_2(volatile signed short *,...);
+void __sync_lock_release(volatile unsigned short *,...);
+void __sync_lock_release_2(volatile unsigned short *,...);
+void __sync_lock_release(volatile signed int *,...);
+void __sync_lock_release_4(volatile signed int *,...);
+void __sync_lock_release(volatile unsigned int *,...);
+void __sync_lock_release_4(volatile unsigned int *,...);
+void __sync_lock_release(volatile signed long long int *,...);
+void __sync_lock_release_8(volatile signed long long int *,...);
+void __sync_lock_release(volatile unsigned long long int *,...);
+void __sync_lock_release_8(volatile unsigned long long int *,...);
+#if defined(__SIZEOF_INT128__)
+void __sync_lock_release(volatile signed __int128 *,...);
+void __sync_lock_release_16(volatile signed __int128 *,...);
+void __sync_lock_release(volatile unsigned __int128 *,...);
+void __sync_lock_release_16(volatile unsigned __int128 *,...);
+#endif
+
+void __sync_synchronize();
+
+
+
+
+_Bool __atomic_test_and_set(volatile _Bool *, int);
+_Bool __atomic_test_and_set(volatile char *, int);
+_Bool __atomic_test_and_set(volatile signed char *, int);
+_Bool __atomic_test_and_set(volatile unsigned char *, int);
+_Bool __atomic_test_and_set(volatile signed short *, int);
+_Bool __atomic_test_and_set(volatile unsigned short *, int);
+_Bool __atomic_test_and_set(volatile signed int *, int);
+_Bool __atomic_test_and_set(volatile unsigned int *, int);
+_Bool __atomic_test_and_set(volatile signed long long int *, int);
+_Bool __atomic_test_and_set(volatile unsigned long long int *, int);
+#if defined(__SIZEOF_INT128__)
+_Bool __atomic_test_and_set(volatile signed __int128 *, int);
+_Bool __atomic_test_and_set(volatile unsigned __int128 *, int);
+#endif
+
+void __atomic_clear(volatile _Bool *, int);
+void __atomic_clear(volatile char *, int);
+void __atomic_clear(volatile signed char *, int);
+void __atomic_clear(volatile unsigned char *, int);
+void __atomic_clear(volatile signed short *, int);
+void __atomic_clear(volatile unsigned short *, int);
+void __atomic_clear(volatile signed int *, int);
+void __atomic_clear(volatile unsigned int *, int);
+void __atomic_clear(volatile signed long long int *, int);
+void __atomic_clear(volatile unsigned long long int *, int);
+#if defined(__SIZEOF_INT128__)
+void __atomic_clear(volatile signed __int128 *, int);
+void __atomic_clear(volatile unsigned __int128 *, int);
+#endif
+
+char __atomic_exchange_n(volatile char *, volatile char *, int);
+char __atomic_exchange_1(volatile char *, char, int);
+void __atomic_exchange(volatile char *, volatile char *, volatile char *, int);
+signed char __atomic_exchange_n(volatile signed char *, volatile signed char *, int);
+signed char __atomic_exchange_1(volatile signed char *, signed char, int);
+void __atomic_exchange(volatile signed char *, volatile signed char *, volatile signed char *, int);
+unsigned char __atomic_exchange_n(volatile unsigned char *, volatile unsigned char *, int);
+unsigned char __atomic_exchange_1(volatile unsigned char *, unsigned char, int);
+void __atomic_exchange(volatile unsigned char *, volatile unsigned char *, volatile unsigned char *, int);
+signed short __atomic_exchange_n(volatile signed short *, volatile signed short *, int);
+signed short __atomic_exchange_2(volatile signed short *, signed short, int);
+void __atomic_exchange(volatile signed short *, volatile signed short *, volatile signed short *, int);
+unsigned short __atomic_exchange_n(volatile unsigned short *, volatile unsigned short *, int);
+unsigned short __atomic_exchange_2(volatile unsigned short *, unsigned short, int);
+void __atomic_exchange(volatile unsigned short *, volatile unsigned short *, volatile unsigned short *, int);
+signed int __atomic_exchange_n(volatile signed int *, volatile signed int *, int);
+signed int __atomic_exchange_4(volatile signed int *, signed int, int);
+void __atomic_exchange(volatile signed int *, volatile signed int *, volatile signed int *, int);
+unsigned int __atomic_exchange_n(volatile unsigned int *, volatile unsigned int *, int);
+unsigned int __atomic_exchange_4(volatile unsigned int *, unsigned int, int);
+void __atomic_exchange(volatile unsigned int *, volatile unsigned int *, volatile unsigned int *, int);
+signed long long int __atomic_exchange_n(volatile signed long long int *, volatile signed long long int *, int);
+signed long long int __atomic_exchange_8(volatile signed long long int *, signed long long int, int);
+void __atomic_exchange(volatile signed long long int *, volatile signed long long int *, volatile signed long long int *, int);
+unsigned long long int __atomic_exchange_n(volatile unsigned long long int *, volatile unsigned long long int *, int);
+unsigned long long int __atomic_exchange_8(volatile unsigned long long int *, unsigned long long int, int);
+void __atomic_exchange(volatile unsigned long long int *, volatile unsigned long long int *, volatile unsigned long long int *, int);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __atomic_exchange_n(volatile signed __int128 *, volatile signed __int128 *, int);
+signed __int128 __atomic_exchange_16(volatile signed __int128 *, signed __int128, int);
+void __atomic_exchange(volatile signed __int128 *, volatile signed __int128 *, volatile signed __int128 *, int);
+unsigned __int128 __atomic_exchange_n(volatile unsigned __int128 *, volatile unsigned __int128 *, int);
+unsigned __int128 __atomic_exchange_16(volatile unsigned __int128 *, unsigned __int128, int);
+void __atomic_exchange(volatile unsigned __int128 *, volatile unsigned __int128 *, volatile unsigned __int128 *, int);
+#endif
+
+_Bool __atomic_load_n(const volatile _Bool *, int);
+void __atomic_load(const volatile _Bool *, volatile _Bool *, int);
+char __atomic_load_n(const volatile char *, int);
+char __atomic_load_1(const volatile char *, int);
+void __atomic_load(const volatile char *, volatile char *, int);
+signed char __atomic_load_n(const volatile signed char *, int);
+signed char __atomic_load_1(const volatile signed char *, int);
+void __atomic_load(const volatile signed char *, volatile signed char *, int);
+unsigned char __atomic_load_n(const volatile unsigned char *, int);
+unsigned char __atomic_load_1(const volatile unsigned char *, int);
+void __atomic_load(const volatile unsigned char *, volatile unsigned char *, int);
+signed short __atomic_load_n(const volatile signed short *, int);
+signed short __atomic_load_2(const volatile signed short *, int);
+void __atomic_load(const volatile signed short *, volatile signed short *, int);
+unsigned short __atomic_load_n(const volatile unsigned short *, int);
+unsigned short __atomic_load_2(const volatile unsigned short *, int);
+void __atomic_load(const volatile unsigned short *, volatile unsigned short *, int);
+signed int __atomic_load_n(const volatile signed int *, int);
+signed int __atomic_load_4(const volatile signed int *, int);
+void __atomic_load(const volatile signed int *, volatile signed int *, int);
+unsigned int __atomic_load_n(const volatile unsigned int *, int);
+unsigned int __atomic_load_4(const volatile unsigned int *, int);
+void __atomic_load(const volatile unsigned int *, volatile unsigned int *, int);
+signed long long int __atomic_load_n(const volatile signed long long int *, int);
+signed long long int __atomic_load_8(const volatile signed long long int *, int);
+void __atomic_load(const volatile signed long long int *, volatile signed long long int *, int);
+unsigned long long int __atomic_load_n(const volatile unsigned long long int *, int);
+unsigned long long int __atomic_load_8(const volatile unsigned long long int *, int);
+void __atomic_load(const volatile unsigned long long int *, volatile unsigned long long int *, int);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __atomic_load_n(const volatile signed __int128 *, int);
+signed __int128 __atomic_load_16(const volatile signed __int128 *, int);
+void __atomic_load(const volatile signed __int128 *, volatile signed __int128 *, int);
+unsigned __int128 __atomic_load_n(const volatile unsigned __int128 *, int);
+unsigned __int128 __atomic_load_16(const volatile unsigned __int128 *, int);
+void __atomic_load(const volatile unsigned __int128 *, volatile unsigned __int128 *, int);
+#endif
+
+_Bool __atomic_compare_exchange_n(volatile char *, char *, char, _Bool, int, int);
+_Bool __atomic_compare_exchange_1(volatile char *, char *, char, _Bool, int, int);
+_Bool __atomic_compare_exchange (volatile char *, char *, char *, _Bool, int, int);
+_Bool __atomic_compare_exchange_n(volatile signed char *, signed char *, signed char, _Bool, int, int);
+_Bool __atomic_compare_exchange_1(volatile signed char *, signed char *, signed char, _Bool, int, int);
+_Bool __atomic_compare_exchange (volatile signed char *, signed char *, signed char *, _Bool, int, int);
+_Bool __atomic_compare_exchange_n(volatile unsigned char *, unsigned char *, unsigned char, _Bool, int, int);
+_Bool __atomic_compare_exchange_1(volatile unsigned char *, unsigned char *, unsigned char, _Bool, int, int);
+_Bool __atomic_compare_exchange (volatile unsigned char *, unsigned char *, unsigned char *, _Bool, int, int);
+_Bool __atomic_compare_exchange_n(volatile signed short *, signed short *, signed short, _Bool, int, int);
+_Bool __atomic_compare_exchange_2(volatile signed short *, signed short *, signed short, _Bool, int, int);
+_Bool __atomic_compare_exchange (volatile signed short *, signed short *, signed short *, _Bool, int, int);
+_Bool __atomic_compare_exchange_n(volatile unsigned short *, unsigned short *, unsigned short, _Bool, int, int);
+_Bool __atomic_compare_exchange_2(volatile unsigned short *, unsigned short *, unsigned short, _Bool, int, int);
+_Bool __atomic_compare_exchange (volatile unsigned short *, unsigned short *, unsigned short *, _Bool, int, int);
+_Bool __atomic_compare_exchange_n(volatile signed int *, signed int *, signed int, _Bool, int, int);
+_Bool __atomic_compare_exchange_4(volatile signed int *, signed int *, signed int, _Bool, int, int);
+_Bool __atomic_compare_exchange (volatile signed int *, signed int *, signed int *, _Bool, int, int);
+_Bool __atomic_compare_exchange_n(volatile unsigned int *, unsigned int *, unsigned int, _Bool, int, int);
+_Bool __atomic_compare_exchange_4(volatile unsigned int *, unsigned int *, unsigned int, _Bool, int, int);
+_Bool __atomic_compare_exchange (volatile unsigned int *, unsigned int *, unsigned int *, _Bool, int, int);
+_Bool __atomic_compare_exchange_n(volatile signed long long int *, signed long long int *, signed long long int, _Bool, int, int);
+_Bool __atomic_compare_exchange_8(volatile signed long long int *, signed long long int *, signed long long int, _Bool, int, int);
+_Bool __atomic_compare_exchange (volatile signed long long int *, signed long long int *, signed long long int *, _Bool, int, int);
+_Bool __atomic_compare_exchange_n(volatile unsigned long long int *, unsigned long long int *, unsigned long long int, _Bool, int, int);
+_Bool __atomic_compare_exchange_8(volatile unsigned long long int *, unsigned long long int *, unsigned long long int, _Bool, int, int);
+_Bool __atomic_compare_exchange (volatile unsigned long long int *, unsigned long long int *, unsigned long long int *, _Bool, int, int);
+#if defined(__SIZEOF_INT128__)
+_Bool __atomic_compare_exchange_n (volatile signed __int128 *, signed __int128 *, signed __int128, _Bool, int, int);
+_Bool __atomic_compare_exchange_16(volatile signed __int128 *, signed __int128 *, signed __int128, _Bool, int, int);
+_Bool __atomic_compare_exchange (volatile signed __int128 *, signed __int128 *, signed __int128 *, _Bool, int, int);
+_Bool __atomic_compare_exchange_n (volatile unsigned __int128 *, unsigned __int128 *, unsigned __int128, _Bool, int, int);
+_Bool __atomic_compare_exchange_16(volatile unsigned __int128 *, unsigned __int128 *, unsigned __int128, _Bool, int, int);
+_Bool __atomic_compare_exchange (volatile unsigned __int128 *, unsigned __int128 *, unsigned __int128 *, _Bool, int, int);
+#endif
+
+void __atomic_store_n(volatile _Bool *, _Bool, int);
+void __atomic_store(volatile _Bool *, _Bool *, int);
+void __atomic_store_n(volatile char *, char, int);
+void __atomic_store_1(volatile char *, char, int);
+void __atomic_store(volatile char *, char *, int);
+void __atomic_store_n(volatile signed char *, signed char, int);
+void __atomic_store_1(volatile signed char *, signed char, int);
+void __atomic_store(volatile signed char *, signed char *, int);
+void __atomic_store_n(volatile unsigned char *, unsigned char, int);
+void __atomic_store_1(volatile unsigned char *, unsigned char, int);
+void __atomic_store(volatile unsigned char *, unsigned char *, int);
+void __atomic_store_n(volatile signed short *, signed short, int);
+void __atomic_store_2(volatile signed short *, signed short, int);
+void __atomic_store(volatile signed short *, signed short *, int);
+void __atomic_store_n(volatile unsigned short *, unsigned short, int);
+void __atomic_store_2(volatile unsigned short *, unsigned short, int);
+void __atomic_store(volatile unsigned short *, unsigned short *, int);
+void __atomic_store_n(volatile signed int *, signed int, int);
+void __atomic_store_4(volatile signed int *, signed int, int);
+void __atomic_store(volatile signed int *, signed int *, int);
+void __atomic_store_n(volatile unsigned int *, unsigned int, int);
+void __atomic_store_4(volatile unsigned int *, unsigned int, int);
+void __atomic_store(volatile unsigned int *, unsigned int *, int);
+void __atomic_store_n(volatile signed long long int *, signed long long int, int);
+void __atomic_store_8(volatile signed long long int *, signed long long int, int);
+void __atomic_store(volatile signed long long int *, signed long long int *, int);
+void __atomic_store_n(volatile unsigned long long int *, unsigned long long int, int);
+void __atomic_store_8(volatile unsigned long long int *, unsigned long long int, int);
+void __atomic_store(volatile unsigned long long int *, unsigned long long int *, int);
+#if defined(__SIZEOF_INT128__)
+void __atomic_store_n(volatile signed __int128 *, signed __int128, int);
+void __atomic_store_16(volatile signed __int128 *, signed __int128, int);
+void __atomic_store(volatile signed __int128 *, signed __int128 *, int);
+void __atomic_store_n(volatile unsigned __int128 *, unsigned __int128, int);
+void __atomic_store_16(volatile unsigned __int128 *, unsigned __int128, int);
+void __atomic_store(volatile unsigned __int128 *, unsigned __int128 *, int);
+#endif
+
+char __atomic_add_fetch (volatile char *, char, int);
+char __atomic_add_fetch_1(volatile char *, char, int);
+signed char __atomic_add_fetch (volatile signed char *, signed char, int);
+signed char __atomic_add_fetch_1(volatile signed char *, signed char, int);
+unsigned char __atomic_add_fetch (volatile unsigned char *, unsigned char, int);
+unsigned char __atomic_add_fetch_1(volatile unsigned char *, unsigned char, int);
+signed short __atomic_add_fetch (volatile signed short *, signed short, int);
+signed short __atomic_add_fetch_2(volatile signed short *, signed short, int);
+unsigned short __atomic_add_fetch (volatile unsigned short *, unsigned short, int);
+unsigned short __atomic_add_fetch_2(volatile unsigned short *, unsigned short, int);
+signed int __atomic_add_fetch (volatile signed int *, signed int, int);
+signed int __atomic_add_fetch_4(volatile signed int *, signed int, int);
+unsigned int __atomic_add_fetch (volatile unsigned int *, unsigned int, int);
+unsigned int __atomic_add_fetch_4(volatile unsigned int *, unsigned int, int);
+signed long long int __atomic_add_fetch (volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_add_fetch_8(volatile signed long long int *, signed long long int, int);
+unsigned long long int __atomic_add_fetch (volatile unsigned long long int *, unsigned long long int, int);
+unsigned long long int __atomic_add_fetch_8(volatile unsigned long long int *, unsigned long long int, int);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __atomic_add_fetch (volatile signed __int128 *, signed __int128, int);
+signed __int128 __atomic_add_fetch_16(volatile signed __int128 *, signed __int128, int);
+unsigned __int128 __atomic_add_fetch (volatile unsigned __int128 *, unsigned __int128, int);
+unsigned __int128 __atomic_add_fetch_16(volatile unsigned __int128 *, unsigned __int128, int);
+#endif
+
+char __atomic_sub_fetch (volatile char *, char, int);
+char __atomic_sub_fetch_1(volatile char *, char, int);
+signed char __atomic_sub_fetch (volatile signed char *, signed char, int);
+signed char __atomic_sub_fetch_1(volatile signed char *, signed char, int);
+unsigned char __atomic_sub_fetch (volatile unsigned char *, unsigned char, int);
+unsigned char __atomic_sub_fetch_1(volatile unsigned char *, unsigned char, int);
+signed short __atomic_sub_fetch (volatile signed short *, signed short, int);
+signed short __atomic_sub_fetch_2(volatile signed short *, signed short, int);
+unsigned short __atomic_sub_fetch (volatile unsigned short *, unsigned short, int);
+unsigned short __atomic_sub_fetch_2(volatile unsigned short *, unsigned short, int);
+signed int __atomic_sub_fetch (volatile signed int *, signed int, int);
+signed int __atomic_sub_fetch_4(volatile signed int *, signed int, int);
+unsigned int __atomic_sub_fetch (volatile unsigned int *, unsigned int, int);
+unsigned int __atomic_sub_fetch_4(volatile unsigned int *, unsigned int, int);
+signed long long int __atomic_sub_fetch (volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_sub_fetch_8(volatile signed long long int *, signed long long int, int);
+unsigned long long int __atomic_sub_fetch (volatile unsigned long long int *, unsigned long long int, int);
+unsigned long long int __atomic_sub_fetch_8(volatile unsigned long long int *, unsigned long long int, int);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __atomic_sub_fetch (volatile signed __int128 *, signed __int128, int);
+signed __int128 __atomic_sub_fetch_16(volatile signed __int128 *, signed __int128, int);
+unsigned __int128 __atomic_sub_fetch (volatile unsigned __int128 *, unsigned __int128, int);
+unsigned __int128 __atomic_sub_fetch_16(volatile unsigned __int128 *, unsigned __int128, int);
+#endif
+
+char __atomic_and_fetch (volatile char *, char, int);
+char __atomic_and_fetch_1(volatile char *, char, int);
+signed char __atomic_and_fetch (volatile signed char *, signed char, int);
+signed char __atomic_and_fetch_1(volatile signed char *, signed char, int);
+unsigned char __atomic_and_fetch (volatile unsigned char *, unsigned char, int);
+unsigned char __atomic_and_fetch_1(volatile unsigned char *, unsigned char, int);
+signed short __atomic_and_fetch (volatile signed short *, signed short, int);
+signed short __atomic_and_fetch_2(volatile signed short *, signed short, int);
+unsigned short __atomic_and_fetch (volatile unsigned short *, unsigned short, int);
+unsigned short __atomic_and_fetch_2(volatile unsigned short *, unsigned short, int);
+signed int __atomic_and_fetch (volatile signed int *, signed int, int);
+signed int __atomic_and_fetch_4(volatile signed int *, signed int, int);
+unsigned int __atomic_and_fetch (volatile unsigned int *, unsigned int, int);
+unsigned int __atomic_and_fetch_4(volatile unsigned int *, unsigned int, int);
+signed long long int __atomic_and_fetch (volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_and_fetch_8(volatile signed long long int *, signed long long int, int);
+unsigned long long int __atomic_and_fetch (volatile unsigned long long int *, unsigned long long int, int);
+unsigned long long int __atomic_and_fetch_8(volatile unsigned long long int *, unsigned long long int, int);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __atomic_and_fetch (volatile signed __int128 *, signed __int128, int);
+signed __int128 __atomic_and_fetch_16(volatile signed __int128 *, signed __int128, int);
+unsigned __int128 __atomic_and_fetch (volatile unsigned __int128 *, unsigned __int128, int);
+unsigned __int128 __atomic_and_fetch_16(volatile unsigned __int128 *, unsigned __int128, int);
+#endif
+
+char __atomic_nand_fetch (volatile char *, char, int);
+char __atomic_nand_fetch_1(volatile char *, char, int);
+signed char __atomic_nand_fetch (volatile signed char *, signed char, int);
+signed char __atomic_nand_fetch_1(volatile signed char *, signed char, int);
+unsigned char __atomic_nand_fetch (volatile unsigned char *, unsigned char, int);
+unsigned char __atomic_nand_fetch_1(volatile unsigned char *, unsigned char, int);
+signed short __atomic_nand_fetch (volatile signed short *, signed short, int);
+signed short __atomic_nand_fetch_2(volatile signed short *, signed short, int);
+unsigned short __atomic_nand_fetch (volatile unsigned short *, unsigned short, int);
+unsigned short __atomic_nand_fetch_2(volatile unsigned short *, unsigned short, int);
+signed int __atomic_nand_fetch (volatile signed int *, signed int, int);
+signed int __atomic_nand_fetch_4(volatile signed int *, signed int, int);
+unsigned int __atomic_nand_fetch (volatile unsigned int *, unsigned int, int);
+unsigned int __atomic_nand_fetch_4(volatile unsigned int *, unsigned int, int);
+signed long long int __atomic_nand_fetch (volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_nand_fetch_8(volatile signed long long int *, signed long long int, int);
+unsigned long long int __atomic_nand_fetch (volatile unsigned long long int *, unsigned long long int, int);
+unsigned long long int __atomic_nand_fetch_8(volatile unsigned long long int *, unsigned long long int, int);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __atomic_nand_fetch (volatile signed __int128 *, signed __int128, int);
+signed __int128 __atomic_nand_fetch_16(volatile signed __int128 *, signed __int128, int);
+unsigned __int128 __atomic_nand_fetch (volatile unsigned __int128 *, unsigned __int128, int);
+unsigned __int128 __atomic_nand_fetch_16(volatile unsigned __int128 *, unsigned __int128, int);
+#endif
+
+char __atomic_xor_fetch (volatile char *, char, int);
+char __atomic_xor_fetch_1(volatile char *, char, int);
+signed char __atomic_xor_fetch (volatile signed char *, signed char, int);
+signed char __atomic_xor_fetch_1(volatile signed char *, signed char, int);
+unsigned char __atomic_xor_fetch (volatile unsigned char *, unsigned char, int);
+unsigned char __atomic_xor_fetch_1(volatile unsigned char *, unsigned char, int);
+signed short __atomic_xor_fetch (volatile signed short *, signed short, int);
+signed short __atomic_xor_fetch_2(volatile signed short *, signed short, int);
+unsigned short __atomic_xor_fetch (volatile unsigned short *, unsigned short, int);
+unsigned short __atomic_xor_fetch_2(volatile unsigned short *, unsigned short, int);
+signed int __atomic_xor_fetch (volatile signed int *, signed int, int);
+signed int __atomic_xor_fetch_4(volatile signed int *, signed int, int);
+unsigned int __atomic_xor_fetch (volatile unsigned int *, unsigned int, int);
+unsigned int __atomic_xor_fetch_4(volatile unsigned int *, unsigned int, int);
+signed long long int __atomic_xor_fetch (volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_xor_fetch_8(volatile signed long long int *, signed long long int, int);
+unsigned long long int __atomic_xor_fetch (volatile unsigned long long int *, unsigned long long int, int);
+unsigned long long int __atomic_xor_fetch_8(volatile unsigned long long int *, unsigned long long int, int);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __atomic_xor_fetch (volatile signed __int128 *, signed __int128, int);
+signed __int128 __atomic_xor_fetch_16(volatile signed __int128 *, signed __int128, int);
+unsigned __int128 __atomic_xor_fetch (volatile unsigned __int128 *, unsigned __int128, int);
+unsigned __int128 __atomic_xor_fetch_16(volatile unsigned __int128 *, unsigned __int128, int);
+#endif
+
+char __atomic_or_fetch (volatile char *, char, int);
+char __atomic_or_fetch_1(volatile char *, char, int);
+signed char __atomic_or_fetch (volatile signed char *, signed char, int);
+signed char __atomic_or_fetch_1(volatile signed char *, signed char, int);
+unsigned char __atomic_or_fetch (volatile unsigned char *, unsigned char, int);
+unsigned char __atomic_or_fetch_1(volatile unsigned char *, unsigned char, int);
+signed short __atomic_or_fetch (volatile signed short *, signed short, int);
+signed short __atomic_or_fetch_2(volatile signed short *, signed short, int);
+unsigned short __atomic_or_fetch (volatile unsigned short *, unsigned short, int);
+unsigned short __atomic_or_fetch_2(volatile unsigned short *, unsigned short, int);
+signed int __atomic_or_fetch (volatile signed int *, signed int, int);
+signed int __atomic_or_fetch_4(volatile signed int *, signed int, int);
+unsigned int __atomic_or_fetch (volatile unsigned int *, unsigned int, int);
+unsigned int __atomic_or_fetch_4(volatile unsigned int *, unsigned int, int);
+signed long long int __atomic_or_fetch (volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_or_fetch_8(volatile signed long long int *, signed long long int, int);
+unsigned long long int __atomic_or_fetch (volatile unsigned long long int *, unsigned long long int, int);
+unsigned long long int __atomic_or_fetch_8(volatile unsigned long long int *, unsigned long long int, int);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __atomic_or_fetch (volatile signed __int128 *, signed __int128, int);
+signed __int128 __atomic_or_fetch_16(volatile signed __int128 *, signed __int128, int);
+unsigned __int128 __atomic_or_fetch (volatile unsigned __int128 *, unsigned __int128, int);
+unsigned __int128 __atomic_or_fetch_16(volatile unsigned __int128 *, unsigned __int128, int);
+#endif
+
+char __atomic_fetch_add (volatile char *, char, int);
+char __atomic_fetch_add_1(volatile char *, char, int);
+signed char __atomic_fetch_add (volatile signed char *, signed char, int);
+signed char __atomic_fetch_add_1(volatile signed char *, signed char, int);
+unsigned char __atomic_fetch_add (volatile unsigned char *, unsigned char, int);
+unsigned char __atomic_fetch_add_1(volatile unsigned char *, unsigned char, int);
+signed short __atomic_fetch_add (volatile signed short *, signed short, int);
+signed short __atomic_fetch_add_2(volatile signed short *, signed short, int);
+unsigned short __atomic_fetch_add (volatile unsigned short *, unsigned short, int);
+unsigned short __atomic_fetch_add_2(volatile unsigned short *, unsigned short, int);
+signed int __atomic_fetch_add (volatile signed int *, signed int, int);
+signed int __atomic_fetch_add_4(volatile signed int *, signed int, int);
+unsigned int __atomic_fetch_add (volatile unsigned int *, unsigned int, int);
+unsigned int __atomic_fetch_add_4(volatile unsigned int *, unsigned int, int);
+signed long long int __atomic_fetch_add (volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_fetch_add_8(volatile signed long long int *, signed long long int, int);
+unsigned long long int __atomic_fetch_add (volatile unsigned long long int *, unsigned long long int, int);
+unsigned long long int __atomic_fetch_add_8(volatile unsigned long long int *, unsigned long long int, int);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __atomic_fetch_add (volatile signed __int128 *, signed __int128, int);
+signed __int128 __atomic_fetch_add_16(volatile signed __int128 *, signed __int128, int);
+unsigned __int128 __atomic_fetch_add (volatile unsigned __int128 *, unsigned __int128, int);
+unsigned __int128 __atomic_fetch_add_16(volatile unsigned __int128 *, unsigned __int128, int);
+#endif
+
+char __atomic_fetch_sub (volatile char *, char, int);
+char __atomic_fetch_sub_1(volatile char *, char, int);
+signed char __atomic_fetch_sub (volatile signed char *, signed char, int);
+signed char __atomic_fetch_sub_1(volatile signed char *, signed char, int);
+unsigned char __atomic_fetch_sub (volatile unsigned char *, unsigned char, int);
+unsigned char __atomic_fetch_sub_1(volatile unsigned char *, unsigned char, int);
+signed short __atomic_fetch_sub (volatile signed short *, signed short, int);
+signed short __atomic_fetch_sub_2(volatile signed short *, signed short, int);
+unsigned short __atomic_fetch_sub (volatile unsigned short *, unsigned short, int);
+unsigned short __atomic_fetch_sub_2(volatile unsigned short *, unsigned short, int);
+signed int __atomic_fetch_sub (volatile signed int *, signed int, int);
+signed int __atomic_fetch_sub_4(volatile signed int *, signed int, int);
+unsigned int __atomic_fetch_sub (volatile unsigned int *, unsigned int, int);
+unsigned int __atomic_fetch_sub_4(volatile unsigned int *, unsigned int, int);
+signed long long int __atomic_fetch_sub (volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_fetch_sub_8(volatile signed long long int *, signed long long int, int);
+unsigned long long int __atomic_fetch_sub (volatile unsigned long long int *, unsigned long long int, int);
+unsigned long long int __atomic_fetch_sub_8(volatile unsigned long long int *, unsigned long long int, int);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __atomic_fetch_sub (volatile signed __int128 *, signed __int128, int);
+signed __int128 __atomic_fetch_sub_16(volatile signed __int128 *, signed __int128, int);
+unsigned __int128 __atomic_fetch_sub (volatile unsigned __int128 *, unsigned __int128, int);
+unsigned __int128 __atomic_fetch_sub_16(volatile unsigned __int128 *, unsigned __int128, int);
+#endif
+
+char __atomic_fetch_and (volatile char *, char, int);
+char __atomic_fetch_and_1(volatile char *, char, int);
+signed char __atomic_fetch_and (volatile signed char *, signed char, int);
+signed char __atomic_fetch_and_1(volatile signed char *, signed char, int);
+unsigned char __atomic_fetch_and (volatile unsigned char *, unsigned char, int);
+unsigned char __atomic_fetch_and_1(volatile unsigned char *, unsigned char, int);
+signed short __atomic_fetch_and (volatile signed short *, signed short, int);
+signed short __atomic_fetch_and_2(volatile signed short *, signed short, int);
+unsigned short __atomic_fetch_and (volatile unsigned short *, unsigned short, int);
+unsigned short __atomic_fetch_and_2(volatile unsigned short *, unsigned short, int);
+signed int __atomic_fetch_and (volatile signed int *, signed int, int);
+signed int __atomic_fetch_and_4(volatile signed int *, signed int, int);
+unsigned int __atomic_fetch_and (volatile unsigned int *, unsigned int, int);
+unsigned int __atomic_fetch_and_4(volatile unsigned int *, unsigned int, int);
+signed long long int __atomic_fetch_and (volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_fetch_and_8(volatile signed long long int *, signed long long int, int);
+unsigned long long int __atomic_fetch_and (volatile unsigned long long int *, unsigned long long int, int);
+unsigned long long int __atomic_fetch_and_8(volatile unsigned long long int *, unsigned long long int, int);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __atomic_fetch_and (volatile signed __int128 *, signed __int128, int);
+signed __int128 __atomic_fetch_and_16(volatile signed __int128 *, signed __int128, int);
+unsigned __int128 __atomic_fetch_and (volatile unsigned __int128 *, unsigned __int128, int);
+unsigned __int128 __atomic_fetch_and_16(volatile unsigned __int128 *, unsigned __int128, int);
+#endif
+
+char __atomic_fetch_nand (volatile char *, char, int);
+char __atomic_fetch_nand_1(volatile char *, char, int);
+signed char __atomic_fetch_nand (volatile signed char *, signed char, int);
+signed char __atomic_fetch_nand_1(volatile signed char *, signed char, int);
+unsigned char __atomic_fetch_nand (volatile unsigned char *, unsigned char, int);
+unsigned char __atomic_fetch_nand_1(volatile unsigned char *, unsigned char, int);
+signed short __atomic_fetch_nand (volatile signed short *, signed short, int);
+signed short __atomic_fetch_nand_2(volatile signed short *, signed short, int);
+unsigned short __atomic_fetch_nand (volatile unsigned short *, unsigned short, int);
+unsigned short __atomic_fetch_nand_2(volatile unsigned short *, unsigned short, int);
+signed int __atomic_fetch_nand (volatile signed int *, signed int, int);
+signed int __atomic_fetch_nand_4(volatile signed int *, signed int, int);
+unsigned int __atomic_fetch_nand (volatile unsigned int *, unsigned int, int);
+unsigned int __atomic_fetch_nand_4(volatile unsigned int *, unsigned int, int);
+signed long long int __atomic_fetch_nand (volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_fetch_nand_8(volatile signed long long int *, signed long long int, int);
+unsigned long long int __atomic_fetch_nand (volatile unsigned long long int *, unsigned long long int, int);
+unsigned long long int __atomic_fetch_nand_8(volatile unsigned long long int *, unsigned long long int, int);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __atomic_fetch_nand (volatile signed __int128 *, signed __int128, int);
+signed __int128 __atomic_fetch_nand_16(volatile signed __int128 *, signed __int128, int);
+unsigned __int128 __atomic_fetch_nand (volatile unsigned __int128 *, unsigned __int128, int);
+unsigned __int128 __atomic_fetch_nand_16(volatile unsigned __int128 *, unsigned __int128, int);
+#endif
+
+char __atomic_fetch_xor (volatile char *, char, int);
+char __atomic_fetch_xor_1(volatile char *, char, int);
+signed char __atomic_fetch_xor (volatile signed char *, signed char, int);
+signed char __atomic_fetch_xor_1(volatile signed char *, signed char, int);
+unsigned char __atomic_fetch_xor (volatile unsigned char *, unsigned char, int);
+unsigned char __atomic_fetch_xor_1(volatile unsigned char *, unsigned char, int);
+signed short __atomic_fetch_xor (volatile signed short *, signed short, int);
+signed short __atomic_fetch_xor_2(volatile signed short *, signed short, int);
+unsigned short __atomic_fetch_xor (volatile unsigned short *, unsigned short, int);
+unsigned short __atomic_fetch_xor_2(volatile unsigned short *, unsigned short, int);
+signed int __atomic_fetch_xor (volatile signed int *, signed int, int);
+signed int __atomic_fetch_xor_4(volatile signed int *, signed int, int);
+unsigned int __atomic_fetch_xor (volatile unsigned int *, unsigned int, int);
+unsigned int __atomic_fetch_xor_4(volatile unsigned int *, unsigned int, int);
+signed long long int __atomic_fetch_xor (volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_fetch_xor_8(volatile signed long long int *, signed long long int, int);
+unsigned long long int __atomic_fetch_xor (volatile unsigned long long int *, unsigned long long int, int);
+unsigned long long int __atomic_fetch_xor_8(volatile unsigned long long int *, unsigned long long int, int);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __atomic_fetch_xor (volatile signed __int128 *, signed __int128, int);
+signed __int128 __atomic_fetch_xor_16(volatile signed __int128 *, signed __int128, int);
+unsigned __int128 __atomic_fetch_xor (volatile unsigned __int128 *, unsigned __int128, int);
+unsigned __int128 __atomic_fetch_xor_16(volatile unsigned __int128 *, unsigned __int128, int);
+#endif
+
+char __atomic_fetch_or (volatile char *, char, int);
+char __atomic_fetch_or_1(volatile char *, char, int);
+signed char __atomic_fetch_or (volatile signed char *, signed char, int);
+signed char __atomic_fetch_or_1(volatile signed char *, signed char, int);
+unsigned char __atomic_fetch_or (volatile unsigned char *, unsigned char, int);
+unsigned char __atomic_fetch_or_1(volatile unsigned char *, unsigned char, int);
+signed short __atomic_fetch_or (volatile signed short *, signed short, int);
+signed short __atomic_fetch_or_2(volatile signed short *, signed short, int);
+unsigned short __atomic_fetch_or (volatile unsigned short *, unsigned short, int);
+unsigned short __atomic_fetch_or_2(volatile unsigned short *, unsigned short, int);
+signed int __atomic_fetch_or (volatile signed int *, signed int, int);
+signed int __atomic_fetch_or_4(volatile signed int *, signed int, int);
+unsigned int __atomic_fetch_or (volatile unsigned int *, unsigned int, int);
+unsigned int __atomic_fetch_or_4(volatile unsigned int *, unsigned int, int);
+signed long long int __atomic_fetch_or (volatile signed long long int *, signed long long int, int);
+signed long long int __atomic_fetch_or_8(volatile signed long long int *, signed long long int, int);
+unsigned long long int __atomic_fetch_or (volatile unsigned long long int *, unsigned long long int, int);
+unsigned long long int __atomic_fetch_or_8(volatile unsigned long long int *, unsigned long long int, int);
+#if defined(__SIZEOF_INT128__)
+signed __int128 __atomic_fetch_or (volatile signed __int128 *, signed __int128, int);
+signed __int128 __atomic_fetch_or_16(volatile signed __int128 *, signed __int128, int);
+unsigned __int128 __atomic_fetch_or (volatile unsigned __int128 *, unsigned __int128, int);
+unsigned __int128 __atomic_fetch_or_16(volatile unsigned __int128 *, unsigned __int128, int);
+#endif
+
+_Bool __atomic_always_lock_free(unsigned long, const volatile void *);
+_Bool __atomic_is_lock_free(unsigned long, const volatile void *);
+
+void __atomic_thread_fence (int);
+void __atomic_signal_fence (int);
+void __atomic_feraiseexcept(int);
Index: libcfa/prelude/sync-builtins.def
===================================================================
--- libcfa/prelude/sync-builtins.def (revision bf71cfdb7285490eee552b461158846f626cc52f)
+++ libcfa/prelude/sync-builtins.def (revision bf71cfdb7285490eee552b461158846f626cc52f)
@@ -0,0 +1,614 @@
+/* This file contains the definitions and documentation for the
+ synchronization builtins used in the GNU compiler.
+ Copyright (C) 2005-2016 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC 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 3, or (at your option) any later
+version.
+
+GCC 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 GCC; see the file COPYING3. If not see
+. */
+
+/* Before including this file, you should define a macro:
+
+ DEF_SYNC_BUILTIN (ENUM, NAME, TYPE, ATTRS)
+
+ See builtins.def for details. */
+
+/* Synchronization Primitives. The "_N" version is the one that the user
+ is supposed to be using. It's overloaded, and is resolved to one of the
+ "_1" through "_16" versions, plus some extra casts. */
+
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_ADD_N, "__sync_fetch_and_add",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_ADD_1, "__sync_fetch_and_add_1",
+ BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_ADD_2, "__sync_fetch_and_add_2",
+ BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_ADD_4, "__sync_fetch_and_add_4",
+ BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_ADD_8, "__sync_fetch_and_add_8",
+ BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_ADD_16, "__sync_fetch_and_add_16",
+ BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_SUB_N, "__sync_fetch_and_sub",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_SUB_1, "__sync_fetch_and_sub_1",
+ BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_SUB_2, "__sync_fetch_and_sub_2",
+ BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_SUB_4, "__sync_fetch_and_sub_4",
+ BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_SUB_8, "__sync_fetch_and_sub_8",
+ BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_SUB_16, "__sync_fetch_and_sub_16",
+ BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_OR_N, "__sync_fetch_and_or",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_OR_1, "__sync_fetch_and_or_1",
+ BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_OR_2, "__sync_fetch_and_or_2",
+ BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_OR_4, "__sync_fetch_and_or_4",
+ BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_OR_8, "__sync_fetch_and_or_8",
+ BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_OR_16, "__sync_fetch_and_or_16",
+ BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_AND_N, "__sync_fetch_and_and",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_AND_1, "__sync_fetch_and_and_1",
+ BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_AND_2, "__sync_fetch_and_and_2",
+ BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_AND_4, "__sync_fetch_and_and_4",
+ BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_AND_8, "__sync_fetch_and_and_8",
+ BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_AND_16, "__sync_fetch_and_and_16",
+ BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_XOR_N, "__sync_fetch_and_xor",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_XOR_1, "__sync_fetch_and_xor_1",
+ BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_XOR_2, "__sync_fetch_and_xor_2",
+ BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_XOR_4, "__sync_fetch_and_xor_4",
+ BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_XOR_8, "__sync_fetch_and_xor_8",
+ BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_XOR_16, "__sync_fetch_and_xor_16",
+ BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_NAND_N, "__sync_fetch_and_nand",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_NAND_1, "__sync_fetch_and_nand_1",
+ BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_NAND_2, "__sync_fetch_and_nand_2",
+ BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_NAND_4, "__sync_fetch_and_nand_4",
+ BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_NAND_8, "__sync_fetch_and_nand_8",
+ BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_FETCH_AND_NAND_16, "__sync_fetch_and_nand_16",
+ BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_ADD_AND_FETCH_N, "__sync_add_and_fetch",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_ADD_AND_FETCH_1, "__sync_add_and_fetch_1",
+ BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_ADD_AND_FETCH_2, "__sync_add_and_fetch_2",
+ BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_ADD_AND_FETCH_4, "__sync_add_and_fetch_4",
+ BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_ADD_AND_FETCH_8, "__sync_add_and_fetch_8",
+ BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_ADD_AND_FETCH_16, "__sync_add_and_fetch_16",
+ BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_SUB_AND_FETCH_N, "__sync_sub_and_fetch",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_SUB_AND_FETCH_1, "__sync_sub_and_fetch_1",
+ BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_SUB_AND_FETCH_2, "__sync_sub_and_fetch_2",
+ BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_SUB_AND_FETCH_4, "__sync_sub_and_fetch_4",
+ BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_SUB_AND_FETCH_8, "__sync_sub_and_fetch_8",
+ BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_SUB_AND_FETCH_16, "__sync_sub_and_fetch_16",
+ BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_OR_AND_FETCH_N, "__sync_or_and_fetch",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_OR_AND_FETCH_1, "__sync_or_and_fetch_1",
+ BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_OR_AND_FETCH_2, "__sync_or_and_fetch_2",
+ BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_OR_AND_FETCH_4, "__sync_or_and_fetch_4",
+ BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_OR_AND_FETCH_8, "__sync_or_and_fetch_8",
+ BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_OR_AND_FETCH_16, "__sync_or_and_fetch_16",
+ BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_AND_AND_FETCH_N, "__sync_and_and_fetch",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_AND_AND_FETCH_1, "__sync_and_and_fetch_1",
+ BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_AND_AND_FETCH_2, "__sync_and_and_fetch_2",
+ BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_AND_AND_FETCH_4, "__sync_and_and_fetch_4",
+ BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_AND_AND_FETCH_8, "__sync_and_and_fetch_8",
+ BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_AND_AND_FETCH_16, "__sync_and_and_fetch_16",
+ BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_XOR_AND_FETCH_N, "__sync_xor_and_fetch",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_XOR_AND_FETCH_1, "__sync_xor_and_fetch_1",
+ BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_XOR_AND_FETCH_2, "__sync_xor_and_fetch_2",
+ BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_XOR_AND_FETCH_4, "__sync_xor_and_fetch_4",
+ BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_XOR_AND_FETCH_8, "__sync_xor_and_fetch_8",
+ BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_XOR_AND_FETCH_16, "__sync_xor_and_fetch_16",
+ BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_NAND_AND_FETCH_N, "__sync_nand_and_fetch",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_NAND_AND_FETCH_1, "__sync_nand_and_fetch_1",
+ BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_NAND_AND_FETCH_2, "__sync_nand_and_fetch_2",
+ BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_NAND_AND_FETCH_4, "__sync_nand_and_fetch_4",
+ BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_NAND_AND_FETCH_8, "__sync_nand_and_fetch_8",
+ BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_NAND_AND_FETCH_16, "__sync_nand_and_fetch_16",
+ BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_N,
+ "__sync_bool_compare_and_swap",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1,
+ "__sync_bool_compare_and_swap_1",
+ BT_FN_BOOL_VPTR_I1_I1, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_2,
+ "__sync_bool_compare_and_swap_2",
+ BT_FN_BOOL_VPTR_I2_I2, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_4,
+ "__sync_bool_compare_and_swap_4",
+ BT_FN_BOOL_VPTR_I4_I4, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_8,
+ "__sync_bool_compare_and_swap_8",
+ BT_FN_BOOL_VPTR_I8_I8, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_16,
+ "__sync_bool_compare_and_swap_16",
+ BT_FN_BOOL_VPTR_I16_I16, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_N,
+ "__sync_val_compare_and_swap",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1,
+ "__sync_val_compare_and_swap_1",
+ BT_FN_I1_VPTR_I1_I1, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_2,
+ "__sync_val_compare_and_swap_2",
+ BT_FN_I2_VPTR_I2_I2, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_4,
+ "__sync_val_compare_and_swap_4",
+ BT_FN_I4_VPTR_I4_I4, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_8,
+ "__sync_val_compare_and_swap_8",
+ BT_FN_I8_VPTR_I8_I8, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_16,
+ "__sync_val_compare_and_swap_16",
+ BT_FN_I16_VPTR_I16_I16, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_LOCK_TEST_AND_SET_N,
+ "__sync_lock_test_and_set",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_LOCK_TEST_AND_SET_1,
+ "__sync_lock_test_and_set_1",
+ BT_FN_I1_VPTR_I1, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_LOCK_TEST_AND_SET_2,
+ "__sync_lock_test_and_set_2",
+ BT_FN_I2_VPTR_I2, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_LOCK_TEST_AND_SET_4,
+ "__sync_lock_test_and_set_4",
+ BT_FN_I4_VPTR_I4, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_LOCK_TEST_AND_SET_8,
+ "__sync_lock_test_and_set_8",
+ BT_FN_I8_VPTR_I8, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_LOCK_TEST_AND_SET_16,
+ "__sync_lock_test_and_set_16",
+ BT_FN_I16_VPTR_I16, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_LOCK_RELEASE_N, "__sync_lock_release",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_LOCK_RELEASE_1, "__sync_lock_release_1",
+ BT_FN_VOID_VPTR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_LOCK_RELEASE_2, "__sync_lock_release_2",
+ BT_FN_VOID_VPTR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_LOCK_RELEASE_4, "__sync_lock_release_4",
+ BT_FN_VOID_VPTR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_LOCK_RELEASE_8, "__sync_lock_release_8",
+ BT_FN_VOID_VPTR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_LOCK_RELEASE_16, "__sync_lock_release_16",
+ BT_FN_VOID_VPTR, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_SYNC_SYNCHRONIZE, "__sync_synchronize",
+ BT_FN_VOID, ATTR_NOTHROWCALL_LEAF_LIST)
+
+/* __sync* builtins for the C++ memory model. */
+
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_TEST_AND_SET, "__atomic_test_and_set",
+ BT_FN_BOOL_VPTR_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_CLEAR, "__atomic_clear", BT_FN_VOID_VPTR_INT,
+ ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_EXCHANGE,
+ "__atomic_exchange",
+ BT_FN_VOID_SIZE_VPTR_PTR_PTR_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_EXCHANGE_N,
+ "__atomic_exchange_n",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_EXCHANGE_1,
+ "__atomic_exchange_1",
+ BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_EXCHANGE_2,
+ "__atomic_exchange_2",
+ BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_EXCHANGE_4,
+ "__atomic_exchange_4",
+ BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_EXCHANGE_8,
+ "__atomic_exchange_8",
+ BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_EXCHANGE_16,
+ "__atomic_exchange_16",
+ BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_LOAD,
+ "__atomic_load",
+ BT_FN_VOID_SIZE_CONST_VPTR_PTR_INT,
+ ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_LOAD_N,
+ "__atomic_load_n",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_LOAD_1,
+ "__atomic_load_1",
+ BT_FN_I1_CONST_VPTR_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_LOAD_2,
+ "__atomic_load_2",
+ BT_FN_I2_CONST_VPTR_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_LOAD_4,
+ "__atomic_load_4",
+ BT_FN_I4_CONST_VPTR_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_LOAD_8,
+ "__atomic_load_8",
+ BT_FN_I8_CONST_VPTR_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_LOAD_16,
+ "__atomic_load_16",
+ BT_FN_I16_CONST_VPTR_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_COMPARE_EXCHANGE,
+ "__atomic_compare_exchange",
+ BT_FN_BOOL_SIZE_VPTR_PTR_PTR_INT_INT,
+ ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_COMPARE_EXCHANGE_N,
+ "__atomic_compare_exchange_n",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1,
+ "__atomic_compare_exchange_1",
+ BT_FN_BOOL_VPTR_PTR_I1_BOOL_INT_INT,
+ ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_COMPARE_EXCHANGE_2,
+ "__atomic_compare_exchange_2",
+ BT_FN_BOOL_VPTR_PTR_I2_BOOL_INT_INT,
+ ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_COMPARE_EXCHANGE_4,
+ "__atomic_compare_exchange_4",
+ BT_FN_BOOL_VPTR_PTR_I4_BOOL_INT_INT,
+ ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_COMPARE_EXCHANGE_8,
+ "__atomic_compare_exchange_8",
+ BT_FN_BOOL_VPTR_PTR_I8_BOOL_INT_INT,
+ ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_COMPARE_EXCHANGE_16,
+ "__atomic_compare_exchange_16",
+ BT_FN_BOOL_VPTR_PTR_I16_BOOL_INT_INT,
+ ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_STORE,
+ "__atomic_store",
+ BT_FN_VOID_SIZE_VPTR_PTR_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_STORE_N,
+ "__atomic_store_n",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_STORE_1,
+ "__atomic_store_1",
+ BT_FN_VOID_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_STORE_2,
+ "__atomic_store_2",
+ BT_FN_VOID_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_STORE_4,
+ "__atomic_store_4",
+ BT_FN_VOID_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_STORE_8,
+ "__atomic_store_8",
+ BT_FN_VOID_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_STORE_16,
+ "__atomic_store_16",
+ BT_FN_VOID_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_ADD_FETCH_N,
+ "__atomic_add_fetch",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_ADD_FETCH_1,
+ "__atomic_add_fetch_1",
+ BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_ADD_FETCH_2,
+ "__atomic_add_fetch_2",
+ BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_ADD_FETCH_4,
+ "__atomic_add_fetch_4",
+ BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_ADD_FETCH_8,
+ "__atomic_add_fetch_8",
+ BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_ADD_FETCH_16,
+ "__atomic_add_fetch_16",
+ BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_SUB_FETCH_N,
+ "__atomic_sub_fetch",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_SUB_FETCH_1,
+ "__atomic_sub_fetch_1",
+ BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_SUB_FETCH_2,
+ "__atomic_sub_fetch_2",
+ BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_SUB_FETCH_4,
+ "__atomic_sub_fetch_4",
+ BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_SUB_FETCH_8,
+ "__atomic_sub_fetch_8",
+ BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_SUB_FETCH_16,
+ "__atomic_sub_fetch_16",
+ BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_AND_FETCH_N,
+ "__atomic_and_fetch",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_AND_FETCH_1,
+ "__atomic_and_fetch_1",
+ BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_AND_FETCH_2,
+ "__atomic_and_fetch_2",
+ BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_AND_FETCH_4,
+ "__atomic_and_fetch_4",
+ BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_AND_FETCH_8,
+ "__atomic_and_fetch_8",
+ BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_AND_FETCH_16,
+ "__atomic_and_fetch_16",
+ BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_NAND_FETCH_N,
+ "__atomic_nand_fetch",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_NAND_FETCH_1,
+ "__atomic_nand_fetch_1",
+ BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_NAND_FETCH_2,
+ "__atomic_nand_fetch_2",
+ BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_NAND_FETCH_4,
+ "__atomic_nand_fetch_4",
+ BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_NAND_FETCH_8,
+ "__atomic_nand_fetch_8",
+ BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_NAND_FETCH_16,
+ "__atomic_nand_fetch_16",
+ BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_XOR_FETCH_N,
+ "__atomic_xor_fetch",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_XOR_FETCH_1,
+ "__atomic_xor_fetch_1",
+ BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_XOR_FETCH_2,
+ "__atomic_xor_fetch_2",
+ BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_XOR_FETCH_4,
+ "__atomic_xor_fetch_4",
+ BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_XOR_FETCH_8,
+ "__atomic_xor_fetch_8",
+ BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_XOR_FETCH_16,
+ "__atomic_xor_fetch_16",
+ BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_OR_FETCH_N,
+ "__atomic_or_fetch",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_OR_FETCH_1,
+ "__atomic_or_fetch_1",
+ BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_OR_FETCH_2,
+ "__atomic_or_fetch_2",
+ BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_OR_FETCH_4,
+ "__atomic_or_fetch_4",
+ BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_OR_FETCH_8,
+ "__atomic_or_fetch_8",
+ BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_OR_FETCH_16,
+ "__atomic_or_fetch_16",
+ BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_ADD_N,
+ "__atomic_fetch_add",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_ADD_1,
+ "__atomic_fetch_add_1",
+ BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_ADD_2,
+ "__atomic_fetch_add_2",
+ BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_ADD_4,
+ "__atomic_fetch_add_4",
+ BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_ADD_8,
+ "__atomic_fetch_add_8",
+ BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_ADD_16,
+ "__atomic_fetch_add_16",
+ BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_SUB_N,
+ "__atomic_fetch_sub",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_SUB_1,
+ "__atomic_fetch_sub_1",
+ BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_SUB_2,
+ "__atomic_fetch_sub_2",
+ BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_SUB_4,
+ "__atomic_fetch_sub_4",
+ BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_SUB_8,
+ "__atomic_fetch_sub_8",
+ BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_SUB_16,
+ "__atomic_fetch_sub_16",
+ BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_AND_N,
+ "__atomic_fetch_and",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_AND_1,
+ "__atomic_fetch_and_1",
+ BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_AND_2,
+ "__atomic_fetch_and_2",
+ BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_AND_4,
+ "__atomic_fetch_and_4",
+ BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_AND_8,
+ "__atomic_fetch_and_8",
+ BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_AND_16,
+ "__atomic_fetch_and_16",
+ BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_NAND_N,
+ "__atomic_fetch_nand",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_NAND_1,
+ "__atomic_fetch_nand_1",
+ BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_NAND_2,
+ "__atomic_fetch_nand_2",
+ BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_NAND_4,
+ "__atomic_fetch_nand_4",
+ BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_NAND_8,
+ "__atomic_fetch_nand_8",
+ BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_NAND_16,
+ "__atomic_fetch_nand_16",
+ BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_XOR_N,
+ "__atomic_fetch_xor",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_XOR_1,
+ "__atomic_fetch_xor_1",
+ BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_XOR_2,
+ "__atomic_fetch_xor_2",
+ BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_XOR_4,
+ "__atomic_fetch_xor_4",
+ BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_XOR_8,
+ "__atomic_fetch_xor_8",
+ BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_XOR_16,
+ "__atomic_fetch_xor_16",
+ BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+
+
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_OR_N,
+ "__atomic_fetch_or",
+ BT_FN_VOID_VAR, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_OR_1,
+ "__atomic_fetch_or_1",
+ BT_FN_I1_VPTR_I1_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_OR_2,
+ "__atomic_fetch_or_2",
+ BT_FN_I2_VPTR_I2_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_OR_4,
+ "__atomic_fetch_or_4",
+ BT_FN_I4_VPTR_I4_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_OR_8,
+ "__atomic_fetch_or_8",
+ BT_FN_I8_VPTR_I8_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FETCH_OR_16,
+ "__atomic_fetch_or_16",
+ BT_FN_I16_VPTR_I16_INT, ATTR_NOTHROWCALL_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE,
+ "__atomic_always_lock_free",
+ BT_FN_BOOL_SIZE_CONST_VPTR, ATTR_CONST_NOTHROW_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_IS_LOCK_FREE,
+ "__atomic_is_lock_free",
+ BT_FN_BOOL_SIZE_CONST_VPTR, ATTR_CONST_NOTHROW_LEAF_LIST)
+
+
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_THREAD_FENCE,
+ "__atomic_thread_fence",
+ BT_FN_VOID_INT, ATTR_NOTHROW_LEAF_LIST)
+
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_SIGNAL_FENCE,
+ "__atomic_signal_fence",
+ BT_FN_VOID_INT, ATTR_NOTHROW_LEAF_LIST)
+
+/* This one is actually a function in libatomic and not expected to be
+ inlined, declared here for convenience of targets generating calls
+ to it. */
+DEF_SYNC_BUILTIN (BUILT_IN_ATOMIC_FERAISEEXCEPT,
+ "__atomic_feraiseexcept",
+ BT_FN_VOID_INT, ATTR_LEAF_LIST)