1 /* This is just like the default gvarargs.h 2 except for differences described below. */ 3 4 /* Define __gnuc_va_list. */ 5 6 #ifndef __GNUC_VA_LIST 7 #define __GNUC_VA_LIST 8 #if ! defined (__svr4__) && ! defined (__linux__) && ! defined (__arch64__) 9 /* This has to be a char * to be compatible with Sun. 10 i.e., we have to pass a `va_list' to vsprintf. */ 11 typedef char * __gnuc_va_list; 12 #else 13 /* This has to be a void * to be compatible with Sun svr4. 14 i.e., we have to pass a `va_list' to vsprintf. */ 15 typedef void * __gnuc_va_list; 16 #endif 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 #ifdef _STDARG_H 24 25 /* Call __builtin_next_arg even though we aren't using its value, so that 26 we can verify that LASTARG is correct. */ 27 #if defined (__GCC_NEW_VARARGS__) || defined (__arch64__) 28 #define va_start(AP, LASTARG) \ 29 (__builtin_next_arg (LASTARG), AP = (char *) __builtin_saveregs ()) 30 #else 31 #define va_start(AP, LASTARG) \ 32 (__builtin_saveregs (), AP = ((char *) __builtin_next_arg (LASTARG))) 33 #endif 34 35 #else 36 37 #define va_alist __builtin_va_alist 38 #define va_dcl int __builtin_va_alist;... 39 40 #if defined (__GCC_NEW_VARARGS__) || defined (__arch64__) 41 #define va_start(AP) ((AP) = (char *) __builtin_saveregs ()) 42 #else 43 #define va_start(AP) \ 44 (__builtin_saveregs (), (AP) = ((char *) &__builtin_va_alist)) 45 #endif 46 47 #endif 48 49 #ifndef va_end 50 void va_end (__gnuc_va_list); /* Defined in libgcc.a */ 51 52 /* Values returned by __builtin_classify_type. */ 53 54 enum __va_type_classes { 55 __no_type_class = -1, 56 __void_type_class, 57 __integer_type_class, 58 __char_type_class, 59 __enumeral_type_class, 60 __boolean_type_class, 61 __pointer_type_class, 62 __reference_type_class, 63 __offset_type_class, 64 __real_type_class, 65 __complex_type_class, 66 __function_type_class, 67 __method_type_class, 68 __record_type_class, 69 __union_type_class, 70 __array_type_class, 71 __string_type_class, 72 __set_type_class, 73 __file_type_class, 74 __lang_type_class 75 }; 76 77 #endif 78 #define va_end(pvar) ((void)0) 79 80 /* Avoid errors if compiling GCC v2 with GCC v1. */ 81 #if __GNUC__ == 1 82 #define __extension__ 83 #endif 84 85 /* RECORD_TYPE args passed using the C calling convention are 86 passed by invisible reference. ??? RECORD_TYPE args passed 87 in the stack are made to be word-aligned; for an aggregate that is 88 not word-aligned, we advance the pointer to the first non-reg slot. */ 89 90 #ifdef __arch64__ 91 92 typedef unsigned int __ptrint __attribute__ ((__mode__ (__DI__))); 93 94 /* ??? TODO: little endian support */ 95 96 #define va_arg(pvar, TYPE) \ 97 __extension__ \ 98 (*({int __type = __builtin_classify_type (* (TYPE *) 0); \ 99 char * __result; \ 100 if (__type == __real_type_class) /* float? */ \ 101 { \ 102 if (__alignof__ (TYPE) == 16) \ 103 (pvar) = (void *) (((__ptrint) (pvar) + 15) & -16); \ 104 __result = (pvar); \ 105 (pvar) = (char *) (pvar) + sizeof (TYPE); \ 106 } \ 107 else if (__type < __record_type_class) /* integer? */ \ 108 { \ 109 (pvar) = (char *) (pvar) + 8; \ 110 __result = (char *) (pvar) - sizeof (TYPE); \ 111 } \ 112 else /* aggregate object */ \ 113 { \ 114 if (sizeof (TYPE) <= 8) \ 115 { \ 116 __result = (pvar); \ 117 (pvar) = (char *) (pvar) + 8; \ 118 } \ 119 else if (sizeof (TYPE) <= 16) \ 120 { \ 121 if (__alignof__ (TYPE) == 16) \ 122 (pvar) = (void *) (((__ptrint) (pvar) + 15) & -16); \ 123 __result = (pvar); \ 124 (pvar) = (char *) (pvar) + 16; \ 125 } \ 126 else \ 127 { \ 128 __result = * (void **) (pvar); \ 129 (pvar) = (char *) (pvar) + 8; \ 130 } \ 131 } \ 132 (TYPE *) __result;})) 133 134 #else /* not __arch64__ */ 135 136 #define __va_rounded_size(TYPE) \ 137 (((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int)) 138 139 /* We don't declare the union member `d' to have type TYPE 140 because that would lose in C++ if TYPE has a constructor. */ 141 /* We cast to void * and then to TYPE * because this avoids 142 a warning about increasing the alignment requirement. 143 The casts to char * avoid warnings about invalid pointer arithmetic. */ 144 #define va_arg(pvar,TYPE) \ 145 __extension__ \ 146 (*({((__builtin_classify_type (*(TYPE*) 0) >= __record_type_class \ 147 || (__builtin_classify_type (*(TYPE*) 0) == __real_type_class \ 148 && sizeof (TYPE) == 16)) \ 149 ? ((pvar) = (char *)(pvar) + __va_rounded_size (TYPE *), \ 150 *(TYPE **) (void *) ((char *)(pvar) - __va_rounded_size (TYPE *))) \ 151 : __va_rounded_size (TYPE) == 8 \ 152 ? ({ union {char __d[sizeof (TYPE)]; int __i[2];} __u; \ 153 __u.__i[0] = ((int *) (void *) (pvar))[0]; \ 154 __u.__i[1] = ((int *) (void *) (pvar))[1]; \ 155 (pvar) = (char *)(pvar) + 8; \ 156 (TYPE *) (void *) __u.__d; }) \ 157 : ((pvar) = (char *)(pvar) + __va_rounded_size (TYPE), \ 158 ((TYPE *) (void *) ((char *)(pvar) - __va_rounded_size (TYPE)))));})) 159 160 #endif /* not __arch64__ */ 161 162 /* Copy __gnuc_va_list into another variable of this type. */ 163 #define __va_copy(dest, src) (dest) = (src) 164 165 #endif /* defined (_STDARG_H) || defined (_VARARGS_H) */ 166