xref: /titanic_41/usr/src/uts/common/sys/va-sparc.h (revision 7c478bd95313f5f23a4c958a745db2134aa03244)
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