Index: src/libcfa/Makefile.am =================================================================== --- src/libcfa/Makefile.am (revision 37efaf560e5598df41fa83d32959ac18fc1420ba) +++ src/libcfa/Makefile.am (revision a7741435e0c633ce848e2268e9ac69fac9d35686) @@ -11,6 +11,6 @@ ## Created On : Sun May 31 08:54:01 2015 ## Last Modified By : Peter A. Buhr -## Last Modified On : Fri Aug 26 12:03:37 2016 -## Update Count : 199 +## Last Modified On : Wed Dec 14 15:17:30 2016 +## Update Count : 211 ############################################################################### @@ -28,34 +28,4 @@ endif -# put into lib for now -cfalibdir = ${libdir} -cfalib_DATA = builtins.cf extras.cf prelude.cf - -# create extra forward types/declarations to reduce inclusion of library files -extras.cf : extras.regx extras.c - ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -E ${srcdir}/extras.c | grep -f extras.regx > ${srcdir}/extras.cf - -# create forward declarations for gcc builtins -builtins.cf : builtins.c - ${AM_V_GEN}if [ -e $< ] ; then \ - @BACKEND_CC@ -E -P $^ | sed -e "/targetm/s/.*//" -e "/_Decimal/s/.*//" -e "s/void (const char \*)0();//" -e "s/\"//g" -e "s/\(__builtin_\) /\1/" > $@ ; \ - fi - -builtins.c : builtins.def prototypes.awk - ${AM_V_GEN}if [ -e $< ] ; then \ - @BACKEND_CC@ -E prototypes.c | awk -f prototypes.awk > $@ ; \ - fi - -builtins.def : - -prototypes.awk : - -MAINTAINERCLEANFILES = builtins.cf extras.cf ${addprefix ${libdir}/,${cfalib_DATA}} ${addprefix ${libdir}/,${lib_LIBRARIES}} - -#-------------------------------------------------- - -libcfa-prelude.c : ${srcdir}/prelude.cf ${srcdir}/extras.cf ${srcdir}/builtins.cf - ${AM_V_GEN}${abs_top_srcdir}/src/driver/cfa-cpp -l ${srcdir}/prelude.cf $@ # use src/cfa-cpp as not in lib until after install - libcfa_a-libcfa-prelude.o : libcfa-prelude.c ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -O2 -c -o $@ $< @@ -64,5 +34,5 @@ ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -D__CFA_DEBUG__ -O0 -c -o $@ $< -EXTRA_FLAGS = -g -Wall -Wno-unused-function -I${abs_top_srcdir}/src/libcfa/libhdr @CFA_FLAGS@ +EXTRA_FLAGS = -g -Wall -Wno-unused-function -I${abs_top_srcdir}/src/libcfa/libhdr @CFA_FLAGS@ AM_CCASFLAGS = @CFA_FLAGS@ @@ -77,4 +47,9 @@ % : %.c @true + +# %.$(OJBEXT) : libcfa-prelude.c +# echo "FRED" +# @false +# ${AM_V_CC} ${abs_top_srcdir}/src/driver/cfa concurrency/libcfa_a-invoke.o : concurrency/invoke.c Index: src/libcfa/Makefile.in =================================================================== --- src/libcfa/Makefile.in (revision 37efaf560e5598df41fa83d32959ac18fc1420ba) +++ src/libcfa/Makefile.in (revision a7741435e0c633ce848e2268e9ac69fac9d35686) @@ -18,5 +18,4 @@ ######################## -*- Mode: Makefile-Automake -*- ###################### ############################################################################### - @@ -80,6 +79,5 @@ $(am__cd) "$$dir" && rm -f $$files; }; \ } -am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(cfalibdir)" \ - "$(DESTDIR)$(includedir)" +am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(includedir)" LIBRARIES = $(lib_LIBRARIES) AR = ar @@ -146,5 +144,4 @@ SOURCES = $(libcfa_d_a_SOURCES) $(libcfa_a_SOURCES) DIST_SOURCES = $(libcfa_d_a_SOURCES) $(libcfa_a_SOURCES) -DATA = $(cfalib_DATA) HEADERS = $(nobase_include_HEADERS) ETAGS = etags @@ -273,10 +270,5 @@ AUTOMAKE_OPTIONS = subdir-objects lib_LIBRARIES = $(am__append_1) $(am__append_2) - -# put into lib for now -cfalibdir = ${libdir} -cfalib_DATA = builtins.cf extras.cf prelude.cf -MAINTAINERCLEANFILES = builtins.cf extras.cf ${addprefix ${libdir}/,${cfalib_DATA}} ${addprefix ${libdir}/,${lib_LIBRARIES}} -EXTRA_FLAGS = -g -Wall -Wno-unused-function -I${abs_top_srcdir}/src/libcfa/libhdr @CFA_FLAGS@ +EXTRA_FLAGS = -g -Wall -Wno-unused-function -I${abs_top_srcdir}/src/libcfa/libhdr @CFA_FLAGS@ AM_CCASFLAGS = @CFA_FLAGS@ headers = limits stdlib math iostream fstream iterator rational assert containers/vector concurrency/threads @@ -769,22 +761,4 @@ @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o concurrency/libcfa_a-invoke.obj `if test -f 'concurrency/invoke.c'; then $(CYGPATH_W) 'concurrency/invoke.c'; else $(CYGPATH_W) '$(srcdir)/concurrency/invoke.c'; fi` -install-cfalibDATA: $(cfalib_DATA) - @$(NORMAL_INSTALL) - test -z "$(cfalibdir)" || $(MKDIR_P) "$(DESTDIR)$(cfalibdir)" - @list='$(cfalib_DATA)'; test -n "$(cfalibdir)" || list=; \ - 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) install-nobase_includeHEADERS: $(nobase_include_HEADERS) @$(NORMAL_INSTALL) @@ -893,7 +867,7 @@ check-am: all-am check: check-am -all-am: Makefile $(LIBRARIES) $(DATA) $(HEADERS) +all-am: Makefile $(LIBRARIES) $(HEADERS) installdirs: - for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(cfalibdir)" "$(DESTDIR)$(includedir)"; do \ + for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(includedir)"; do \ test -z "$$dir" || $(MKDIR_P) "$$dir"; \ done @@ -933,5 +907,4 @@ @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 @@ -956,5 +929,5 @@ info-am: -install-data-am: install-cfalibDATA install-nobase_includeHEADERS +install-data-am: install-nobase_includeHEADERS install-dvi: install-dvi-am @@ -1002,6 +975,5 @@ ps-am: -uninstall-am: uninstall-cfalibDATA uninstall-libLIBRARIES \ - uninstall-nobase_includeHEADERS +uninstall-am: uninstall-libLIBRARIES uninstall-nobase_includeHEADERS .MAKE: install-am install-strip @@ -1010,8 +982,8 @@ clean-libLIBRARIES ctags distclean distclean-compile \ distclean-generic distclean-tags 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-libLIBRARIES install-man \ + html-am info info-am install install-am 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-libLIBRARIES install-man \ install-nobase_includeHEADERS install-pdf install-pdf-am \ install-ps install-ps-am install-strip installcheck \ @@ -1019,31 +991,7 @@ maintainer-clean-generic maintainer-clean-local mostlyclean \ mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \ - tags uninstall uninstall-am uninstall-cfalibDATA \ - uninstall-libLIBRARIES uninstall-nobase_includeHEADERS - - -# create extra forward types/declarations to reduce inclusion of library files -extras.cf : extras.regx extras.c - ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -E ${srcdir}/extras.c | grep -f extras.regx > ${srcdir}/extras.cf - -# create forward declarations for gcc builtins -builtins.cf : builtins.c - ${AM_V_GEN}if [ -e $< ] ; then \ - @BACKEND_CC@ -E -P $^ | sed -e "/targetm/s/.*//" -e "/_Decimal/s/.*//" -e "s/void (const char \*)0();//" -e "s/\"//g" -e "s/\(__builtin_\) /\1/" > $@ ; \ - fi - -builtins.c : builtins.def prototypes.awk - ${AM_V_GEN}if [ -e $< ] ; then \ - @BACKEND_CC@ -E prototypes.c | awk -f prototypes.awk > $@ ; \ - fi - -builtins.def : - -prototypes.awk : - -#-------------------------------------------------- - -libcfa-prelude.c : ${srcdir}/prelude.cf ${srcdir}/extras.cf ${srcdir}/builtins.cf - ${AM_V_GEN}${abs_top_srcdir}/src/driver/cfa-cpp -l ${srcdir}/prelude.cf $@ # use src/cfa-cpp as not in lib until after install + tags uninstall uninstall-am uninstall-libLIBRARIES \ + uninstall-nobase_includeHEADERS + libcfa_a-libcfa-prelude.o : libcfa-prelude.c @@ -1057,4 +1005,9 @@ @true +# %.$(OJBEXT) : libcfa-prelude.c +# echo "FRED" +# @false +# ${AM_V_CC} ${abs_top_srcdir}/src/driver/cfa + concurrency/libcfa_a-invoke.o : concurrency/invoke.c ${AM_V_CC}@BACKEND_CC@ -DHAVE_CONFIG_H -I. -I../.. -O2 ${EXTRA_FLAGS} -c -o $@ $< Index: src/libcfa/builtins.c =================================================================== --- src/libcfa/builtins.c (revision 37efaf560e5598df41fa83d32959ac18fc1420ba) +++ (revision ) @@ -1,217 +1,0 @@ -#define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT, COND) TYPE(NAME) -#define FUNC_SIMPLE(RETURN, NAME, ARGS...) RETURN NAME(ARGS); -#define BT_LAST(NAME) FUNC_SIMPLE(void, NAME) - -#define BT_UINTMAX unsigned long int -#define BT_UINT16 short int -#define BT_UINT32 int -#define BT_UINT64 long long int -#define BT_UINT unsigned int -#define BT_INTMAX long int -#define BT_INTPTR int * -#define BT_WINT unsigned int -#define BT_INT int -#define BT_ULONGLONG unsigned long long -#define BT_ULONG unsigned long -#define BT_UNSIGNED unsigned -#define BT_COMPLEX_LONGDOUBLE _Complex long double -#define BT_COMPLEX_DOUBLE _Complex double -#define BT_COMPLEX_FLOAT _Complex float -#define BT_LONGDOUBLEPTR long double * -#define BT_LONGDOUBLE long double -#define BT_LONGLONG long long -#define BT_LONG long -#define BT_DFLOAT32 _Decimal32 -#define BT_DFLOAT64 _Decimal64 -#define BT_DFLOAT128 _Decimal128 -#define BT_DOUBLEPTR double * -#define BT_DOUBLE double -#define BT_FLOATPTR float * -#define BT_FLOAT float -#define BT_CONST_PTR const void * -#define BT_CONST_STRING const char * -#define BT_PTR_FN_VOID_VAR_PTR_SIZE -#define BT_PTR_CONST_STRING char *const -#define BT_PTRMODE_PTR -#define BT_PTRPTR void ** -#define BT_PTR void * -#define BT_VOID void -#define BT_STRING char * -#define BT_FILEPTR struct _IO_FILE * -#define BT_SIZE unsigned long -#define BT_VAR ... -#define BT_VALIST_ARG __builtin_va_list -#define BT_VALIST_REF __builtin_va_list -#define BT_UNWINDWORD void * -#define BT_WORD -#define BT_SSIZE long int -#define BT_PID int - -#define BT_FN_COMPLEX_LONGDOUBLE_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_COMPLEX_LONGDOUBLE, NAME, BT_LONGDOUBLE) -#define BT_FN_INT_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_VOID_PTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_PTR) -#define BT_FN_INT_CONST_PTR_CONST_PTR_SIZE(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_PTR, BT_CONST_PTR, BT_SIZE) -#define BT_FN_VOID_VALIST_REF(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_VALIST_REF) -#define BT_FN_FLOAT_COMPLEX_FLOAT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_COMPLEX_FLOAT) -#define BT_FN_INT_STRING_SIZE_INT_SIZE_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_SIZE, BT_INT, BT_SIZE, BT_CONST_STRING, BT_VAR) -#define BT_FN_VOID_PTR_PTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_PTR, BT_PTR) -#define BT_FN_FLOAT_FLOAT_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_LONGDOUBLE) -#define BT_FN_INT_UINT(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_UINT) -#define BT_FN_CONST_STRING(NAME) FUNC_SIMPLE(BT_CONST_STRING, NAME) -#define BT_FN_FLOAT_FLOAT_FLOATPTR(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_FLOATPTR) -#define BT_FN_INT_INT_INT_INT_INT_INT_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_INT, BT_INT, BT_INT, BT_INT, BT_INT, BT_VAR) -#define BT_FN_INT_INT(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_INT) -#define BT_FN_INT_FILEPTR_INT_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_FILEPTR, BT_INT, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_INT_LONG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_LONG) -#define BT_FN_INT_STRING_SIZE_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_SIZE, BT_CONST_STRING, BT_VAR) -#define BT_FN_VOID_PTR_WORD_WORD_PTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_PTR, BT_WORD, BT_WORD, BT_PTR) -#define BT_FN_SIZE_STRING_SIZE_CONST_STRING_CONST_PTR(NAME) FUNC_SIMPLE(BT_SIZE, NAME, BT_STRING, BT_SIZE, BT_CONST_STRING, BT_CONST_PTR) -#define BT_FN_INT_DFLOAT128(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_DFLOAT128) -#define BT_FN_DOUBLE_DOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE) -#define BT_FN_FLOAT_CONST_STRING(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_CONST_STRING) -#define BT_FN_LONGDOUBLE_LONGDOUBLE_INT(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_INT) -#define BT_FN_FLOAT_FLOAT_INT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_INT) -#define BT_FN_INT_CONST_STRING_CONST_STRING(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_CONST_STRING) -#define BT_FN_INT_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_LONGDOUBLE) -#define BT_FN_SIZE_CONST_STRING_CONST_STRING(NAME) FUNC_SIMPLE(BT_SIZE, NAME, BT_CONST_STRING, BT_CONST_STRING) -#define BT_FN_VOID_PTR_SIZE(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_PTR, BT_SIZE) -#define BT_FN_INT_CONST_STRING_PTR_CONST_STRING(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_PTR_CONST_STRING) -#define BT_FN_DFLOAT64(NAME) FUNC_SIMPLE(BT_DFLOAT64, NAME) -#define BT_FN_INT_UINTMAX(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_UINTMAX) -#define BT_FN_DOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME) -#define BT_FN_INT(NAME) FUNC_SIMPLE(BT_INT, NAME) -#define BT_FN_FLOAT_FLOAT_FLOAT_INTPTR(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_FLOAT, BT_INTPTR) -#define BT_FN_DOUBLE_DOUBLE_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_LONGDOUBLE) -#define BT_FN_PTR_CONST_PTR_SIZE_VAR(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_CONST_PTR, BT_SIZE, BT_VAR) -#define BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT_COMPLEX_FLOAT(NAME) FUNC_SIMPLE(BT_COMPLEX_FLOAT, NAME, BT_COMPLEX_FLOAT, BT_COMPLEX_FLOAT) -#define BT_FN_LONGDOUBLE_COMPLEX_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_COMPLEX_LONGDOUBLE) -#define BT_FN_STRING_CONST_STRING_CONST_STRING_INT(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_CONST_STRING, BT_CONST_STRING, BT_INT) -#define BT_FN_LONGDOUBLE_LONGDOUBLE_LONG(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_LONG) -#define BT_FN_COMPLEX_DOUBLE_DOUBLE(NAME) FUNC_SIMPLE(BT_COMPLEX_DOUBLE, NAME, BT_DOUBLE) -#define BT_FN_VOID(NAME) FUNC_SIMPLE(BT_VOID, NAME) -#define BT_FN_FLOAT_FLOAT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT) -#define BT_FN_INT_FILEPTR_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_FILEPTR, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_VOID_FLOAT_FLOATPTR_FLOATPTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_FLOAT, BT_FLOATPTR, BT_FLOATPTR) -#define BT_FN_INT_DFLOAT64(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_DFLOAT64) -#define BT_FN_FLOAT_FLOAT_INTPTR(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_INTPTR) -#define BT_FN_WINT_WINT(NAME) FUNC_SIMPLE(BT_WINT, NAME, BT_WINT) -#define BT_FN_LONGLONG_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGLONG, NAME, BT_LONGDOUBLE) -#define BT_FN_DOUBLE_DOUBLE_DOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_DOUBLE) -#define BT_FN_DFLOAT64_CONST_STRING(NAME) FUNC_SIMPLE(BT_DFLOAT64, NAME, BT_CONST_STRING) -#define BT_FN_DOUBLE_DOUBLE_INT(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_INT) -#define BT_FN_INTMAX_INTMAX(NAME) FUNC_SIMPLE(BT_INTMAX, NAME, BT_INTMAX) -#define BT_FN_INT_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_VAR) -#define BT_FN_LONG_LONG_LONG(NAME) FUNC_SIMPLE(BT_LONG, NAME, BT_LONG, BT_LONG) -#define BT_FN_DOUBLE_DOUBLE_LONG(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_LONG) -#define BT_FN_LONG_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONG, NAME, BT_LONGDOUBLE) -#define BT_FN_FLOAT_FLOAT_FLOAT_FLOAT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_FLOAT, BT_FLOAT) -#define BT_FN_VOID_VALIST_REF_VAR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_VALIST_REF, BT_VAR) -#define BT_FN_STRING_CONST_STRING(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_CONST_STRING) -#define BT_FN_VOID_VALIST_REF_VALIST_ARG(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_VALIST_REF, BT_VALIST_ARG) -#define BT_FN_LONGDOUBLE_CONST_STRING(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_CONST_STRING) -#define BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE_INTPTR(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_LONGDOUBLE, BT_INTPTR) -#define BT_FN_PTR_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_SIZE) -#define BT_FN_DOUBLE_DOUBLE_DOUBLE_DOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_DOUBLE, BT_DOUBLE) -#define BT_FN_STRING_STRING_CONST_STRING(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_STRING, BT_CONST_STRING) -#define BT_FN_VOID_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_INT) -#define BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_LONGDOUBLE) -#define BT_FN_INT_ULONGLONG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_ULONGLONG) -#define BT_FN_INT_FILEPTR_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_FILEPTR, BT_CONST_STRING, BT_VAR) -#define BT_FN_LONGLONG_DOUBLE(NAME) FUNC_SIMPLE(BT_LONGLONG, NAME, BT_DOUBLE) -#define BT_FN_INT_INT_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_INT, BT_CONST_STRING, BT_VAR) -#define BT_FN_VOID_PTR_INT(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_PTR, BT_INT) -#define BT_FN_COMPLEX_FLOAT_COMPLEX_FLOAT(NAME) FUNC_SIMPLE(BT_COMPLEX_FLOAT, NAME, BT_COMPLEX_FLOAT) -#define BT_FN_INT_WINT(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_WINT) -#define BT_FN_PTR_PTR_INT_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR, BT_INT, BT_SIZE) -#define BT_FN_STRING_CONST_STRING_INT(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_CONST_STRING, BT_INT) -#define BT_FN_INT_FLOAT(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_FLOAT) -#define BT_FN_DOUBLE_CONST_STRING(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_CONST_STRING) -#define BT_FN_LONG_FLOAT(NAME) FUNC_SIMPLE(BT_LONG, NAME, BT_FLOAT) -#define BT_FN_PTR_SIZE_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_SIZE, BT_SIZE) -#define BT_FN_STRING_STRING_CONST_STRING_SIZE(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_STRING, BT_CONST_STRING, BT_SIZE) -#define BT_FN_LONGLONG_LONGLONG(NAME) FUNC_SIMPLE(BT_LONGLONG, NAME, BT_LONGLONG) -#define BT_FN_PTR_PTR(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR) -#define BT_FN_PTR_PTR_CONST_PTR_SIZE_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR, BT_CONST_PTR, BT_SIZE, BT_SIZE) -#define BT_FN_FLOAT_FLOAT_LONG(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_LONG) -#define BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_COMPLEX_LONGDOUBLE, NAME, BT_COMPLEX_LONGDOUBLE) -#define BT_FN_PTR_PTR_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR, BT_SIZE) -#define BT_FN_PTR_VAR(NAME) FUNC_SIMPLE(BT_PTR, NAME) -#define BT_FN_SIZE_CONST_PTR_INT(NAME) FUNC_SIMPLE(BT_SIZE, NAME, BT_CONST_PTR, BT_INT) -#define BT_FN_INT_CONST_STRING(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING) -#define BT_FN_INT_STRING_SIZE_INT_SIZE_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_SIZE, BT_INT, BT_SIZE, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_INT_STRING_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_DFLOAT32(NAME) FUNC_SIMPLE(BT_DFLOAT32, NAME) -#define BT_FN_LONGDOUBLE_LONGDOUBLE_INTPTR(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_INTPTR) -#define BT_FN_STRING_STRING_CONST_STRING_SIZE_SIZE(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_STRING, BT_CONST_STRING, BT_SIZE, BT_SIZE) -#define BT_FN_PTR_UINT(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_UINT) -#define BT_FN_INT_CONST_STRING_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_DFLOAT128_CONST_STRING(NAME) FUNC_SIMPLE(BT_DFLOAT128, NAME, BT_CONST_STRING) -#define BT_FN_DOUBLE_DOUBLE_DOUBLEPTR(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_DOUBLEPTR) -#define BT_FN_SSIZE_STRING_SIZE_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_SSIZE, NAME, BT_STRING, BT_SIZE, BT_CONST_STRING, BT_VAR) -#define BT_FN_DFLOAT32_DFLOAT32(NAME) FUNC_SIMPLE(BT_DFLOAT32, NAME, BT_DFLOAT32) -#define BT_FN_INT_PTR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_PTR) -#define BT_FN_UINT32_UINT32(NAME) FUNC_SIMPLE(BT_UINT32, NAME, BT_UINT32) -#define BT_FN_PTR_PTR_FN_VOID_VAR_PTR_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR_FN_VOID_VAR_PTR_SIZE) -#define BT_FN_INT_DOUBLE(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_DOUBLE) -#define BT_FN_INT_STRING_INT_SIZE_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_INT, BT_SIZE, BT_CONST_STRING, BT_VAR) -#define BT_FN_INT_ULONG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_ULONG) -#define BT_FN_DOUBLE_DOUBLE_INTPTR(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_INTPTR) -#define BT_FN_UINT64_UINT64(NAME) FUNC_SIMPLE(BT_UINT64, NAME, BT_UINT64) -#define BT_FN_STRING_CONST_STRING_CONST_STRING(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_CONST_STRING, BT_CONST_STRING) -#define BT_FN_INT_INT_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_INT, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_PTR_PTR_INT_SIZE_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR, BT_INT, BT_SIZE, BT_SIZE) -#define BT_FN_DOUBLE_COMPLEX_DOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_COMPLEX_DOUBLE) -#define BT_FN_VOID_CONST_PTR_VAR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_CONST_PTR, BT_VAR) -#define BT_FN_INT_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME) -#define BT_FN_INT_PTRPTR_SIZE_SIZE(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_PTRPTR, BT_SIZE, BT_SIZE) -#define BT_FN_INT_CONST_STRING_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_CONST_STRING, BT_VAR) -#define BT_FN_INT_DFLOAT32(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_DFLOAT32) -#define BT_FN_DFLOAT64_DFLOAT64(NAME) FUNC_SIMPLE(BT_DFLOAT64, NAME, BT_DFLOAT64) -#define BT_FN_VOID_CONST_PTR_PTR_SIZE(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_CONST_PTR, BT_PTR, BT_SIZE) -#define BT_FN_UNWINDWORD_PTR(NAME) FUNC_SIMPLE(BT_UNWINDWORD, NAME, BT_PTR) -#define BT_FN_FLOAT_FLOAT_FLOAT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_FLOAT, BT_FLOAT) -#define BT_FN_COMPLEX_FLOAT_FLOAT(NAME) FUNC_SIMPLE(BT_COMPLEX_FLOAT, NAME, BT_FLOAT) -#define BT_FN_UINT(NAME) FUNC_SIMPLE(BT_UINT, NAME) -#define BT_FN_DOUBLE_DOUBLE_DOUBLE_INTPTR(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_DOUBLE, BT_DOUBLE, BT_INTPTR) -#define BT_FN_UINT16_UINT16(NAME) FUNC_SIMPLE(BT_UINT16, NAME, BT_UINT16) -#define BT_FN_INT_STRING_INT_SIZE_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_INT, BT_SIZE, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_LONGDOUBLE_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE) -#define BT_FN_LONG_LONG(NAME) FUNC_SIMPLE(BT_LONG, NAME, BT_LONG) -#define BT_FN_INT_STRING_SIZE_CONST_STRING_VALIST_ARG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_SIZE, BT_CONST_STRING, BT_VALIST_ARG) -#define BT_FN_FLOAT_INT_FLOAT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME, BT_INT, BT_FLOAT) -#define BT_FN_PTR(NAME) FUNC_SIMPLE(BT_PTR, NAME) -#define BT_FN_SIZE_CONST_PTR_SIZE_SIZE_FILEPTR(NAME) FUNC_SIMPLE(BT_SIZE, NAME, BT_CONST_PTR, BT_SIZE, BT_SIZE, BT_FILEPTR) -#define BT_FN_VOID_DOUBLE_DOUBLEPTR_DOUBLEPTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_DOUBLE, BT_DOUBLEPTR, BT_DOUBLEPTR) -#define BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE_COMPLEX_DOUBLE(NAME) FUNC_SIMPLE(BT_COMPLEX_DOUBLE, NAME, BT_COMPLEX_DOUBLE, BT_COMPLEX_DOUBLE) -#define BT_FN_LONG_DOUBLE(NAME) FUNC_SIMPLE(BT_LONG, NAME, BT_DOUBLE) -#define BT_FN_SIZE_CONST_STRING(NAME) FUNC_SIMPLE(BT_SIZE, NAME, BT_CONST_STRING) -#define BT_FN_LONGLONG_FLOAT(NAME) FUNC_SIMPLE(BT_LONGLONG, NAME, BT_FLOAT) -#define BT_FN_INT_CONST_STRING_CONST_STRING_SIZE(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_CONST_STRING, BT_SIZE) -#define BT_FN_PTR_PTR_CONST_PTR_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_PTR, BT_CONST_PTR, BT_SIZE) -#define BT_FN_DFLOAT128(NAME) FUNC_SIMPLE(BT_DFLOAT128, NAME) -#define BT_FN_PID(NAME) FUNC_SIMPLE(BT_PID, NAME) -#define BT_FN_INT_CONST_STRING_FILEPTR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_FILEPTR) -#define BT_FN_INT_LONGLONG(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_LONGLONG) -#define BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_LONGDOUBLE, BT_LONGDOUBLE) -#define BT_FN_INT_INT_FILEPTR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_INT, BT_FILEPTR) -#define BT_FN_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE_COMPLEX_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_COMPLEX_LONGDOUBLE, NAME, BT_COMPLEX_LONGDOUBLE, BT_COMPLEX_LONGDOUBLE) -#define BT_FN_VOID_PTRMODE_PTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_PTRMODE_PTR) -#define BT_FN_INT_STRING_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_STRING, BT_CONST_STRING, BT_VAR) -#define BT_FN_COMPLEX_DOUBLE_COMPLEX_DOUBLE(NAME) FUNC_SIMPLE(BT_COMPLEX_DOUBLE, NAME, BT_COMPLEX_DOUBLE) -#define BT_FN_DFLOAT32_CONST_STRING(NAME) FUNC_SIMPLE(BT_DFLOAT32, NAME, BT_CONST_STRING) -#define BT_FN_INT_CONST_STRING_PTR_CONST_STRING_PTR_CONST_STRING(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_CONST_STRING, BT_PTR_CONST_STRING, BT_PTR_CONST_STRING) -#define BT_FN_STRING_CONST_STRING_SIZE(NAME) FUNC_SIMPLE(BT_STRING, NAME, BT_CONST_STRING, BT_SIZE) -#define BT_FN_INT_FILEPTR_INT_CONST_STRING_VAR(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_FILEPTR, BT_INT, BT_CONST_STRING, BT_VAR) -#define BT_FN_DFLOAT128_DFLOAT128(NAME) FUNC_SIMPLE(BT_DFLOAT128, NAME, BT_DFLOAT128) -#define BT_FN_DOUBLE_INT_DOUBLE(NAME) FUNC_SIMPLE(BT_DOUBLE, NAME, BT_INT, BT_DOUBLE) -#define BT_FN_FLOAT(NAME) FUNC_SIMPLE(BT_FLOAT, NAME) -#define BT_FN_LONGDOUBLE_INT_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_INT, BT_LONGDOUBLE) -#define BT_FN_PTR_CONST_PTR_INT_SIZE(NAME) FUNC_SIMPLE(BT_PTR, NAME, BT_CONST_PTR, BT_INT, BT_SIZE) -#define BT_FN_VOID_LONGDOUBLE_LONGDOUBLEPTR_LONGDOUBLEPTR(NAME) FUNC_SIMPLE(BT_VOID, NAME, BT_LONGDOUBLE, BT_LONGDOUBLEPTR, BT_LONGDOUBLEPTR) -#define BT_FN_INT_INTMAX(NAME) FUNC_SIMPLE(BT_INT, NAME, BT_INTMAX) -#define BT_FN_LONGDOUBLE(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME) -#define BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLEPTR(NAME) FUNC_SIMPLE(BT_LONGDOUBLE, NAME, BT_LONGDOUBLE, BT_LONGDOUBLEPTR) - -#include "builtins.def" - -extern const char *__PRETTY_FUNCTION__; Index: src/libcfa/builtins.def =================================================================== --- src/libcfa/builtins.def (revision 37efaf560e5598df41fa83d32959ac18fc1420ba) +++ (revision ) @@ -1,874 +1,0 @@ -/* This file contains the definitions and documentation for the - builtins used in the GNU compiler. - Copyright (C) 2000-2014 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 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) - -/* 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) - -/* 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_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 GNU OpenMP. None of these are - actually implemented in the compiler; they're all in libgomp. */ -#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_openmp || flag_tree_parallelize_loops)) - -/* 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))) - -#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) - -/* 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_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_ERRNO) -DEF_C99_BUILTIN (BUILT_IN_RINTF, "rintf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) -DEF_C99_BUILTIN (BUILT_IN_RINTL, "rintl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) -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_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) -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 (BUILT_IN_MEMCPY, "memcpy", BT_FN_PTR_PTR_CONST_PTR_SIZE, ATTR_RET1_NOTHROW_NONNULL_LEAF) -DEF_LIB_BUILTIN (BUILT_IN_MEMMOVE, "memmove", BT_FN_PTR_PTR_CONST_PTR_SIZE, ATTR_RET1_NOTHROW_NONNULL_LEAF) -DEF_EXT_LIB_BUILTIN (BUILT_IN_MEMPCPY, "mempcpy", BT_FN_PTR_PTR_CONST_PTR_SIZE, ATTR_NOTHROW_NONNULL_LEAF) -DEF_LIB_BUILTIN (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 (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 (BUILT_IN_STRCAT, "strcat", BT_FN_STRING_STRING_CONST_STRING, ATTR_NOTHROW_NONNULL_LEAF) -DEF_LIB_BUILTIN (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 (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 (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: miscellaneous builtins. */ -DEF_LIB_BUILTIN (BUILT_IN_ABORT, "abort", BT_FN_VOID, ATTR_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 (BUILT_IN_MEMCPY_CHK, "__memcpy_chk", BT_FN_PTR_PTR_CONST_PTR_SIZE_SIZE, ATTR_RET1_NOTHROW_NONNULL_LEAF) -DEF_EXT_LIB_BUILTIN (BUILT_IN_MEMMOVE_CHK, "__memmove_chk", BT_FN_PTR_PTR_CONST_PTR_SIZE_SIZE, ATTR_RET1_NOTHROW_NONNULL_LEAF) -DEF_EXT_LIB_BUILTIN (BUILT_IN_MEMPCPY_CHK, "__mempcpy_chk", BT_FN_PTR_PTR_CONST_PTR_SIZE_SIZE, ATTR_NOTHROW_NONNULL_LEAF) -DEF_EXT_LIB_BUILTIN (BUILT_IN_MEMSET_CHK, "__memset_chk", BT_FN_PTR_PTR_INT_SIZE_SIZE, ATTR_NOTHROW_NONNULL_LEAF) -DEF_EXT_LIB_BUILTIN (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 (BUILT_IN_STRCAT_CHK, "__strcat_chk", BT_FN_STRING_STRING_CONST_STRING_SIZE, ATTR_NOTHROW_NONNULL_LEAF) -DEF_EXT_LIB_BUILTIN (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 -/* Synchronization Primitives. */ -#include "sync-builtins.def" - -/* OpenMP 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" -#endif Index: src/libcfa/extras.c =================================================================== --- src/libcfa/extras.c (revision 37efaf560e5598df41fa83d32959ac18fc1420ba) +++ (revision ) @@ -1,3 +1,0 @@ -#include -#include -#include Index: src/libcfa/extras.regx =================================================================== --- src/libcfa/extras.regx (revision 37efaf560e5598df41fa83d32959ac18fc1420ba) +++ (revision ) @@ -1,8 +1,0 @@ -typedef.* size_t; -typedef.* ptrdiff_t; -extern.* abort\(.*\).* -extern.* atexit\(.*\).* -extern.* exit\(.*\).* -extern.* free\(.*\).* -extern.*\*malloc\(.*\).* -extern.* printf\(.*\).* Index: src/libcfa/prelude.cf =================================================================== --- src/libcfa/prelude.cf (revision 37efaf560e5598df41fa83d32959ac18fc1420ba) +++ (revision ) @@ -1,808 +1,0 @@ -// -*- Mode: C -*- -// -// Copyright (C) Glen Ditchfield 1994, 1999 -// -// prelude.cf -- Standard Cforall Preample for C99 -// -// Author : Glen Ditchfield -// Created On : Sat Nov 29 07:23:41 2014 -// Last Modified By : Peter A. Buhr -// Last Modified On : Tue Jul 5 18:04:40 2016 -// Update Count : 92 -// - -# 2 "prelude.cf" // needed for error messages from this file - -// Section numbers from: http://plg.uwaterloo.ca/~cforall/refrat.pdf - -// ------------------------------------------------------------ -// -// Section 4.1 Primary Expressions -// -// ------------------------------------------------------------ - -//We have none - -// ------------------------------------------------------------ -// -// Section 4.2 Postfix Operators -// -// ------------------------------------------------------------ - -_Bool ?++( _Bool * ), ?++( volatile _Bool * ); -_Bool ?--( _Bool * ), ?--( volatile _Bool * ); -unsigned char ?++( unsigned char * ), ?++( volatile unsigned char * ); -signed int ?++( signed int * ), ?++( volatile signed int * ); -signed int ?--( signed int * ), ?--( volatile signed int * ); -unsigned int ?++( unsigned int * ), ?++( volatile unsigned int * ); -unsigned int ?--( unsigned int * ), ?--( volatile unsigned int * ); -signed long int ?++( signed long int * ), ?++( volatile signed long int * ); -signed long int ?--( signed long int * ), ?--( volatile signed long int * ); -unsigned long int ?++( unsigned long int * ), ?++( volatile unsigned long int * ); -unsigned long int ?--( unsigned long int * ), ?--( volatile unsigned long int * ); -signed long long int ?++( signed long long int * ), ?++( volatile signed long long int * ); -signed long long int ?--( signed long long int * ), ?--( volatile signed long long int * ); -unsigned long long int ?++( unsigned long long int * ), ?++( volatile unsigned long long int * ); -unsigned long long int ?--( unsigned long long int * ), ?--( volatile unsigned long long int * ); -float ?++( float * ), ?++( volatile float * ); -float ?--( float * ), ?--( volatile float * ); -double ?++( double * ), ?++( volatile double * ); -double ?--( double * ), ?--( volatile double * ); -long double ?++( long double * ), ?++( volatile long double * ); -long double ?--( long double * ), ?--( volatile long double * ); -float _Complex ?++( float _Complex * ), ?++( volatile float _Complex * ); -float _Complex ?--( float _Complex * ), ?--( volatile float _Complex * ); -double _Complex ?++( double _Complex * ), ?++( volatile double _Complex * ); -double _Complex ?--( double _Complex * ), ?--( volatile double _Complex * ); -long double _Complex ?++( long double _Complex * ), ?++( volatile long double _Complex * ); -long double _Complex ?--( long double _Complex * ), ?--( volatile long double _Complex * ); - -forall( otype T ) T * ?++( T ** ); -forall( otype T ) const T * ?++( const T ** ); -forall( otype T ) volatile T * ?++( volatile T ** ); -forall( otype T ) const volatile T * ?++( const volatile T ** ); -forall( otype T ) T * ?--( T ** ); -forall( otype T ) const T * ?--( const T ** ); -forall( otype T ) volatile T * ?--( volatile T ** ); -forall( otype T ) const volatile T * ?--( const volatile T ** ); - -forall( otype T ) lvalue T ?[?]( T *, ptrdiff_t ); -forall( otype T ) const lvalue T ?[?]( const T *, ptrdiff_t ); -forall( otype T ) volatile lvalue T ?[?]( volatile T *, ptrdiff_t ); -forall( otype T ) const volatile lvalue T ?[?]( const volatile T *, ptrdiff_t ); -forall( otype T ) lvalue T ?[?]( ptrdiff_t, T * ); -forall( otype T ) const lvalue T ?[?]( ptrdiff_t, const T * ); -forall( otype T ) volatile lvalue T ?[?]( ptrdiff_t, volatile T * ); -forall( otype T ) const volatile lvalue T ?[?]( ptrdiff_t, const volatile T * ); - -// ------------------------------------------------------------ -// -// Section 4.3 Unary 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 * ); -float ++?( float * ), --?( float * ); -double ++?( double * ), --?( double * ); -long double ++?( long double * ), --?( long double * ); -float _Complex ++?( float _Complex * ), --?( float _Complex * ); -double _Complex ++?( double _Complex * ), --?( double _Complex * ); -long double _Complex ++?( long double _Complex * ), --?( long double _Complex * ); - -forall( otype T ) T * ++?( T ** ); -forall( otype T ) const T * ++?( const T ** ); -forall( otype T ) volatile T * ++?( volatile T ** ); -forall( otype T ) const volatile T * ++?( const volatile T ** ); -forall( otype T ) T * --?( T ** ); -forall( otype T ) const T * --?( const T ** ); -forall( otype T ) volatile T * --?( volatile T ** ); -forall( otype T ) const volatile T * --?( const volatile T ** ); - -forall( otype T ) lvalue T *?( T * ); -forall( otype T ) const lvalue T *?( const T * ); -forall( otype T ) volatile lvalue T *?( volatile T * ); -forall( otype T ) const volatile lvalue T *?( const volatile T * ); -forall( ftype FT ) lvalue FT *?( FT * ); - -_Bool +?( _Bool ), -?( _Bool ), ~?( _Bool ); -signed int +?( signed int ), -?( signed int ), ~?( signed int ); -unsigned int +?( unsigned int ), -?( unsigned int ), ~?( unsigned int ); -signed long int +?( signed long int ), -?( signed long int ), ~?( signed long int ); -unsigned long int +?( unsigned long int ), -?( unsigned long int ), ~?( unsigned long int ); -signed long 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 ), ~?( unsigned long long int ); -float +?( float ), -?( float ); -double +?( double ), -?( double ); -long double +?( long double ), -?( long double ); -float _Complex +?( float _Complex ), -?( float _Complex ); -double _Complex +?( double _Complex ), -?( double _Complex ); -long double _Complex +?( long double _Complex ), -?( long double _Complex ); - -signed int !?( signed int ), !?( unsigned int ), - !?( long int ), !?( unsigned long int ), - !?( long long int ), !?( unsigned long long int ), - !?( float ), !?( double ), !?( long double ), - !?( float _Complex ), !?( double _Complex ), !?( long double _Complex ); - -forall ( dtype DT ) int !?( const volatile DT * ); -forall ( ftype FT ) int !?( FT * ); - -// ------------------------------------------------------------ -// -// Section 4.5 Multiplicative Operators -// -// ------------------------------------------------------------ - -_Bool ?*?( _Bool, _Bool ), ?/?( _Bool, _Bool ), ?%?( _Bool, _Bool ); -signed int ?*?( signed int, signed int ), ?/?( signed int, signed int ), ?%?( signed int, signed int ); -unsigned int ?*?( unsigned int, unsigned int ), ?/?( unsigned int, unsigned int ), ?%?( unsigned int, unsigned int ); -signed long int ?*?( signed long int, signed long int ), ?/?( signed long int, signed long int ), ?%?( signed long int, signed long int ); -unsigned long int ?*?( unsigned long int, unsigned long int ), ?/?( unsigned long int, unsigned long int ), ?%?( unsigned long int, unsigned long int ); -signed long long int ?*?( signed long long int, signed long long int ), ?/?( signed long 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 ), ?/?( unsigned long long int, unsigned long long int ), ?%?( unsigned long long int, unsigned long long int ); -float ?*?( float, float ), ?/?( float, float ); -double ?*?( double, double ), ?/?( double, double ); -long double ?*?( long double, long double ), ?/?( long double, long double ); -// gcc does not support _Imaginary -//float _Imaginary ?*?( float _Imaginary, float _Imaginary), ?/?( float _Imaginary, float _Imaginary ); -//double _Imaginary ?*?( double _Imaginary, double _Imaginary), ?/?( double _Imaginary, double _Imaginary ); -//long double _Imaginary ?*?( long double _Imaginary, long double _Imaginary), ?/?( long double _Imaginary, long double _Imaginary ); -float _Complex ?*?( float _Complex, float _Complex ), ?/?( float _Complex, float _Complex ); -double _Complex ?*?( double _Complex, double _Complex ), ?/?( double _Complex, double _Complex ); -long double _Complex ?*?( long double _Complex, long double _Complex ), ?/?( long double _Complex, long double _Complex ); - -// ------------------------------------------------------------ -// -// Section 4.6 Additive Operators -// -// ------------------------------------------------------------ - -_Bool ?+?( _Bool, _Bool ), ?-?( _Bool, _Bool ); -signed int ?+?( signed int, signed int ), ?-?( signed int, signed int ); -unsigned int ?+?( unsigned int, unsigned int ), ?-?( unsigned int, unsigned int ); -signed long int ?+?( signed long int, signed long int ), ?-?( signed long int, signed long int ); -unsigned long int ?+?( unsigned long int, unsigned long int ), ?-?( unsigned long int, unsigned long int ); -signed long long int ?+?( signed long long int, long long int signed), ?-?( signed long long int, signed long long int ); -unsigned long long int ?+?( unsigned long long int, unsigned long long int ), ?-?( unsigned long long int, unsigned long long int ); -float ?+?( float, float ), ?-?( float, float ); -double ?+?( double, double ), ?-?( double, double ); -long double ?+?( long double, long double ), ?-?( long double, long double ); -float _Complex ?+?( float _Complex, float _Complex ), ?-?( float _Complex, float _Complex ); -double _Complex ?+?( double _Complex, double _Complex ), ?-?( double _Complex, double _Complex ); -long double _Complex ?+?( long double _Complex, long double _Complex ), ?-?( long double _Complex, long double _Complex ); - -forall( otype T ) T * ?+?( T *, ptrdiff_t ); -forall( otype T ) T * ?+?( ptrdiff_t, T * ); -forall( otype T ) const T * ?+?( const T *, ptrdiff_t ); -forall( otype T ) const T * ?+?( ptrdiff_t, const T * ); -forall( otype T ) volatile T * ?+?( volatile T *, ptrdiff_t ); -forall( otype T ) volatile T * ?+?( ptrdiff_t, volatile T * ); -forall( otype T ) const volatile T * ?+?( const volatile T *, ptrdiff_t ); -forall( otype T ) const volatile T * ?+?( ptrdiff_t, const volatile T * ); -forall( otype T ) T * ?-?( T *, ptrdiff_t ); -forall( otype T ) const T * ?-?( const T *, ptrdiff_t ); -forall( otype T ) volatile T * ?-?( volatile T *, ptrdiff_t ); -forall( otype T ) const volatile T * ?-?( const volatile T *, ptrdiff_t ); -forall( otype T ) ptrdiff_t ?-?( const volatile T *, const volatile T * ); - -// ------------------------------------------------------------ -// -// Section 4.7 Bitwise Shift 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.8 Relational Operators -// -// ------------------------------------------------------------ - -signed int ??( _Bool, _Bool ), ?>=?( _Bool, _Bool ); -signed int ??( unsigned char, unsigned char ), ?>=?( unsigned char, unsigned char ); -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 ??( const volatile DT *, const volatile DT * ); -forall( dtype DT ) signed int ?<=?( const volatile DT *, const 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 ?==?( 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 *, forall( dtype DT2 )const DT2 * ); -// forall( dtype DT ) signed int ?==?( forall( dtype DT2 )const DT2 *, const volatile DT * ); -// forall( ftype FT ) signed int ?==?( FT *, forall( ftype FT2 )FT2 * ); -// forall( ftype FT ) signed int ?==?( forall( ftype FT2 )FT2 *, FT * ); -// forall( dtype DT ) signed int ?!=?( const volatile DT *, forall( dtype DT2 )const DT2 * ); -// forall( dtype DT ) signed int ?!=?( forall( dtype DT2 )const DT2 *, const volatile DT * ); -// forall( ftype FT ) signed int ?!=?( FT *, forall( ftype FT2 )FT2 * ); -// forall( ftype FT ) signed int ?!=?( forall( ftype FT2 )FT2 *, 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 ) DT * ?=?( DT * *, void * ); -forall( dtype DT ) DT * ?=?( DT * volatile *, void * ); -forall( dtype DT ) const DT * ?=?( const DT * *, void * ); -forall( dtype DT ) const DT * ?=?( const DT * volatile *, void * ); -forall( dtype DT ) const DT * ?=?( const DT * *, const void * ); -forall( dtype DT ) const DT * ?=?( const DT * volatile *, const void * ); -forall( dtype DT ) volatile DT * ?=?( volatile DT * *, void * ); -forall( dtype DT ) volatile DT * ?=?( volatile DT * volatile *, void * ); -forall( dtype DT ) volatile DT * ?=?( volatile DT * *, volatile void * ); -forall( dtype DT ) volatile DT * ?=?( volatile DT * volatile *, volatile void * ); - -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * *, void * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile *, void * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * *, const void * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile *, const void * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * *, volatile void * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile *, volatile void * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * *, const volatile void * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile *, const volatile void * ); - -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 * ); - -void * ?=?( void * *, void * ); -void * ?=?( void * volatile *, void * ); -const void * ?=?( const void * *, void * ); -const void * ?=?( const void * volatile *, void * ); -const void * ?=?( const void * *, const void * ); -const void * ?=?( const void * volatile *, const void * ); -volatile void * ?=?( volatile void * *, void * ); -volatile void * ?=?( volatile void * volatile *, void * ); -volatile void * ?=?( volatile void * *, volatile void * ); -volatile void * ?=?( volatile void * volatile *, volatile void * ); -const volatile void * ?=?( const volatile void * *, void * ); -const volatile void * ?=?( const volatile void * volatile *, void * ); -const volatile void * ?=?( const volatile void * *, const void * ); -const volatile void * ?=?( const volatile void * volatile *, const void * ); -const volatile void * ?=?( const volatile void * *, volatile void * ); -const volatile void * ?=?( const volatile void * volatile *, volatile void * ); -const volatile void * ?=?( const volatile void * *, const volatile void * ); -const volatile void * ?=?( const volatile void * volatile *, const volatile void * ); - -//forall( dtype DT ) DT * ?=?( DT * *, forall( dtype DT2 ) const DT2 * ); -//forall( dtype DT ) DT * ?=?( DT * volatile *, forall( dtype DT2 ) const DT2 * ); -forall( dtype DT ) const DT * ?=?( const DT * *, forall( dtype DT2 ) const DT2 * ); -forall( dtype DT ) const DT * ?=?( const DT * volatile *, forall( dtype DT2 ) const DT2 * ); -//forall( dtype DT ) volatile DT * ?=?( volatile DT * *, forall( dtype DT2 ) const DT2 * ); -//forall( dtype DT ) volatile DT * ?=?( volatile DT * volatile *, forall( dtype DT2 ) const DT2 * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * *, forall( dtype DT2 ) const DT2 * ); -forall( dtype DT ) const volatile DT * ?=?( const volatile DT * volatile *, forall( dtype DT2 ) const DT2 * ); - -forall( ftype FT ) FT * ?=?( FT * *, forall( ftype FT2 ) FT2 * ); -forall( ftype FT ) FT * ?=?( FT * volatile *, forall( ftype FT2 ) FT2 * ); - -forall( otype T ) T * ?+=?( T * *, ptrdiff_t ); -forall( otype T ) T * ?+=?( T * volatile *, ptrdiff_t ); -forall( otype T ) const T * ?+=?( const T * *, ptrdiff_t ); -forall( otype T ) const T * ?+=?( const T * volatile *, ptrdiff_t ); -forall( otype T ) volatile T * ?+=?( volatile T * *, ptrdiff_t ); -forall( otype T ) volatile T * ?+=?( volatile T * volatile *, ptrdiff_t ); -forall( otype T ) const volatile T * ?+=?( const volatile T * *, ptrdiff_t ); -forall( otype T ) const volatile T * ?+=?( const volatile T * volatile *, ptrdiff_t ); -forall( otype T ) T * ?-=?( T * *, ptrdiff_t ); -forall( otype T ) T * ?-=?( T * volatile *, ptrdiff_t ); -forall( otype T ) const T * ?-=?( const T * *, ptrdiff_t ); -forall( otype T ) const T * ?-=?( const T * volatile *, ptrdiff_t ); -forall( otype T ) volatile T * ?-=?( volatile T * *, ptrdiff_t ); -forall( otype T ) volatile T * ?-=?( volatile T * volatile *, ptrdiff_t ); -forall( otype T ) const volatile T * ?-=?( const volatile T * *, ptrdiff_t ); -forall( otype 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 ); - - -_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 ); - -_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 ); - -_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 ); - -_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 ?{}( DT * *, void * ); -forall( dtype DT ) void ?{}( const DT * *, void * ); -forall( dtype DT ) void ?{}( const DT * *, const void * ); -forall( dtype DT ) void ?{}( volatile DT * *, void * ); -forall( dtype DT ) void ?{}( volatile DT * *, volatile void * ); - -forall( dtype DT ) void ?{}( const volatile DT * *, void * ); -forall( dtype DT ) void ?{}( const volatile DT * *, const void * ); -forall( dtype DT ) void ?{}( const volatile DT * *, volatile void * ); -forall( dtype DT ) void ?{}( const volatile DT * *, const volatile void * ); - -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 * ); - -void ?{}( void * *, void * ); -void ?{}( const void * *, void * ); -void ?{}( const void * *, const void * ); -void ?{}( volatile void * *, void * ); -void ?{}( volatile void * *, volatile void * ); -void ?{}( const volatile void * *, void * ); -void ?{}( const volatile void * *, const void * ); -void ?{}( const volatile void * *, volatile void * ); -void ?{}( const volatile void * *, const volatile void * ); - -//forall( dtype DT ) void ?{}( DT * *, forall( dtype DT2 ) const DT2 * ); -//forall( dtype DT ) void ?{}( DT * volatile *, forall( dtype DT2 ) const DT2 * ); -forall( dtype DT ) void ?{}( const DT * *, forall( dtype DT2 ) const DT2 * ); -//forall( dtype DT ) void ?{}( volatile DT * *, forall( dtype DT2 ) const DT2 * ); -//forall( dtype DT ) void ?{}( volatile DT * volatile *, forall( dtype DT2 ) const DT2 * ); -forall( dtype DT ) void ?{}( const volatile DT * *, forall( dtype DT2 ) const DT2 * ); - -forall( ftype FT ) void ?{}( FT * *, forall( ftype FT2 ) FT2 * ); - -// 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: src/libcfa/prototypes.awk =================================================================== --- src/libcfa/prototypes.awk (revision 37efaf560e5598df41fa83d32959ac18fc1420ba) +++ (revision ) @@ -1,135 +1,0 @@ -# -# 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 - types[0] = "UINTMAX"; vtypes[0] = "unsigned long int" - types[1] = "UINT16"; vtypes[1] = "short int" - types[2] = "UINT32"; vtypes[2] = "int" - types[3] = "UINT64"; vtypes[3] = "long long int" - types[4] = "UINT"; vtypes[4] = "unsigned int" - types[5] = "INTMAX"; vtypes[5] = "long int" - types[6] = "INTPTR"; vtypes[6] = "int *" - types[7] = "WINT"; vtypes[7] = "unsigned int" - types[8] = "INT"; vtypes[8] = "int" - types[9] = "ULONGLONG"; vtypes[9] = "unsigned long long" - types[10] = "ULONG"; vtypes[10] = "unsigned long" - types[11] = "UNSIGNED"; vtypes[11] = "unsigned" - types[12] = "COMPLEX_LONGDOUBLE"; vtypes[12] = "_Complex long double" - types[13] = "COMPLEX_DOUBLE"; vtypes[13] = "_Complex double" - types[14] = "COMPLEX_FLOAT"; vtypes[14] = "_Complex float" - types[15] = "LONGDOUBLEPTR"; vtypes[15] = "long double *" - types[16] = "LONGDOUBLE"; vtypes[16] = "long double" - types[17] = "LONGLONG"; vtypes[17] = "long long" - types[18] = "LONG"; vtypes[18] = "long" - types[19] = "DFLOAT32"; vtypes[19] = "_Decimal32" - types[20] = "DFLOAT64"; vtypes[20] = "_Decimal64" - types[21] = "DFLOAT128"; vtypes[21] = "_Decimal128" - types[22] = "DOUBLEPTR"; vtypes[22] = "double *" - types[23] = "DOUBLE"; vtypes[23] = "double" - types[24] = "FLOATPTR"; vtypes[24] = "float *" - types[25] = "FLOAT"; vtypes[25] = "float" - types[26] = "CONST_PTR"; vtypes[26] = "const void *" - types[27] = "CONST_STRING"; vtypes[27] = "const char *" - types[28] = "PTR_FN_VOID_VAR_PTR_SIZE"; vtypes[28] = "" - types[29] = "PTR_CONST_STRING"; vtypes[29] = "char *const" - types[30] = "PTRMODE_PTR"; vtypes[30] = "" - types[31] = "PTRPTR"; vtypes[31] = "void **" - types[32] = "PTR"; vtypes[32] = "void *" - types[33] = "VOID"; vtypes[33] = "void" - types[34] = "STRING"; vtypes[34] = "char *" - types[35] = "FILEPTR"; vtypes[35] = "struct _IO_FILE *" - types[36] = "SIZE"; vtypes[36] = "unsigned long" - types[37] = "VAR"; vtypes[37] = "..." - types[38] = "VALIST_ARG"; vtypes[38] = "__builtin_va_list" - types[39] = "VALIST_REF"; vtypes[39] = "__builtin_va_list" - types[40] = "UNWINDWORD"; vtypes[40] = "void *" - types[41] = "WORD"; vtypes[41] = "" - types[42] = "SSIZE"; vtypes[42] = "long int" - types[43] = "PID"; vtypes[43] = "int" - N = 44 -} # BEGIN - -/^BT_/ { prototypes[$1] = $1 } - -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 ) { - 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( "extern const char *__PRETTY_FUNCTION__;\n" ); -} # END - -# Local Variables: # -# tab-width: 4 # -# mode: awk # -# compile-command: "make install" # -# End: # Index: src/libcfa/prototypes.c =================================================================== --- src/libcfa/prototypes.c (revision 37efaf560e5598df41fa83d32959ac18fc1420ba) +++ (revision ) @@ -1,2 +1,0 @@ -#define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT, COND) TYPE(NAME) -#include "builtins.def"