Skip to content

R
riscv-gcc-1
Commit 5c9f708d by Richard Henderson
Options

Makefile.in (USER_H): Remove va-foo.h. 

        * Makefile.in (USER_H): Remove va-foo.h.

        * ginclude/{va-alpha.h,va-arc.h,va-c4x.h,va-clipper.h,va-h8300.h,
        va-i860.h,va-i960.h,va-m32r.h,va-m88k.h,va-mips.h,va-mn10200.h,
        va-mn10300.h,va-pa.h,va-ppc.h,va-pyr.h,va-sh.h,va-sparc.h,
        va-spur.h,va-v850.h}: Remove.

From-SVN: r29424
parent 5126c35a
Showing with 2 additions and 1862 deletions
gcc/Makefile.in
......@@ -146,18 +146,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 \
$(srcdir)/ginclude/va-c4x.h $(EXTRA_HEADERS) $(LANG_EXTRA_HEADERS) \
$(srcdir)/ginclude/proto.h $(srcdir)/ginclude/stdbool.h
$(srcdir)/ginclude/varargs.h $(srcdir)/ginclude/proto.h \
$(srcdir)/ginclude/stdbool.h $(EXTRA_HEADERS) $(LANG_EXTRA_HEADERS)
# Target to use whe installing assert.h. Some systems may
# want to set this empty.
......
gcc/ginclude/va-alpha.h deleted 100644 → 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 */
gcc/ginclude/va-arc.h deleted 100644 → 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) */
gcc/ginclude/va-c4x.h deleted 100644 → 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) */
gcc/ginclude/va-clipper.h deleted 100644 → 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) */
gcc/ginclude/va-h8300.h deleted 100644 → 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) */
gcc/ginclude/va-i860.h deleted 100644 → 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) */
gcc/ginclude/va-i960.h deleted 100644 → 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) */
gcc/ginclude/va-m32r.h deleted 100644 → 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) */
gcc/ginclude/va-m88k.h deleted 100644 → 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) */
gcc/ginclude/va-mn10200.h deleted 100644 → 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 __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
gcc/ginclude/va-mn10300.h deleted 100644 → 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
gcc/ginclude/va-pa.h deleted 100644 → 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) */
gcc/ginclude/va-ppc.h deleted 100644 → 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 {
unsigned 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. */
unsigned 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,OFS,TYPE) \
((TYPE *) (void *) (&(((__va_regsave_t *) \
(AP)->reg_save_area)->__fp_save[OFS])))
#define __VA_GP_REGSAVE(AP,OFS,TYPE) \
((TYPE *) (void *) (&(((__va_regsave_t *) \
(AP)->reg_save_area)->__gp_save[OFS])))
/* Common code for va_start for both varargs and stdarg. We allow all
the work to be done by __builtin_saveregs. It returns a pointer to
a va_list that was constructed on the stack; we must simply copy it
to the user's variable. */
#define __va_start_common(AP, FAKE) \
__builtin_memcpy ((AP), __builtin_saveregs (), sizeof(__gnuc_va_list))
#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_aggregate_p(TYPE) (__builtin_classify_type(*(TYPE *)0) >= 12)
#define __va_size(TYPE) ((sizeof(TYPE) + sizeof (long) - 1) / sizeof (long))
/* This symbol isn't defined. It is used to flag type promotion violations
at link time. We can only do this when optimizing. Use __builtin_trap
instead of abort so that we don't require a prototype for abort. */
#ifdef __OPTIMIZE__
extern void __va_arg_type_violation(void) __attribute__((__noreturn__));
#else
#define __va_arg_type_violation() __builtin_trap()
#endif
#define va_arg(AP,TYPE) \
__extension__ (*({ \
register TYPE *__ptr; \
\
if (__va_float_p (TYPE) && sizeof (TYPE) < 16) \
{ \
unsigned char __fpr = (AP)->fpr; \
if (__fpr < 8) \
{ \
__ptr = __VA_FP_REGSAVE (AP, __fpr, TYPE); \
(AP)->fpr = __fpr + 1; \
} \
else if (sizeof (TYPE) == 8) \
{ \
unsigned long __addr = (unsigned long) (__va_overflow (AP)); \
__ptr = (TYPE *)((__addr + 7) & -8); \
__va_overflow (AP) = (char *)(__ptr + 1); \
} \
else \
{ \
/* float is promoted to double. */ \
__va_arg_type_violation (); \
} \
} \
\
/* Aggregates and long doubles are passed by reference. */ \
else if (__va_aggregate_p (TYPE) || __va_float_p (TYPE)) \
{ \
unsigned char __gpr = (AP)->gpr; \
if (__gpr < 8) \
{ \
__ptr = * __VA_GP_REGSAVE (AP, __gpr, TYPE *); \
(AP)->gpr = __gpr + 1; \
} \
else \
{ \
TYPE **__pptr = (TYPE **) (__va_overflow (AP)); \
__ptr = * __pptr; \
__va_overflow (AP) = (char *) (__pptr + 1); \
} \
} \
\
/* Only integrals remaining. */ \
else \
{ \
/* longlong is aligned. */ \
if (sizeof (TYPE) == 8) \
{ \
unsigned char __gpr = (AP)->gpr; \
if (__gpr < 7) \
{ \
__gpr += __gpr & 1; \
__ptr = __VA_GP_REGSAVE (AP, __gpr, TYPE); \
(AP)->gpr = __gpr + 2; \
} \
else \
{ \
unsigned long __addr = (unsigned long) (__va_overflow (AP)); \
__ptr = (TYPE *)((__addr + 7) & -8); \
(AP)->gpr = 8; \
__va_overflow (AP) = (char *)(__ptr + 1); \
} \
} \
else if (sizeof (TYPE) == 4) \
{ \
unsigned char __gpr = (AP)->gpr; \
if (__gpr < 8) \
{ \
__ptr = __VA_GP_REGSAVE (AP, __gpr, TYPE); \
(AP)->gpr = __gpr + 1; \
} \
else \
{ \
__ptr = (TYPE *) __va_overflow (AP); \
__va_overflow (AP) = (char *)(__ptr + 1); \
} \
} \
else \
{ \
/* Everything else was promoted to int. */ \
__va_arg_type_violation (); \
} \
} \
__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 */
gcc/ginclude/va-pyr.h deleted 100644 → 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) */
gcc/ginclude/va-sh.h deleted 100644 → 0
/* The ! __SH3E_VARG case is similar to the default gvarargs.h . */
#if (defined (__SH3E__) || defined (__SH4_SINGLE__) || defined (__SH4__) || defined (__SH4_SINGLE_ONLY__)) && ! defined (__HITACHI__)
#define __SH3E_VARG
#endif
/* Define __gnuc_va_list. */
#ifndef __GNUC_VA_LIST
#define __GNUC_VA_LIST
#ifdef __SH3E_VARG
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
#ifdef __SH3E_VARG
#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;...
#ifdef __SH3E_VARG
#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);})
#ifdef __SH3E_VARG
#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) */
gcc/ginclude/va-sparc.h deleted 100644 → 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) */
gcc/ginclude/va-spur.h deleted 100644 → 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)
gcc/ginclude/va-v850.h deleted 100644 → 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
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment