1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 * 22 * Copyright 2000 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 /* This is just like the default gvarargs.h 27 except for differences described below. */ 28 29 /* Define __gnuc_va_list. */ 30 31 #ifndef __GNUC_VA_LIST 32 #define __GNUC_VA_LIST 33 34 #pragma ident "%Z%%M% %I% %E% SMI" 35 36 #ifdef __sparc_v9__ 37 typedef long long __va_greg; 38 typedef double __va_freg; 39 typedef struct { 40 __va_greg * __va_next_o; /* next available %o* register */ 41 __va_greg * __va_next_o_limit; /* past last available %o* register */ 42 __va_freg * __va_next_fp; /* next available %f* register */ 43 __va_freg * __va_next_fp_limit; /* last available %f* register */ 44 __va_greg * __va_next_stack; /* next extended word on stack */ 45 } __gnuc_va_list; 46 #else 47 #ifndef __svr4__ 48 /* This has to be a char * to be compatible with Sun. 49 i.e., we have to pass a `va_list' to vsprintf. */ 50 typedef char * __gnuc_va_list; 51 #else 52 /* This has to be a void * to be compatible with Sun svr4. 53 i.e., we have to pass a `va_list' to vsprintf. */ 54 typedef void * __gnuc_va_list; 55 #endif 56 #endif /* not __sparc_v9__ */ 57 #endif /* not __GNUC_VA_LIST */ 58 59 /* If this is for internal libc use, don't define anything but 60 __gnuc_va_list. */ 61 #if defined (_STDARG_H) || defined (_VARARGS_H) 62 63 #ifdef _KERNEL 64 /* 65 * The Solaris kernel stdarg style va_start() even though it includes 66 * <sys/varargs.h>. 67 */ 68 #define _STDARG_H 69 #undef _VARARGS_H 70 #endif /* _KERNEL */ 71 72 #ifdef _STDARG_H 73 74 #ifdef __sparc_v9__ 75 #define va_start(AP, LASTARG) \ 76 __extension__ \ 77 ({ \ 78 AP.__va_next_o = (__va_greg *) __builtin_saveregs (); \ 79 AP.__va_next_o_limit = (AP.__va_next_o + \ 80 (__builtin_args_info (0) < 6 ? 6 - __builtin_args_info (0) : 0)); \ 81 AP.__va_next_fp = (__va_freg *) AP.__va_next_o_limit; \ 82 AP.__va_next_fp_limit = (AP.__va_next_fp + \ 83 (__builtin_args_info (1) < 16 ? (16 - __builtin_args_info (1) + 1) / 2 : 0)); \ 84 AP.__va_next_stack = (__va_greg *) __builtin_next_arg (LASTARG); \ 85 }) 86 #else 87 /* Call __builtin_next_arg even though we aren't using its value, so that 88 we can verify that LASTARG is correct. */ 89 #ifdef __GCC_NEW_VARARGS__ 90 #define va_start(AP, LASTARG) \ 91 (__builtin_next_arg (LASTARG), AP = (char *) __builtin_saveregs ()) 92 #else 93 #define va_start(AP, LASTARG) \ 94 (__builtin_saveregs (), AP = ((char *) __builtin_next_arg (LASTARG))) 95 #endif 96 #endif /* not __sparc_v9__ */ 97 98 #else 99 100 #define va_alist __builtin_va_alist 101 #define va_dcl int __builtin_va_alist;... 102 103 #ifdef __sparc_v9__ 104 #ifdef __sparcv9 105 #define va_start(AP) \ 106 __extension__ \ 107 ({ \ 108 AP.__va_next_o = (__va_greg *) __builtin_saveregs (); \ 109 AP.__va_next_o_limit = (AP.__va_next_o + \ 110 (__builtin_args_info (0) < 6 ? 6 - __builtin_args_info (0) : 0)); \ 111 AP.__va_next_fp = (__va_freg *) AP.__va_next_o_limit; \ 112 AP.__va_next_fp_limit = (AP.__va_next_fp + \ 113 (__builtin_args_info (1) < 16 ? (16 - __builtin_args_info (1) + 1) / 2 : 0)); \ 114 /* CYGNUS LOCAL dje/sparc64 */ \ 115 AP.__va_next_stack = (__va_greg *) __builtin_next_arg (__builtin_va_alist) \ 116 - (__builtin_args_info (0) >= 6 || __builtin_args_info (1) >= 16 ? 1 : 0); \ 117 }) 118 #else /* __sparcv9 */ 119 #define va_start(AP) \ 120 __extension__ \ 121 ({ \ 122 AP.__va_next_o = (__va_greg *) __builtin_saveregs (); \ 123 AP.__va_next_o_limit = (AP.__va_next_o + \ 124 (__builtin_args_info (0) < 6 ? 6 - __builtin_args_info (0) : 0)); \ 125 AP.__va_next_fp = (__va_freg *) AP.__va_next_o_limit; \ 126 AP.__va_next_fp_limit = (AP.__va_next_fp + \ 127 (__builtin_args_info (1) < 16 ? (16 - __builtin_args_info (1) + 1) / 2 : 0)); \ 128 /* CYGNUS LOCAL dje/sparc64 */ \ 129 AP.__va_next_stack = (__va_greg *) __builtin_next_arg (__builtin_va_alist) \ 130 - (__builtin_args_info (0) >= 6 || __builtin_args_info (1) >= 16 ? 1 : 0); \ 131 }) 132 #endif /* __sparcv9 */ 133 #else 134 #ifdef __GCC_NEW_VARARGS__ 135 #define va_start(AP) ((AP) = (char *) __builtin_saveregs ()) 136 #else 137 #define va_start(AP) \ 138 (__builtin_saveregs (), (AP) = ((char *) &__builtin_va_alist)) 139 #endif 140 #endif /* not __sparc_v9__ */ 141 142 #endif 143 144 #ifndef va_end 145 void va_end (__gnuc_va_list); /* Defined in libgcc.a */ 146 147 /* Values returned by __builtin_classify_type. */ 148 149 enum __va_type_classes { 150 __no_type_class = -1, 151 __void_type_class, 152 __integer_type_class, 153 __char_type_class, 154 __enumeral_type_class, 155 __boolean_type_class, 156 __pointer_type_class, 157 __reference_type_class, 158 __offset_type_class, 159 __real_type_class, 160 __complex_type_class, 161 __function_type_class, 162 __method_type_class, 163 __record_type_class, 164 __union_type_class, 165 __array_type_class, 166 __string_type_class, 167 __set_type_class, 168 __file_type_class, 169 __lang_type_class 170 }; 171 172 #endif 173 #define va_end(pvar) ((void)0) 174 175 /* Avoid errors if compiling GCC v2 with GCC v1. */ 176 #if __GNUC__ == 1 177 #define __extension__ 178 #endif 179 180 /* RECORD_TYPE args passed using the C calling convention are 181 passed by invisible reference. ??? RECORD_TYPE args passed 182 in the stack are made to be word-aligned; for an aggregate that is 183 not word-aligned, we advance the pointer to the first non-reg slot. */ 184 185 #ifdef __sparc_v9__ 186 187 #define va_arg(pvar,TYPE) \ 188 __extension__ \ 189 (*({int __type = __builtin_classify_type (* (TYPE *) 0); \ 190 void * __result; \ 191 if (__type == __real_type_class) /* float? */ \ 192 { \ 193 __va_freg *__r; \ 194 /* see PASS_IN_REG_P in gcc's sparc.h */ \ 195 if (pvar.__va_next_fp < pvar.__va_next_fp_limit \ 196 && ((__r = (__va_freg *) (((__va_greg) pvar.__va_next_fp + sizeof (TYPE) - 1) & ~(__va_greg) (sizeof (TYPE) - 1))) \ 197 < pvar.__va_next_fp_limit)) \ 198 { \ 199 pvar.__va_next_fp = __r + (sizeof (TYPE) + 7) / 8; \ 200 } \ 201 else \ 202 { \ 203 __r = (__va_freg *) pvar.__va_next_stack; \ 204 pvar.__va_next_stack += (sizeof (TYPE) + 7) / 8; \ 205 } \ 206 __result = __r; \ 207 } \ 208 else if (__type < __record_type_class) /* integer? */ \ 209 { \ 210 __va_greg *__r; \ 211 if (pvar.__va_next_o < pvar.__va_next_o_limit) \ 212 __r = pvar.__va_next_o++; \ 213 else \ 214 __r = pvar.__va_next_stack++; \ 215 /* adjust for 4 byte ints */ \ 216 __result = (char *) __r + 8 - sizeof (TYPE); \ 217 } \ 218 else /* aggregate object */ \ 219 { \ 220 void **__r; \ 221 if (pvar.__va_next_o < pvar.__va_next_o_limit) \ 222 __r = (void **) pvar.__va_next_o++; \ 223 else \ 224 __r = (void **) pvar.__va_next_stack++; \ 225 __result = *__r; \ 226 } \ 227 (TYPE *) __result;})) 228 229 #else /* not __sparc_v9__ */ 230 231 #define __va_rounded_size(TYPE) \ 232 (((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int)) 233 234 /* We don't declare the union member `d' to have type TYPE 235 because that would lose in C++ if TYPE has a constructor. */ 236 /* We cast to void * and then to TYPE * because this avoids 237 a warning about increasing the alignment requirement. 238 The casts to char * avoid warnings about invalid pointer arithmetic. */ 239 #define va_arg(pvar,TYPE) \ 240 __extension__ \ 241 (*({((__builtin_classify_type (*(TYPE*) 0) >= __record_type_class \ 242 || (__builtin_classify_type (*(TYPE*) 0) == __real_type_class \ 243 && sizeof (TYPE) == 16)) \ 244 ? ((pvar) = (char *)(pvar) + __va_rounded_size (TYPE *), \ 245 *(TYPE **) (void *) ((char *)(pvar) - __va_rounded_size (TYPE *))) \ 246 : __va_rounded_size (TYPE) == 8 \ 247 ? ({ union {char __d[sizeof (TYPE)]; int __i[2];} __u; \ 248 __u.__i[0] = ((int *) (void *) (pvar))[0]; \ 249 __u.__i[1] = ((int *) (void *) (pvar))[1]; \ 250 (pvar) = (char *)(pvar) + 8; \ 251 (TYPE *) (void *) __u.__d; }) \ 252 : ((pvar) = (char *)(pvar) + __va_rounded_size (TYPE), \ 253 ((TYPE *) (void *) ((char *)(pvar) - __va_rounded_size (TYPE)))));})) 254 #endif /* not __sparc_v9__ */ 255 256 #endif /* defined (_STDARG_H) || defined (_VARARGS_H) */ 257