![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to va-alpha.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to va-alpha.h CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* GNU C varargs and stdargs support for the DEC Alpha. */
2:
3: /* Note: We must use the name __builtin_savregs. GCC attaches special
4: significance to that name. In particular, regardless of where in a
5: function __builtin_saveregs is called, GCC moves the call up to the
6: very start of the function. */
7:
8: /* Define __gnuc_va_list. */
9:
10: #ifndef __GNUC_VA_LIST
11: #define __GNUC_VA_LIST
12:
13: typedef struct {
14: long __va_arg; /* Current argument number. */
15: long *__va_stack; /* Start of arguments on stack */
16: long *__va_iregs; /* Integer parameter registers ($16-$21) */
17: long *__va_fregs; /* FP parameter registers ($f16-$f21) */
18: } __gnuc_va_list;
19: #endif /* not __GNUC_VA_LIST */
20:
21: /* If this is for internal libc use, don't define anything but
22: __gnuc_va_list. */
23: #if defined (_STDARG_H) || defined (_VARARGS_H)
24:
25: #define va_list __gnuc_va_list
26: #define _VA_LIST
27: #define _VA_LIST_
28:
29: #if !defined(_STDARG_H)
30:
31: /* varargs support */
32: #define va_alist __builtin_va_alist
33: #define va_dcl
34: #define va_start(pvar) ((pvar) = * (__gnuc_va_list *) __builtin_saveregs ())
35:
36: #else /* STDARG.H */
37:
38: /* ANSI alternative. */
39:
40: #define va_start(pvar, firstarg) \
41: ((pvar) = *(__gnuc_va_list *) __builtin_saveregs ())
42:
43: #endif /* _STDARG_H */
44:
45: #ifndef va_end
46:
47: #define va_end(__va)
48:
49: /* Values returned by __builtin_classify_type. */
50:
51: enum {
52: __no_type_class = -1,
53: __void_type_class,
54: __integer_type_class,
55: __char_type_class,
56: __enumeral_type_class,
57: __boolean_type_class,
58: __pointer_type_class,
59: __reference_type_class,
60: __offset_type_class,
61: __real_type_class,
62: __complex_type_class,
63: __function_type_class,
64: __method_type_class,
65: __record_type_class,
66: __union_type_class,
67: __array_type_class,
68: __string_type_class,
69: __set_type_class,
70: __file_type_class,
71: __lang_type_class
72: };
73:
74: #endif
75:
76: /* Note that parameters are always aligned at least to a word boundary
77: (when passed) regardless of what GCC's __alignof__ operator says. */
78:
79: /* Avoid errors if compiling GCC v2 with GCC v1. */
80: #if __GNUC__ == 1
81: #define __extension__
82: #endif
83:
84: /* Get the rounded number of words of a type. */
85:
86: #define __va_nwords(__type) \
87: ((sizeof (__type) + sizeof (long) - 1) / sizeof (long))
88:
89: #define va_arg(__va, __type) \
90: __extension__ \
91: (* (__type *) \
92: ({ \
93: register void *__rv; /* result value */ \
94: switch (__builtin_classify_type (* (__type *) 0)) \
95: { \
96: case __real_type_class: \
97: \
98: /* Get a pointer to the value. If we want a float instead of \
99: a double, we have to make one and point to it instead. */ \
100: \
101: __rv = (void *) & ((__va).__va_arg < 6 \
102: ? (__va).__va_fregs[(__va).__va_arg] \
103: : (__va).__va_stack[(__va).__va_arg - 6]); \
104: \
105: if (sizeof (__type) == sizeof (float)) \
106: { \
107: float __rf = * ((double *) __rv); \
108: \
109: __rv = (void *) &__rf; \
110: } \
111: \
112: break; \
113: \
114: case __void_type_class: \
115: case __integer_type_class: \
116: case __char_type_class: \
117: case __enumeral_type_class: \
118: case __boolean_type_class: \
119: case __pointer_type_class: \
120: case __reference_type_class: \
121: case __offset_type_class: \
122: case __record_type_class: \
123: case __union_type_class: \
124: \
125: /* Force this on the stack if it's alignment isn't right. */ \
126: \
127: if ((__va).__va_arg < 6) \
128: switch (sizeof (__type)) \
129: { \
130: case sizeof (char): \
131: break; \
132: case sizeof (short): \
133: if (__alignof__ (__type) < sizeof (short)) \
134: (__va).__va_arg = 6; \
135: break; \
136: case 3: \
137: case sizeof (int): \
138: if (__alignof__ (__type) < sizeof (int)) \
139: (__va).__va_arg = 6; \
140: break; \
141: default: \
142: if (__alignof__ (__type) < sizeof (long)) \
143: (__va).__va_arg = 6; \
144: break; \
145: } \
146: \
147: /* If this object is only one word long, just get it. If it is \
148: longer, we need to worry about the possibility that it is \
149: passed both in registers and in memory. */ \
150: \
151: if (sizeof (__type) <= sizeof (long) \
152: || (__va).__va_arg >= 6 \
153: || (__va).__va_arg + __va_nwords (__type) < 6) \
154: __rv = (void *) & ((__va).__va_arg < 6 \
155: ? (__va).__va_iregs[(__va).__va_arg] \
156: : (__va).__va_stack[(__va).__va_arg - 6]); \
157: else \
158: { \
159: long __obj[__va_nwords (__type)]; \
160: int __i; \
161: \
162: for (__i = 0; __i < __va_nwords (__type); __i++) \
163: __obj[__i] = ((__va).__va_arg + __i < 6 \
164: ? (__va).__va_iregs[(__va).__va_arg + __i] \
165: : (__va).__va_stack[(__va).__va_arg + __i - 6]); \
166: \
167: __rv = (void *) &__obj[0]; \
168: } \
169: break; \
170: \
171: case __complex_type_class: \
172: case __function_type_class: \
173: case __method_type_class: \
174: case __array_type_class: \
175: case __string_type_class: \
176: case __set_type_class: \
177: case __file_type_class: \
178: case __lang_type_class: \
179: case __no_type_class: \
180: default: \
181: abort (); \
182: } \
183: \
184: (__va).__va_arg += __va_nwords (__type); \
185: \
186: __rv; \
187: }))
188:
189: #endif /* defined (_STDARG_H) || defined (_VARARGS_H) */
190:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.