Leahnaya/agbcc
1
0
Fork 0
mirror of https://github.com/pret/agbcc.git synced 2026-07-12 22:21:07 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

clean up standard headers

Browse Source
This commit is contained in:
YamaArashi 2016-02-13 00:13:45 -08:00
parent a61ab2707a
commit 56d3f75d13
32 changed files with 25 additions and 4805 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

118
gcc/Makefile.in
View File

@ -141,22 +141,8 @@ INSTALL_HEADERS_DIR = @build_install_headers_dir@
# Header files that are made available under the same name
# to programs compiled with GCC.
USER_H = $(srcdir)/ginclude/stdarg.h $(srcdir)/ginclude/stddef.h \
$(srcdir)/ginclude/varargs.h $(srcdir)/ginclude/va-alpha.h \
$(srcdir)/ginclude/va-h8300.h $(srcdir)/ginclude/va-i860.h \
$(srcdir)/ginclude/va-i960.h $(srcdir)/ginclude/va-mips.h \
$(srcdir)/ginclude/va-m88k.h $(srcdir)/ginclude/va-mn10200.h \
$(srcdir)/ginclude/va-mn10300.h $(srcdir)/ginclude/va-pa.h \
$(srcdir)/ginclude/va-pyr.h $(srcdir)/ginclude/va-sparc.h \
$(srcdir)/ginclude/va-clipper.h $(srcdir)/ginclude/va-spur.h \
$(srcdir)/ginclude/va-m32r.h $(srcdir)/ginclude/va-sh.h \
$(srcdir)/ginclude/va-v850.h $(srcdir)/ginclude/va-arc.h \
$(srcdir)/ginclude/iso646.h $(srcdir)/ginclude/va-ppc.h \
$(CYGNUS-LOCAL-d10v) $(srcdir)/ginclude/va-d10v.h \
$(CYGNUS-LOCAL-fr30) $(srcdir)/ginclude/va-fr30.h \
$(CYGNUS-LOCAL-d30v) $(srcdir)/ginclude/va-d30v.h \
$(srcdir)/ginclude/va-c4x.h $(EXTRA_HEADERS) $(LANG_EXTRA_HEADERS) \
$(srcdir)/ginclude/proto.h $(srcdir)/ginclude/stdbool.h \
$(srcdir)/ginclude/limits.h
$(srcdir)/ginclude/iso646.h $(srcdir)/ginclude/stdbool.h \
$(srcdir)/ginclude/limits.h $(srcdir)/ginclude/float.h
# Target to use whe installing assert.h. Some systems may
# want to set this empty.
@ -375,10 +361,6 @@ LIB1FUNCS_EXTRA =
# Assembler files should have names ending in `.asm'.
LIB2FUNCS_EXTRA =
# We do not try to build float.h anymore. Let configure select the
# appropriate pre-built float.h file for the target.
FLOAT_H=@float_h_file@
# Program to convert libraries.
LIBCONVERT =
@ -769,14 +751,14 @@ all.internal: start.encap rest.encap
# This is what to compile if making a cross-compiler.
# Note that we can compile enquire using the cross-compiler just built,
# although we can't run it on this machine.
all.cross: native gcc-cross specs stmp-headers $(LIBGCC) \
all.cross: native gcc-cross specs $(LIBGCC) \
$(LIBGCC1_TEST) lang.all.cross
# This is what to compile if making gcc with a cross-compiler.
all.build: native xgcc$(exeext) lang.all.build
# This is what must be made before installing GCC and converting libraries.
start.encap: native xgcc$(exeext) specs $(LIBGCC1) lang.start.encap
# These can't be made until after GCC can run.
rest.encap: stmp-headers $(LIBGCC) lang.rest.encap
rest.encap: $(LIBGCC) lang.rest.encap
# This is what is made with the host's compiler
# whether making a cross compiler or not.
native: config.status auto-host.h cpp$(exeext) $(LANGUAGES) \
@ -1843,8 +1825,7 @@ SYSCALLS.c.X: $(srcdir)/sys-types.h $(srcdir)/sys-protos.h $(GCC_PASSES) \
# s-* so that mostlyclean does not force the include directory to
# be rebuilt.
# Build the include directory including float.h (which no longer depends upon
# enquire).
# Build the include directory
stmp-int-hdrs: $(USER_H)
# Copy in the headers provided with gcc.
rm -rf include
@ -1856,15 +1837,6 @@ stmp-int-hdrs: $(USER_H)
chmod a+r include/$$realfile; \
fi; \
done
rm -f include/float.h
if [ x$(FLOAT_H) != xMakefile.in ]; then \
cp $(srcdir)/config/$(FLOAT_H) include/float.h && \
chmod a+r include/float.h; \
fi
# Now that float.h no longer depends upon enquire, this is actually a no-op.
stmp-headers:
touch $@
# Remake the info files.
# CYGNUS LOCAL: built in build directory
@ -1937,7 +1909,7 @@ mostlyclean: lang.mostlyclean
-rm -f tmplibgcc* tmpcopy libgcc1-test
for name in $(LIB1FUNCS); do rm -f $${name}.c; done
# Delete other built files.
-rm -f t-float.h-cross xsys-protos.hT fp-bit.c dp-bit.c
-rm -f xsys-protos.hT fp-bit.c dp-bit.c
# Delete the stamp and temporary files.
-rm -f s-* tmp-* stamp-* stmp-*
-rm -f */stamp-* */tmp-*
@ -1949,7 +1921,7 @@ mostlyclean: lang.mostlyclean
-rm -f */*.tree */*.loop */*.dbr */*.jump2 */*.sched */*.cse2
-rm -f */*.sched2 */*.stack */*.regmove */*.gcse
# Delete some files made during installation.
-rm -f specs float.h-* enquire SYSCALLS.c.X SYSCALLS.c
-rm -f specs enquire SYSCALLS.c.X SYSCALLS.c
-rm -f collect mips-tfile mips-tdump alloca.s
# CYGNUS LOCAL: binary installation
# Delete unwanted output files from TeX.
@ -2008,7 +1980,6 @@ distclean: clean lang.distclean
-rm -f */stage1 */stage2 */stage3 */stage4 */include
-rm -f c-parse.output
-rm -f *.asm
-rm -f float.h
-rm -f site.exp site.bak testsuite/site.exp testsuite/site.bak
-rm -f testsuite/{gcc,g++}.{log,sum}
@ -2068,23 +2039,6 @@ install-normal: install-common $(INSTALL_HEADERS) $(INSTALL_LIBGCC) \
install-build: force
@echo You have to install gcc on your target machine by hand.
# Run this on the target machine
# to finish installation of cross compiler.
# This is not used anymore now that float.h does not depend on enquire.
install-cross-rest: install-float-h-cross
# Install float.h for cross compiler.
# Run this on the target machine!
# This is not used anymore now that float.h does not depend on enquire.
install-float-h-cross: installdirs
# if [ -f enquire ] ; then true; else false; fi
# Note: don't use -. We should fail right away if enquire was not made.
./enquire -f > $(tmpdir)/float.h
-rm -f $(libsubdir)/include/float.h
$(INSTALL_DATA) $(tmpdir)/float.h $(libsubdir)/include/float.h
-rm -f $(tmpdir)/float.h
chmod a-x $(libsubdir)/include/float.h
# Create the installation directories.
installdirs:
-if [ -d $(prefix) ] ; then true ; else mkdir $(prefix) ; chmod a+rx $(prefix) ; fi
@ -2220,7 +2174,7 @@ install-include-dir: installdirs
-chmod a+rx $(libsubdir)/include
# Install the include directory using tar.
install-headers-tar: stmp-headers $(STMP_FIXPROTO) install-include-dir
install-headers-tar: $(STMP_FIXPROTO) install-include-dir
(cd include; \
tar -cf - .; exit 0) | (cd $(libsubdir)/include; tar $(TAROUTOPTS) - )
# /bin/sh on some systems returns the status of the first tar,
@ -2228,7 +2182,7 @@ install-headers-tar: stmp-headers $(STMP_FIXPROTO) install-include-dir
# So use `exit 0' to ignore its exit status.
# Install the include directory using cpio.
install-headers-cpio: stmp-headers $(STMP_FIXPROTO) install-include-dir
install-headers-cpio: $(STMP_FIXPROTO) install-include-dir
(cd include; find . -print) | (cd include; cpio -pdum $(libsubdir)/include)
# Put assert.h where it won't override GNU libc's assert.h.
@ -2681,57 +2635,3 @@ risky-stage4: stage4
.PHONY: risky-stage1 risky-stage2 risky-stage3 risky-stage4
force:
# ---
# The enquire rules are still useful for building new float-anything.h.
# Special flags for compiling enquire.
# We disable optimization to make floating point more reliable.
ENQUIRE_CFLAGS = -DNO_MEM -DNO_LONG_DOUBLE_IO -O0
ENQUIRE_LDFLAGS = $(LDFLAGS)
# Enquire target (This is a variable so that a target can choose not to
# build it.)
ENQUIRE = enquire
# Test to see whether <float.h> exists in the system header files,
# and is not derived from GCC.
FLOAT_H_TEST = \
[ -f $(SYSTEM_HEADER_DIR)/float.h ] && \
if grep 'ifndef _FLOAT_H___' $(SYSTEM_HEADER_DIR)/float.h >/dev/null; \
then false; \
else :; fi
# We pretend to not having a usable <float.h>, hence disable the FLOAT_H_TEST
# to ensure, we're emitting a full blown <float.h> ourselves.
FLOAT_H_TEST = false
# Used to compile enquire with standard cc, but have forgotten why.
# Let's try with GCC.
enquire: enquire.o $(GCC_PARTS)
$(GCC_FOR_TARGET) $(GCC_CFLAGS) $(ENQUIRE_LDFLAGS) enquire.o -o $@
enquire.o: $(srcdir)/enquire.c $(GCC_PASSES) stmp-int-hdrs
if $(FLOAT_H_TEST); then \
rm -f include/float.h; \
SYS_FLOAT_H_WRAP=1; \
else :; \
SYS_FLOAT_H_WRAP=0; \
fi; \
$(GCC_FOR_TARGET) $(GCC_CFLAGS) $(ALL_CPPFLAGS) $(ENQUIRE_CFLAGS) \
-DSYS_FLOAT_H_WRAP=$$SYS_FLOAT_H_WRAP \
-I. -c $(srcdir)/enquire.c
# Create float.h source for the native machine.
# Make it empty if we can use the system float.h without changes.
float.h-nat: enquire
-./enquire -f > tmp-float.h
grep '#define [^_]' tmp-float.h >/dev/null || true > tmp-float.h
mv tmp-float.h float.h-nat
# Create a dummy float.h source for a cross-compiler.
# ??? This isn't used anymore. Should we create config/float-unkn.h
# and make that the default float_format in configure?
float.h-cross:
echo "#ifndef __GCC_FLOAT_NOT_NEEDED" > t-float.h-cross
echo "#error float.h values not known for cross-compiler" >> t-float.h-cross
echo "#endif" >> t-float.h-cross
mv t-float.h-cross float.h-cross

0
gcc/config/float-i64.h → gcc/ginclude/float.h Executable file → Normal file
View File

461
gcc/ginclude/math-3300.h
View File

