Return to va-alpha.h CVS log

Up to [GCC 2.x] / gcc / ginclude

Annotation of gcc/ginclude/va-alpha.h, revision 1.1.1.1

1.1       root        1: /* GNU C varargs and stdargs support for the DEC Alpha.  */
                      2: 
                      3: /* Note:  We must use the name __builtin_savregs.  GCC attaches special
                      4:    significance to that name.  In particular, regardless of where in a
                      5:    function __builtin_saveregs is called, GCC moves the call up to the
                      6:    very start of the function.  */
                      7: 
                      8: /* Define __gnuc_va_list.  */
                      9: 
                     10: #ifndef __GNUC_VA_LIST
                     11: #define __GNUC_VA_LIST
                     12: 
                     13: typedef struct {
                     14:   char *__base;                        /* Pointer to first integer register. */
                     15:   long __offset;               /* Byte offset of args so far. */
                     16: } __gnuc_va_list;
                     17: #endif /* not __GNUC_VA_LIST */
                     18: 
                     19: /* If this is for internal libc use, don't define anything but
                     20:    __gnuc_va_list.  */
                     21: #if defined (_STDARG_H) || defined (_VARARGS_H)
                     22: 
                     23: #define va_list __gnuc_va_list
                     24: #define _VA_LIST
                     25: #define _VA_LIST_
                     26: 
                     27: #if !defined(_STDARG_H)
                     28: 
                     29: /* varargs support */
                     30: #define va_alist __builtin_va_alist
                     31: #define va_dcl  int __builtin_va_alist;...
                     32: #define va_start(pvar) ((pvar) = * (__gnuc_va_list *) __builtin_saveregs ())
                     33: 
                     34: #else /* STDARG.H */
                     35: 
                     36: /* ANSI alternative.  */
                     37: 
                     38: /* Call __builtin_next_arg even though we aren't using its value, so that
                     39:    we can verify that firstarg is correct.  */
                     40: #define va_start(pvar, firstarg)                               \
                     41:   (__builtin_next_arg (firstarg),                              \
                     42:    (pvar) = *(__gnuc_va_list *) __builtin_saveregs ())
                     43: 
                     44: #endif /* _STDARG_H */
                     45: 
                     46: #ifndef va_end
                     47: 
                     48: #define va_end(__va)
                     49: 
                     50: /* Values returned by __builtin_classify_type.  */
                     51: 
                     52: enum {
                     53:   __no_type_class = -1,
                     54:   __void_type_class,
                     55:   __integer_type_class,
                     56:   __char_type_class,
                     57:   __enumeral_type_class,
                     58:   __boolean_type_class,
                     59:   __pointer_type_class,
                     60:   __reference_type_class,
                     61:   __offset_type_class,
                     62:   __real_type_class,
                     63:   __complex_type_class,
                     64:   __function_type_class,
                     65:   __method_type_class,
                     66:   __record_type_class,
                     67:   __union_type_class,
                     68:   __array_type_class,
                     69:   __string_type_class,
                     70:   __set_type_class,
                     71:   __file_type_class,
                     72:   __lang_type_class
                     73: };
                     74: 
                     75: #endif
                     76: 
                     77: /* Note that parameters are always aligned at least to a word boundary
                     78:    (when passed) regardless of what GCC's __alignof__ operator says.  */
                     79: 
                     80: /* Avoid errors if compiling GCC v2 with GCC v1.  */
                     81: #if __GNUC__ == 1
                     82: #define __extension__
                     83: #endif
                     84: 
                     85: /* Get the size of a type in bytes, rounded up to an integral number
                     86:    of words.  */
                     87: 
                     88: #define __va_tsize(__type)  \
                     89:   (((sizeof (__type) + sizeof (long) - 1) / sizeof (long)) * sizeof (long))
                     90: 
                     91: #define va_arg(__va, __type)                                           \
                     92: (*(((__va).__offset += __va_tsize (__type)),                           \
                     93:    (__type *)(void *)((__va).__base + (__va).__offset                  \
                     94:              - (((__builtin_classify_type (* (__type *) 0)             \
                     95:                   == __real_type_class) && (__va).__offset <= (6 * 8)) \
                     96:                 ? (6 * 8) + 8 : __va_tsize (__type)))))
                     97: 
                     98: #endif /* defined (_STDARG_H) || defined (_VARARGS_H) */
                     99: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.