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__
37typedef long long __va_greg;
38typedef double __va_freg;
39typedef 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.  */
50typedef 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.  */
54typedef 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
145void va_end (__gnuc_va_list);		/* Defined in libgcc.a */
146
147/* Values returned by __builtin_classify_type.  */
148
149enum __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