stdarg.h (13469B)
1 #ifndef STDARG_H 2 #define STDARG_H 3 4 // When not building with IDO, use the builtin vaarg macros for portability. 5 #if !defined(__sgi) && (__GNUC__ > 2) 6 #define va_list __builtin_va_list 7 #define va_start __builtin_va_start 8 #define va_arg __builtin_va_arg 9 #define va_end __builtin_va_end 10 11 #elif (__GNUC__ == 2) 12 13 typedef void *__gnuc_va_list; 14 typedef __gnuc_va_list va_list; 15 16 #ifndef _VA_MIPS_H_ENUM 17 #define _VA_MIPS_H_ENUM 18 enum { 19 __no_type_class = -1, 20 __void_type_class, 21 __integer_type_class, 22 __char_type_class, 23 __enumeral_type_class, 24 __boolean_type_class, 25 __pointer_type_class, 26 __reference_type_class, 27 __offset_type_class, 28 __real_type_class, 29 __complex_type_class, 30 __function_type_class, 31 __method_type_class, 32 __record_type_class, 33 __union_type_class, 34 __array_type_class, 35 __string_type_class, 36 __set_type_class, 37 __file_type_class, 38 __lang_type_class 39 }; 40 #endif 41 42 /* In GCC version 2, we want an ellipsis at the end of the declaration 43 of the argument list. GCC version 1 can't parse it. */ 44 45 #if __GNUC__ > 1 46 #define __va_ellipsis ... 47 #else 48 #define __va_ellipsis 49 #endif 50 51 #ifdef __mips64 52 #define __va_rounded_size(__TYPE) \ 53 (((sizeof (__TYPE) + 8 - 1) / 8) * 8) 54 #else 55 #define __va_rounded_size(__TYPE) \ 56 (((sizeof (__TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int)) 57 #endif 58 59 #ifdef __mips64 60 #define __va_reg_size 8 61 #else 62 #define __va_reg_size 4 63 #endif 64 65 /* Get definitions for _MIPS_SIM_ABI64 etc. */ 66 #ifdef _MIPS_SIM 67 //#include <sgidefs.h> 68 #endif 69 70 #ifdef STDARG_H 71 #if defined (__mips_eabi) 72 #if ! defined (__mips_soft_float) && ! defined (__mips_single_float) 73 #ifdef __mips64 74 #define va_start(__AP, __LASTARG) \ 75 (__AP.__gp_regs = ((char *) __builtin_next_arg (__LASTARG) \ 76 - (__builtin_args_info (2) < 8 \ 77 ? (8 - __builtin_args_info (2)) * __va_reg_size \ 78 : 0)), \ 79 __AP.__fp_left = 8 - __builtin_args_info (3), \ 80 __AP.__fp_regs = __AP.__gp_regs - __AP.__fp_left * __va_reg_size) 81 #else /* ! defined (__mips64) */ 82 #define va_start(__AP, __LASTARG) \ 83 (__AP.__gp_regs = ((char *) __builtin_next_arg (__LASTARG) \ 84 - (__builtin_args_info (2) < 8 \ 85 ? (8 - __builtin_args_info (2)) * __va_reg_size \ 86 : 0)), \ 87 __AP.__fp_left = (8 - __builtin_args_info (3)) / 2, \ 88 __AP.__fp_regs = __AP.__gp_regs - __AP.__fp_left * 8, \ 89 __AP.__fp_regs = (char *) ((int) __AP.__fp_regs & -8)) 90 #endif /* ! defined (__mips64) */ 91 #else /* ! (! defined (__mips_soft_float) && ! defined (__mips_single_float) ) */ 92 #define va_start(__AP, __LASTARG) \ 93 (__AP = ((__gnuc_va_list) __builtin_next_arg (__LASTARG) \ 94 - (__builtin_args_info (2) >= 8 ? 0 \ 95 : (8 - __builtin_args_info (2)) * __va_reg_size))) 96 #endif /* ! (! defined (__mips_soft_float) && ! defined (__mips_single_float) ) */ 97 #else /* ! defined (__mips_eabi) */ 98 #define va_start(__AP, __LASTARG) \ 99 (__AP = (__gnuc_va_list) __builtin_next_arg (__LASTARG)) 100 #endif /* ! (defined (__mips_eabi) && ! defined (__mips_soft_float) && ! defined (__mips_single_float)) */ 101 #else /* ! _STDARG_H */ 102 #define va_alist __builtin_va_alist 103 #ifdef __mips64 104 /* This assumes that `long long int' is always a 64 bit type. */ 105 #define va_dcl long long int __builtin_va_alist; __va_ellipsis 106 #else 107 #define va_dcl int __builtin_va_alist; __va_ellipsis 108 #endif 109 #if defined (__mips_eabi) 110 #if ! defined (__mips_soft_float) && ! defined (__mips_single_float) 111 #ifdef __mips64 112 #define va_start(__AP) \ 113 (__AP.__gp_regs = ((char *) __builtin_next_arg () \ 114 - (__builtin_args_info (2) < 8 \ 115 ? (8 - __builtin_args_info (2)) * __va_reg_size \ 116 : __va_reg_size)), \ 117 __AP.__fp_left = 8 - __builtin_args_info (3), \ 118 __AP.__fp_regs = __AP.__gp_regs - __AP.__fp_left * __va_reg_size) 119 #else /* ! defined (__mips64) */ 120 #define va_start(__AP) \ 121 (__AP.__gp_regs = ((char *) __builtin_next_arg () \ 122 - (__builtin_args_info (2) < 8 \ 123 ? (8 - __builtin_args_info (2)) * __va_reg_size \ 124 : __va_reg_size)), \ 125 __AP.__fp_left = (8 - __builtin_args_info (3)) / 2, \ 126 __AP.__fp_regs = __AP.__gp_regs - __AP.__fp_left * 8, \ 127 __AP.__fp_regs = (char *) ((int) __AP.__fp_regs & -8)) 128 #endif /* ! defined (__mips64) */ 129 #else /* ! (! defined (__mips_soft_float) && ! defined (__mips_single_float)) */ 130 #define va_start(__AP) \ 131 (__AP = ((__gnuc_va_list) __builtin_next_arg () \ 132 - (__builtin_args_info (2) >= 8 ? __va_reg_size \ 133 : (8 - __builtin_args_info (2)) * __va_reg_size))) 134 #endif /* ! (! defined (__mips_soft_float) && ! defined (__mips_single_float)) */ 135 /* Need alternate code for _MIPS_SIM_ABI64. */ 136 #elif defined(_MIPS_SIM) && (_MIPS_SIM == _MIPS_SIM_ABI64 || _MIPS_SIM == _MIPS_SIM_NABI32) 137 #define va_start(__AP) \ 138 (__AP = (__gnuc_va_list) __builtin_next_arg () \ 139 + (__builtin_args_info (2) >= 8 ? -8 : 0)) 140 #else 141 #define va_start(__AP) __AP = (char *) &__builtin_va_alist 142 #endif 143 #endif /* ! _STDARG_H */ 144 145 #ifndef va_end 146 void va_end (__gnuc_va_list); /* Defined in libgcc.a */ 147 #endif 148 #define va_end(__AP) ((void)0) 149 150 #if defined (__mips_eabi) 151 152 #if ! defined (__mips_soft_float) && ! defined (__mips_single_float) 153 #ifdef __mips64 154 #define __va_next_addr(__AP, __type) \ 155 ((__builtin_classify_type (*(__type *) 0) == __real_type_class \ 156 && __AP.__fp_left > 0) \ 157 ? (--__AP.__fp_left, (__AP.__fp_regs += 8) - 8) \ 158 : (__AP.__gp_regs += __va_reg_size) - __va_reg_size) 159 #else 160 #define __va_next_addr(__AP, __type) \ 161 ((__builtin_classify_type (*(__type *) 0) == __real_type_class \ 162 && __AP.__fp_left > 0) \ 163 ? (--__AP.__fp_left, (__AP.__fp_regs += 8) - 8) \ 164 : (((__builtin_classify_type (* (__type *) 0) < __record_type_class \ 165 && __alignof__ (__type) > 4) \ 166 ? __AP.__gp_regs = (char *) (((int) __AP.__gp_regs + 8 - 1) & -8) \ 167 : (char *) 0), \ 168 (__builtin_classify_type (* (__type *) 0) >= __record_type_class \ 169 ? (__AP.__gp_regs += __va_reg_size) - __va_reg_size \ 170 : ((__AP.__gp_regs += __va_rounded_size (__type)) \ 171 - __va_rounded_size (__type))))) 172 #endif 173 #else /* ! (! defined (__mips_soft_float) && ! defined (__mips_single_float)) */ 174 #ifdef __mips64 175 #define __va_next_addr(__AP, __type) \ 176 ((__AP += __va_reg_size) - __va_reg_size) 177 #else 178 #define __va_next_addr(__AP, __type) \ 179 (((__builtin_classify_type (* (__type *) 0) < __record_type_class \ 180 && __alignof__ (__type) > 4) \ 181 ? __AP = (char *) (((__PTRDIFF_TYPE__) __AP + 8 - 1) & -8) \ 182 : (char *) 0), \ 183 (__builtin_classify_type (* (__type *) 0) >= __record_type_class \ 184 ? (__AP += __va_reg_size) - __va_reg_size \ 185 : ((__AP += __va_rounded_size (__type)) \ 186 - __va_rounded_size (__type)))) 187 #endif 188 #endif /* ! (! defined (__mips_soft_float) && ! defined (__mips_single_float)) */ 189 190 #ifdef __MIPSEB__ 191 #define va_arg(__AP, __type) \ 192 ((__va_rounded_size (__type) <= __va_reg_size) \ 193 ? *(__type *) (void *) (__va_next_addr (__AP, __type) \ 194 + __va_reg_size \ 195 - sizeof (__type)) \ 196 : (__builtin_classify_type (*(__type *) 0) >= __record_type_class \ 197 ? **(__type **) (void *) (__va_next_addr (__AP, __type) \ 198 + __va_reg_size \ 199 - sizeof (char *)) \ 200 : *(__type *) (void *) __va_next_addr (__AP, __type))) 201 #else 202 #define va_arg(__AP, __type) \ 203 ((__va_rounded_size (__type) <= __va_reg_size) \ 204 ? *(__type *) (void *) __va_next_addr (__AP, __type) \ 205 : (__builtin_classify_type (* (__type *) 0) >= __record_type_class \ 206 ? **(__type **) (void *) __va_next_addr (__AP, __type) \ 207 : *(__type *) (void *) __va_next_addr (__AP, __type))) 208 #endif 209 210 #else /* ! defined (__mips_eabi) */ 211 212 /* We cast to void * and then to TYPE * because this avoids 213 a warning about increasing the alignment requirement. */ 214 /* The __mips64 cases are reversed from the 32 bit cases, because the standard 215 32 bit calling convention left-aligns all parameters smaller than a word, 216 whereas the __mips64 calling convention does not (and hence they are 217 right aligned). */ 218 #ifdef __mips64 219 #ifdef __MIPSEB__ 220 #define va_arg(__AP, __type) \ 221 ((__type *) (void *) (__AP = (char *) \ 222 ((((__PTRDIFF_TYPE__)__AP + 8 - 1) & -8) \ 223 + __va_rounded_size (__type))))[-1] 224 #else 225 #define va_arg(__AP, __type) \ 226 ((__AP = (char *) ((((__PTRDIFF_TYPE__)__AP + 8 - 1) & -8) \ 227 + __va_rounded_size (__type))), \ 228 *(__type *) (void *) (__AP - __va_rounded_size (__type))) 229 #endif 230 231 #else /* not __mips64 */ 232 233 #ifdef __MIPSEB__ 234 /* For big-endian machines. */ 235 #define va_arg(__AP, __type) \ 236 ((__AP = (char *) ((__alignof__ (__type) > 4 \ 237 ? ((__PTRDIFF_TYPE__)__AP + 8 - 1) & -8 \ 238 : ((__PTRDIFF_TYPE__)__AP + 4 - 1) & -4) \ 239 + __va_rounded_size (__type))), \ 240 *(__type *) (void *) (__AP - __va_rounded_size (__type))) 241 #else 242 /* For little-endian machines. */ 243 #define va_arg(__AP, __type) \ 244 ((__type *) (void *) (__AP = (char *) ((__alignof__(__type) > 4 \ 245 ? ((__PTRDIFF_TYPE__)__AP + 8 - 1) & -8 \ 246 : ((__PTRDIFF_TYPE__)__AP + 4 - 1) & -4) \ 247 + __va_rounded_size(__type))))[-1] 248 #endif 249 #endif 250 #endif /* ! defined (__mips_eabi) */ 251 252 /* Copy __gnuc_va_list into another variable of this type. */ 253 #define __va_copy(dest, src) (dest) = (src) 254 255 #else 256 257 typedef char *va_list; 258 #define _FP 1 259 #define _INT 0 260 #define _STRUCT 2 261 262 #define _VA_FP_SAVE_AREA 0x10 263 #define _VA_ALIGN(p, a) (((unsigned int)(((char *)p) + ((a) > 4 ? (a) : 4) - 1)) & -((a) > 4 ? (a) : 4)) 264 #define va_start(vp, parmN) (vp = ((va_list)&parmN + sizeof(parmN))) 265 266 #define __va_stack_arg(list, mode) \ 267 ( \ 268 ((list) = (char *)_VA_ALIGN(list, __builtin_alignof(mode)) + \ 269 _VA_ALIGN(sizeof(mode), 4)), \ 270 (((char *)list) - (_VA_ALIGN(sizeof(mode), 4) - sizeof(mode)))) 271 272 #define __va_double_arg(list, mode) \ 273 ( \ 274 (((long)list & 0x1) /* 1 byte aligned? */ \ 275 ? (list = (char *)((long)list + 7), (char *)((long)list - 6 - _VA_FP_SAVE_AREA)) \ 276 : (((long)list & 0x2) /* 2 byte aligned? */ \ 277 ? (list = (char *)((long)list + 10), (char *)((long)list - 24 - _VA_FP_SAVE_AREA)) \ 278 : __va_stack_arg(list, mode)))) 279 280 #define va_arg(list, mode) ((mode *)(((__builtin_classof(mode) == _FP && \ 281 __builtin_alignof(mode) == sizeof(double)) \ 282 ? __va_double_arg(list, mode) \ 283 : __va_stack_arg(list, mode))))[-1] 284 #define va_end(__list) 285 286 #endif 287 #endif