@ -1,461 +0,0 @@
/******************************************************************\
* *
* <math-68881.h> last modified: 18 May 1989. *
* *
* Copyright (C) 1989 by Matthew Self. *
* You may freely distribute verbatim copies of this software *
* provided that this copyright notice is retained in all copies. *
* You may distribute modifications to this software under the *
* conditions above if you also clearly note such modifications *
* with their author and date. *
* *
* Note: errno is not set to EDOM when domain errors occur for *
* most of these functions. Rather, it is assumed that the *
* 68881's OPERR exception will be enabled and handled *
* appropriately by the operating system. Similarly, overflow *
* and underflow do not set errno to ERANGE. *
* *
* Send bugs to Matthew Self (self@bayes.arc.nasa.gov). *
* *
\******************************************************************/
#include <errno.h>
#undef HUGE_VAL
#define HUGE_VAL \
({ \
double huge_val; \
\
__asm ("fmove%.d %#0x7ff0000000000000,%0" /* Infinity */ \
: "=f" (huge_val) \
: /* no inputs */); \
huge_val; \
})
__inline static const double sin (double x)
{
double value;
__asm ("fsin%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline static const double cos (double x)
{
double value;
__asm ("fcos%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline static const double tan (double x)
{
double value;
__asm ("ftan%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline static const double asin (double x)
{
double value;
__asm ("fasin%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline static const double acos (double x)
{
double value;
__asm ("facos%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline static const double atan (double x)
{
double value;
__asm ("fatan%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline static const double atan2 (double y, double x)
{
double pi, pi_over_2;
__asm ("fmovecr%.x %#0,%0" /* extended precision pi */
: "=f" (pi)
: /* no inputs */ );
__asm ("fscale%.b %#-1,%0" /* no loss of accuracy */
: "=f" (pi_over_2)
: "0" (pi));
if (x > 0)
{
if (y > 0)
{
if (x > y)
return atan (y / x);
else
return pi_over_2 - atan (x / y);
}
else
{
if (x > -y)
return atan (y / x);
else
return - pi_over_2 - atan (x / y);
}
}
else
{
if (y > 0)
{
if (-x > y)
return pi + atan (y / x);
else
return pi_over_2 - atan (x / y);
}
else
{
if (-x > -y)
return - pi + atan (y / x);
else if (y < 0)
return - pi_over_2 - atan (x / y);
else
{
double value;
errno = EDOM;
__asm ("fmove%.d %#0x7fffffffffffffff,%0" /* quiet NaN */
: "=f" (value)
: /* no inputs */);
return value;
}
}
}
}
__inline static const double sinh (double x)
{
double value;
__asm ("fsinh%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline static const double cosh (double x)
{
double value;
__asm ("fcosh%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline static const double tanh (double x)
{
double value;
__asm ("ftanh%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline static const double atanh (double x)
{
double value;
__asm ("fatanh%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline static const double exp (double x)
{
double value;
__asm ("fetox%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline static const double expm1 (double x)
{
double value;
__asm ("fetoxm1%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline static const double log (double x)
{
double value;
__asm ("flogn%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline static const double log1p (double x)
{
double value;
__asm ("flognp1%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline static const double log10 (double x)
{
double value;
__asm ("flog10%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline static const double sqrt (double x)
{
double value;
__asm ("fsqrt%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline static const double pow (const double x, const double y)
{
if (x > 0)
return exp (y * log (x));
else if (x == 0)
{
if (y > 0)
return 0.0;
else
{
double value;
errno = EDOM;
__asm ("fmove%.d %#0x7fffffffffffffff,%0" /* quiet NaN */
: "=f" (value)
: /* no inputs */);
return value;
}
}
else
{
double temp;
__asm ("fintrz%.x %1,%0"
: "=f" (temp) /* integer-valued float */
: "f" (y));
if (y == temp)
{
int i = (int) y;
if ((i & 1) == 0) /* even */
return exp (y * log (x));
else
return - exp (y * log (x));
}
else
{
double value;
errno = EDOM;
__asm ("fmove%.d %#0x7fffffffffffffff,%0" /* quiet NaN */
: "=f" (value)
: /* no inputs */);
return value;
}
}
}
__inline static const double fabs (double x)
{
double value;
__asm ("fabs%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline static const double ceil (double x)
{
int rounding_mode, round_up;
double value;
__asm volatile ("fmove%.l %%fpcr,%0"
: "=dm" (rounding_mode)
: /* no inputs */ );
round_up = rounding_mode | 0x30;
__asm volatile ("fmove%.l %0,%%fpcr"
: /* no outputs */
: "dmi" (round_up));
__asm volatile ("fint%.x %1,%0"
: "=f" (value)
: "f" (x));
__asm volatile ("fmove%.l %0,%%fpcr"
: /* no outputs */
: "dmi" (rounding_mode));
return value;
}
__inline static const double floor (double x)
{
int rounding_mode, round_down;
double value;
__asm volatile ("fmove%.l %%fpcr,%0"
: "=dm" (rounding_mode)
: /* no inputs */ );
round_down = (rounding_mode & ~0x10)
| 0x20;
__asm volatile ("fmove%.l %0,%%fpcr"
: /* no outputs */
: "dmi" (round_down));
__asm volatile ("fint%.x %1,%0"
: "=f" (value)
: "f" (x));
__asm volatile ("fmove%.l %0,%%fpcr"
: /* no outputs */
: "dmi" (rounding_mode));
return value;
}
__inline static const double rint (double x)
{
int rounding_mode, round_nearest;
double value;
__asm volatile ("fmove%.l %%fpcr,%0"
: "=dm" (rounding_mode)
: /* no inputs */ );
round_nearest = rounding_mode & ~0x30;
__asm volatile ("fmove%.l %0,%%fpcr"
: /* no outputs */
: "dmi" (round_nearest));
__asm volatile ("fint%.x %1,%0"
: "=f" (value)
: "f" (x));
__asm volatile ("fmove%.l %0,%%fpcr"
: /* no outputs */
: "dmi" (rounding_mode));
return value;
}
__inline static const double fmod (double x, double y)
{
double value;
__asm ("fmod%.x %2,%0"
: "=f" (value)
: "0" (x),
"f" (y));
return value;
}
__inline static const double drem (double x, double y)
{
double value;
__asm ("frem%.x %2,%0"
: "=f" (value)
: "0" (x),
"f" (y));
return value;
}
__inline static const double scalb (double x, int n)
{
double value;
__asm ("fscale%.l %2,%0"
: "=f" (value)
: "0" (x),
"dmi" (n));
return value;
}
__inline static double logb (double x)
{
double exponent;
__asm ("fgetexp%.x %1,%0"
: "=f" (exponent)
: "f" (x));
return exponent;
}
__inline static const double ldexp (double x, int n)
{
double value;
__asm ("fscale%.l %2,%0"
: "=f" (value)
: "0" (x),
"dmi" (n));
return value;
}
__inline static double frexp (double x, int *exp)
{
double float_exponent;
int int_exponent;
double mantissa;
__asm ("fgetexp%.x %1,%0"
: "=f" (float_exponent) /* integer-valued float */
: "f" (x));
int_exponent = (int) float_exponent;
__asm ("fgetman%.x %1,%0"
: "=f" (mantissa) /* 1.0 <= mantissa < 2.0 */
: "f" (x));
if (mantissa != 0)
{
__asm ("fscale%.b %#-1,%0"
: "=f" (mantissa) /* mantissa /= 2.0 */
: "0" (mantissa));
int_exponent += 1;
}
*exp = int_exponent;
return mantissa;
}
__inline static double modf (double x, double *ip)
{
double temp;
__asm ("fintrz%.x %1,%0"
: "=f" (temp) /* integer-valued float */
: "f" (x));
*ip = temp;
return x - temp;
}

529
gcc/ginclude/math-68881.h
View File

@ -1,529 +0,0 @@
/******************************************************************\
* *
* <math-68881.h> last modified: 23 May 1992. *
* *
* Copyright (C) 1989 by Matthew Self. *
* You may freely distribute verbatim copies of this software *
* provided that this copyright notice is retained in all copies. *
* You may distribute modifications to this software under the *
* conditions above if you also clearly note such modifications *
* with their author and date. *
* *
* Note: errno is not set to EDOM when domain errors occur for *
* most of these functions. Rather, it is assumed that the *
* 68881's OPERR exception will be enabled and handled *
* appropriately by the operating system. Similarly, overflow *
* and underflow do not set errno to ERANGE. *
* *
* Send bugs to Matthew Self (self@bayes.arc.nasa.gov). *
* *
\******************************************************************/
/* This file is NOT a part of GCC, just distributed with it. */
/* If you find this in GCC,
please send bug reports to bug-gcc@prep.ai.mit.edu. */
/* Changed by Richard Stallman:
May 1993, add conditional to prevent multiple inclusion.
% inserted before a #.
New function `hypot' added.
Nans written in hex to avoid 0rnan.
May 1992, use %! for fpcr register. Break lines before function names.
December 1989, add parens around `&' in pow.
November 1990, added alternate definition of HUGE_VAL for Sun. */
/* Changed by Jim Wilson:
September 1993, Use #undef before HUGE_VAL instead of #ifdef/#endif. */
/* Changed by Ian Lance Taylor:
September 1994, use extern inline instead of static inline. */
#ifndef __math_68881
#define __math_68881
#include <errno.h>
#undef HUGE_VAL
#ifdef __sun__
/* The Sun assembler fails to handle the hex constant in the usual defn. */
#define HUGE_VAL \
({ \
static union { int i[2]; double d; } u = { {0x7ff00000, 0} }; \
u.d; \
})
#else
#define HUGE_VAL \
({ \
double huge_val; \
\
__asm ("fmove%.d %#0x7ff0000000000000,%0" /* Infinity */ \
: "=f" (huge_val) \
: /* no inputs */); \
huge_val; \
})
#endif
__inline extern double
sin (double x)
{
double value;
__asm ("fsin%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline extern double
cos (double x)
{
double value;
__asm ("fcos%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline extern double
tan (double x)
{
double value;
__asm ("ftan%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline extern double
asin (double x)
{
double value;
__asm ("fasin%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline extern double
acos (double x)
{
double value;
__asm ("facos%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline extern double
atan (double x)
{
double value;
__asm ("fatan%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline extern double
atan2 (double y, double x)
{
double pi, pi_over_2;
__asm ("fmovecr%.x %#0,%0" /* extended precision pi */
: "=f" (pi)
: /* no inputs */ );
__asm ("fscale%.b %#-1,%0" /* no loss of accuracy */
: "=f" (pi_over_2)
: "0" (pi));
if (x > 0)
{
if (y > 0)
{
if (x > y)
return atan (y / x);
else
return pi_over_2 - atan (x / y);
}
else
{
if (x > -y)
return atan (y / x);
else
return - pi_over_2 - atan (x / y);
}
}
else
{
if (y < 0)
{
if (-x > -y)
return - pi + atan (y / x);
else
return - pi_over_2 - atan (x / y);
}
else
{
if (-x > y)
return pi + atan (y / x);
else if (y > 0)
return pi_over_2 - atan (x / y);
else
{
double value;
errno = EDOM;
__asm ("fmove%.d %#0x7fffffffffffffff,%0" /* quiet NaN */
: "=f" (value)
: /* no inputs */);
return value;
}
}
}
}
__inline extern double
sinh (double x)
{
double value;
__asm ("fsinh%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline extern double
cosh (double x)
{
double value;
__asm ("fcosh%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline extern double
tanh (double x)
{
double value;
__asm ("ftanh%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline extern double
atanh (double x)
{
double value;
__asm ("fatanh%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline extern double
exp (double x)
{
double value;
__asm ("fetox%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline extern double
expm1 (double x)
{
double value;
__asm ("fetoxm1%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline extern double
log (double x)
{
double value;
__asm ("flogn%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline extern double
log1p (double x)
{
double value;
__asm ("flognp1%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline extern double
log10 (double x)
{
double value;
__asm ("flog10%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline extern double
sqrt (double x)
{
double value;
__asm ("fsqrt%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline extern double
hypot (double x, double y)
{
return sqrt (x*x + y*y);
}
__inline extern double
pow (double x, double y)
{
if (x > 0)
return exp (y * log (x));
else if (x == 0)
{
if (y > 0)
return 0.0;
else
{
double value;
errno = EDOM;
__asm ("fmove%.d %#0x7fffffffffffffff,%0" /* quiet NaN */
: "=f" (value)
: /* no inputs */);
return value;
}
}
else
{
double temp;
__asm ("fintrz%.x %1,%0"
: "=f" (temp) /* integer-valued float */
: "f" (y));
if (y == temp)
{
int i = (int) y;
if ((i & 1) == 0) /* even */
return exp (y * log (-x));
else
return - exp (y * log (-x));
}
else
{
double value;
errno = EDOM;
__asm ("fmove%.d %#0x7fffffffffffffff,%0" /* quiet NaN */
: "=f" (value)
: /* no inputs */);
return value;
}
}
}
__inline extern double
fabs (double x)
{
double value;
__asm ("fabs%.x %1,%0"
: "=f" (value)
: "f" (x));
return value;
}
__inline extern double
ceil (double x)
{
int rounding_mode, round_up;
double value;
__asm volatile ("fmove%.l %!,%0"
: "=dm" (rounding_mode)
: /* no inputs */ );
round_up = rounding_mode | 0x30;
__asm volatile ("fmove%.l %0,%!"
: /* no outputs */
: "dmi" (round_up));
__asm volatile ("fint%.x %1,%0"
: "=f" (value)
: "f" (x));
__asm volatile ("fmove%.l %0,%!"
: /* no outputs */
: "dmi" (rounding_mode));
return value;
}
__inline extern double
floor (double x)
{
int rounding_mode, round_down;
double value;
__asm volatile ("fmove%.l %!,%0"
: "=dm" (rounding_mode)
: /* no inputs */ );
round_down = (rounding_mode & ~0x10)
| 0x20;
__asm volatile ("fmove%.l %0,%!"
: /* no outputs */
: "dmi" (round_down));
__asm volatile ("fint%.x %1,%0"
: "=f" (value)
: "f" (x));
__asm volatile ("fmove%.l %0,%!"
: /* no outputs */
: "dmi" (rounding_mode));
return value;
}
__inline extern double
rint (double x)
{
int rounding_mode, round_nearest;
double value;
__asm volatile ("fmove%.l %!,%0"
: "=dm" (rounding_mode)
: /* no inputs */ );
round_nearest = rounding_mode & ~0x30;
__asm volatile ("fmove%.l %0,%!"
: /* no outputs */
: "dmi" (round_nearest));
__asm volatile ("fint%.x %1,%0"
: "=f" (value)
: "f" (x));
__asm volatile ("fmove%.l %0,%!"
: /* no outputs */
: "dmi" (rounding_mode));
return value;
}
__inline extern double
fmod (double x, double y)
{
double value;
__asm ("fmod%.x %2,%0"
: "=f" (value)
: "0" (x),
"f" (y));
return value;
}
__inline extern double
drem (double x, double y)
{
double value;
__asm ("frem%.x %2,%0"
: "=f" (value)
: "0" (x),
"f" (y));
return value;
}
__inline extern double
scalb (double x, int n)
{
double value;
__asm ("fscale%.l %2,%0"
: "=f" (value)
: "0" (x),
"dmi" (n));
return value;
}
__inline extern double
logb (double x)
{
double exponent;
__asm ("fgetexp%.x %1,%0"
: "=f" (exponent)
: "f" (x));
return exponent;
}
__inline extern double
ldexp (double x, int n)
{
double value;
__asm ("fscale%.l %2,%0"
: "=f" (value)
: "0" (x),
"dmi" (n));
return value;
}
__inline extern double
frexp (double x, int *exp)
{
double float_exponent;
int int_exponent;
double mantissa;
__asm ("fgetexp%.x %1,%0"
: "=f" (float_exponent) /* integer-valued float */
: "f" (x));
int_exponent = (int) float_exponent;
__asm ("fgetman%.x %1,%0"
: "=f" (mantissa) /* 1.0 <= mantissa < 2.0 */
: "f" (x));
if (mantissa != 0)
{
__asm ("fscale%.b %#-1,%0"
: "=f" (mantissa) /* mantissa /= 2.0 */
: "0" (mantissa));
int_exponent += 1;
}
*exp = int_exponent;
return mantissa;
}
__inline extern double
modf (double x, double *ip)
{
double temp;
__asm ("fintrz%.x %1,%0"
: "=f" (temp) /* integer-valued float */
: "f" (x));
*ip = temp;
return x - temp;
}
#endif /* not __math_68881 */

187
gcc/ginclude/ppc-asm.h
View File

@ -1,187 +0,0 @@
/* PowerPC asm definitions for GNU C. */
/* Under winnt, 1) gas supports the following as names and 2) in particular
defining "toc" breaks the FUNC_START macro as ".toc" becomes ".2" */
#if !defined(__WINNT__)
#define r0 0
#define sp 1
#define toc 2
#define r3 3
#define r4 4
#define r5 5
#define r6 6
#define r7 7
#define r8 8
#define r9 9
#define r10 10
#define r11 11
#define r12 12
#define r13 13
#define r14 14
#define r15 15
#define r16 16
#define r17 17
#define r18 18
#define r19 19
#define r20 20
#define r21 21
#define r22 22
#define r23 23
#define r24 24
#define r25 25
#define r26 26
#define r27 27
#define r28 28
#define r29 29
#define r30 30
#define r31 31
#define cr0 0
#define cr1 1
#define cr2 2
#define cr3 3
#define cr4 4
#define cr5 5
#define cr6 6
#define cr7 7
#define f0 0
#define f1 1
#define f2 2
#define f3 3
#define f4 4
#define f5 5
#define f6 6
#define f7 7
#define f8 8
#define f9 9
#define f10 10
#define f11 11
#define f12 12
#define f13 13
#define f14 14
#define f15 15
#define f16 16
#define f17 17
#define f18 18
#define f19 19
#define f20 20
#define f21 21
#define f22 22
#define f23 23
#define f24 24
#define f25 25
#define f26 26
#define f27 27
#define f28 28
#define f29 29
#define f30 30
#define f31 31
#endif
/*
* Macros to glue together two tokens.
*/
#ifdef __STDC__
#define XGLUE(a,b) a##b
#else
#define XGLUE(a,b) a/**/b
#endif
#define GLUE(a,b) XGLUE(a,b)
/*
* Macros to begin and end a function written in assembler. If -mcall-aixdesc
* or -mcall-nt, create a function descriptor with the given name, and create
* the real function with one or two leading periods respectively.
*/
#ifdef _RELOCATABLE
#define DESC_SECTION ".got2"
#else
#define DESC_SECTION ".got1"
#endif
#if defined(_CALL_AIXDESC)
#define FUNC_NAME(name) GLUE(.,name)
#define FUNC_START(name) \
.section DESC_SECTION,"aw"; \
name: \
.long GLUE(.,name); \
.long _GLOBAL_OFFSET_TABLE_; \
.long 0; \
.previous; \
.type GLUE(.,name),@function; \
.globl name; \
.globl GLUE(.,name); \
GLUE(.,name):
#define FUNC_END(name) \
GLUE(.L,name): \
.size GLUE(.,name),GLUE(.L,name)-GLUE(.,name)
#elif defined(__WINNT__)
#define FUNC_NAME(name) GLUE(..,name)
#define FUNC_START(name) \
.pdata; \
.align 2; \
.ualong GLUE(..,name),GLUE(name,.e),0,0,GLUE(..,name); \
.reldata; \
name: \
.ualong GLUE(..,name),.toc; \
.section .text; \
.globl name; \
.globl GLUE(..,name); \
GLUE(..,name):
#define FUNC_END(name) \
GLUE(name,.e): ; \
GLUE(FE_MOT_RESVD..,name):
#elif defined(_CALL_NT)
#define FUNC_NAME(name) GLUE(..,name)
#define FUNC_START(name) \
.section DESC_SECTION,"aw"; \
name: \
.long GLUE(..,name); \
.long _GLOBAL_OFFSET_TABLE_; \
.previous; \
.type GLUE(..,name),@function; \
.globl name; \
.globl GLUE(..,name); \
GLUE(..,name):
#define FUNC_END(name) \
GLUE(.L,name): \
.size GLUE(..,name),GLUE(.L,name)-GLUE(..,name)
#else
/* CYGNUS LOCAL vmakarov */
#if 0
/* CYGNUS LOCAL */
#define FUNC_NAME(name) name
#define FUNC_START(name) \
.type name,@function; \
.globl name; \
name:
#define FUNC_END(name) \
GLUE(.L,name): \
.size name,GLUE(.L,name)-name
/* CYGNUS LOCAL vmakarov */
#endif
#define FUNC_NAME(name) GLUE(__USER_LABEL_PREFIX__,name)
#define FUNC_START(name) \
.type FUNC_NAME(name),@function; \
.globl FUNC_NAME(name); \
FUNC_NAME(name):
#define FUNC_END(name) \
GLUE(.L,name): \
.size FUNC_NAME(name),GLUE(.L,name)-FUNC_NAME(name)
/* END CYGNUS LOCAL */
#endif

4
gcc/ginclude/proto.h
View File

@ -1,4 +0,0 @@
/* This header file is to avoid trouble with semi-ANSI header files
on the Convex in system version 8.0. */
#define _PROTO(list) ()

232
gcc/ginclude/stdarg.h
View File

@ -4,242 +4,30 @@
Thus, va_arg (..., short) is not valid. */
#ifndef _STDARG_H
#ifndef _ANSI_STDARG_H_
#ifndef __need___va_list
#define _STDARG_H
#define _ANSI_STDARG_H_
#endif /* not __need___va_list */
#undef __need___va_list
#ifdef __clipper__
#include "va-clipper.h"
#else
#ifdef __m88k__
#include "va-m88k.h"
#else
#ifdef __i860__
#include "va-i860.h"
#else
#ifdef __hppa__
#include "va-pa.h"
#else
#ifdef __mips__
#include "va-mips.h"
#else
#ifdef __sparc__
#include "va-sparc.h"
#else
#ifdef __i960__
#include "va-i960.h"
#else
#ifdef __alpha__
#include "va-alpha.h"
#else
#if defined (__H8300__) || defined (__H8300H__) || defined (__H8300S__)
#include "va-h8300.h"
#else
#if defined (__PPC__) && (defined (_CALL_SYSV) || defined (_WIN32))
#include "va-ppc.h"
#else
#ifdef __arc__
#include "va-arc.h"
#else
/* CYGNUS LOCAL -- meissner/d10v */
#ifdef __D10V__
#include "va-d10v.h"
#else
/* END CYGNUS LOCAL -- meissner/d10v */
#ifdef __M32R__
#include "va-m32r.h"
#else
#ifdef __sh__
#include "va-sh.h"
#else
#ifdef __mn10300__
#include "va-mn10300.h"
#else
#ifdef __mn10200__
#include "va-mn10200.h"
#else
#ifdef __v850__
#include "va-v850.h"
#else
/* CYGNUS LOCAL v850e */
#ifdef __v850e__
#include "va-v850.h"
#else
#ifdef __v850ea__
#include "va-v850.h"
#else
/* END CYGNUS LOCAL */
/* CYGNUS LOCAL d30v */
#ifdef __D30V__
#include "va-d30v.h"
#else
/* END CYGNUS LOCAL d30v */
#if defined (_TMS320C4x) || defined (_TMS320C3x)
#include <va-c4x.h>
#else
/* CYGNUS LOCAL fr30 */
#ifdef __fr30__
#include "va-fr30.h"
#else
/* END CYGNUS LOCAL fr30 */
/* Define __gnuc_va_list. */
#ifndef __GNUC_VA_LIST
#define __GNUC_VA_LIST
#if defined(__svr4__) || defined(_AIX) || defined(_M_UNIX) || defined(__NetBSD__)
typedef char *__gnuc_va_list;
#else
typedef void *__gnuc_va_list;
#endif
#endif
/* Define the standard macros for the user,
if this invocation was from the user program. */
#ifdef _STDARG_H
/* Amount of space required in an argument list for an arg of type TYPE.
TYPE may alternatively be an expression whose type is used. */
#define __va_rounded_size(TYPE) \
(((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))
#if defined(sysV68)
#define __va_rounded_size(TYPE) \
(((sizeof (TYPE) + sizeof (short) - 1) / sizeof (short)) * sizeof (short))
#else
#define __va_rounded_size(TYPE) \
(((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))
#endif
#define va_start(AP, LASTARG) \
(AP = ((__gnuc_va_list) __builtin_next_arg(LASTARG)))
#define va_start(AP, LASTARG) \
(AP = ((__gnuc_va_list) __builtin_next_arg (LASTARG)))
#undef va_end
void va_end (__gnuc_va_list); /* Defined in libgcc.a */
#define va_end(AP) ((void)0)
#define va_end(AP) ((void)0)
/* We cast to void * and then to TYPE * because this avoids
a warning about increasing the alignment requirement. */
#if (defined (__arm__) && ! defined (__ARMEB__)) || defined (__i386__) || defined (__i860__) || defined (__ns32000__) || defined (__vax__)
/* This is for little-endian machines; small args are padded upward. */
#define va_arg(AP, TYPE) \
(AP = (__gnuc_va_list) ((char *) (AP) + __va_rounded_size (TYPE)), \
*((TYPE *) (void *) ((char *) (AP) - __va_rounded_size (TYPE))))
#else /* big-endian */
/* This is for big-endian machines; small args are padded downward. */
#define va_arg(AP, TYPE) \
(AP = (__gnuc_va_list) ((char *) (AP) + __va_rounded_size (TYPE)), \
*((TYPE *) (void *) ((char *) (AP) \
- ((sizeof (TYPE) < __va_rounded_size (char) \
? sizeof (TYPE) : __va_rounded_size (TYPE))))))
#endif /* big-endian */
a warning about increasing the alignment requirement.
This is for little-endian machines; small args are padded upward. */
#define va_arg(AP, TYPE) \
(AP = (__gnuc_va_list)((char *)(AP) + __va_rounded_size(TYPE)), \
*((TYPE *)(void *)((char *)(AP) - __va_rounded_size(TYPE))))
/* Copy __gnuc_va_list into another variable of this type. */
#define __va_copy(dest, src) (dest) = (src)
#endif /* _STDARG_H */
/* CYGNUS LOCAL fr30 */
#endif /* not fr30 */
/* END CYGNUS LOCAL fr30 */
#endif /* not TMS320C3x or TMS320C4x */
/* CYGNUS LOCAL d30v */
#endif /* not d30v */
/* END CYGNUS LOCAL d30v */
/* CYGNUS LOCAL v850e */
#endif /* not v850ea */
#endif /* not v850e */
/* END CYGNUS LOCAL */
#endif /* not v850 */
#endif /* not mn10200 */
#endif /* not mn10300 */
#endif /* not sh */
#endif /* not m32r */
/* CYGNUS LOCAL -- meissner/d10v */
#endif /* not d10v */
/* END CYGNUS LOCAL -- meissner/d10v */
#endif /* not arc */
#endif /* not powerpc with V.4 calling sequence */
#endif /* not h8300 */
#endif /* not alpha */
#endif /* not i960 */
#endif /* not sparc */
#endif /* not mips */
#endif /* not hppa */
#endif /* not i860 */
#endif /* not m88k */
#endif /* not clipper */
#ifdef _STDARG_H
/* Define va_list, if desired, from __gnuc_va_list. */
/* We deliberately do not define va_list when called from
stdio.h, because ANSI C says that stdio.h is not supposed to define
va_list. stdio.h needs to have access to that data type,
but must not use that name. It should use the name __gnuc_va_list,
which is safe because it is reserved for the implementation. */
#ifdef _HIDDEN_VA_LIST /* On OSF1, this means varargs.h is "half-loaded". */
#undef _VA_LIST
#endif
#ifdef _BSD_VA_LIST
#undef _BSD_VA_LIST
#endif
#if defined(__svr4__) || (defined(_SCO_DS) && !defined(__VA_LIST))
/* SVR4.2 uses _VA_LIST for an internal alias for va_list,
so we must avoid testing it and setting it here.
SVR4 uses _VA_LIST as a flag in stdarg.h, but we should
have no conflict with that. */
#ifndef _VA_LIST_
#define _VA_LIST_
#ifdef __i860__
#ifndef _VA_LIST
#define _VA_LIST va_list
#endif
#endif /* __i860__ */
typedef __gnuc_va_list va_list;
#ifdef _SCO_DS
#define __VA_LIST
#endif
#endif /* _VA_LIST_ */
#else /* not __svr4__ || _SCO_DS */
/* The macro _VA_LIST_ is the same thing used by this file in Ultrix.
But on BSD NET2 we must not test or define or undef it.
(Note that the comments in NET 2's ansi.h
are incorrect for _VA_LIST_--see stdio.h!) */
#if !defined (_VA_LIST_) || defined (__BSD_NET2__) || defined (____386BSD____) || defined (__bsdi__) || defined (__sequent__) || defined (__FreeBSD__) || defined(WINNT)
/* The macro _VA_LIST_DEFINED is used in Windows NT 3.5 */
#ifndef _VA_LIST_DEFINED
/* The macro _VA_LIST is used in SCO Unix 3.2. */
#ifndef _VA_LIST
/* The macro _VA_LIST_T_H is used in the Bull dpx2 */
#ifndef _VA_LIST_T_H
typedef __gnuc_va_list va_list;
#endif /* not _VA_LIST_T_H */
#endif /* not _VA_LIST */
#endif /* not _VA_LIST_DEFINED */
#if !(defined (__BSD_NET2__) || defined (____386BSD____) || defined (__bsdi__) || defined (__sequent__) || defined (__FreeBSD__))
#define _VA_LIST_
#endif
#ifndef _VA_LIST
#define _VA_LIST
#endif
#ifndef _VA_LIST_DEFINED
#define _VA_LIST_DEFINED
#endif
#ifndef _VA_LIST_T_H
#define _VA_LIST_T_H
#endif
#endif /* not _VA_LIST_, except on certain systems */
#endif /* not __svr4__ */
#endif /* _STDARG_H */
#endif /* not _ANSI_STDARG_H_ */
#endif /* not _STDARG_H */

327
gcc/ginclude/stddef.h
View File

@ -1,342 +1,27 @@
#if (!defined(_STDDEF_H) && !defined(_STDDEF_H_) && !defined(_ANSI_STDDEF_H) \
&& !defined(__STDDEF_H__)) \
|| defined(__need_wchar_t) || defined(__need_size_t) \
|| defined(__need_ptrdiff_t) || defined(__need_NULL) \
|| defined(__need_wint_t)
/* Any one of these symbols __need_* means that GNU libc
wants us just to define one data type. So don't define
the symbols that indicate this file's entire job has been done. */
#if (!defined(__need_wchar_t) && !defined(__need_size_t) \
&& !defined(__need_ptrdiff_t) && !defined(__need_NULL) \
&& !defined(__need_wint_t))
#ifndef _STDDEF_H
#define _STDDEF_H
#define _STDDEF_H_
/* snaroff@next.com says the NeXT needs this. */
#define _ANSI_STDDEF_H
/* Irix 5.1 needs this. */
#define __STDDEF_H__
#endif
#ifndef __sys_stdtypes_h
/* This avoids lossage on SunOS but only if stdtypes.h comes first.
There's no way to win with the other order! Sun lossage. */
/* On 4.3bsd-net2, make sure ansi.h is included, so we have
one less case to deal with in the following. */
#if defined (__BSD_NET2__) || defined (____386BSD____) || defined (__FreeBSD__) || defined(__NetBSD__)
#include <machine/ansi.h>
#endif
/* In 4.3bsd-net2, machine/ansi.h defines these symbols, which are
defined if the corresponding type is *not* defined.
FreeBSD-2.1 defines _MACHINE_ANSI_H_ instead of _ANSI_H_ */
#if defined(_ANSI_H_) || defined(_MACHINE_ANSI_H_)
#if !defined(_SIZE_T_) && !defined(_BSD_SIZE_T_)
#define _SIZE_T
#endif
#if !defined(_PTRDIFF_T_) && !defined(_BSD_PTRDIFF_T_)
#define _PTRDIFF_T
#endif
/* On BSD/386 1.1, at least, machine/ansi.h defines _BSD_WCHAR_T_
instead of _WCHAR_T_. */
#if !defined(_WCHAR_T_) && !defined(_BSD_WCHAR_T_)
#ifndef _BSD_WCHAR_T_
#define _WCHAR_T
#endif
#endif
/* Undef _FOO_T_ if we are supposed to define foo_t. */
#if defined (__need_ptrdiff_t) || defined (_STDDEF_H_)
#undef _PTRDIFF_T_
#undef _BSD_PTRDIFF_T_
#endif
#if defined (__need_size_t) || defined (_STDDEF_H_)
#undef _SIZE_T_
#undef _BSD_SIZE_T_
#endif
#if defined (__need_wchar_t) || defined (_STDDEF_H_)
#undef _WCHAR_T_
#undef _BSD_WCHAR_T_
#endif
#endif /* defined(_ANSI_H_) || defined(_MACHINE_ANSI_H_) */
/* Sequent's header files use _PTRDIFF_T_ in some conflicting way.
Just ignore it. */
#if defined (__sequent__) && defined (_PTRDIFF_T_)
#undef _PTRDIFF_T_
#endif
/* On VxWorks, <type/vxTypesBase.h> may have defined macros like
_TYPE_size_t which will typedef size_t. fixincludes patched the
vxTypesBase.h so that this macro is only defined if _GCC_SIZE_T is
not defined, and so that defining this macro defines _GCC_SIZE_T.
If we find that the macros are still defined at this point, we must
invoke them so that the type is defined as expected. */
#if defined (_TYPE_ptrdiff_t) && (defined (__need_ptrdiff_t) || defined (_STDDEF_H_))
_TYPE_ptrdiff_t;
#undef _TYPE_ptrdiff_t
#endif
#if defined (_TYPE_size_t) && (defined (__need_size_t) || defined (_STDDEF_H_))
_TYPE_size_t;
#undef _TYPE_size_t
#endif
#if defined (_TYPE_wchar_t) && (defined (__need_wchar_t) || defined (_STDDEF_H_))
_TYPE_wchar_t;
#undef _TYPE_wchar_t
#endif
/* In case nobody has defined these types, but we aren't running under
GCC 2.00, make sure that __PTRDIFF_TYPE__, __SIZE__TYPE__, and
__WCHAR_TYPE__ have reasonable values. This can happen if the
parts of GCC is compiled by an older compiler, that actually
include gstddef.h, such as collect2. */
/* Signed type of difference of two pointers. */
/* Define this type if we are doing the whole job,
or if we want this type in particular. */
#if defined (_STDDEF_H) || defined (__need_ptrdiff_t)
#ifndef _PTRDIFF_T /* in case <sys/types.h> has defined it. */
#ifndef _T_PTRDIFF_
#ifndef _T_PTRDIFF
#ifndef __PTRDIFF_T
#ifndef _PTRDIFF_T_
#ifndef _BSD_PTRDIFF_T_
#ifndef ___int_ptrdiff_t_h
#ifndef _GCC_PTRDIFF_T
#define _PTRDIFF_T
#define _T_PTRDIFF_
#define _T_PTRDIFF
#define __PTRDIFF_T
#define _PTRDIFF_T_
#define _BSD_PTRDIFF_T_
#define ___int_ptrdiff_t_h
#define _GCC_PTRDIFF_T
#ifndef __PTRDIFF_TYPE__
#define __PTRDIFF_TYPE__ long int
#endif
typedef __PTRDIFF_TYPE__ ptrdiff_t;
#endif /* _GCC_PTRDIFF_T */
#endif /* ___int_ptrdiff_t_h */
#endif /* _BSD_PTRDIFF_T_ */
#endif /* _PTRDIFF_T_ */
#endif /* __PTRDIFF_T */
#endif /* _T_PTRDIFF */
#endif /* _T_PTRDIFF_ */
#endif /* _PTRDIFF_T */
/* If this symbol has done its job, get rid of it. */
#undef __need_ptrdiff_t
#endif /* _STDDEF_H or __need_ptrdiff_t. */
typedef long int ptrdiff_t;
/* Unsigned type of `sizeof' something. */
/* Define this type if we are doing the whole job,
or if we want this type in particular. */
#if defined (_STDDEF_H) || defined (__need_size_t)
#ifndef __size_t__ /* BeOS */
#ifndef _SIZE_T /* in case <sys/types.h> has defined it. */
#ifndef _SYS_SIZE_T_H
#ifndef _T_SIZE_
#ifndef _T_SIZE
#ifndef __SIZE_T
#ifndef _SIZE_T_
#ifndef _BSD_SIZE_T_
#ifndef _SIZE_T_DEFINED_
#ifndef _SIZE_T_DEFINED
#ifndef ___int_size_t_h
#ifndef _GCC_SIZE_T
#ifndef _SIZET_
#ifndef __size_t
#define __size_t__ /* BeOS */
#define _SIZE_T
#define _SYS_SIZE_T_H
#define _T_SIZE_
#define _T_SIZE
#define __SIZE_T
#define _SIZE_T_
#define _BSD_SIZE_T_
#define _SIZE_T_DEFINED_
#define _SIZE_T_DEFINED
#define ___int_size_t_h
#define _GCC_SIZE_T
#define _SIZET_
#define __size_t
#ifndef __SIZE_TYPE__
#define __SIZE_TYPE__ long unsigned int
#endif
#if !(defined (__GNUG__) && defined (size_t))
typedef __SIZE_TYPE__ size_t;
#ifdef __BEOS__
typedef long ssize_t;
#endif /* __BEOS__ */
#endif /* !(defined (__GNUG__) && defined (size_t)) */
#endif /* __size_t */
#endif /* _SIZET_ */
#endif /* _GCC_SIZE_T */
#endif /* ___int_size_t_h */
#endif /* _SIZE_T_DEFINED */
#endif /* _SIZE_T_DEFINED_ */
#endif /* _BSD_SIZE_T_ */
#endif /* _SIZE_T_ */
#endif /* __SIZE_T */
#endif /* _T_SIZE */
#endif /* _T_SIZE_ */
#endif /* _SYS_SIZE_T_H */
#endif /* _SIZE_T */
#endif /* __size_t__ */
#undef __need_size_t
#endif /* _STDDEF_H or __need_size_t. */
typedef unsigned long int size_t;
/* Wide character type.
Locale-writers should change this as necessary to
be big enough to hold unique values not between 0 and 127,
and not (wchar_t) -1, for each defined multibyte character. */
/* Define this type if we are doing the whole job,
or if we want this type in particular. */
#if defined (_STDDEF_H) || defined (__need_wchar_t)
#ifndef __wchar_t__ /* BeOS */
#ifndef _WCHAR_T
#ifndef _T_WCHAR_
#ifndef _T_WCHAR
#ifndef __WCHAR_T
#ifndef _WCHAR_T_
#ifndef _BSD_WCHAR_T_
#ifndef _WCHAR_T_DEFINED_
#ifndef _WCHAR_T_DEFINED
#ifndef _WCHAR_T_H
#ifndef ___int_wchar_t_h
#ifndef __INT_WCHAR_T_H
#ifndef _GCC_WCHAR_T
#define __wchar_t__ /* BeOS */
#define _WCHAR_T
#define _T_WCHAR_
#define _T_WCHAR
#define __WCHAR_T
#define _WCHAR_T_
#define _BSD_WCHAR_T_
#define _WCHAR_T_DEFINED_
#define _WCHAR_T_DEFINED
#define _WCHAR_T_H
#define ___int_wchar_t_h
#define __INT_WCHAR_T_H
#define _GCC_WCHAR_T
/* On BSD/386 1.1, at least, machine/ansi.h defines _BSD_WCHAR_T_
instead of _WCHAR_T_, and _BSD_RUNE_T_ (which, unlike the other
symbols in the _FOO_T_ family, stays defined even after its
corresponding type is defined). If we define wchar_t, then we
must undef _WCHAR_T_; for BSD/386 1.1 (and perhaps others), if
we undef _WCHAR_T_, then we must also define rune_t, since
headers like runetype.h assume that if machine/ansi.h is included,
and _BSD_WCHAR_T_ is not defined, then rune_t is available.
machine/ansi.h says, "Note that _WCHAR_T_ and _RUNE_T_ must be of
the same type." */
#ifdef _BSD_WCHAR_T_
#undef _BSD_WCHAR_T_
#ifdef _BSD_RUNE_T_
#if !defined (_ANSI_SOURCE) && !defined (_POSIX_SOURCE)
typedef _BSD_RUNE_T_ rune_t;
#endif
#endif
#endif
#ifndef __WCHAR_TYPE__
#ifdef __BEOS__
#define __WCHAR_TYPE__ unsigned char
#else
#define __WCHAR_TYPE__ int
#endif
#endif
#ifndef __cplusplus
typedef __WCHAR_TYPE__ wchar_t;
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif /* __wchar_t__ */
#undef __need_wchar_t
#endif /* _STDDEF_H or __need_wchar_t. */
#if defined (_STDDEF_H) || defined (__need_wint_t)
#ifndef _WINT_T
#define _WINT_T
#ifndef __WINT_TYPE__
#define __WINT_TYPE__ unsigned int
#endif
typedef __WINT_TYPE__ wint_t;
#endif
#undef __need_wint_t
#endif
/* In 4.3bsd-net2, leave these undefined to indicate that size_t, etc.
are already defined. */
/* BSD/OS 3.1 requires the MACHINE_ANSI_H check here. FreeBSD 2.x apparently
does not, even though there is a check for MACHINE_ANSI_H above. */
#if defined(_ANSI_H_) || (defined(__bsdi__) && defined(_MACHINE_ANSI_H_))
/* The references to _GCC_PTRDIFF_T_, _GCC_SIZE_T_, and _GCC_WCHAR_T_
are probably typos and should be removed before 2.8 is released. */
#ifdef _GCC_PTRDIFF_T_
#undef _PTRDIFF_T_
#undef _BSD_PTRDIFF_T_
#endif
#ifdef _GCC_SIZE_T_
#undef _SIZE_T_
#undef _BSD_SIZE_T_
#endif
#ifdef _GCC_WCHAR_T_
#undef _WCHAR_T_
#undef _BSD_WCHAR_T_
#endif
/* The following ones are the real ones. */
#ifdef _GCC_PTRDIFF_T
#undef _PTRDIFF_T_
#undef _BSD_PTRDIFF_T_
#endif
#ifdef _GCC_SIZE_T
#undef _SIZE_T_
#undef _BSD_SIZE_T_
#endif
#ifdef _GCC_WCHAR_T
#undef _WCHAR_T_
#undef _BSD_WCHAR_T_
#endif
#endif /* _ANSI_H_ || ( __bsdi__ && _MACHINE_ANSI_H_ ) */
#endif /* __sys_stdtypes_h */
typedef int wchar_t;
/* A null pointer constant. */
#if defined (_STDDEF_H) || defined (__need_NULL)
#undef NULL /* in case <stdio.h> has defined it. */
#ifdef __GNUG__
#define NULL __null
#else /* G++ */
#define NULL ((void *)0)
#endif /* G++ */
#endif /* NULL not defined and <stddef.h> or need NULL. */
#undef __need_NULL
#ifdef _STDDEF_H
/* Offset of member MEMBER in a struct of type TYPE. */
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
#define offsetof(TYPE, MEMBER) ((size_t)&((TYPE *)0)->MEMBER)
#endif /* _STDDEF_H was defined this time */
#endif /* !_STDDEF_H && !_STDDEF_H_ && !_ANSI_STDDEF_H && !__STDDEF_H__
|| __need_XXX was not defined before */
#endif /* _STDDEF_H */

128
gcc/ginclude/va-alpha.h
View File

@ -1,128 +0,0 @@
/* GNU C varargs and stdargs support for the DEC Alpha. */
/* Note: We must use the name __builtin_savregs. GCC attaches special
significance to that name. In particular, regardless of where in a
function __builtin_saveregs is called, GCC moves the call up to the
very start of the function. */
/* Define __gnuc_va_list. */
#ifndef __GNUC_VA_LIST
#define __GNUC_VA_LIST
/* In VMS, __gnuc_va_list is simply char *; on OSF, it's a structure. */
#ifdef __VMS__
typedef char *__gnuc_va_list;
#else
typedef struct {
char *__base; /* Pointer to first integer register. */
int __offset; /* Byte offset of args so far. */
} __gnuc_va_list;
#endif
#endif /* __GNUC_VA_LIST */
/* If this is for internal libc use, don't define anything but
__gnuc_va_list. */
#if !defined(__GNUC_VA_LIST_1) && (defined (_STDARG_H) || defined (_VARARGS_H))
#define __GNUC_VA_LIST_1
#define _VA_LIST
#define _VA_LIST_
typedef __gnuc_va_list va_list;
#if !defined(_STDARG_H)
/* varargs support */
#define va_alist __builtin_va_alist
#define va_dcl int __builtin_va_alist;...
#ifdef __VMS__
#define va_start(pvar) ((pvar) = __builtin_saveregs ())
#else
#define va_start(pvar) ((pvar) = * (__gnuc_va_list *) __builtin_saveregs ())
#endif
#else /* STDARG.H */
/* ANSI alternative. */
/* Call __builtin_next_arg even though we aren't using its value, so that
we can verify that firstarg is correct. */
#ifdef __VMS__
#define va_start(pvar, firstarg) \
(__builtin_next_arg (firstarg), \
(pvar) = __builtin_saveregs ())
#else
#define va_start(pvar, firstarg) \
(__builtin_next_arg (firstarg), \
(pvar) = *(__gnuc_va_list *) __builtin_saveregs ())
#endif
#endif /* _STDARG_H */
#define va_end(__va) ((void) 0)
/* Values returned by __builtin_classify_type. */
enum {
__no_type_class = -1,
__void_type_class,
__integer_type_class,
__char_type_class,
__enumeral_type_class,
__boolean_type_class,
__pointer_type_class,
__reference_type_class,
__offset_type_class,
__real_type_class,
__complex_type_class,
__function_type_class,
__method_type_class,
__record_type_class,
__union_type_class,
__array_type_class,
__string_type_class,
__set_type_class,
__file_type_class,
__lang_type_class
};
/* Note that parameters are always aligned at least to a word boundary
(when passed) regardless of what GCC's __alignof__ operator says. */
/* Avoid errors if compiling GCC v2 with GCC v1. */
#if __GNUC__ == 1
#define __extension__
#endif
/* Get the size of a type in bytes, rounded up to an integral number
of words. */
#define __va_tsize(__type) \
(((sizeof (__type) + __extension__ sizeof (long long) - 1) \
/ __extension__ sizeof (long long)) * __extension__ sizeof (long long))
#ifdef __VMS__
#define va_arg(__va, __type) \
(*(((__va) += __va_tsize (__type)), \
(__type *)(void *)((__va) - __va_tsize (__type))))
#else
#define va_arg(__va, __type) \
(*(((__va).__offset += __va_tsize (__type)), \
(__type *)(void *)((__va).__base + (__va).__offset \
- (((__builtin_classify_type (* (__type *) 0) \
== __real_type_class) && (__va).__offset <= (6 * 8)) \
? (6 * 8) + 8 : __va_tsize (__type)))))
#endif
/* Copy __gnuc_va_list into another variable of this type. */
#define __va_copy(dest, src) (dest) = (src)
#endif /* __GNUC_VA_LIST_1 */

111
gcc/ginclude/va-arc.h
View File

@ -1,111 +0,0 @@
/* stdarg/varargs support for the ARC */
/* Define __gnuc_va_list. */
#ifndef __GNUC_VA_LIST
#define __GNUC_VA_LIST
typedef void * __gnuc_va_list;
#endif /* not __GNUC_VA_LIST */
/* If this is for internal libc use, don't define anything but
__gnuc_va_list. */
#if defined (_STDARG_H) || defined (_VARARGS_H)
/* In GCC version 2, we want an ellipsis at the end of the declaration
of the argument list. GCC version 1 can't parse it. */
#if __GNUC__ > 1
#define __va_ellipsis ...
#else
#define __va_ellipsis
#endif
/* See arc_setup_incoming_varargs for reasons for the oddity in va_start. */
#ifdef _STDARG_H
#define va_start(AP, LASTARG) \
(AP = (__gnuc_va_list) ((int *) __builtin_next_arg (LASTARG) \
+ (__builtin_args_info (0) < 8 \
? (__builtin_args_info (0) & 1) \
: 0)))
#else
#define va_alist __builtin_va_alist
#define va_dcl int __builtin_va_alist; __va_ellipsis
#define va_start(AP) \
(AP = (__gnuc_va_list) ((int *) &__builtin_va_alist \
+ (__builtin_args_info (0) < 8 \
? (__builtin_args_info (0) & 1) \
: 0)))
#endif
#ifndef va_end
void va_end (__gnuc_va_list); /* Defined in libgcc.a */
/* Values returned by __builtin_classify_type. */
enum __va_type_classes {
__no_type_class = -1,
__void_type_class,
__integer_type_class,
__char_type_class,
__enumeral_type_class,
__boolean_type_class,
__pointer_type_class,
__reference_type_class,
__offset_type_class,
__real_type_class,
__complex_type_class,
__function_type_class,
__method_type_class,
__record_type_class,
__union_type_class,
__array_type_class,
__string_type_class,
__set_type_class,
__file_type_class,
__lang_type_class
};
#endif
#define va_end(AP) ((void)0)
/* Avoid errors if compiling GCC v2 with GCC v1. */
#if __GNUC__ == 1
#define __extension__
#endif
/* All aggregates are passed by reference. All scalar types larger than 8
bytes are passed by reference. */
/* We cast to void * and then to TYPE * because this avoids
a warning about increasing the alignment requirement.
The casts to char * avoid warnings about invalid pointer arithmetic. */
#define __va_rounded_size(TYPE) \
(((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))
#ifdef __big_endian__
#define va_arg(AP,TYPE) \
__extension__ \
(*({((__builtin_classify_type (*(TYPE*) 0) >= __record_type_class \
|| __va_rounded_size (TYPE) > 8) \
? ((AP) = (char *)(AP) + __va_rounded_size (TYPE *), \
*(TYPE **) (void *) ((char *)(AP) - __va_rounded_size (TYPE *))) \
: ((TYPE *) (void *) \
(AP = (void *) ((__alignof__ (TYPE) > 4 \
? ((int) AP + 8 - 1) & -8 \
: (int) AP) \
+ __va_rounded_size (TYPE))) - 1));}))
#else
#define va_arg(AP,TYPE) \
__extension__ \
(*({((__builtin_classify_type (*(TYPE*) 0) >= __record_type_class \
|| __va_rounded_size (TYPE) > 8) \
? ((AP) = (char *)(AP) + __va_rounded_size (TYPE *), \
*(TYPE **) (void *) ((char *)(AP) - __va_rounded_size (TYPE *))) \
: ((AP = (void *) ((__alignof__ (TYPE) > 4 \
? ((int) AP + 8 - 1) & -8 \
: (int) AP) \
+ __va_rounded_size (TYPE))), \
(TYPE *) (void *) (AP - __va_rounded_size (TYPE))));}))
#endif
#endif /* defined (_STDARG_H) || defined (_VARARGS_H) */

34
gcc/ginclude/va-c4x.h
View File

@ -1,34 +0,0 @@
/* GNU C varargs support for the TMS320C[34]x */
/* C[34]x arguments grow in weird ways (downwards) that the standard
varargs stuff can't handle. */
#ifndef __GNUC_VA_LIST
#define __GNUC_VA_LIST
typedef void *__gnuc_va_list;
#endif /* not __GNUC_VA_LIST */
/* If this is for internal libc use, don't define anything but
__gnuc_va_list. */
#if defined (_STDARG_H) || defined (_VARARGS_H)
#ifdef _STDARG_H /* stdarg.h support */
#define va_start(AP,LASTARG) AP=(__gnuc_va_list) __builtin_next_arg (LASTARG)
#else /* varargs.h support */
#define __va_ellipsis ...
#define va_alist __builtin_va_alist
#define va_dcl int __builtin_va_alist; __va_ellipsis
#define va_start(AP) AP=(__gnuc_va_list) ((int *)&__builtin_va_alist + 1)
#endif /* _STDARG_H */
#define va_end(AP) ((void) 0)
#define va_arg(AP,TYPE) (AP = (__gnuc_va_list) ((char *) (AP) - sizeof(TYPE)), \
*((TYPE *) ((char *) (AP))))
#endif /* defined (_STDARG_H) || defined (_VARARGS_H) */

60
gcc/ginclude/va-clipper.h
View File

@ -1,60 +0,0 @@
/* GNU C varargs and stdargs support for Clipper. */
/* Define __gnuc_va_list. */
#ifndef __GNUC_VA_LIST
#define __GNUC_VA_LIST
typedef struct
{
int __va_ap; /* pointer to stack args */
void *__va_reg[4]; /* pointer to r0,f0,r1,f1 */
int __va_num; /* number of args processed */
} __gnuc_va_list;
#endif /* not __GNUC_VA_LIST */
#if defined (_STDARG_H) || defined (_VARARGS_H)
typedef __gnuc_va_list va_list;
#define __va_list __gnuc_va_list /* acc compatibility */
#define _VA_LIST
#define _VA_LIST_
#define _SYS_INT_STDARG_H /* acc compatibility */
/* Call __builtin_next_arg even though we aren't using its value, so that
we can verify that LASTARG is correct. */
#ifdef _STDARG_H
#define va_start(AP,LASTARG) \
(__builtin_next_arg (LASTARG), \
(AP) = *(va_list *)__builtin_saveregs(), \
(AP).__va_num = __builtin_args_info (0), \
(AP).__va_ap += __builtin_args_info (1))
#else
#define va_alist __builtin_va_alist
/* The ... causes current_function_varargs to be set in cc1. */
#define va_dcl va_list __builtin_va_alist; ...
#define va_start(AP) \
((AP) = *(va_list *)__builtin_saveregs(), \
(AP).__va_num = __builtin_args_info (0))
#endif /* _STDARG_H */
/* round to alignment of `type' but keep a least integer alignment */
#define __va_round(AP,TYPE) \
((AP).__va_ap = ((AP).__va_ap + __alignof__ (TYPE) - 1 ) & \
~(__alignof__ (TYPE) - 1), \
((AP).__va_ap = ((AP).__va_ap + sizeof (int) - 1) & ~(sizeof (int) - 1)))
#define va_arg(AP, TYPE) \
(*((AP).__va_num < 2 && __builtin_classify_type (* (TYPE *)0) < 12 \
? (__builtin_classify_type (* (TYPE *)0) == 8 \
? ((TYPE *)(AP).__va_reg[2 * (AP).__va_num++ + 1]) \
: ((TYPE *)(AP).__va_reg[2 * (AP).__va_num++ ])) \
: ((AP).__va_num++, __va_round (AP,TYPE), ((TYPE *)((AP).__va_ap))++)))
#define va_end(AP) ((void) 0)
/* Copy __gnuc_va_list into another variable of this type. */
#define __va_copy(dest, src) (dest) = (src)
#endif /* defined (_STDARG_H) || defined (_VARARGS_H) */

81
gcc/ginclude/va-d10v.h
View File

@ -1,81 +0,0 @@
/* GNU C stdarg/varargs support for the D10V */
/* Define __gnuc_va_list. */
#ifndef __GNUC_VA_LIST
#define __GNUC_VA_LIST
typedef struct __va_list_tag {
short *__va_reg_base; /* start of the register save area */
short __va_reg_num; /* argument number */
char *__va_stack;
} __va_list[1], __gnuc_va_list[1];
#endif /* not __GNUC_VA_LIST */
/* If this is for internal libc use, don't define anything but
__gnuc_va_list. */
#if defined (_STDARG_H) || defined (_VARARGS_H)
/* Common code for va_start for both varargs and stdarg. This depends
on the format of the CUMULATIVE_ARGS type. On the d10v, we use just
a single word that is the argument number. */
#define __va_start_common(AP) \
__extension__ ({ \
(AP)->__va_reg_base = (short *) __builtin_saveregs (); \
(AP)->__va_reg_num = __builtin_args_info (0); \
(AP)->__va_stack \
= (char *)((AP)->__va_reg_base + __builtin_args_info (1)); \
(void)0; \
})
#ifdef _STDARG_H /* stdarg.h support */
/* Calling __builtin_next_arg gives the proper error message if LASTARG is
not indeed the last argument. */
#define va_start(AP,LASTARG) \
(__builtin_next_arg (LASTARG), __va_start_common (AP))
#else /* varargs.h support */
#define va_start(AP) __va_start_common (AP)
#define va_alist __builtin_va_alist
#define va_dcl register int va_alist; ...
#endif /* _STDARG_H */
/* Nothing needs to be done to end varargs/stdarg processing */
#define va_end(AP) ((void)0)
#define va_arg(AP,TYPE) \
__extension__ (*({ \
register TYPE *__ptr; \
\
int __va_reg_now = (AP)->__va_reg_num, __va_reg_new; \
\
if (sizeof (TYPE) >= 4 && (__va_reg_now & 1) != 0) \
__va_reg_now++; \
__va_reg_new = __va_reg_now + (sizeof (TYPE) + 1) / 2; \
if (__va_reg_new <= 4) \
{ \
(AP)->__va_reg_num = __va_reg_new; \
__ptr = (TYPE *)(((char *)(void *) \
((AP)->__va_reg_base + __va_reg_now)) \
+ (sizeof (TYPE) < 2)); \
} \
else \
{ \
/* ??? According to PARM_BOUNDARY, there should be no extra \
alignment here - but there is, see testcase execute/va-arg-6.c.\
That seems to be a backend bug */ \
if (sizeof (TYPE) >= 4 \
&& (((AP)->__va_stack - (char *)(AP)->__va_reg_base) & 2) != 0)\
\
(AP)->__va_stack += 2; \
__ptr = (TYPE *)((AP)->__va_stack + (sizeof (TYPE) < 2)); \
(AP)->__va_stack += (sizeof (TYPE) + 1) & ~1; \
} \
\
__ptr; \
}))
#endif /* defined (_STDARG_H) || defined (_VARARGS_H) */

64
gcc/ginclude/va-d30v.h
View File

@ -1,64 +0,0 @@
/* CYGNUS LOCAL entire file/d30v */
/* GNU C stdarg/varargs support for the D30V */
/* Define __gnuc_va_list. */
#ifndef __GNUC_VA_LIST
#define __GNUC_VA_LIST
typedef struct __va_list_tag {
int *__va_arg_ptr; /* start of the register save area */
int __va_arg_num; /* argument number */
} __va_list[1], __gnuc_va_list[1];
#endif /* not __GNUC_VA_LIST */
/* If this is for internal libc use, don't define anything but
__gnuc_va_list. */
#if defined (_STDARG_H) || defined (_VARARGS_H)
/* Common code for va_start for both varargs and stdarg. This depends
on the format of the CUMULATIVE_ARGS type. On the d30v, we use just
a single word that is the register number. */
#define __va_start_common(AP) \
__extension__ ({ \
(AP)->__va_arg_ptr = (int *) __builtin_saveregs (); \
(AP)->__va_arg_num = __builtin_args_info (0) - 2 /* first arg # */; \
(void)0; \
})
#ifdef _STDARG_H /* stdarg.h support */
/* Calling __builtin_next_arg gives the proper error message if LASTARG is
not indeed the last argument. */
#define va_start(AP,LASTARG) \
(__builtin_next_arg (LASTARG), __va_start_common (AP))
#else /* varargs.h support */
#define va_start(AP) __va_start_common (AP)
#define va_alist __builtin_va_alist
#define va_dcl register int va_alist; ...
#endif /* _STDARG_H */
/* Nothing needs to be done to end varargs/stdarg processing */
#define va_end(AP) ((void)0)
#define va_arg(AP,TYPE) \
__extension__ (*({ \
register TYPE *__ptr; \
\
if (sizeof (TYPE) > 4 && ((AP)->__va_arg_num & 1) != 0) \
(AP)->__va_arg_num++; \
\
__ptr = (TYPE *)(((char *)(void *) \
((AP)->__va_arg_ptr + (AP)->__va_arg_num))); \
\
if (sizeof (TYPE) < 4) \
__ptr = (void*)__ptr + 4 - sizeof (TYPE); \
(AP)->__va_arg_num += (sizeof (TYPE) + 3) / 4; \
__ptr; \
}))
#endif /* defined (_STDARG_H) || defined (_VARARGS_H) */
/* END CYGNUS LOCAL */

49
gcc/ginclude/va-fr30.h
View File

@ -1,49 +0,0 @@
/* Define __gnuc_va_list. */
#ifndef __GNUC_VA_LIST
#define __GNUC_VA_LIST
typedef void * __gnuc_va_list;
#endif /* not __GNUC_VA_LIST */
/* If this is for internal libc use, don't define anything but
__gnuc_va_list. */
#if defined (_STDARG_H) || defined (_VARARGS_H)
#ifdef _STDARG_H
#define va_start(AP, LASTARG) \
(AP = ((__gnuc_va_list) __builtin_next_arg (LASTARG)))
#else
#define __va_ellipsis ...
#define va_alist __builtin_va_alist
#define va_dcl int __builtin_va_alist; __va_ellipsis
#define va_start(AP) AP = (char *) & __builtin_va_alist
#endif
/* Now stuff common to both varargs & stdarg implementations. */
#define __va_rounded_size(TYPE) \
(((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))
#undef va_end
void va_end (__gnuc_va_list);
#define va_end(AP) ((void)0)
/* We need to be able to detect structures and handle them specially. */
#define __va_aggregate_p(TYPE) (__builtin_classify_type(*(TYPE *)0) >= 12)
#define va_arg(AP, TYPE) \
(__va_aggregate_p (TYPE) ? \
(AP = (__gnuc_va_list) ((char *) (AP) + __va_rounded_size (char *)), \
** ((TYPE **) (void *)((char *) (AP) - __va_rounded_size (char *)))) \
: (sizeof (TYPE) % sizeof (int) == 0) ? \
(AP = (__gnuc_va_list) ((char *) (AP) + __va_rounded_size (TYPE)), \
* ((TYPE *) (void *) ((char *) (AP) - __va_rounded_size (TYPE)))) \
: (sizeof (TYPE) < 4) ? \
(AP = (__gnuc_va_list) ((char *) (AP) + __va_rounded_size (TYPE)), \
* ((TYPE *) (void *) ((char *) (AP) - sizeof (TYPE)))) \
: \
(AP = (__gnuc_va_list) ((char *) (AP) + __va_rounded_size (char *)), \
** ((TYPE **) (void *)((char *) (AP) - __va_rounded_size (char *)))))
#endif /* defined (_STDARG_H) || defined (_VARARGS_H) */

56
gcc/ginclude/va-h8300.h
View File

@ -1,56 +0,0 @@
/* stdarg/vararg support for the Hitachi h8/300 and h8/300h */
/* Define __gnuc_va_list. */
#ifndef __GNUC_VA_LIST
#define __GNUC_VA_LIST
typedef void *__gnuc_va_list;
#endif
/* If this is for internal libc use, don't define anything but
__gnuc_va_list. */
#if defined (_STDARG_H) || defined (_VARARGS_H)
/* In GCC version 2, we want an ellipsis at the end of the declaration
of the argument list. GCC version 1 can't parse it. */
#if __GNUC__ > 1
#define __va_ellipsis ...
#else
#define __va_ellipsis
#endif
#ifdef __H8300__
#define __va_rounded_size(TYPE) \
(((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))
#else
#define __va_rounded_size(TYPE) \
(((sizeof (TYPE) + sizeof (long) - 1) / sizeof (long)) * sizeof (long))
#endif
#ifdef _STDARG_H
#define va_start(AP,LASTARG) \
(AP = ((__gnuc_va_list) __builtin_next_arg (LASTARG)))
#else /* _VARARGS_H */
#define va_alist __builtin_va_alist
/* The ... causes current_function_varargs to be set in cc1. */
#define va_dcl int __builtin_va_alist; __va_ellipsis
#define va_start(AP) AP = (void *) &__builtin_va_alist
#endif /* _VARARGS_H */
#define va_arg(AP, TYPE) \
(AP = (__gnuc_va_list) ((char *) (AP) + __va_rounded_size (TYPE)), \
*((TYPE *) (void *) ((char *) (AP) \
- ((sizeof (TYPE) < __va_rounded_size (int) \
? sizeof (TYPE) : __va_rounded_size (TYPE))))))
#define va_end(AP) ((void) 0)
/* Copy __gnuc_va_list into another variable of this type. */
#define __va_copy(dest, src) (dest) = (src)
#endif /* defined (_STDARG_H) || defined (_VARARGS_H) */

214
gcc/ginclude/va-i860.h
View File

@ -1,214 +0,0 @@
/* Note: We must use the name __builtin_savregs. GCC attaches special
significance to that name. In particular, regardless of where in a
function __builtin_saveregs is called, GCC moves the call up to the
very start of the function. */
/* Define __gnuc_va_list. */
#ifndef __GNUC_VA_LIST
#define __GNUC_VA_LIST
typedef union {
float __freg[8];
double __dreg[4];
} __f_regs;
typedef struct {
#if defined (__SVR4__) || defined (__svr4__) || defined (__alliant__) || defined (__PARAGON__)
__f_regs __float_regs; long __ireg[12];
#else /* pre-SVR4 */
long __ireg[12]; __f_regs __float_regs;
#endif
} __va_saved_regs;
typedef struct {
#if defined(__SVR4__) || defined(__svr4__) || defined(__alliant__) || defined (__PARAGON__)
unsigned __ireg_used; /* How many int regs consumed 'til now? */
unsigned __freg_used; /* How many flt regs consumed 'til now? */
long *__reg_base; /* Address of where we stored the regs. */
long * __mem_ptr; /* Address of memory overflow args area. */
#else /* pre-SVR4 */
long *__reg_base; /* Address of where we stored the regs. */
long * __mem_ptr; /* Address of memory overflow args area. */
unsigned __ireg_used; /* How many int regs consumed 'til now? */
unsigned __freg_used; /* How many flt regs consumed 'til now? */
#endif
} __gnuc_va_list;
#endif /* not __GNUC_VA_LIST */
/* If this is for internal libc use, don't define anything but
__gnuc_va_list. */
#if defined (_STDARG_H) || defined (_VARARGS_H)
#if !defined(_STDARG_H)
/* varargs support */
#define va_alist __builtin_va_alist
#if defined (__PARAGON__)
#define va_dcl int va_alist;
#else /* __PARAGON__ */
#define va_dcl
#endif /* __PARAGON__ */
#define va_start(pvar) ((pvar) = * (__gnuc_va_list *) __builtin_saveregs ())
#else /* STDARG.H */
/* ANSI alternative. */
/* Note that CUMULATIVE_ARGS elements are measured in bytes on the i860,
so we divide by 4 to get # of registers. */
#define va_start(pvar, firstarg) \
((pvar) = *(__gnuc_va_list *) __builtin_saveregs (), \
(pvar).__ireg_used = __builtin_args_info (0) / 4, \
(pvar).__freg_used = __builtin_args_info (1) / 4, \
(pvar).__mem_ptr = __builtin_next_arg (firstarg))
#endif /* _STDARG_H */
/* Values returned by __builtin_classify_type. */
#ifndef va_end
enum {
__no_type_class = -1,
__void_type_class,
__integer_type_class,
__char_type_class,
__enumeral_type_class,
__boolean_type_class,
__pointer_type_class,
__reference_type_class,
__offset_type_class,
__real_type_class,
__complex_type_class,
__function_type_class,
__method_type_class,
__record_type_class,
__union_type_class,
__array_type_class,
__string_type_class,
__set_type_class,
__file_type_class,
__lang_type_class
};
void va_end (__gnuc_va_list); /* Defined in libgcc.a */
#endif
#define va_end(__va) ((void) 0)
#define __NUM_PARM_FREGS 8
#define __NUM_PARM_IREGS 12
#define __savereg(__va) ((__va_saved_regs *) ((__va).__reg_base))
/* This macro works both for SVR4 and pre-SVR4 environments. */
/* Note that parameters are always aligned at least to a word boundary
(when passed) regardless of what GCC's __alignof__ operator says. */
/* Make allowances here for adding 128-bit (long double) floats someday. */
#if 0 /* What was this for? */
#ifndef __GNU_VA_LIST
#define __ireg_used ireg_used
#define __freg_used freg_used
#define __mem_ptr mem_ptr
#define __reg_base reg_base
#endif
#endif /* 0 */
/* Avoid errors if compiling GCC v2 with GCC v1. */
#if __GNUC__ == 1
#define __extension__
#endif
#define va_arg(__va, __type) \
__extension__ \
(* (__type *) \
({ \
register void *__rv; /* result value */ \
register unsigned __align; \
switch (__builtin_classify_type (* (__type *) 0)) \
{ \
case __real_type_class: \
switch (sizeof (__type)) \
{ \
case sizeof (float): \
case sizeof (double): \
if ((__va).__freg_used < __NUM_PARM_FREGS - 1) \
{ \
if (((__va).__freg_used & 1) != 0) \
(__va).__freg_used++; /* skip odd */ \
__rv = &__savereg((__va))->__float_regs.__freg[(__va).__freg_used];\
(__va).__freg_used += 2; \
} \
else \
{ \
if ((((unsigned) (__va).__mem_ptr) & (sizeof(double)-1)) != 0) \
(__va).__mem_ptr++; /* skip odd */ \
__rv = (__va).__mem_ptr; \
(__va).__mem_ptr += 2; \
} \
if (sizeof (__type) == sizeof (float)) \
{ \
*((float *) __rv) = *((double *) __rv); \
*(((long *) __rv) + 1) = 0xfff00001; \
} \
break; \
default: \
abort (); \
} \
break; \
case __void_type_class: \
case __integer_type_class: \
case __char_type_class: \
case __enumeral_type_class: \
case __boolean_type_class: \
case __pointer_type_class: \
case __reference_type_class: \
case __offset_type_class: \
if (sizeof (__type) <= 4) \
{ \
__rv = ((__va).__ireg_used < __NUM_PARM_IREGS \
? (&__savereg((__va))->__ireg[(__va).__ireg_used++]) \
: (__va).__mem_ptr++); \
break; \
} \
else if ((__va).__ireg_used + sizeof (__type) / 4 <= __NUM_PARM_IREGS) \
{ \
__rv = &__savereg((__va))->__ireg[(__va).__ireg_used]; \
(__va).__ireg_used += sizeof (__type) / 4; \
break; \
} \
/* Fall through to fetch from memory. */ \
case __record_type_class: \
case __union_type_class: \
__align = (__alignof__ (__type) < sizeof (long) \
? sizeof (long) \
: __alignof__ (__type)); \
(__va).__mem_ptr \
= (long *) \
((((unsigned) (__va).__mem_ptr) + (__align-1)) & ~(__align-1)); \
__rv = (__va).__mem_ptr; \
(__va).__mem_ptr \
+= ((sizeof (__type) + sizeof (long) - 1) / sizeof (long)); \
break; \
case __complex_type_class: \
case __function_type_class: \
case __method_type_class: \
case __array_type_class: \
case __string_type_class: \
case __set_type_class: \
case __file_type_class: \
case __lang_type_class: \
case __no_type_class: \
default: \
abort (); \
} \
__rv; \
}))
/* Copy __gnuc_va_list into another variable of this type. */
#define __va_copy(dest, src) (dest) = (src)
#endif /* defined (_STDARG_H) || defined (_VARARGS_H) */

79
gcc/ginclude/va-i960.h
View File

@ -1,79 +0,0 @@
/* GNU C varargs support for the Intel 80960. */
/* Define __gnuc_va_list. */
#ifndef __GNUC_VA_LIST
#define __GNUC_VA_LIST
/* The first element is the address of the first argument.
The second element is the number of bytes skipped past so far. */
typedef unsigned __gnuc_va_list[2];
#endif /* not __GNUC_VA_LIST */
/* If this is for internal libc use, don't define anything but
__gnuc_va_list. */
#if defined (_STDARG_H) || defined (_VARARGS_H)
/* In GCC version 2, we want an ellipsis at the end of the declaration
of the argument list. GCC version 1 can't parse it. */
#if __GNUC__ > 1
#define __va_ellipsis ...
#else
#define __va_ellipsis
#endif
/* The stack size of the type t. */
#define __vsiz(T) (((sizeof (T) + 3) / 4) * 4)
/* The stack alignment of the type t. */
#define __vali(T) (__alignof__ (T) >= 4 ? __alignof__ (T) : 4)
/* The offset of the next stack argument after one of type t at offset i. */
#define __vpad(I, T) ((((I) + __vali (T) - 1) / __vali (T)) \
* __vali (T) + __vsiz (T))
/* Avoid errors if compiling GCC v2 with GCC v1. */
#if __GNUC__ == 1
#define __extension__
#endif
#ifdef _STDARG_H
/* Call __builtin_next_arg even though we aren't using its value, so that
we can verify that firstarg is correct. */
#define va_start(AP, LASTARG) \
__extension__ \
({ __builtin_next_arg (LASTARG); \
__asm__ ("st g14,%0" : "=m" (*(AP))); \
(AP)[1] = (__builtin_args_info (0) + __builtin_args_info (1)) * 4; })
#else
#define va_alist __builtin_va_alist
#define va_dcl char *__builtin_va_alist; __va_ellipsis
#define va_start(AP) \
__extension__ \
({ __asm__ ("st g14,%0" : "=m" (*(AP))); \
(AP)[1] = (__builtin_args_info (0) + __builtin_args_info (1)) * 4; })
#endif
/* We cast to void * and then to TYPE * because this avoids
a warning about increasing the alignment requirement. */
#define va_arg(AP, T) \
( \
( \
((AP)[1] <= 48 && (__vpad ((AP)[1], T) > 48 || __vsiz (T) > 16)) \
? ((AP)[1] = 48 + __vsiz (T)) \
: ((AP)[1] = __vpad ((AP)[1], T)) \
), \
\
*((T *) (void *) ((char *) *(AP) + (AP)[1] - __vsiz (T))) \
)
#ifndef va_end
void va_end (__gnuc_va_list); /* Defined in libgcc.a */
#endif
#define va_end(AP) ((void) 0)
/* Copy __gnuc_va_list into another variable of this type. */
#define __va_copy(dest, src) (dest) = (src)
#endif /* defined (_STDARG_H) || defined (_VARARGS_H) */

86
gcc/ginclude/va-m32r.h
View File

@ -1,86 +0,0 @@
/* GNU C stdarg/varargs support for the M32R */
/* Define __gnuc_va_list. */
#ifndef __GNUC_VA_LIST
#define __GNUC_VA_LIST
typedef void *__gnuc_va_list;
#endif /* not __GNUC_VA_LIST */
/* If this is for internal libc use, don't define anything but
__gnuc_va_list. */
#if defined (_STDARG_H) || defined (_VARARGS_H)
/* Common code for va_start for both varargs and stdarg. */
#define __va_rounded_size(TYPE) \
(((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))
#ifdef _STDARG_H /* stdarg.h support */
/* Calling __builtin_next_arg gives the proper error message if LASTARG is
not indeed the last argument. */
#define va_start(AP, LASTARG) \
(AP = ((__gnuc_va_list) __builtin_next_arg (LASTARG)))
#else /* varargs.h support */
#define va_alist __builtin_va_alist
/* The ... causes current_function_varargs to be set in cc1. */
#define va_dcl int __builtin_va_alist; ...
#define va_start(AP) AP=(char *) &__builtin_va_alist
#endif /* _STDARG_H */
/* Nothing needs to be done to end varargs/stdarg processing */
#define va_end(AP) ((void) 0)
/* Values returned by __builtin_classify_type. */
enum __type_class
{
__no_type_class = -1,
__void_type_class,
__integer_type_class,
__char_type_class,
__enumeral_type_class,
__boolean_type_class,
__pointer_type_class,
__reference_type_class,
__offset_type_class,
__real_type_class,
__complex_type_class,
__function_type_class,
__method_type_class,
__record_type_class,
__union_type_class,
__array_type_class,
__string_type_class,
__set_type_class,
__file_type_class,
__lang_type_class
};
/* Return whether a type is passed by reference. */
#define __va_by_reference_p(TYPE) (sizeof (TYPE) > 8)
#define va_arg(AP,TYPE) \
__extension__ (*({ \
register TYPE *__ptr; \
\
if (__va_by_reference_p (TYPE)) \
{ \
__ptr = *(TYPE **)(void *) (AP); \
(AP) = (__gnuc_va_list) ((char *) (AP) + sizeof (void *)); \
} \
else \
{ \
__ptr = (TYPE *)(void *) \
((char *) (AP) + (sizeof (TYPE) < __va_rounded_size (char) \
? __va_rounded_size (TYPE) - sizeof (TYPE) \
: 0)); \
(AP) = (__gnuc_va_list) ((char *) (AP) + __va_rounded_size (TYPE)); \
} \
\
__ptr; \
}))
#endif /* defined (_STDARG_H) || defined (_VARARGS_H) */

87
gcc/ginclude/va-m88k.h
View File

@ -1,87 +0,0 @@
/* GNU C varargs support for the Motorola 88100 */
/* Define __gnuc_va_list. */
#ifndef __GNUC_VA_LIST
#define __GNUC_VA_LIST
typedef struct
{
int __va_arg; /* argument number */
int *__va_stk; /* start of args passed on stack */
int *__va_reg; /* start of args passed in regs */
} __gnuc_va_list;
#endif /* not __GNUC_VA_LIST */
/* If this is for internal libc use, don't define anything but
__gnuc_va_list. */
#if defined (_STDARG_H) || defined (_VARARGS_H)
#ifdef _STDARG_H /* stdarg.h support */
/* Call __builtin_next_arg even though we aren't using its value, so that
we can verify that LASTARG is correct. */
#if __GNUC__ > 1 /* GCC 2.0 and beyond */
#define va_start(AP,LASTARG) \
(__builtin_next_arg (LASTARG), \
(AP) = *(__gnuc_va_list *)__builtin_saveregs())
#else
#define va_start(AP,LASTARG) \
( (AP).__va_reg = (int *) __builtin_saveregs2(0), \
(AP).__va_stk = (int *) __builtin_argptr(), \
(AP).__va_arg = (int) (__builtin_argsize() + 3) / 4 )
#endif
#else /* varargs.h support */
#if __GNUC__ > 1 /* GCC 2.0 and beyond */
#define va_start(AP) ((AP) = *(__gnuc_va_list *)__builtin_saveregs())
#else
#define va_start(AP) \
( (AP).__va_reg = (int *) __builtin_saveregs2(1), \
(AP).__va_stk = (int *) __builtin_argptr(), \
(AP).__va_arg = (int) (__builtin_argsize() - 4 + 3) / 4 )
#endif
#define va_alist __va_1st_arg
#define va_dcl register int va_alist;...
#endif /* _STDARG_H */
/* Avoid trouble between this file and _int_varargs.h under DG/UX. This file
can be included by <stdio.h> and others and provides definitions of
__va_size and __va_reg_p and a va_list typedef. Avoid defining va_list
again with _VA_LIST. */
#ifdef __INT_VARARGS_H
#undef __va_size
#undef __va_reg_p
#define __gnuc_va_list va_list
#define _VA_LIST
#define _VA_LIST_
#else
/* Similarly, if this gets included first, do nothing in _int_varargs.h. */
#define __INT_VARARGS_H
#endif
#define __va_reg_p(TYPE) \
(__builtin_classify_type(*(TYPE *)0) < 12 \
? sizeof(TYPE) <= 8 : sizeof(TYPE) == 4 && __alignof__(TYPE) == 4)
#define __va_size(TYPE) ((sizeof(TYPE) + 3) >> 2)
/* We cast to void * and then to TYPE * because this avoids
a warning about increasing the alignment requirement. */
#define va_arg(AP,TYPE) \
( (AP).__va_arg = (((AP).__va_arg + (1 << (__alignof__(TYPE) >> 3)) - 1) \
& ~((1 << (__alignof__(TYPE) >> 3)) - 1)) \
+ __va_size(TYPE), \
*((TYPE *) (void *) ((__va_reg_p(TYPE) \
&& (AP).__va_arg < 8 + __va_size(TYPE) \
? (AP).__va_reg : (AP).__va_stk) \
+ ((AP).__va_arg - __va_size(TYPE)))))
#define va_end(AP) ((void)0)
/* Copy __gnuc_va_list into another variable of this type. */
#define __va_copy(dest, src) (dest) = (src)
#endif /* defined (_STDARG_H) || defined (_VARARGS_H) */

277
gcc/ginclude/va-mips.h
View File

@ -1,277 +0,0 @@
/* ---------------------------------------- */
/* VARARGS for MIPS/GNU CC */
/* */
/* */
/* */
/* */
/* ---------------------------------------- */
/* These macros implement varargs for GNU C--either traditional or ANSI. */
/* Define __gnuc_va_list. */
#ifndef __GNUC_VA_LIST
#define __GNUC_VA_LIST
#if defined (__mips_eabi) && ! defined (__mips_soft_float) && ! defined (__mips_single_float)
typedef struct {
/* Pointer to FP regs. */
char *__fp_regs;
/* Number of FP regs remaining. */
int __fp_left;
/* Pointer to GP regs followed by stack parameters. */
char *__gp_regs;
} __gnuc_va_list;
#else /* ! (defined (__mips_eabi) && ! defined (__mips_soft_float) && ! defined (__mips_single_float)) */
typedef char * __gnuc_va_list;
#endif /* ! (defined (__mips_eabi) && ! defined (__mips_soft_float) && ! defined (__mips_single_float)) */
#endif /* not __GNUC_VA_LIST */
/* If this is for internal libc use, don't define anything but
__gnuc_va_list. */
#if defined (_STDARG_H) || defined (_VARARGS_H)
#ifndef _VA_MIPS_H_ENUM
#define _VA_MIPS_H_ENUM
enum {
__no_type_class = -1,
__void_type_class,
__integer_type_class,
__char_type_class,
__enumeral_type_class,
__boolean_type_class,
__pointer_type_class,
__reference_type_class,
__offset_type_class,
__real_type_class,
__complex_type_class,
__function_type_class,
__method_type_class,
__record_type_class,
__union_type_class,
__array_type_class,
__string_type_class,
__set_type_class,
__file_type_class,
__lang_type_class
};
#endif
/* In GCC version 2, we want an ellipsis at the end of the declaration
of the argument list. GCC version 1 can't parse it. */
#if __GNUC__ > 1
#define __va_ellipsis ...
#else
#define __va_ellipsis
#endif
#ifdef __mips64
#define __va_rounded_size(__TYPE) \
(((sizeof (__TYPE) + 8 - 1) / 8) * 8)
#else
#define __va_rounded_size(__TYPE) \
(((sizeof (__TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))
#endif
#ifdef __mips64
#define __va_reg_size 8
#else
#define __va_reg_size 4
#endif
/* Get definitions for _MIPS_SIM_ABI64 etc. */
#ifdef _MIPS_SIM
#include <sgidefs.h>
#endif
#ifdef _STDARG_H
#if defined (__mips_eabi)
#if ! defined (__mips_soft_float) && ! defined (__mips_single_float)
#ifdef __mips64
#define va_start(__AP, __LASTARG) \
(__AP.__gp_regs = ((char *) __builtin_next_arg (__LASTARG) \
- (__builtin_args_info (2) < 8 \
? (8 - __builtin_args_info (2)) * __va_reg_size \
: 0)), \
__AP.__fp_left = 8 - __builtin_args_info (3), \
__AP.__fp_regs = __AP.__gp_regs - __AP.__fp_left * __va_reg_size)
#else /* ! defined (__mips64) */
#define va_start(__AP, __LASTARG) \
(__AP.__gp_regs = ((char *) __builtin_next_arg (__LASTARG) \
- (__builtin_args_info (2) < 8 \
? (8 - __builtin_args_info (2)) * __va_reg_size \
: 0)), \
__AP.__fp_left = (8 - __builtin_args_info (3)) / 2, \
__AP.__fp_regs = __AP.__gp_regs - __AP.__fp_left * 8, \
__AP.__fp_regs = (char *) ((int) __AP.__fp_regs & -8))
#endif /* ! defined (__mips64) */
#else /* ! (! defined (__mips_soft_float) && ! defined (__mips_single_float) ) */
#define va_start(__AP, __LASTARG) \
(__AP = ((__gnuc_va_list) __builtin_next_arg (__LASTARG) \
- (__builtin_args_info (2) >= 8 ? 0 \
: (8 - __builtin_args_info (2)) * __va_reg_size)))
#endif /* ! (! defined (__mips_soft_float) && ! defined (__mips_single_float) ) */
#else /* ! defined (__mips_eabi) */
#define va_start(__AP, __LASTARG) \
(__AP = (__gnuc_va_list) __builtin_next_arg (__LASTARG))
#endif /* ! (defined (__mips_eabi) && ! defined (__mips_soft_float) && ! defined (__mips_single_float)) */
#else /* ! _STDARG_H */
#define va_alist __builtin_va_alist
#ifdef __mips64
/* This assumes that `long long int' is always a 64 bit type. */
#define va_dcl long long int __builtin_va_alist; __va_ellipsis
#else
#define va_dcl int __builtin_va_alist; __va_ellipsis
#endif
#if defined (__mips_eabi)
#if ! defined (__mips_soft_float) && ! defined (__mips_single_float)
#ifdef __mips64
#define va_start(__AP) \
(__AP.__gp_regs = ((char *) __builtin_next_arg () \
- (__builtin_args_info (2) < 8 \
? (8 - __builtin_args_info (2)) * __va_reg_size \
: __va_reg_size)), \
__AP.__fp_left = 8 - __builtin_args_info (3), \
__AP.__fp_regs = __AP.__gp_regs - __AP.__fp_left * __va_reg_size)
#else /* ! defined (__mips64) */
#define va_start(__AP) \
(__AP.__gp_regs = ((char *) __builtin_next_arg () \
- (__builtin_args_info (2) < 8 \
? (8 - __builtin_args_info (2)) * __va_reg_size \
: __va_reg_size)), \
__AP.__fp_left = (8 - __builtin_args_info (3)) / 2, \
__AP.__fp_regs = __AP.__gp_regs - __AP.__fp_left * 8, \
__AP.__fp_regs = (char *) ((int) __AP.__fp_regs & -8))
#endif /* ! defined (__mips64) */
#else /* ! (! defined (__mips_soft_float) && ! defined (__mips_single_float)) */
#define va_start(__AP) \
(__AP = ((__gnuc_va_list) __builtin_next_arg () \
- (__builtin_args_info (2) >= 8 ? __va_reg_size \
: (8 - __builtin_args_info (2)) * __va_reg_size)))
#endif /* ! (! defined (__mips_soft_float) && ! defined (__mips_single_float)) */
/* Need alternate code for _MIPS_SIM_ABI64. */
#elif defined(_MIPS_SIM) && (_MIPS_SIM == _MIPS_SIM_ABI64 || _MIPS_SIM == _MIPS_SIM_NABI32)
#define va_start(__AP) \
(__AP = (__gnuc_va_list) __builtin_next_arg () \
+ (__builtin_args_info (2) >= 8 ? -8 : 0))
#else
#define va_start(__AP) __AP = (char *) &__builtin_va_alist
#endif
#endif /* ! _STDARG_H */
#ifndef va_end
void va_end (__gnuc_va_list); /* Defined in libgcc.a */
#endif
#define va_end(__AP) ((void)0)
#if defined (__mips_eabi)
#if ! defined (__mips_soft_float) && ! defined (__mips_single_float)
#ifdef __mips64
#define __va_next_addr(__AP, __type) \
((__builtin_classify_type (*(__type *) 0) == __real_type_class \
&& __AP.__fp_left > 0) \
? (--__AP.__fp_left, (__AP.__fp_regs += 8) - 8) \
: (__AP.__gp_regs += __va_reg_size) - __va_reg_size)
#else
#define __va_next_addr(__AP, __type) \
((__builtin_classify_type (*(__type *) 0) == __real_type_class \
&& __AP.__fp_left > 0) \
? (--__AP.__fp_left, (__AP.__fp_regs += 8) - 8) \
: (((__builtin_classify_type (* (__type *) 0) < __record_type_class \
&& __alignof__ (__type) > 4) \
? __AP.__gp_regs = (char *) (((int) __AP.__gp_regs + 8 - 1) & -8) \
: (char *) 0), \
(__builtin_classify_type (* (__type *) 0) >= __record_type_class \
? (__AP.__gp_regs += __va_reg_size) - __va_reg_size \
: ((__AP.__gp_regs += __va_rounded_size (__type)) \
- __va_rounded_size (__type)))))
#endif
#else /* ! (! defined (__mips_soft_float) && ! defined (__mips_single_float)) */
#ifdef __mips64
#define __va_next_addr(__AP, __type) \
((__AP += __va_reg_size) - __va_reg_size)
#else
#define __va_next_addr(__AP, __type) \
(((__builtin_classify_type (* (__type *) 0) < __record_type_class \
&& __alignof__ (__type) > 4) \
? __AP = (char *) (((__PTRDIFF_TYPE__) __AP + 8 - 1) & -8) \
: (char *) 0), \
(__builtin_classify_type (* (__type *) 0) >= __record_type_class \
? (__AP += __va_reg_size) - __va_reg_size \
: ((__AP += __va_rounded_size (__type)) \
- __va_rounded_size (__type))))
#endif
#endif /* ! (! defined (__mips_soft_float) && ! defined (__mips_single_float)) */
#ifdef __MIPSEB__
#define va_arg(__AP, __type) \
((__va_rounded_size (__type) <= __va_reg_size) \
? *(__type *) (void *) (__va_next_addr (__AP, __type) \
+ __va_reg_size \
- sizeof (__type)) \
: (__builtin_classify_type (*(__type *) 0) >= __record_type_class \
? **(__type **) (void *) (__va_next_addr (__AP, __type) \
+ __va_reg_size \
- sizeof (char *)) \
: *(__type *) (void *) __va_next_addr (__AP, __type)))
#else
#define va_arg(__AP, __type) \
((__va_rounded_size (__type) <= __va_reg_size) \
? *(__type *) (void *) __va_next_addr (__AP, __type) \
: (__builtin_classify_type (* (__type *) 0) >= __record_type_class \
? **(__type **) (void *) __va_next_addr (__AP, __type) \
: *(__type *) (void *) __va_next_addr (__AP, __type)))
#endif
#else /* ! defined (__mips_eabi) */
/* We cast to void * and then to TYPE * because this avoids
a warning about increasing the alignment requirement. */
/* The __mips64 cases are reversed from the 32 bit cases, because the standard
32 bit calling convention left-aligns all parameters smaller than a word,
whereas the __mips64 calling convention does not (and hence they are
right aligned). */
#ifdef __mips64
#ifdef __MIPSEB__
#define va_arg(__AP, __type) \
((__type *) (void *) (__AP = (char *) \
((((__PTRDIFF_TYPE__)__AP + 8 - 1) & -8) \
+ __va_rounded_size (__type))))[-1]
#else
#define va_arg(__AP, __type) \
((__AP = (char *) ((((__PTRDIFF_TYPE__)__AP + 8 - 1) & -8) \
+ __va_rounded_size (__type))), \
*(__type *) (void *) (__AP - __va_rounded_size (__type)))
#endif
#else /* not __mips64 */
#ifdef __MIPSEB__
/* For big-endian machines. */
#define va_arg(__AP, __type) \
((__AP = (char *) ((__alignof__ (__type) > 4 \
? ((__PTRDIFF_TYPE__)__AP + 8 - 1) & -8 \
: ((__PTRDIFF_TYPE__)__AP + 4 - 1) & -4) \
+ __va_rounded_size (__type))), \
*(__type *) (void *) (__AP - __va_rounded_size (__type)))
#else
/* For little-endian machines. */
#define va_arg(__AP, __type) \
((__type *) (void *) (__AP = (char *) ((__alignof__(__type) > 4 \
? ((__PTRDIFF_TYPE__)__AP + 8 - 1) & -8 \
: ((__PTRDIFF_TYPE__)__AP + 4 - 1) & -4) \
+ __va_rounded_size(__type))))[-1]
#endif
#endif
#endif /* ! defined (__mips_eabi) */
/* Copy __gnuc_va_list into another variable of this type. */
#define __va_copy(dest, src) (dest) = (src)
#endif /* defined (_STDARG_H) || defined (_VARARGS_H) */

37
gcc/ginclude/va-mn10200.h
View File

@ -1,37 +0,0 @@
/* CYGNUS LOCAL entire file/law */
/* Define __gnuc_va_list. */
#ifndef __GNUC_VA_LIST
#define __GNUC_VA_LIST
typedef void *__gnuc_va_list;
#endif /* not __GNUC_VA_LIST */
/* If this is for internal libc use, don't define anything but
__gnuc_va_list. */
#if defined (_STDARG_H) || defined (_VARARGS_H)
#define __gnuc_va_start(AP) (AP = (__gnuc_va_list)__builtin_saveregs())
#define __va_ellipsis ...
#ifdef _STDARG_H
#define va_start(AP, LASTARG) \
(AP = ((__gnuc_va_list) __builtin_next_arg (LASTARG)))
#else
#define va_alist __builtin_va_alist
#define va_dcl int __builtin_va_alist; __va_ellipsis
#define va_start(AP) AP=(char *) &__builtin_va_alist
#endif
/* Now stuff common to both varargs & stdarg implementations. */
#define __va_rounded_size(TYPE) \
(((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))
#undef va_end
void va_end (__gnuc_va_list);
#define va_end(AP) ((void)0)
#define va_arg(AP, TYPE) \
(sizeof (TYPE) > 8 \
? (AP = (__gnuc_va_list) ((char *) (AP) + __va_rounded_size (char *)),\
**((TYPE **) (void *) ((char *) (AP) - __va_rounded_size (char *))))\
: (AP = (__gnuc_va_list) ((char *) (AP) + __va_rounded_size (TYPE)), \
*((TYPE *) (void *) ((char *) (AP) - __va_rounded_size (TYPE)))))
#endif
/* END CYGNUS LOCAL */

35
gcc/ginclude/va-mn10300.h
View File

@ -1,35 +0,0 @@
/* Define __gnuc_va_list. */
#ifndef __GNUC_VA_LIST
#define __GNUC_VA_LIST
typedef void *__gnuc_va_list;
#endif /* not __GNUC_VA_LIST */
/* If this is for internal libc use, don't define anything but
__gnuc_va_list. */
#if defined (_STDARG_H) || defined (_VARARGS_H)
#define __gnuc_va_start(AP) (AP = (__gnuc_va_list)__builtin_saveregs())
#define __va_ellipsis ...
#ifdef _STDARG_H
#define va_start(AP, LASTARG) \
(__builtin_next_arg (LASTARG), __gnuc_va_start (AP))
#else
#define va_alist __builtin_va_alist
#define va_dcl int __builtin_va_alist; __va_ellipsis
#define va_start(AP) AP=(char *) &__builtin_va_alist
#endif
/* Now stuff common to both varargs & stdarg implementations. */
#define __va_rounded_size(TYPE) \
(((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))
#undef va_end
void va_end (__gnuc_va_list);
#define va_end(AP) ((void)0)
#define va_arg(AP, TYPE) \
(sizeof (TYPE) > 8 \
? (AP = (__gnuc_va_list) ((char *) (AP) + __va_rounded_size (char *)),\
**((TYPE **) (void *) ((char *) (AP) - __va_rounded_size (char *))))\
: (AP = (__gnuc_va_list) ((char *) (AP) + __va_rounded_size (TYPE)), \
*((TYPE *) (void *) ((char *) (AP) - __va_rounded_size (TYPE)))))
#endif

52
gcc/ginclude/va-pa.h
View File

@ -1,52 +0,0 @@
/* Define __gnuc_va_list. */
#ifndef __GNUC_VA_LIST
#define __GNUC_VA_LIST
typedef void *__gnuc_va_list;
#endif /* not __GNUC_VA_LIST */
/* If this is for internal libc use, don't define anything but
__gnuc_va_list. */
#if defined (_STDARG_H) || defined (_VARARGS_H)
#if __GNUC__ > 1
#define __va_ellipsis ...
#define __gnuc_va_start(AP) ((AP) = (va_list)__builtin_saveregs())
#else
#define va_alist __va_a__, __va_b__, __va_c__, __va_d__
#define __va_ellipsis
#define __gnuc_va_start(AP)\
(AP) = (double *) &__va_a__, &__va_b__, &__va_c__, &__va_d__, \
(AP) = (double *)((char *)(AP) + 4)
#endif /* __GNUC__ > 1 */
/* Call __builtin_next_arg even though we aren't using its value, so that
we can verify that LASTARG is correct. */
#ifdef _STDARG_H
#define va_start(AP,LASTARG) \
(__builtin_next_arg (LASTARG), __gnuc_va_start (AP))
#else
/* The ... causes current_function_varargs to be set in cc1. */
#define va_dcl long va_alist; __va_ellipsis
#define va_start(AP) __gnuc_va_start (AP)
#endif
#define va_arg(AP,TYPE) \
(*(sizeof(TYPE) > 8 ? \
((AP = (__gnuc_va_list) ((char *)AP - sizeof (int))), \
(((TYPE *) (void *) (*((int *) (AP)))))) \
:((AP = \
(__gnuc_va_list) ((long)((char *)AP - sizeof (TYPE)) \
& (sizeof(TYPE) > 4 ? ~0x7 : ~0x3))), \
(((TYPE *) (void *) ((char *)AP + ((8 - sizeof(TYPE)) % 4)))))))
#ifndef va_end
void va_end (__gnuc_va_list); /* Defined in libgcc.a */
#endif
#define va_end(AP) ((void)0)
/* Copy __gnuc_va_list into another variable of this type. */
#define __va_copy(dest, src) (dest) = (src)
#endif /* defined (_STDARG_H) || defined (_VARARGS_H) */

230
gcc/ginclude/va-ppc.h
View File

@ -1,230 +0,0 @@
/* GNU C varargs support for the PowerPC with either the V.4 or Windows NT calling sequences */
#ifndef _WIN32
/* System V.4 support */
/* Define __gnuc_va_list. */
#ifndef __GNUC_VA_LIST
#define __GNUC_VA_LIST
#ifndef _SYS_VA_LIST_H
#define _SYS_VA_LIST_H /* Solaris sys/va_list.h */
/* Solaris decided to rename overflow_arg_area to input_arg_area,
so handle it via a macro. */
#define __va_overflow(AP) (AP)->overflow_arg_area
/* Note that the names in this structure are in the user's namespace, but
that the V.4 abi explicitly states that these names should be used. */
typedef struct __va_list_tag {
char gpr; /* index into the array of 8 GPRs stored in the
register save area gpr=0 corresponds to r3,
gpr=1 to r4, etc. */
char fpr; /* index into the array of 8 FPRs stored in the
register save area fpr=0 corresponds to f1,
fpr=1 to f2, etc. */
char *overflow_arg_area; /* location on stack that holds the next
overflow argument */
char *reg_save_area; /* where r3:r10 and f1:f8, if saved are stored */
} __va_list[1], __gnuc_va_list[1];
#else /* _SYS_VA_LIST */
typedef __va_list __gnuc_va_list;
#define __va_overflow(AP) (AP)->input_arg_area
#endif /* not _SYS_VA_LIST */
#endif /* not __GNUC_VA_LIST */
/* If this is for internal libc use, don't define anything but
__gnuc_va_list. */
#if defined (_STDARG_H) || defined (_VARARGS_H)
/* Register save area located below the frame pointer */
#ifndef __VA_PPC_H__
#define __VA_PPC_H__
typedef struct {
long __gp_save[8]; /* save area for GP registers */
double __fp_save[8]; /* save area for FP registers */
} __va_regsave_t;
/* Macros to access the register save area */
/* We cast to void * and then to TYPE * because this avoids
a warning about increasing the alignment requirement. */
#define __VA_FP_REGSAVE(AP,TYPE) \
((TYPE *) (void *) (&(((__va_regsave_t *) \
(AP)->reg_save_area)->__fp_save[(int)(AP)->fpr])))
#define __VA_GP_REGSAVE(AP,TYPE) \
((TYPE *) (void *) (&(((__va_regsave_t *) \
(AP)->reg_save_area)->__gp_save[(int)(AP)->gpr])))
/* Common code for va_start for both varargs and stdarg. This depends
on the format of rs6000_args in rs6000.h. The fields used are:
#0 WORDS # words used for GP regs/stack values
#1 FREGNO next available FP register
#2 NARGS_PROTOTYPE # args left in the current prototype
#3 ORIG_NARGS original value of NARGS_PROTOTYPE
#4 VARARGS_OFFSET offset from frame pointer of varargs area */
#define __va_words __builtin_args_info (0)
#define __va_fregno __builtin_args_info (1)
#define __va_nargs __builtin_args_info (2)
#define __va_orig_nargs __builtin_args_info (3)
#define __va_varargs_offset __builtin_args_info (4)
#define __va_start_common(AP, FAKE) \
__extension__ ({ \
register int __words = __va_words - FAKE; \
\
(AP)->gpr = (__words < 8) ? __words : 8; \
(AP)->fpr = __va_fregno - 33; \
(AP)->reg_save_area = (((char *) __builtin_frame_address (0)) \
+ __va_varargs_offset); \
__va_overflow(AP) = ((char *)__builtin_saveregs () \
+ (((__words >= 8) ? __words - 8 : 0) \
* sizeof (long))); \
(void)0; \
})
#ifdef _STDARG_H /* stdarg.h support */
/* Calling __builtin_next_arg gives the proper error message if LASTARG is
not indeed the last argument. */
#define va_start(AP,LASTARG) \
(__builtin_next_arg (LASTARG), __va_start_common (AP, 0))
#else /* varargs.h support */
#define va_start(AP) __va_start_common (AP, 1)
#define va_alist __va_1st_arg
#define va_dcl register int va_alist; ...
#endif /* _STDARG_H */
#ifdef _SOFT_FLOAT
#define __va_float_p(TYPE) 0
#else
#define __va_float_p(TYPE) (__builtin_classify_type(*(TYPE *)0) == 8)
#endif
#define __va_longlong_p(TYPE) \
((__builtin_classify_type(*(TYPE *)0) == 1) && (sizeof(TYPE) == 8))
#define __va_aggregate_p(TYPE) (__builtin_classify_type(*(TYPE *)0) >= 12)
#define __va_size(TYPE) ((sizeof(TYPE) + sizeof (long) - 1) / sizeof (long))
#define va_arg(AP,TYPE) \
__extension__ (*({ \
register TYPE *__ptr; \
\
if (__va_float_p (TYPE) && (AP)->fpr < 8) \
{ \
__ptr = __VA_FP_REGSAVE (AP, TYPE); \
(AP)->fpr++; \
} \
\
else if (__va_aggregate_p (TYPE) && (AP)->gpr < 8) \
{ \
__ptr = * __VA_GP_REGSAVE (AP, TYPE *); \
(AP)->gpr++; \
} \
\
else if (!__va_float_p (TYPE) && !__va_aggregate_p (TYPE) \
&& (AP)->gpr + __va_size(TYPE) <= 8 \
&& (!__va_longlong_p(TYPE) \
|| (AP)->gpr + __va_size(TYPE) <= 8)) \
{ \
if (__va_longlong_p(TYPE) && ((AP)->gpr & 1) != 0) \
(AP)->gpr++; \
\
__ptr = __VA_GP_REGSAVE (AP, TYPE); \
(AP)->gpr += __va_size (TYPE); \
} \
\
else if (!__va_float_p (TYPE) && !__va_aggregate_p (TYPE) \
&& (AP)->gpr < 8) \
{ \
(AP)->gpr = 8; \
__ptr = (TYPE *) (void *) (__va_overflow(AP)); \
__va_overflow(AP) += __va_size (TYPE) * sizeof (long); \
} \
\
else if (__va_aggregate_p (TYPE)) \
{ \
__ptr = * (TYPE **) (void *) (__va_overflow(AP)); \
__va_overflow(AP) += sizeof (TYPE *); \
} \
else \
{ \
__ptr = (TYPE *) (void *) (__va_overflow(AP)); \
__va_overflow(AP) += __va_size (TYPE) * sizeof (long); \
} \
\
__ptr; \
}))
#define va_end(AP) ((void)0)
/* Copy __gnuc_va_list into another variable of this type. */
#define __va_copy(dest, src) *(dest) = *(src)
#endif /* __VA_PPC_H__ */
#endif /* defined (_STDARG_H) || defined (_VARARGS_H) */
#else
/* Windows NT */
/* Define __gnuc_va_list. */
#ifndef __GNUC_VA_LIST
#define __GNUC_VA_LIST
typedef char *__gnuc_va_list;
#endif /* not __GNUC_VA_LIST */
/* If this is for internal libc use, don't define anything but
__gnuc_va_list. */
#if defined (_STDARG_H) || defined (_VARARGS_H)
#define __va_start_common(AP, LASTARG, FAKE) \
((__builtin_saveregs ()), ((AP) = ((char *) &LASTARG) + __va_rounded_size (AP)), 0)
#ifdef _STDARG_H /* stdarg.h support */
/* Calling __builtin_next_arg gives the proper error message if LASTARG is
not indeed the last argument. */
#define va_start(AP,LASTARG) \
(__builtin_saveregs (), \
(AP) = __builtin_next_arg (LASTARG), \
0)
#else /* varargs.h support */
#define va_start(AP) \
(__builtin_saveregs (), \
(AP) = __builtin_next_arg (__va_1st_arg) - sizeof (int), \
0)
#define va_alist __va_1st_arg
#define va_dcl register int __va_1st_arg; ...
#endif /* _STDARG_H */
#define __va_rounded_size(TYPE) ((sizeof (TYPE) + 3) & ~3)
#define __va_align(AP, TYPE) \
((((unsigned long)(AP)) + ((sizeof (TYPE) >= 8) ? 7 : 3)) \
& ~((sizeof (TYPE) >= 8) ? 7 : 3))
#define va_arg(AP,TYPE) \
( *(TYPE *)((AP = (char *) (__va_align(AP, TYPE) \
+ __va_rounded_size(TYPE))) \
- __va_rounded_size(TYPE)))
#define va_end(AP) ((void)0)
/* Copy __gnuc_va_list into another variable of this type. */
#define __va_copy(dest, src) (dest) = (src)
#endif /* defined (_STDARG_H) || defined (_VARARGS_H) */
#endif /* Windows NT */

130
gcc/ginclude/va-pyr.h
View File

@ -1,130 +0,0 @@
/**
*
* Varargs for PYR/GNU CC
*
* WARNING -- WARNING -- DANGER
*
* The code in this file implements varargs for gcc on a pyr in
* a way that is compatible with code compiled by the Pyramid Technology
* C compiler.
* As such, it depends strongly on the Pyramid conventions for
* parameter passing.ct and independent implementation.
* These (somewhat bizarre) parameter-passing conventions are described
* in the ``OSx Operating System Porting Guide''.
*
* A quick summary is useful:
* 12 of the 48 register-windowed regs available for
* parameter passing. Parameters of a function call that are eligible
* to be passed in registers are assigned registers from TR0/PR0 onwards;
* all other arguments are passed on the stack.
* Structure and union parameters are *never* passed in registers,
* even if they are small enough to fit. They are always passed on
* the stack.
*
* Double-sized parameters cannot be passed in TR11, because
* TR12 is not used for passing parameters. If, in the absence of this
* rule, a double-sized param would have been passed in TR11,
* that parameter is passed on the stack and no parameters are
* passed in TR11.
*
* It is only known to work for passing 32-bit integer quantities
* (ie chars, shorts, ints/enums, longs), doubles, or pointers.
* Passing structures on a Pyramid via varargs is a loser.
* Passing an object larger than 8 bytes on a pyramid via varargs may
* also be a loser.
*
*/
/*
* pointer to next stack parameter in __va_buf[0]
* pointer to next parameter register in __va_buf[1]
* Count of registers seen at __va_buf[2]
* saved pr0..pr11 in __va_buf[3..14]
* # of calls to va_arg (debugging) at __va_buf[15]
*/
/* Define __gnuc_va_list. */
#ifndef __GNUC_VA_LIST
#define __GNUC_VA_LIST
typedef void *__voidptr;
#if 1
typedef struct __va_regs {
__voidptr __stackp,__regp,__count;
__voidptr __pr0,__pr1,__pr2,__pr3,__pr4,__pr5,__pr6,__pr7,__pr8,__pr9,__pr10,__pr11;
} __va_regs;
typedef __va_regs __va_buf;
#else
/* __va_buf[0] = address of next arg passed on the stack
__va_buf[1] = address of next arg passed in a register
__va_buf[2] = register-# of next arg passed in a register
*/
typedef __voidptr(*__va_buf);
#endif
typedef __va_buf __gnuc_va_list;
#endif /* not __GNUC_VA_LIST */
/* If this is for internal libc use, don't define anything but
__gnuc_va_list. */
#if defined (_STDARG_H) || defined (_VARARGS_H)
/* In GCC version 2, we want an ellipsis at the end of the declaration
of the argument list. GCC version 1 can't parse it. */
#if __GNUC__ > 1
#define __va_ellipsis ...
#else
#define __va_ellipsis
#endif
#define va_alist \
__va0,__va1,__va2,__va3,__va4,__va5,__va6,__va7,__va8,__va9,__va10,__va11, \
__builtin_va_alist
/* The ... causes current_function_varargs to be set in cc1. */
#define va_dcl __voidptr va_alist; __va_ellipsis
/* __asm ("rcsp %0" : "=r" ( _AP [0]));*/
#define va_start(_AP) \
_AP = ((struct __va_regs) { \
&(_AP.__pr0), (void*)&__builtin_va_alist, (void*)0, \
__va0,__va1,__va2,__va3,__va4,__va5, \
__va6,__va7,__va8,__va9,__va10,__va11})
/* Avoid errors if compiling GCC v2 with GCC v1. */
#if __GNUC__ == 1
#define __extension__
#endif
/* We cast to void * and then to TYPE * because this avoids
a warning about increasing the alignment requirement. */
#define va_arg(_AP, _MODE) \
__extension__ \
(*({__voidptr *__ap = (__voidptr*)&_AP; \
register int __size = sizeof (_MODE); \
register int __onstack = \
(__size > 8 || ( (int)(__ap[2]) > 11) || \
(__size==8 && (int)(__ap[2])==11)); \
register int* __param_addr = ((int*)((__ap) [__onstack])); \
\
((void *)__ap[__onstack])+=__size; \
if (__onstack==0 || (int)(__ap[2])==11) \
__ap[2]+= (__size >> 2); \
(( _MODE *) (void *) __param_addr); \
}))
void va_end (__gnuc_va_list); /* Defined in libgcc.a */
#define va_end(_X) ((void)0)
#endif /* defined (_STDARG_H) || defined (_VARARGS_H) */

226
gcc/ginclude/va-sh.h
View File

@ -1,226 +0,0 @@
/* This is just like the default gvarargs.h
except for differences described below. */
/* Define __gnuc_va_list. */
#ifndef __GNUC_VA_LIST
#define __GNUC_VA_LIST
#if defined (__SH3E__) || defined (__SH4_SINGLE__) || defined (__SH4__) || defined (__SH4_SINGLE_ONLY__)
typedef long __va_greg;
typedef float __va_freg;
typedef struct {
__va_greg * __va_next_o; /* next available register */
__va_greg * __va_next_o_limit; /* past last available register */
__va_freg * __va_next_fp; /* next available fp register */
__va_freg * __va_next_fp_limit; /* last available fp register */
__va_greg * __va_next_stack; /* next extended word on stack */
} __gnuc_va_list;
#else /* ! SH3E */
typedef void *__gnuc_va_list;
#endif /* ! SH3E */
#endif /* __GNUC_VA_LIST */
/* If this is for internal libc use, don't define anything but
__gnuc_va_list. */
#if defined (_STDARG_H) || defined (_VARARGS_H)
#ifdef _STDARG_H
#if defined (__SH3E__) || defined (__SH4_SINGLE__) || defined (__SH4__) || defined (__SH4_SINGLE_ONLY__)
#define va_start(AP, LASTARG) \
__extension__ \
({ \
(AP).__va_next_fp = (__va_freg *) __builtin_saveregs (); \
(AP).__va_next_fp_limit = ((AP).__va_next_fp + \
(__builtin_args_info (1) < 8 ? 8 - __builtin_args_info (1) : 0)); \
(AP).__va_next_o = (__va_greg *) (AP).__va_next_fp_limit; \
(AP).__va_next_o_limit = ((AP).__va_next_o + \
(__builtin_args_info (0) < 4 ? 4 - __builtin_args_info (0) : 0)); \
(AP).__va_next_stack = (__va_greg *) __builtin_next_arg (LASTARG); \
})
#else /* ! SH3E */
#define va_start(AP, LASTARG) \
((AP) = ((__gnuc_va_list) __builtin_next_arg (LASTARG)))
#endif /* ! SH3E */
#else /* _VARARGS_H */
#define va_alist __builtin_va_alist
#define va_dcl int __builtin_va_alist;...
#if defined (__SH3E__) || defined (__SH4_SINGLE__) || defined (__SH4__) || defined (__SH4_SINGLE_ONLY__)
#define va_start(AP) \
__extension__ \
({ \
(AP).__va_next_fp = (__va_freg *) __builtin_saveregs (); \
(AP).__va_next_fp_limit = ((AP).__va_next_fp + \
(__builtin_args_info (1) < 8 ? 8 - __builtin_args_info (1) : 0)); \
(AP).__va_next_o = (__va_greg *) (AP).__va_next_fp_limit; \
(AP).__va_next_o_limit = ((AP).__va_next_o + \
(__builtin_args_info (0) < 4 ? 4 - __builtin_args_info (0) : 0)); \
(AP).__va_next_stack \
= ((__va_greg *) __builtin_next_arg (__builtin_va_alist) \
- (__builtin_args_info (0) >= 4 || __builtin_args_info (1) >= 8 \
? 1 : 0)); \
})
#else /* ! SH3E */
#define va_start(AP) ((AP) = (char *) &__builtin_va_alist)
#endif /* ! SH3E */
#endif /* _STDARG */
#ifndef va_end
void va_end (__gnuc_va_list); /* Defined in libgcc.a */
/* Values returned by __builtin_classify_type. */
enum __va_type_classes {
__no_type_class = -1,
__void_type_class,
__integer_type_class,
__char_type_class,
__enumeral_type_class,
__boolean_type_class,
__pointer_type_class,
__reference_type_class,
__offset_type_class,
__real_type_class,
__complex_type_class,
__function_type_class,
__method_type_class,
__record_type_class,
__union_type_class,
__array_type_class,
__string_type_class,
__set_type_class,
__file_type_class,
__lang_type_class
};
#endif
#define va_end(pvar) ((void)0)
#ifdef __LITTLE_ENDIAN__
#define __LITTLE_ENDIAN_P 1
#else
#define __LITTLE_ENDIAN_P 0
#endif
#define __SCALAR_TYPE(TYPE) \
((TYPE) == __integer_type_class \
|| (TYPE) == __char_type_class \
|| (TYPE) == __enumeral_type_class)
/* RECORD_TYPE args passed using the C calling convention are
passed by invisible reference. ??? RECORD_TYPE args passed
in the stack are made to be word-aligned; for an aggregate that is
not word-aligned, we advance the pointer to the first non-reg slot. */
/* When this is a smaller-than-int integer, using
auto-increment in the promoted (SImode) is fastest;
however, there is no way to express that is C. Therefore,
we use an asm.
We want the MEM_IN_STRUCT_P bit set in the emitted RTL, therefore we
use unions even when it would otherwise be unnecessary. */
/* gcc has an extension that allows to use a casted lvalue as an lvalue,
But it doesn't work in C++ with -pedantic - even in the presence of
__extension__ . We work around this problem by using a reference type. */
#ifdef __cplusplus
#define __VA_REF &
#else
#define __VA_REF
#endif
#define __va_arg_sh1(AP, TYPE) __extension__ \
({(sizeof (TYPE) == 1 \
? ({union {TYPE t; char c;} __t; \
__asm("" \
: "=r" (__t.c) \
: "0" ((((union { int i, j; } *__VA_REF) (AP))++)->i)); \
__t.t;}) \
: sizeof (TYPE) == 2 \
? ({union {TYPE t; short s;} __t; \
__asm("" \
: "=r" (__t.s) \
: "0" ((((union { int i, j; } *__VA_REF) (AP))++)->i)); \
__t.t;}) \
: sizeof (TYPE) >= 4 || __LITTLE_ENDIAN_P \
? (((union { TYPE t; int i;} *__VA_REF) (AP))++)->t \
: ((union {TYPE t;TYPE u;}*) ((char *)++(int *__VA_REF)(AP) - sizeof (TYPE)))->t);})
#if defined (__SH3E__) || defined (__SH4_SINGLE__) || defined (__SH4__) || defined (__SH4_SINGLE_ONLY__)
#define __PASS_AS_FLOAT(TYPE_CLASS,SIZE) \
(TYPE_CLASS == __real_type_class && SIZE == 4)
#define __TARGET_SH4_P 0
#if defined(__SH4__) || defined(__SH4_SINGLE__)
#undef __PASS_AS_FLOAT
#define __PASS_AS_FLOAT(TYPE_CLASS,SIZE) \
(TYPE_CLASS == __real_type_class && SIZE <= 8 \
|| TYPE_CLASS == __complex_type_class && SIZE <= 16)
#undef __TARGET_SH4_P
#define __TARGET_SH4_P 1
#endif
#define va_arg(pvar,TYPE) \
__extension__ \
({int __type = __builtin_classify_type (* (TYPE *) 0); \
void * __result_p; \
if (__PASS_AS_FLOAT (__type, sizeof(TYPE))) \
{ \
if ((pvar).__va_next_fp < (pvar).__va_next_fp_limit) \
{ \
if (((__type == __real_type_class && sizeof (TYPE) > 4)\
|| sizeof (TYPE) > 8) \
&& (((int) (pvar).__va_next_fp ^ (int) (pvar).__va_next_fp_limit)\
& 4)) \
(pvar).__va_next_fp++; \
__result_p = &(pvar).__va_next_fp; \
} \
else \
__result_p = &(pvar).__va_next_stack; \
} \
else \
{ \
if ((pvar).__va_next_o + ((sizeof (TYPE) + 3) / 4) \
<= (pvar).__va_next_o_limit) \
__result_p = &(pvar).__va_next_o; \
else \
{ \
if (sizeof (TYPE) > 4) \
if (! __TARGET_SH4_P) \
(pvar).__va_next_o = (pvar).__va_next_o_limit; \
\
__result_p = &(pvar).__va_next_stack; \
} \
} \
__va_arg_sh1(*(void **)__result_p, TYPE);})
#else /* ! SH3E */
#define va_arg(AP, TYPE) __va_arg_sh1((AP), TYPE)
#endif /* SH3E */
/* Copy __gnuc_va_list into another variable of this type. */
#define __va_copy(dest, src) ((dest) = (src))
#endif /* defined (_STDARG_H) || defined (_VARARGS_H) */

165
gcc/ginclude/va-sparc.h
View File

@ -1,165 +0,0 @@
/* This is just like the default gvarargs.h
except for differences described below. */
/* Define __gnuc_va_list. */
#ifndef __GNUC_VA_LIST
#define __GNUC_VA_LIST
#if ! defined (__svr4__) && ! defined (__linux__) && ! defined (__arch64__)
/* This has to be a char * to be compatible with Sun.
i.e., we have to pass a `va_list' to vsprintf. */
typedef char * __gnuc_va_list;
#else
/* This has to be a void * to be compatible with Sun svr4.
i.e., we have to pass a `va_list' to vsprintf. */
typedef void * __gnuc_va_list;
#endif
#endif /* not __GNUC_VA_LIST */
/* If this is for internal libc use, don't define anything but
__gnuc_va_list. */
#if defined (_STDARG_H) || defined (_VARARGS_H)
#ifdef _STDARG_H
/* Call __builtin_next_arg even though we aren't using its value, so that
we can verify that LASTARG is correct. */
#if defined (__GCC_NEW_VARARGS__) || defined (__arch64__)
#define va_start(AP, LASTARG) \
(__builtin_next_arg (LASTARG), AP = (char *) __builtin_saveregs ())
#else
#define va_start(AP, LASTARG) \
(__builtin_saveregs (), AP = ((char *) __builtin_next_arg (LASTARG)))
#endif
#else
#define va_alist __builtin_va_alist
#define va_dcl int __builtin_va_alist;...
#if defined (__GCC_NEW_VARARGS__) || defined (__arch64__)
#define va_start(AP) ((AP) = (char *) __builtin_saveregs ())
#else
#define va_start(AP) \
(__builtin_saveregs (), (AP) = ((char *) &__builtin_va_alist))
#endif
#endif
#ifndef va_end
void va_end (__gnuc_va_list); /* Defined in libgcc.a */
/* Values returned by __builtin_classify_type. */
enum __va_type_classes {
__no_type_class = -1,
__void_type_class,
__integer_type_class,
__char_type_class,
__enumeral_type_class,
__boolean_type_class,
__pointer_type_class,
__reference_type_class,
__offset_type_class,
__real_type_class,
__complex_type_class,
__function_type_class,
__method_type_class,
__record_type_class,
__union_type_class,
__array_type_class,
__string_type_class,
__set_type_class,
__file_type_class,
__lang_type_class
};
#endif
#define va_end(pvar) ((void)0)
/* Avoid errors if compiling GCC v2 with GCC v1. */
#if __GNUC__ == 1
#define __extension__
#endif
/* RECORD_TYPE args passed using the C calling convention are
passed by invisible reference. ??? RECORD_TYPE args passed
in the stack are made to be word-aligned; for an aggregate that is
not word-aligned, we advance the pointer to the first non-reg slot. */
#ifdef __arch64__
typedef unsigned int __ptrint __attribute__ ((__mode__ (__DI__)));
/* ??? TODO: little endian support */
#define va_arg(pvar, TYPE) \
__extension__ \
(*({int __type = __builtin_classify_type (* (TYPE *) 0); \
char * __result; \
if (__type == __real_type_class) /* float? */ \
{ \
if (__alignof__ (TYPE) == 16) \
(pvar) = (void *) (((__ptrint) (pvar) + 15) & -16); \
__result = (pvar); \
(pvar) = (char *) (pvar) + sizeof (TYPE); \
} \
else if (__type < __record_type_class) /* integer? */ \
{ \
(pvar) = (char *) (pvar) + 8; \
__result = (char *) (pvar) - sizeof (TYPE); \
} \
else /* aggregate object */ \
{ \
if (sizeof (TYPE) <= 8) \
{ \
__result = (pvar); \
(pvar) = (char *) (pvar) + 8; \
} \
else if (sizeof (TYPE) <= 16) \
{ \
if (__alignof__ (TYPE) == 16) \
(pvar) = (void *) (((__ptrint) (pvar) + 15) & -16); \
__result = (pvar); \
(pvar) = (char *) (pvar) + 16; \
} \
else \
{ \
__result = * (void **) (pvar); \
(pvar) = (char *) (pvar) + 8; \
} \
} \
(TYPE *) __result;}))
#else /* not __arch64__ */
#define __va_rounded_size(TYPE) \
(((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))
/* We don't declare the union member `d' to have type TYPE
because that would lose in C++ if TYPE has a constructor. */
/* We cast to void * and then to TYPE * because this avoids
a warning about increasing the alignment requirement.
The casts to char * avoid warnings about invalid pointer arithmetic. */
#define va_arg(pvar,TYPE) \
__extension__ \
(*({((__builtin_classify_type (*(TYPE*) 0) >= __record_type_class \
|| (__builtin_classify_type (*(TYPE*) 0) == __real_type_class \
&& sizeof (TYPE) == 16)) \
? ((pvar) = (char *)(pvar) + __va_rounded_size (TYPE *), \
*(TYPE **) (void *) ((char *)(pvar) - __va_rounded_size (TYPE *))) \
: __va_rounded_size (TYPE) == 8 \
? ({ union {char __d[sizeof (TYPE)]; int __i[2];} __u; \
__u.__i[0] = ((int *) (void *) (pvar))[0]; \
__u.__i[1] = ((int *) (void *) (pvar))[1]; \
(pvar) = (char *)(pvar) + 8; \
(TYPE *) (void *) __u.__d; }) \
: ((pvar) = (char *)(pvar) + __va_rounded_size (TYPE), \
((TYPE *) (void *) ((char *)(pvar) - __va_rounded_size (TYPE)))));}))
#endif /* not __arch64__ */
/* Copy __gnuc_va_list into another variable of this type. */
#define __va_copy(dest, src) (dest) = (src)
#endif /* defined (_STDARG_H) || defined (_VARARGS_H) */

64
gcc/ginclude/va-spur.h
View File

@ -1,64 +0,0 @@
/* varargs.h for SPUR */
/* NB. This is NOT the definition needed for the new ANSI proposed
standard */
struct __va_struct { char __regs[20]; };
#define va_alist __va_regs, __va_stack
/* In GCC version 2, we want an ellipsis at the end of the declaration
of the argument list. GCC version 1 can't parse it. */
#if __GNUC__ > 1
#define __va_ellipsis ...
#else
#define __va_ellipsis
#endif
/* The ... causes current_function_varargs to be set in cc1. */
#define va_dcl struct __va_struct __va_regs; int __va_stack;
typedef struct {
int __pnt;
char *__regs;
char *__stack;
} va_list;
#define va_start(pvar) \
((pvar).__pnt = 0, (pvar).__regs = __va_regs.__regs, \
(pvar).__stack = (char *) &__va_stack)
#define va_end(pvar) ((void)0)
/* Avoid errors if compiling GCC v2 with GCC v1. */
#if __GNUC__ == 1
#define __extension__
#endif
#define va_arg(pvar,type) \
__extension__ \
(*({ type *__va_result; \
if ((pvar).__pnt >= 20) { \
__va_result = ( (type *) ((pvar).__stack + (pvar).__pnt - 20)); \
(pvar).__pnt += (sizeof(type) + 7) & ~7; \
} \
else if ((pvar).__pnt + sizeof(type) > 20) { \
__va_result = (type *) (pvar).__stack; \
(pvar).__pnt = 20 + ( (sizeof(type) + 7) & ~7); \
} \
else if (sizeof(type) == 8) { \
union {double d; int i[2];} __u; \
__u.i[0] = *(int *) ((pvar).__regs + (pvar).__pnt); \
__u.i[1] = *(int *) ((pvar).__regs + (pvar).__pnt + 4); \
__va_result = (type *) &__u; \
(pvar).__pnt += 8; \
} \
else { \
__va_result = (type *) ((pvar).__regs + (pvar).__pnt); \
(pvar).__pnt += (sizeof(type) + 3) & ~3; \
} \
__va_result; }))
/* Copy __gnuc_va_list into another variable of this type. */
#define __va_copy(dest, src) (dest) = (src)

34
gcc/ginclude/va-v850.h
View File

@ -1,34 +0,0 @@
/* Define __gnuc_va_list. */
#ifndef __GNUC_VA_LIST
#define __GNUC_VA_LIST
typedef void *__gnuc_va_list;
#endif /* not __GNUC_VA_LIST */
/* If this is for internal libc use, don't define anything but
__gnuc_va_list. */
#if defined (_STDARG_H) || defined (_VARARGS_H)
#ifdef _STDARG_H
#define va_start(AP, LASTARG) \
(AP = ((__gnuc_va_list) __builtin_next_arg (LASTARG)))
#else
#define __va_ellipsis ...
#define va_alist __builtin_va_alist
#define va_dcl int __builtin_va_alist; __va_ellipsis
#define va_start(AP) AP=(char *) &__builtin_va_alist
#endif
/* Now stuff common to both varargs & stdarg implementations. */
#define __va_rounded_size(TYPE) \
(((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))
#undef va_end
void va_end (__gnuc_va_list);
#define va_end(AP) ((void)0)
#define va_arg(AP, TYPE) \
(sizeof (TYPE) > 8 \
? (AP = (__gnuc_va_list) ((char *) (AP) + __va_rounded_size (char *)),\
**((TYPE **) (void *) ((char *) (AP) - __va_rounded_size (char *))))\
: (AP = (__gnuc_va_list) ((char *) (AP) + __va_rounded_size (TYPE)), \
*((TYPE *) (void *) ((char *) (AP) - __va_rounded_size (TYPE)))))
#endif

260
gcc/ginclude/varargs.h
View File

@ -1,260 +0,0 @@
/* Record that this is varargs.h; this turns off stdarg.h. */
#ifndef _VARARGS_H
#define _VARARGS_H
#ifdef __sparc__
#include "va-sparc.h"
#else
#ifdef __spur__
#include "va-spur.h"
#else
#ifdef __mips__
#include "va-mips.h"
#else
#ifdef __i860__
#include "va-i860.h"
#else
#ifdef __pyr__
#include "va-pyr.h"
#else
#ifdef __clipper__
#include "va-clipper.h"
#else
#ifdef __m88k__
#include "va-m88k.h"
#else
#if defined(__hppa__) || defined(hp800)
#include "va-pa.h"
#else
#ifdef __i960__
#include "va-i960.h"
#else
#ifdef __alpha__
#include "va-alpha.h"
#else
#if defined (__H8300__) || defined (__H8300H__) || defined (__H8300S__)
#include "va-h8300.h"
#else
#if defined (__PPC__) && (defined (_CALL_SYSV) || defined (_WIN32))
#include "va-ppc.h"
#else
#ifdef __arc__
#include "va-arc.h"
#else
/* CYGNUS LOCAL -- meissner/d10v */
#ifdef __D10V__
#include "va-d10v.h"
#else
/* END CYGNUS LOCAL -- meissner/d10v */
#ifdef __M32R__
#include "va-m32r.h"
#else
#ifdef __sh__
#include "va-sh.h"
#else
#ifdef __mn10300__
#include "va-mn10300.h"
#else
#ifdef __mn10200__
#include "va-mn10200.h"
#else
#ifdef __v850__
#include "va-v850.h"
#else
/* CYGNUS LOCAL v850e */
#ifdef __v850e__
#include "va-v850.h"
#else
#ifdef __v850ea__
#include "va-v850.h"
#else
/* END CYGNUS LOCAL */
/* CYGNUS LOCAL d30v */
#ifdef __D30V__
#include "va-d30v.h"
#else
/* END CYGNUS LOCAL d30v */
#if defined (_TMS320C4x) || defined (_TMS320C3x)
#include <va-c4x.h>
#else
/* CYGNUS LOCAL fr30 */
#ifdef __fr30__
#include "va-fr30.h"
#else
/* END CYGNUS LOCAL fr30 */
#ifdef __NeXT__
/* On Next, erase any vestiges of stdarg.h. */
#ifdef _ANSI_STDARG_H_
#define _VA_LIST_
#endif
#define _ANSI_STDARG_H_
#undef va_alist
#undef va_dcl
#undef va_list
#undef va_start
#undef va_end
#undef __va_rounded_size
#undef va_arg
#endif /* __NeXT__ */
/* In GCC version 2, we want an ellipsis at the end of the declaration
of the argument list. GCC version 1 can't parse it. */
#if __GNUC__ > 1
#define __va_ellipsis ...
#else
#define __va_ellipsis
#endif
/* These macros implement traditional (non-ANSI) varargs
for GNU C. */
#define va_alist __builtin_va_alist
/* The ... causes current_function_varargs to be set in cc1. */
#define va_dcl int __builtin_va_alist; __va_ellipsis
/* Define __gnuc_va_list, just as in gstdarg.h. */
#ifndef __GNUC_VA_LIST
#define __GNUC_VA_LIST
#if defined(__svr4__) || defined(_AIX) || defined(_M_UNIX)
typedef char *__gnuc_va_list;
#else
typedef void *__gnuc_va_list;
#endif
#endif
#define va_start(AP) AP=(char *) &__builtin_va_alist
#define va_end(AP) ((void)0)
#if defined(sysV68)
#define __va_rounded_size(TYPE) \
(((sizeof (TYPE) + sizeof (short) - 1) / sizeof (short)) * sizeof (short))
#else
#define __va_rounded_size(TYPE) \
(((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))
#endif
#if (defined (__arm__) && ! defined (__ARMEB__)) || defined (__i386__) || defined (__i860__) || defined (__ns32000__) || defined (__vax__)
/* This is for little-endian machines; small args are padded upward. */
#define va_arg(AP, TYPE) \
(AP = (__gnuc_va_list) ((char *) (AP) + __va_rounded_size (TYPE)), \
*((TYPE *) (void *) ((char *) (AP) - __va_rounded_size (TYPE))))
#else /* big-endian */
/* This is for big-endian machines; small args are padded downward. */
#define va_arg(AP, TYPE) \
(AP = (__gnuc_va_list) ((char *) (AP) + __va_rounded_size (TYPE)), \
*((TYPE *) (void *) ((char *) (AP) \
- ((sizeof (TYPE) < __va_rounded_size (char) \
? sizeof (TYPE) : __va_rounded_size (TYPE))))))
#endif /* big-endian */
/* Copy __gnuc_va_list into another variable of this type. */
#define __va_copy(dest, src) (dest) = (src)
/* CYGNUS LOCAL fr30 */
#endif /* not fr30 */
/* END CYGNUS LOCAL fr30 */
#endif /* not TMS320C3x or TMS320C4x */
/* CYGNUS LOCAL d30v */
#endif /* not d30v */
/* END CYGNUS LOCAL d30v */
/* CYGNUS LOCAL v850e */
#endif /* not v850ea */
#endif /* not v850e */
/* END CYGNUS LOCAL */
#endif /* not v850 */
#endif /* not mn10200 */
#endif /* not mn10300 */
#endif /* not sh */
#endif /* not m32r */
/* CYGNUS LOCAL -- meissner/d10v */
#endif /* not d10v */
/* END CYGNUS LOCAL -- meissner/d10v */
#endif /* not arc */
#endif /* not powerpc with V.4 calling sequence */
#endif /* not h8300 */
#endif /* not alpha */
#endif /* not i960 */
#endif /* not hppa */
#endif /* not m88k */
#endif /* not clipper */
#endif /* not pyr */
#endif /* not i860 */
#endif /* not mips */
#endif /* not spur */
#endif /* not sparc */
#endif /* not _VARARGS_H */
/* Define va_list from __gnuc_va_list. */
#ifdef _HIDDEN_VA_LIST /* On OSF1, this means varargs.h is "half-loaded". */
#undef _VA_LIST
#endif
#if defined(__svr4__) || (defined(_SCO_DS) && !defined(__VA_LIST))
/* SVR4.2 uses _VA_LIST for an internal alias for va_list,
so we must avoid testing it and setting it here.
SVR4 uses _VA_LIST as a flag in stdarg.h, but we should
have no conflict with that. */
#ifndef _VA_LIST_
#define _VA_LIST_
#ifdef __i860__
#ifndef _VA_LIST
#define _VA_LIST va_list
#endif
#endif /* __i860__ */
typedef __gnuc_va_list va_list;
#ifdef _SCO_DS
#define __VA_LIST
#endif
#endif /* _VA_LIST_ */
#else /* not __svr4__ || _SCO_DS */
/* The macro _VA_LIST_ is the same thing used by this file in Ultrix.
But on BSD NET2 we must not test or define or undef it.
(Note that the comments in NET 2's ansi.h
are incorrect for _VA_LIST_--see stdio.h!) */
/* Michael Eriksson <mer@sics.se> at Thu Sep 30 11:00:57 1993:
Sequent defines _VA_LIST_ in <machine/machtypes.h> to be the type to
use for va_list (``typedef _VA_LIST_ va_list'') */
#if !defined (_VA_LIST_) || defined (__BSD_NET2__) || defined (____386BSD____) || defined (__bsdi__) || defined (__sequent__) || defined (__FreeBSD__) || defined(WINNT)
/* The macro _VA_LIST_DEFINED is used in Windows NT 3.5 */
#ifndef _VA_LIST_DEFINED
/* The macro _VA_LIST is used in SCO Unix 3.2. */
#ifndef _VA_LIST
/* The macro _VA_LIST_T_H is used in the Bull dpx2 */
#ifndef _VA_LIST_T_H
typedef __gnuc_va_list va_list;
#endif /* not _VA_LIST_T_H */
#endif /* not _VA_LIST */
#endif /* not _VA_LIST_DEFINED */
#if !(defined (__BSD_NET2__) || defined (____386BSD____) || defined (__bsdi__) || defined (__sequent__) || defined (__FreeBSD__))
#define _VA_LIST_
#endif
#ifndef _VA_LIST
#define _VA_LIST
#endif
#ifndef _VA_LIST_DEFINED
#define _VA_LIST_DEFINED
#endif
#ifndef _VA_LIST_T_H
#define _VA_LIST_T_H
#endif
#endif /* not _VA_LIST_, except on certain systems */
#endif /* not __svr4__ */
/* The next BSD release (if there is one) wants this symbol to be
undefined instead of _VA_LIST_. */
#ifdef _BSD_VA_LIST
#undef _BSD_VA_LIST
#endif

413
gcc/makefile.vms
View File

@ -1,413 +0,0 @@
#
# makefile for egcs
#
# Created by Klaus K"ampf, kkaempf@progis.de
#
# choose egcs or dec c
#CC = gcc
CC = cc
# With or withou haifa scheduler ?
#HAIFA=,"HAIFA"
HAIFA=
PWD=sys$$disk:[]
RM=delete/nolog
ifeq ($(CC),gcc)
ifeq ($(ARCH),ALPHA)
CFLAGS=/define=("HAVE_CONFIG_H=1","USE_COLLECT2" $(HAIFA))
LIBS=,gnu_cc_library:libgcc.olb/lib,sys$$library:vaxcrtl.olb/lib,gnu_cc_library:crt0.obj
else
CFLAGS=/define=("HAVE_CONFIG_H=1","USE_COLLECT2" $(HAIFA))
LIBS=,gnu_cc_library:libgcc.olb/lib,sys$$library:vaxcrtl.olb/lib
endif
LFLAGS=/map/full
#LFLAGS=
else
ifeq ($(ARCH),ALPHA)
CFLAGS=/names=as_is/float=ieee/noopt/debug/define=("HAVE_CONFIG_H=1","USE_COLLECT2" $(HAIFA))\
/warning=disable=(missingreturn,implicitfunc,ptrmismatch,undefescap,longextern,duptypespec)
else
CFLAGS=/noopt/debug/define=("HAVE_CONFIG_H=1","USE_COLLECT2" $(HAIFA))
endif
LFLAGS=/nomap
LIBS=,sys$$library:vaxcrtl.olb/lib
endif
BISON = bison
BISON_FLAGS= /Yacc/Define/Verbose
RENAME= rename/New_Version
LINK = link #/noshare/nosysshr
EDIT = edit
SEARCH= search
ABORT = exit %x002C
echo = write sys$$output
CINCL1 = /Incl=([],[.config])
CINCL2 = /Incl=([],[.ginclude],[.config])
CINCL_SUB = /Incl=([],[-],[-.ginclude],[-.config])
CINCL_CP= /Incl=([],[.config],[.cp],[.cp.inc])
MDFILE = [.config.$(ARCH)]$(ARCH).md
ifeq ($(HAIFA),)
SCHED=sched
else
SCHED=haifa-sched
endif
GENOBJS=[]rtl.obj,obstack.obj
INDEPOBJS= []toplev.obj,version.obj,tree.obj,print-tree.obj,stor-layout.obj,\
fold-const.obj,function.obj,stmt.obj,except.obj,expr.obj,calls.obj,expmed.obj,\
explow.obj,optabs.obj,varasm.obj,rtl.obj,print-rtl.obj,rtlanal.obj,\
emit-rtl.obj,genrtl.obj,real.obj,regmove.obj,dbxout.obj,sdbout.obj,dwarfout.obj,\
dwarf2out.obj,xcoffout.obj,bitmap.obj,alias.obj,\
integrate.obj,jump.obj,cse.obj,loop.obj,unroll.obj,flow.obj,stupid.obj,\
combine.obj,regclass.obj,local-alloc.obj,global.obj,reload.obj,\
reload1.obj,caller-save.obj,insn-peep.obj,reorg.obj,$(SCHED).obj,\
final.obj,recog.obj,reg-stack.obj,insn-opinit.obj,insn-recog.obj,\
insn-extract.obj,insn-output.obj,insn-emit.obj,\
profile.obj,insn-attrtab.obj,\
aux-output.obj,getpwd.obj,convert.obj
CC1OBJS=[]c-parse.obj,c-lang.obj,c-lex.obj,c-pragma.obj,c-decl.obj,\
c-typeck.obj,c-convert.obj,c-aux-info.obj,c-common.obj,c-iterate.obj,\
obstack.obj
OBJCOBJS=
# list copied from cc1plus-objs.opt
CC1PLUSOBJS=[.cp]call.obj,[.cp]decl2.obj,\
[.cp]except.obj,[.cp]pt.obj,\
[.cp]spew.obj,[.cp]xref.obj,[.cp]class.obj,\
[.cp]expr.obj,[.cp]lex.obj,\
[.cp]ptree.obj,[.cp]tree.obj,[.cp]cvt.obj,\
[.cp]errfn.obj,[.cp]rtti.obj,[.cp]method.obj,\
[.cp]search.obj,[.cp]typeck.obj,[.cp]decl.obj,\
[.cp]error.obj,[.cp]friend.obj,[.cp]init.obj,[.cp]parse.obj,\
[.cp]sig.obj,[.cp]typeck2.obj,[.cp]repo.obj,\
[.cp]input.obj,\
[]obstack.obj,\
[]c-common.obj,[]c-pragma.obj
CCCPOBJS=[]cccp.obj,cexp.obj,version.obj,prefix.obj
ALLOCA=,[]alloca.obj
LIBIBERTY = [-.libiberty]libiberty.olb
CXX_LIB2FUNCS = [.cp]tinfo.obj,[.cp]tinfo2.obj,\
[.cp]new.obj,[.cp]new1.obj,[.cp]new2.obj,[.cp]exception.obj
.c.obj:
$(CC) $(CFLAGS) $(CINCL1) $</obj=$@
.cc.obj:
$(CC)/plus/CPP="-nostdinc++" $(CFLAGS) $(CINCL_CP) $</obj=$@
INSN_INCLUDES=insn-attr.h insn-codes.h insn-config.h insn-flags.h
#
#
#
all: cpp.exe cc1.exe float.h limits.h libgcc2.olb
allplus: cc1plus.exe libgccplus.olb
libplus: libgccplus.olb
cc1.exe: $(CC1OBJS) $(ALLOCA) $(INDEPOBJS)
$(LINK)$(LFLAGS)/exe=$@ version.opt/opt,cc1-objs.opt/Opt,independent.opt/Opt$(ALLOCA)$(LIBS)
cpp.exe: $(CCCPOBJS) $(ALLOCA)
$(LINK)$(LFLAGS)/exe=$@ $(CCCPOBJS),version.opt/opt$(ALLOCA)$(LIBS)
cc1plus.exe: $(CC1PLUSOBJS) $(ALLOCA) $(INDEPOBJS)
$(LINK)$(LFLAGS)/exe=$@ version.opt/opt,cc1plus-objs.opt/Opt,independent.opt/Opt$(ALLOCA)$(LIBS)
gcc.exe: gcc.obj version.obj choose-temp.obj pexecute.obj prefix.obj obstack.obj
$(LINK)$(LFLAGS)/exe=$@ $^$(ALLOCA)$(LIBS)
install: cpp.exe cc1.exe gcc.exe libgcc2.olb
$(CP) $^ GNU_CC_LIBRARY
installplus: cc1plus.exe libgccplus.olb
$(CP) $^ GNU_CC_LIBRARY
float.h: enquire.exe
mcr $(PWD)enquire.exe -f > $@
limits.h: enquire.exe
mcr $(PWD)enquire.exe -l > $@
enquire.exe: enquire.obj
$(LINK)$(LFLAGS)/exe=$@ enquire.obj$(ALLOCA)$(LIBS)
libgcc2.olb:
$$ @make-l2
libgccplus.olb: $(CXX_LIB2FUNCS)
lib/create libgccplus $(CXX_LIB2FUNCS)
genattr.exe: genattr.obj,$(GENOBJS)$(ALLOCA)
$(LINK) $(LFLAGS)/exe=$@ $^$(LIBS)
insn-attr.h: genattr.exe $(MDFILE)
mcr $(PWD)genattr.exe $(MDFILE) > $@
genflags.exe: genflags.obj,$(GENOBJS)$(ALLOCA)
$(LINK) $(LFLAGS)/exe=$@ $^$(LIBS)
insn-flags.h: genflags.exe $(MDFILE)
mcr $(PWD)genflags.exe $(MDFILE) > $@
gencodes.exe: gencodes.obj,$(GENOBJS)$(ALLOCA)
$(LINK) $(LFLAGS)/exe=$@ $^$(LIBS)
insn-codes.h: gencodes.exe $(MDFILE)
mcr $(PWD)gencodes.exe $(MDFILE) > $@
genconfig.exe: genconfig.obj,$(GENOBJS)$(ALLOCA)
$(LINK) $(LFLAGS)/exe=$@ $^$(LIBS)
insn-config.h: genconfig.exe $(MDFILE)
mcr $(PWD)genconfig.exe $(MDFILE) > $@
genpeep.exe: genpeep.obj,$(GENOBJS)$(ALLOCA)
$(LINK) $(LFLAGS)/exe=$@ $^$(LIBS)
insn-peep.c: genpeep.exe $(MDFILE)
mcr $(PWD)genpeep.exe $(MDFILE) > $@
genopinit.exe: genopinit.obj,$(GENOBJS)$(ALLOCA)
$(LINK) $(LFLAGS)/exe=$@ $^$(LIBS)
insn-opinit.c: genopinit.exe $(MDFILE)
mcr $(PWD)genopinit.exe $(MDFILE) > $@
genrecog.exe: genrecog.obj,$(GENOBJS)$(ALLOCA)
$(LINK) $(LFLAGS)/exe=$@ $^$(LIBS)
insn-recog.c: genrecog.exe $(MDFILE)
mcr $(PWD)genrecog.exe $(MDFILE) > $@
genextract.exe: genextract.obj,$(GENOBJS)$(ALLOCA)
$(LINK) $(LFLAGS)/exe=$@ $^$(LIBS)
insn-extract.c: genextract.exe $(MDFILE)
mcr $(PWD)genextract.exe $(MDFILE) > $@
genoutput.exe: genoutput.obj,$(GENOBJS)$(ALLOCA)
$(LINK) $(LFLAGS)/exe=$@ $^$(LIBS)
insn-output.c: genoutput.exe $(MDFILE)
mcr $(PWD)genoutput.exe $(MDFILE) > $@
genemit.exe: genemit.obj,$(GENOBJS)$(ALLOCA)
$(LINK) $(LFLAGS)/exe=$@ $^$(LIBS)
insn-emit.c: genemit.exe $(MDFILE)
mcr $(PWD)genemit.exe $(MDFILE) > $@
genattrtab.exe: genattrtab.obj,rtlanal.obj,$(GENOBJS)$(ALLOCA)
$(LINK) $(LFLAGS)/exe=$@ $^$(LIBS)
insn-attrtab.c: genattrtab.exe $(MDFILE)
mcr $(PWD)genattrtab.exe $(MDFILE) > $@
gengenrtl.exe: gengenrtl.obj,obstack.obj,$(ALLOCA)
$(LINK) $(LFLAGS)/exe=$@ $^$(LIBS)
genrtl.h genrtl.c: gengenrtl.exe
mcr $(PWD)gengenrtl.exe genrtl.h genrtl.c
cccp.obj: cccp.c config.h
aux-output.obj: aux-output.c insn-attr.h insn-flags.h insn-config.h
caller-save.obj: caller-save.c insn-config.h
calls.obj: calls.c insn-flags.h
combine.obj: combine.c insn-attr.h insn-flags.h insn-codes.h insn-config.h
cse.obj: cse.c insn-config.h
c-decl.obj: c-decl.c expr.h integrate.h insn-codes.h insn-config.h
c-lex.obj: c-lex.c genrtl.h
c-typeck.obj: c-typeck.c
dbxout.obj: dbxout.c insn-config.h
dwarfout.obj: dwarfout.c insn-config.h
dwarf2out.obj: dwarf2out.c insn-config.h
emit-rtl.obj: emit-rtl.c insn-config.h
except.obj: except.c insn-flags.h insn-codes.h insn-config.h
explow.obj: explow.c insn-flags.h insn-codes.h insn-config.h
expmed.obj: expmed.c insn-flags.h insn-codes.h insn-config.h
expr.obj: expr.c insn-flags.h insn-config.h
final.obj: final.c tm.h insn-attr.h insn-flags.h insn-codes.h insn-config.h
flow.obj: flow.c insn-config.h
function.obj: function.c insn-flags.h insn-codes.h insn-config.h insn-codes.h insn-config.h
genattrtab.obj: genattrtab.c insn-config.h
genextract.obj: genextract.c insn-config.h
global.obj: global.c insn-config.h
integrate.obj: integrate.c integrate.h insn-flags.h insn-config.h
jump.obj: jump.c insn-flags.h insn-config.h
local-alloc.obj: local-alloc.c insn-config.h
loop.obj: loop.c insn-flags.h insn-config.h
optabs.obj: optabs.c insn-flags.h insn-codes.h insn-config.h
print-rtl.obj: print-rtl.c
profile.obj: profile.c insn-flags.h insn-config.h
recog.obj: recog.c insn-attr.h insn-flags.h insn-codes.h insn-config.h
regclass.obj: regclass.c insn-config.h
reg-stack.obj: reg-stack.c insn-config.h
reload.obj: reload.c insn-codes.h insn-config.h
reload1.obj: reload1.c insn-flags.h insn-codes.h insn-config.h
reorg.obj: reorg.c insn-attr.h insn-flags.h insn-config.h
sched.obj: sched.c insn-attr.h insn-config.h
haifa-sched.obj: haifa-sched.c insn-attr.h insn-config.h
stmt.obj: stmt.c insn-flags.h insn-codes.h insn-config.h
stor-layout.obj: stor-layout.c
stupid.obj: stupid.c
toplev.obj: toplev.c insn-attr.h insn-config.h
unroll.obj: unroll.c insn-config.h
insn-attrtab.obj: insn-attrtab.c insn-attr.h insn-config.h
insn-output.obj: insn-output.c insn-attr.h insn-flags.h insn-codes.h
insn-emit.obj: insn-emit.c insn-flags.h insn-codes.h insn-config.h
insn-opinit.obj: insn-opinit.c insn-flags.h insn-codes.h insn-config.h
insn-output.obj: insn-config.h
insn-recog.obj: insn-config.h
varasm.obj: varasm.c tm.h
toplev.obj: toplev.c tm.h
cexp.c: cexp.y
$(BISON) $(BISON_FLAGS)/output=$@ $<
c-parse.c: c-parse.y
$(BISON) $(BISON_FLAGS)/output=$@ $<
[.cp]parse.c: [.cp]parse.y
$(BISON) $(BISON_FLAGS)/output=$@ $<
[.cp]parse.h: [.cp]parse.c
@$(ECHO) "Must copy YYEMPTY from [.cp]parse.c to [.cp]parse.h"
$$ stop
aux-output.c: [.config.$(ARCH)]$(ARCH).c
copy $< $@
expr.h: insn-codes.h
reload.h: insn-config.h
integrate.h: insn-config.h
config.h:
$$ @vmsconfig
cleancccp:
$$ purge
$(RM) cccp.obj;,cexp.obj;
$(RM) cpp.exe;
cleanlib:
$$ purge
$(RM) libgcc2.olb;
cleanlibplus:
$$ purge
$(RM) [.cp]tinfo.obj;
$(RM) [.cp]tinfo2.obj;
$(RM) [.cp]new.obj;
$(RM) [.cp]new1.obj;
$(RM) [.cp]new2.obj;
$(RM) [.cp]exception.obj;
$(RM) libgccplus.olb;
clean:
$$ purge
$$ purge [.cp]
$(RM) *.obj;*
$(RM) [.cp]*.obj;*
$(RM) [.cp]parse.output;*
$(RM) *.cpp;*
$(RM) *.s;*
$(RM) *.rtl;*
$(RM) a.out;
$(RM) *.combine;
$(RM) *.cpp;
$(RM) *.cse;
$(RM) *.cse2;
$(RM) *.dbr;
$(RM) *.flow;
$(RM) *.greg;
$(RM) *.jump;
$(RM) *.jump2;
$(RM) *.loop;
$(RM) *.lreg;
$(RM) *.rtl;
$(RM) *.sched;
$(RM) *.sched2;
$(RM) *.map;
$(RM) genattr.exe;,insn-attr.h;
$(RM) genflags.exe;,insn-flags.h;
$(RM) gencodes.exe;,insn-codes.h;
$(RM) genconfig.exe;,insn-config.h;
$(RM) genpeep.exe;,insn-peep.c;
$(RM) genopinit.exe;,insn-opinit.c;
$(RM) genrecog.exe;,insn-recog.c;
$(RM) genextract.exe;,insn-extract.c;
$(RM) genoutput.exe;,insn-output.c;
$(RM) genemit.exe;,insn-emit.c;
$(RM) genattrtab.exe;,insn-attrtab.c;
$(RM) gengenrtl.exe;,genrtl.c;,genrtl.h;
$(RM) cc1.exe;
$(RM) cpp.exe;
$(RM) cc1plus.exe;
$(RM) libgcc2.olb;
$(RM) libgccplus.olb;
$(RM) enquire.exe;,float.h;,limits.h;
#
# clean everything axpconfig.com creates
#
distclean: clean cleancccp
purge [...]
$(RM) config.h;
$(RM) tconfig.h;
$(RM) hconfig.h;
$(RM) tm.h;
$(RM) options.h;
$(RM) specs.h;
$(RM) aux-output.c;
[.cp]call.obj: [.cp]call.c
[.cp]decl2.obj: [.cp]decl2.c
[.cp]except.obj: [.cp]except.c insn-codes.h insn-flags.h
[.cp]pt.obj: [.cp]pt.c
[.cp]spew.obj: [.cp]spew.c
[.cp]xref.obj: [.cp]xref.c
[.cp]class.obj: [.cp]class.c
[.cp]expr.obj: [.cp]expr.c insn-codes.h
[.cp]lex.obj: [.cp]lex.c [.cp]parse.h
[.cp]ptree.obj: [.cp]ptree.c
[.cp]tree.obj: [.cp]tree.c
[.cp]cvt.obj: [.cp]cvt.c
[.cp]errfn.obj: [.cp]errfn.c
[.cp]rtti.obj: [.cp]rtti.c
[.cp]method.obj: [.cp]method.c insn-codes.h
[.cp]search.obj: [.cp]search.c
[.cp]typeck.obj: [.cp]typeck.c
[.cp]decl.obj: [.cp]decl.c
[.cp]error.obj: [.cp]error.c
[.cp]friend.obj: [.cp]friend.c
[.cp]init.obj: [.cp]init.c
[.cp]parse.obj: [.cp]parse.c
$(CC) $(CFLAGS) $(CINCL_CP) $^/obj=$@
[.cp]sig.obj: [.cp]sig.c
[.cp]typeck2.obj: [.cp]typeck2.c
[.cp]repo.obj: [.cp]repo.c
[.cp]input.obj: [.cp]input.c
$(TOUCH) $@
# g++ library
[.cp]tinfo.obj: [.cp]tinfo.cc
[.cp]tinfo2.obj: [.cp]tinfo2.cc
[.cp]new.obj: [.cp]new.cc
[.cp]new1.obj: [.cp]new1.cc
[.cp]new2.obj: [.cp]new2.cc
[.cp]exception.obj: [.cp]exception.cc
#EOF