1 /* { dg-do run } */
2 /* { dg-options "-fno-inline -fomit-frame-pointer -fno-rename-registers" } */
3 /* { dg-additional-options "-mdynamic-no-pic" { target *-*-darwin* } } */
4
5 /* -fno-inline -maltivec -m32/-m64 -mmultiple/no-multiple -Os/-O2. */
6 #ifndef NO_BODY
7 #define abort() __builtin_abort ()
8 #define vec_all_eq(v1,v2) __builtin_vec_vcmpeq_p (2, v1, v2)
9 #define SET(T,R,V) register T R __asm__ (#R) = V
10 #define SET_GPR(R,V) SET (long, R, V)
11 #define SET_FPR(R,V) SET (double, R, V)
12 #define SET_VR(R,V) SET (__attribute__ ((vector_size (16))) int, R, V)
13 /* There doesn't seem to be a way of letting gcc know that cr2, cr3
14 and cr4 are being used, and therefore should not be touched by
15 gcc. Unlike gpr, fpr and vr we can't do something like
16 register __attribute__ ((__mode__ ("__CC__"))) int cr2 __asm__ ("cr2");
17 This makes the test somewhat fragile, dependent on gcc not using
18 any of cr2, cr3 and cr4 in main(), and is why -fno-rename-registers
19 is required. */
20 #define SET_CR(R,V) __asm__ __volatile__ ("mtcrf %0,%1" : : "n" (1<<(7-R)), "r" (V<<(4*(7-R))) : "cr" #R)
21 #define TRASH_GPR(R) SET_GPR (R, 0)
22 #define TRASH_FPR(R) SET_FPR (R, 0)
23 #define TRASH_VR(R) SET_VR (R, val0)
24 #define TRASH_CR(R) SET_CR (R, 0)
25 #define TRASH_SOME_GPR TRASH_GPR (r30); TRASH_GPR (r31)
26 #define TRASH_SOME_FPR TRASH_FPR (fr28); TRASH_FPR (fr31)
27 #define TRASH_SOME_VR TRASH_VR (v26); TRASH_VR (v27); TRASH_VR (v31)
28 #define TRASH_SOME_CR TRASH_CR (2)
29 #define TRASH_ALL_GPR TRASH_GPR (r14); TRASH_GPR (r15); TRASH_GPR (r16); TRASH_GPR (r17); TRASH_GPR (r18); TRASH_GPR (r19); TRASH_GPR (r20); TRASH_GPR (r21); TRASH_GPR (r22); TRASH_GPR (r23); TRASH_GPR (r24); TRASH_GPR (r25); TRASH_GPR (r26); TRASH_GPR (r27); TRASH_GPR (r28); TRASH_GPR (r29); TRASH_GPR (r30); TRASH_GPR (r31)
30 #define TRASH_ALL_FPR TRASH_FPR (fr14); TRASH_FPR (fr15); TRASH_FPR (fr16); TRASH_FPR (fr17); TRASH_FPR (fr18); TRASH_FPR (fr19); TRASH_FPR (fr20); TRASH_FPR (fr21); TRASH_FPR (fr22); TRASH_FPR (fr23); TRASH_FPR (fr24); TRASH_FPR (fr25); TRASH_FPR (fr26); TRASH_FPR (fr27); TRASH_FPR (fr28); TRASH_FPR (fr29); TRASH_FPR (fr30); TRASH_FPR (fr31)
31 #define TRASH_ALL_VR TRASH_VR (v20); TRASH_VR (v21); TRASH_VR (v22); TRASH_VR (v23); TRASH_VR (v24); TRASH_VR (v25); TRASH_VR (v26); TRASH_VR (v27); TRASH_VR (v28); TRASH_VR (v29); TRASH_VR (v30); TRASH_VR (v31)
32 #define TRASH_ALL_CR TRASH_CR (2); TRASH_CR (3); TRASH_CR (4)
33 #define USE_SOME_GPR __asm__ __volatile__ ("#%0 %1" : : "r" (r30), "r" (r31))
34 #define USE_SOME_FPR __asm__ __volatile__ ("#%0 %1" : : "f" (fr28), "f" (fr31))
35 #define USE_SOME_VR __asm__ __volatile__ ("#%0 %1 %2" : : "v" (v26), "v" (v27), "v" (v31))
36 #define USE_SOME_CR
37 #define USE_ALL_GPR __asm__ __volatile__ ("#%0 %1 %2 %3 %4 %5 %6 %7 %8 %9 %10 %11 %12 %13 %14 %15 %16 %17" : : "r" (r14), "r" (r15), "r" (r16), "r" (r17), "r" (r18), "r" (r19), "r" (r20), "r" (r21), "r" (r22), "r" (r23), "r" (r24), "r" (r25), "r" (r26), "r" (r27), "r" (r28), "r" (r29), "r" (r30), "r" (r31))
38 #define USE_ALL_FPR __asm__ __volatile__ ("#%0 %1 %2 %3 %4 %5 %6 %7 %8 %9 %10 %11 %12 %13 %14 %15 %16 %17" : : "f" (fr14), "f" (fr15), "f" (fr16), "f" (fr17), "f" (fr18), "f" (fr19), "f" (fr20), "f" (fr21), "f" (fr22), "f" (fr23), "f" (fr24), "f" (fr25), "f" (fr26), "f" (fr27), "f" (fr28), "f" (fr29), "f" (fr30), "f" (fr31))
39 #define USE_ALL_VR __asm__ __volatile__ ("#%0 %1 %2 %3 %4 %5 %6 %7 %8 %9 %10 %11" : : "v" (v20), "v" (v21), "v" (v22), "v" (v23), "v" (v24), "v" (v25), "v" (v26), "v" (v27), "v" (v28), "v" (v29), "v" (v30), "v" (v31))
40 #define USE_ALL_CR
41
42 #define INIT_GPR SET_GPR (r14, 14); SET_GPR (r15, 15); SET_GPR (r16, 16); SET_GPR (r17, 17); SET_GPR (r18, 18); SET_GPR (r19, 19); SET_GPR (r20, 20); SET_GPR (r21, 21); SET_GPR (r22, 22); SET_GPR (r23, 23); SET_GPR (r24, 24); SET_GPR (r25, 25); SET_GPR (r26, 26); SET_GPR (r27, 27); SET_GPR (r28, 28); SET_GPR (r29, 29); SET_GPR (r30, 30); SET_GPR (r31, 31)
43 #define INIT_FPR SET_FPR (fr14, 140.0); SET_FPR (fr15, 150.0); SET_FPR (fr16, 160.0); SET_FPR (fr17, 170.0); SET_FPR (fr18, 180.0); SET_FPR (fr19, 190.0); SET_FPR (fr20, 200.0); SET_FPR (fr21, 210.0); SET_FPR (fr22, 220.0); SET_FPR (fr23, 230.0); SET_FPR (fr24, 240.0); SET_FPR (fr25, 250.0); SET_FPR (fr26, 260.0); SET_FPR (fr27, 270.0); SET_FPR (fr28, 280.0); SET_FPR (fr29, 290.0); SET_FPR (fr30, 300.0); SET_FPR (fr31, 310.0)
44 #define INIT_VR SET_VR (v20, val20); SET_VR (v21, val21); SET_VR (v22, val22); SET_VR (v23, val23); SET_VR (v24, val24); SET_VR (v25, val25); SET_VR (v26, val26); SET_VR (v27, val27); SET_VR (v28, val28); SET_VR (v29, val29); SET_VR (v30, val30); SET_VR (v31, val31)
45 #define INIT_CR SET_CR (2, 6); SET_CR (3, 7); SET_CR (4, 8)
46 #ifdef __ALTIVEC__
47 __attribute__ ((vector_size (16))) int val0 = {0,0,0,0};
48 __attribute__ ((vector_size (16))) int val20 = {-201,-202,-203,-204};
49 __attribute__ ((vector_size (16))) int val21 = {-211,-212,-213,-214};
50 __attribute__ ((vector_size (16))) int val22 = {-221,-222,-223,-224};
51 __attribute__ ((vector_size (16))) int val23 = {-231,-232,-233,-234};
52 __attribute__ ((vector_size (16))) int val24 = {-241,-242,-243,-244};
53 __attribute__ ((vector_size (16))) int val25 = {-251,-252,-253,-254};
54 __attribute__ ((vector_size (16))) int val26 = {-261,-262,-263,-264};
55 __attribute__ ((vector_size (16))) int val27 = {-271,-272,-273,-274};
56 __attribute__ ((vector_size (16))) int val28 = {-281,-282,-283,-284};
57 __attribute__ ((vector_size (16))) int val29 = {-291,-292,-293,-294};
58 __attribute__ ((vector_size (16))) int val30 = {-301,-302,-303,-304};
59 __attribute__ ((vector_size (16))) int val31 = {-311,-312,-313,-314};
60 #define INIT_REGS INIT_VR; INIT_FPR; INIT_GPR; INIT_CR
61 #else
62 #ifndef __NO_FPRS__
63 #define INIT_REGS INIT_FPR; INIT_GPR; INIT_CR
64 #else
65 #define INIT_REGS INIT_GPR; INIT_CR
66 #endif
67 #endif
68 #define VERIFY_GPR if (r14 != 14 || r15 != 15 || r16 != 16 || r17 != 17 || r18 != 18 || r19 != 19 || r20 != 20 || r21 != 21 || r22 != 22 || r23 != 23 || r24 != 24 || r25 != 25 || r26 != 26 || r27 != 27 || r28 != 28 || r29 != 29 || r30 != 30 || r31 != 31) abort ()
69 #define VERIFY_FPR if (fr14 != 140.0 || fr15 != 150.0 || fr16 != 160.0 || fr17 != 170.0 || fr18 != 180.0 || fr19 != 190.0 || fr20 != 200.0 || fr21 != 210.0 || fr22 != 220.0 || fr23 != 230.0 || fr24 != 240.0 || fr25 != 250.0 || fr26 != 260.0 || fr27 != 270.0 || fr28 != 280.0 || fr29 != 290.0 || fr30 != 300.0 || fr31 != 310.0) abort ()
70 #define VERIFY_VR if (!vec_all_eq (v20, val20) || !vec_all_eq (v21, val21) || !vec_all_eq (v22, val22) || !vec_all_eq (v23, val23) || !vec_all_eq (v24, val24) || !vec_all_eq (v25, val25) || !vec_all_eq (v26, val26) || !vec_all_eq (v27, val27) || !vec_all_eq (v28, val28) || !vec_all_eq (v29, val29) || !vec_all_eq (v30, val30) || !vec_all_eq (v31, val31)) abort ()
71 #define VERIFY_CR ({ int tmp; __asm__ __volatile__ ("mfcr %0" : "=r" (tmp)); if ((tmp & ((15 << 20) | (15 << 16) | (15 << 12))) != ((6 << 20) | (7 << 16) | (8 << 12))) abort (); })
72 #ifdef __ALTIVEC__
73 #define VERIFY_REGS VERIFY_VR; VERIFY_FPR; VERIFY_GPR; VERIFY_CR
74 #else
75 #ifndef __NO_FPRS__
76 #define VERIFY_REGS VERIFY_FPR; VERIFY_GPR; VERIFY_CR
77 #else
78 #define VERIFY_REGS VERIFY_GPR; VERIFY_CR
79 #endif
80 #endif
81
82 #else /* NO_BODY */
83 /* For looking at prologue and epilogue code without distractions. */
84 #define abort()
85 #define TRASH_ALL_CR
86 #define TRASH_ALL_VR
87 #define TRASH_ALL_FPR
88 #define TRASH_ALL_GPR
89 #define USE_ALL_CR
90 #define USE_ALL_VR
91 #define USE_ALL_FPR
92 #define USE_ALL_GPR
93 #define TRASH_SOME_CR
94 #define TRASH_SOME_VR
95 #define TRASH_SOME_FPR
96 #define TRASH_SOME_GPR
97 #define USE_SOME_CR
98 #define USE_SOME_VR
99 #define USE_SOME_FPR
100 #define USE_SOME_GPR
101 #define INIT_REGS
102 #define VERIFY_REGS
103 #endif
104
105 #ifdef __ALTIVEC__
106 #ifndef __NO_FPRS__
107 void b_all (void)
108 {
109 char a[33000];
110 TRASH_ALL_CR;
111 TRASH_ALL_VR;
112 TRASH_ALL_FPR;
113 TRASH_ALL_GPR;
114 USE_ALL_CR;
115 USE_ALL_VR;
116 USE_ALL_FPR;
117 USE_ALL_GPR;
118 __asm __volatile ("#%0" : "=m" (a) : : "cr2", "cr3", "cr4", "v20", "v21", "v22", "v23", "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31", "fr14", "fr15", "fr16", "fr17", "fr18", "fr19", "fr20", "fr21", "fr22", "fr23", "fr24", "fr25", "fr26", "fr27", "fr28", "fr29", "fr30", "fr31", "r14", "r15", "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31");
119 }
120
121 void b_cvfr (void)
122 {
123 char a[33000];
124 TRASH_SOME_CR;
125 TRASH_SOME_VR;
126 TRASH_SOME_FPR;
127 TRASH_SOME_GPR;
128 USE_SOME_CR;
129 USE_SOME_VR;
130 USE_SOME_FPR;
131 USE_SOME_GPR;
132 __asm __volatile ("#%0" : "=m" (a) : : "cr2", "v26", "v27", "v31", "fr28", "fr31", "r30", "r31");
133 }
134
135 void b_vfr (void)
136 {
137 char a[33000];
138 TRASH_SOME_VR;
139 TRASH_SOME_FPR;
140 TRASH_SOME_GPR;
141 USE_SOME_VR;
142 USE_SOME_FPR;
143 USE_SOME_GPR;
144 __asm __volatile ("#%0" : "=m" (a) : : "v26", "v27", "v31", "fr28", "fr31", "r30", "r31");
145 }
146
147 void b_cvf (void)
148 {
149 char a[33000];
150 TRASH_SOME_CR;
151 TRASH_SOME_VR;
152 TRASH_SOME_FPR;
153 USE_SOME_CR;
154 USE_SOME_VR;
155 USE_SOME_FPR;
156 __asm __volatile ("#%0" : "=m" (a) : : "cr2", "v26", "v27", "v31", "fr28", "fr31");
157 }
158
159 void b_vf (void)
160 {
161 char a[33000];
162 TRASH_SOME_VR;
163 TRASH_SOME_FPR;
164 USE_SOME_VR;
165 USE_SOME_FPR;
166 __asm __volatile ("#%0" : "=m" (a) : : "v26", "v27", "v31", "fr28", "fr31");
167 }
168 #endif
169
170 void b_cvr (void)
171 {
172 char a[33000];
173 TRASH_SOME_CR;
174 TRASH_SOME_VR;
175 TRASH_SOME_GPR;
176 USE_SOME_CR;
177 USE_SOME_VR;
178 USE_SOME_GPR;
179 __asm __volatile ("#%0" : "=m" (a) : : "cr2", "v26", "v27", "v31", "r30", "r31");
180 }
181
182 void b_vr (void)
183 {
184 char a[33000];
185 TRASH_SOME_VR;
186 TRASH_SOME_GPR;
187 USE_SOME_VR;
188 USE_SOME_GPR;
189 __asm __volatile ("#%0" : "=m" (a) : : "v26", "v27", "v31", "r30", "r31");
190 }
191
192 void b_cv (void)
193 {
194 char a[33000];
195 TRASH_SOME_CR;
196 TRASH_SOME_VR;
197 USE_SOME_CR;
198 USE_SOME_VR;
199 __asm __volatile ("#%0" : "=m" (a) : : "cr2", "v26", "v27", "v31");
200 }
201
202 void b_v (void)
203 {
204 char a[33000];
205 TRASH_SOME_VR;
206 USE_SOME_VR;
207 __asm __volatile ("#%0" : "=m" (a) : : "v26", "v27", "v31");
208 }
209 #endif
210
211 #ifndef __NO_FPRS__
212 void b_cfr (void)
213 {
214 char a[33000];
215 TRASH_SOME_CR;
216 TRASH_SOME_FPR;
217 TRASH_SOME_GPR;
218 USE_SOME_CR;
219 USE_SOME_FPR;
220 USE_SOME_GPR;
221 __asm __volatile ("#%0" : "=m" (a) : : "cr2", "fr28", "fr31", "r30", "r31");
222 }
223
224 void b_fr (void)
225 {
226 char a[33000];
227 TRASH_SOME_FPR;
228 TRASH_SOME_GPR;
229 USE_SOME_FPR;
230 USE_SOME_GPR;
231 __asm __volatile ("#%0" : "=m" (a) : : "fr28", "fr31", "r30", "r31");
232 }
233
234 void b_cf (void)
235 {
236 char a[33000];
237 TRASH_SOME_CR;
238 TRASH_SOME_FPR;
239 USE_SOME_CR;
240 USE_SOME_FPR;
241 __asm __volatile ("#%0" : "=m" (a) : : "cr2", "fr28", "fr31");
242 }
243
244 void b_f (void)
245 {
246 char a[33000];
247 TRASH_SOME_FPR;
248 USE_SOME_FPR;
249 __asm __volatile ("#%0" : "=m" (a) : : "fr28", "fr31");
250 }
251 #endif
252
253 void b_cr (void)
254 {
255 char a[33000];
256 TRASH_SOME_CR;
257 TRASH_SOME_GPR;
258 USE_SOME_CR;
259 USE_SOME_GPR;
260 __asm __volatile ("#%0" : "=m" (a) : : "cr2", "r30", "r31");
261 }
262
263 void b_r (void)
264 {
265 char a[33000];
266 TRASH_SOME_GPR;
267 USE_SOME_GPR;
268 __asm __volatile ("#%0" : "=m" (a) : : "r30", "r31");
269 }
270
271 void b_c (void)
272 {
273 char a[33000];
274 TRASH_SOME_CR;
275 USE_SOME_CR;
276 __asm __volatile ("#%0" : "=m" (a) : : "cr2");
277 }
278
279 void b_0 (void)
280 {
281 char a[33000];
282 __asm __volatile ("#%0" : "=m" (a) );
283 }
284
285 #ifdef __ALTIVEC__
286 #ifndef __NO_FPRS__
287 void s_all (void)
288 {
289 char a[33];
290 TRASH_ALL_CR;
291 TRASH_ALL_VR;
292 TRASH_ALL_FPR;
293 TRASH_ALL_GPR;
294 USE_ALL_CR;
295 USE_ALL_VR;
296 USE_ALL_FPR;
297 USE_ALL_GPR;
298 __asm __volatile ("#%0" : "=m" (a) : : "cr2", "cr3", "cr4", "v20", "v21", "v22", "v23", "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31", "fr14", "fr15", "fr16", "fr17", "fr18", "fr19", "fr20", "fr21", "fr22", "fr23", "fr24", "fr25", "fr26", "fr27", "fr28", "fr29", "fr30", "fr31", "r14", "r15", "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31");
299 }
300
301 void s_cvfr (void)
302 {
303 char a[33];
304 TRASH_SOME_CR;
305 TRASH_SOME_VR;
306 TRASH_SOME_FPR;
307 TRASH_SOME_GPR;
308 USE_SOME_CR;
309 USE_SOME_VR;
310 USE_SOME_FPR;
311 USE_SOME_GPR;
312 __asm __volatile ("#%0" : "=m" (a) : : "cr2", "v26", "v27", "v31", "fr28", "fr31", "r30", "r31");
313 }
314
315 void s_vfr (void)
316 {
317 char a[33];
318 TRASH_SOME_VR;
319 TRASH_SOME_FPR;
320 TRASH_SOME_GPR;
321 USE_SOME_VR;
322 USE_SOME_FPR;
323 USE_SOME_GPR;
324 __asm __volatile ("#%0" : "=m" (a) : : "v26", "v27", "v31", "fr28", "fr31", "r30", "r31");
325 }
326
327 void s_cvf (void)
328 {
329 char a[33];
330 TRASH_SOME_CR;
331 TRASH_SOME_VR;
332 TRASH_SOME_FPR;
333 USE_SOME_CR;
334 USE_SOME_VR;
335 USE_SOME_FPR;
336 __asm __volatile ("#%0" : "=m" (a) : : "cr2", "v26", "v27", "v31", "fr28", "fr31");
337 }
338
339 void s_vf (void)
340 {
341 char a[33];
342 TRASH_SOME_VR;
343 TRASH_SOME_FPR;
344 USE_SOME_VR;
345 USE_SOME_FPR;
346 __asm __volatile ("#%0" : "=m" (a) : : "v26", "v27", "v31", "fr28", "fr31");
347 }
348 #endif
349
350 void s_cvr (void)
351 {
352 char a[33];
353 TRASH_SOME_CR;
354 TRASH_SOME_VR;
355 TRASH_SOME_GPR;
356 USE_SOME_CR;
357 USE_SOME_VR;
358 USE_SOME_GPR;
359 __asm __volatile ("#%0" : "=m" (a) : : "cr2", "v26", "v27", "v31", "r30", "r31");
360 }
361
362 void s_vr (void)
363 {
364 char a[33];
365 TRASH_SOME_VR;
366 TRASH_SOME_GPR;
367 USE_SOME_VR;
368 USE_SOME_GPR;
369 __asm __volatile ("#%0" : "=m" (a) : : "v26", "v27", "v31", "r30", "r31");
370 }
371
372 void s_cv (void)
373 {
374 char a[33];
375 TRASH_SOME_CR;
376 TRASH_SOME_VR;
377 USE_SOME_CR;
378 USE_SOME_VR;
379 __asm __volatile ("#%0" : "=m" (a) : : "cr2", "v26", "v27", "v31");
380 }
381
382 void s_v (void)
383 {
384 char a[33];
385 TRASH_SOME_VR;
386 USE_SOME_VR;
387 __asm __volatile ("#%0" : "=m" (a) : : "v26", "v27", "v31");
388 }
389 #endif
390
391 #ifndef __NO_FPRS__
392 void s_cfr (void)
393 {
394 char a[33];
395 TRASH_SOME_CR;
396 TRASH_SOME_FPR;
397 TRASH_SOME_GPR;
398 USE_SOME_CR;
399 USE_SOME_FPR;
400 USE_SOME_GPR;
401 __asm __volatile ("#%0" : "=m" (a) : : "cr2", "fr28", "fr31", "r30", "r31");
402 }
403
404 void s_fr (void)
405 {
406 char a[33];
407 TRASH_SOME_FPR;
408 TRASH_SOME_GPR;
409 USE_SOME_FPR;
410 USE_SOME_GPR;
411 __asm __volatile ("#%0" : "=m" (a) : : "fr28", "fr31", "r30", "r31");
412 }
413
414 void s_cf (void)
415 {
416 char a[33];
417 TRASH_SOME_CR;
418 TRASH_SOME_FPR;
419 USE_SOME_CR;
420 USE_SOME_FPR;
421 __asm __volatile ("#%0" : "=m" (a) : : "cr2", "fr28", "fr31");
422 }
423
424 void s_f (void)
425 {
426 char a[33];
427 TRASH_SOME_FPR;
428 USE_SOME_FPR;
429 __asm __volatile ("#%0" : "=m" (a) : : "fr28", "fr31");
430 }
431 #endif
432
433 void s_cr (void)
434 {
435 char a[33];
436 TRASH_SOME_CR;
437 TRASH_SOME_GPR;
438 USE_SOME_CR;
439 USE_SOME_GPR;
440 __asm __volatile ("#%0" : "=m" (a) : : "cr2", "r30", "r31");
441 }
442
443 void s_r (void)
444 {
445 char a[33];
446 TRASH_SOME_GPR;
447 USE_SOME_GPR;
448 __asm __volatile ("#%0" : "=m" (a) : : "r30", "r31");
449 }
450
451 void s_r31 (void)
452 {
453 char a[33];
454 #ifndef NO_BODY
455 TRASH_GPR (r31);
456 __asm__ __volatile__ ("#%0" : : "r" (r31));
457 #endif
458 __asm __volatile ("#%0" : "=m" (a) : : "r31");
459 }
460
461 void s_c (void)
462 {
463 char a[33];
464 TRASH_SOME_CR;
465 USE_SOME_CR;
466 __asm __volatile ("#%0" : "=m" (a) : : "cr2");
467 }
468
469 void s_0 (void)
470 {
471 char a[33];
472 __asm __volatile ("#%0" : "=m" (a) );
473 }
474
475 #ifdef __ALTIVEC__
476 #ifndef __NO_FPRS__
477 void wb_all (void)
478 {
479 char b[10];
480 char *nb_all (void)
481 {
482 char a[33000];
483 TRASH_ALL_CR;
484 TRASH_ALL_VR;
485 TRASH_ALL_FPR;
486 TRASH_ALL_GPR;
487 USE_ALL_CR;
488 USE_ALL_VR;
489 USE_ALL_FPR;
490 USE_ALL_GPR;
491 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "cr3", "cr4", "v20", "v21", "v22", "v23", "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31", "fr14", "fr15", "fr16", "fr17", "fr18", "fr19", "fr20", "fr21", "fr22", "fr23", "fr24", "fr25", "fr26", "fr27", "fr28", "fr29", "fr30", "fr31", "r14", "r15", "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31");
492 return b;
493 }
494 if (nb_all() != b)
495 abort ();
496 }
497
498 void wb_cvfr (void)
499 {
500 char b[10];
501 char *nb_cvfr (void)
502 {
503 char a[33000];
504 TRASH_SOME_CR;
505 TRASH_SOME_VR;
506 TRASH_SOME_FPR;
507 TRASH_SOME_GPR;
508 USE_SOME_CR;
509 USE_SOME_VR;
510 USE_SOME_FPR;
511 USE_SOME_GPR;
512 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "v26", "v27", "v31", "fr28", "fr31", "r30", "r31");
513 return b;
514 }
515 if (nb_cvfr () != b)
516 abort ();
517 }
518
519 void wb_vfr (void)
520 {
521 char b[10];
522 char *nb_vfr (void)
523 {
524 char a[33000];
525 TRASH_SOME_VR;
526 TRASH_SOME_FPR;
527 TRASH_SOME_GPR;
528 USE_SOME_VR;
529 USE_SOME_FPR;
530 USE_SOME_GPR;
531 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "v26", "v27", "v31", "fr28", "fr31", "r30", "r31");
532 return b;
533 }
534 if (nb_vfr () != b)
535 abort ();
536 }
537
538 void wb_cvf (void)
539 {
540 char b[10];
541 char *nb_cvf (void)
542 {
543 char a[33000];
544 TRASH_SOME_CR;
545 TRASH_SOME_VR;
546 TRASH_SOME_FPR;
547 USE_SOME_CR;
548 USE_SOME_VR;
549 USE_SOME_FPR;
550 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "v26", "v27", "v31", "fr28", "fr31");
551 return b;
552 }
553 if (nb_cvf () != b)
554 abort ();
555 }
556
557 void wb_vf (void)
558 {
559 char b[10];
560 char *nb_vf (void)
561 {
562 char a[33000];
563 TRASH_SOME_VR;
564 TRASH_SOME_FPR;
565 USE_SOME_VR;
566 USE_SOME_FPR;
567 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "v26", "v27", "v31", "fr28", "fr31");
568 return b;
569 }
570 if (nb_vf () != b)
571 abort ();
572 }
573 #endif
574
575 void wb_cvr (void)
576 {
577 char b[10];
578 char *nb_cvr (void)
579 {
580 char a[33000];
581 TRASH_SOME_CR;
582 TRASH_SOME_VR;
583 TRASH_SOME_GPR;
584 USE_SOME_CR;
585 USE_SOME_VR;
586 USE_SOME_GPR;
587 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "v26", "v27", "v31", "r30", "r31");
588 return b;
589 }
590 if (nb_cvr () != b)
591 abort ();
592 }
593
594 void wb_vr (void)
595 {
596 char b[10];
597 char *nb_vr (void)
598 {
599 char a[33000];
600 TRASH_SOME_VR;
601 TRASH_SOME_GPR;
602 USE_SOME_VR;
603 USE_SOME_GPR;
604 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "v26", "v27", "v31", "r30", "r31");
605 return b;
606 }
607 if (nb_vr () != b)
608 abort ();
609 }
610
611 void wb_cv (void)
612 {
613 char b[10];
614 char *nb_cv (void)
615 {
616 char a[33000];
617 TRASH_SOME_CR;
618 TRASH_SOME_VR;
619 USE_SOME_CR;
620 USE_SOME_VR;
621 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "v26", "v27", "v31");
622 return b;
623 }
624 if (nb_cv () != b)
625 abort ();
626 }
627
628 void wb_v (void)
629 {
630 char b[10];
631 char *nb_v (void)
632 {
633 char a[33000];
634 TRASH_SOME_VR;
635 USE_SOME_VR;
636 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "v26", "v27", "v31");
637 return b;
638 }
639 if (nb_v () != b)
640 abort ();
641 }
642 #endif
643
644 #ifndef __NO_FPRS__
645 void wb_cfr (void)
646 {
647 char b[10];
648 char *nb_cfr (void)
649 {
650 char a[33000];
651 TRASH_SOME_CR;
652 TRASH_SOME_FPR;
653 TRASH_SOME_GPR;
654 USE_SOME_CR;
655 USE_SOME_FPR;
656 USE_SOME_GPR;
657 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "fr28", "fr31", "r30", "r31");
658 return b;
659 }
660 if (nb_cfr () != b)
661 abort ();
662 }
663
664 void wb_fr (void)
665 {
666 char b[10];
667 char *nb_fr (void)
668 {
669 char a[33000];
670 TRASH_SOME_FPR;
671 TRASH_SOME_GPR;
672 USE_SOME_FPR;
673 USE_SOME_GPR;
674 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "fr28", "fr31", "r30", "r31");
675 return b;
676 }
677 if (nb_fr () != b)
678 abort ();
679 }
680
681 void wb_cf (void)
682 {
683 char b[10];
684 char *nb_cf (void)
685 {
686 char a[33000];
687 TRASH_SOME_CR;
688 TRASH_SOME_FPR;
689 USE_SOME_CR;
690 USE_SOME_FPR;
691 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "fr28", "fr31");
692 return b;
693 }
694 if (nb_cf () != b)
695 abort ();
696 }
697
698 void wb_f (void)
699 {
700 char b[10];
701 char *nb_f (void)
702 {
703 char a[33000];
704 TRASH_SOME_FPR;
705 USE_SOME_FPR;
706 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "fr28", "fr31");
707 return b;
708 }
709 if (nb_f () != b)
710 abort ();
711 }
712 #endif
713
714 void wb_cr (void)
715 {
716 char b[10];
717 char *nb_cr (void)
718 {
719 char a[33000];
720 TRASH_SOME_CR;
721 TRASH_SOME_GPR;
722 USE_SOME_CR;
723 USE_SOME_GPR;
724 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "r30", "r31");
725 return b;
726 }
727 if (nb_cr () != b)
728 abort ();
729 }
730
731 void wb_r (void)
732 {
733 char b[10];
734 char *nb_r (void)
735 {
736 char a[33000];
737 TRASH_SOME_GPR;
738 USE_SOME_GPR;
739 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "r30", "r31");
740 return b;
741 }
742 if (nb_r () != b)
743 abort ();
744 }
745
746 void wb_c (void)
747 {
748 char b[10];
749 char *nb_c (void)
750 {
751 char a[33000];
752 TRASH_SOME_CR;
753 USE_SOME_CR;
754 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2");
755 return b;
756 }
757 if (nb_c () != b)
758 abort ();
759 }
760
761 void wb_0 (void)
762 {
763 char b[10];
764 char *nb_0 (void)
765 {
766 char a[33000];
767 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) );
768 return b;
769 }
770 if (nb_0 () != b)
771 abort ();
772 }
773
774 #ifdef __ALTIVEC__
775 #ifndef __NO_FPRS__
776 void ws_all (void)
777 {
778 char b[10];
779 char *ns_all (void)
780 {
781 char a[33];
782 TRASH_ALL_CR;
783 TRASH_ALL_VR;
784 TRASH_ALL_FPR;
785 TRASH_ALL_GPR;
786 USE_ALL_CR;
787 USE_ALL_VR;
788 USE_ALL_FPR;
789 USE_ALL_GPR;
790 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "cr3", "cr4", "v20", "v21", "v22", "v23", "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31", "fr14", "fr15", "fr16", "fr17", "fr18", "fr19", "fr20", "fr21", "fr22", "fr23", "fr24", "fr25", "fr26", "fr27", "fr28", "fr29", "fr30", "fr31", "r14", "r15", "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31");
791 return b;
792 }
793 if (ns_all() != b)
794 abort ();
795 }
796
797 void ws_cvfr (void)
798 {
799 char b[10];
800 char *ns_cvfr (void)
801 {
802 char a[33];
803 TRASH_SOME_CR;
804 TRASH_SOME_VR;
805 TRASH_SOME_FPR;
806 TRASH_SOME_GPR;
807 USE_SOME_CR;
808 USE_SOME_VR;
809 USE_SOME_FPR;
810 USE_SOME_GPR;
811 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "v26", "v27", "v31", "fr28", "fr31", "r30", "r31");
812 return b;
813 }
814 if (ns_cvfr () != b)
815 abort ();
816 }
817
818 void ws_vfr (void)
819 {
820 char b[10];
821 char *ns_vfr (void)
822 {
823 char a[33];
824 TRASH_SOME_VR;
825 TRASH_SOME_FPR;
826 TRASH_SOME_GPR;
827 USE_SOME_VR;
828 USE_SOME_FPR;
829 USE_SOME_GPR;
830 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "v26", "v27", "v31", "fr28", "fr31", "r30", "r31");
831 return b;
832 }
833 if (ns_vfr () != b)
834 abort ();
835 }
836
837 void ws_cvf (void)
838 {
839 char b[10];
840 char *ns_cvf (void)
841 {
842 char a[33];
843 TRASH_SOME_CR;
844 TRASH_SOME_VR;
845 TRASH_SOME_FPR;
846 USE_SOME_CR;
847 USE_SOME_VR;
848 USE_SOME_FPR;
849 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "v26", "v27", "v31", "fr28", "fr31");
850 return b;
851 }
852 if (ns_cvf () != b)
853 abort ();
854 }
855
856 void ws_vf (void)
857 {
858 char b[10];
859 char *ns_vf (void)
860 {
861 char a[33];
862 TRASH_SOME_VR;
863 TRASH_SOME_FPR;
864 USE_SOME_VR;
865 USE_SOME_FPR;
866 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "v26", "v27", "v31", "fr28", "fr31");
867 return b;
868 }
869 if (ns_vf () != b)
870 abort ();
871 }
872 #endif
873
874 void ws_cvr (void)
875 {
876 char b[10];
877 char *ns_cvr (void)
878 {
879 char a[33];
880 TRASH_SOME_CR;
881 TRASH_SOME_VR;
882 TRASH_SOME_GPR;
883 USE_SOME_CR;
884 USE_SOME_VR;
885 USE_SOME_GPR;
886 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "v26", "v27", "v31", "r30", "r31");
887 return b;
888 }
889 if (ns_cvr () != b)
890 abort ();
891 }
892
893 void ws_vr (void)
894 {
895 char b[10];
896 char *ns_vr (void)
897 {
898 char a[33];
899 TRASH_SOME_VR;
900 TRASH_SOME_FPR;
901 USE_SOME_VR;
902 USE_SOME_FPR;
903 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "v26", "v27", "v31", "r30", "r31");
904 return b;
905 }
906 if (ns_vr () != b)
907 abort ();
908 }
909
910 void ws_cv (void)
911 {
912 char b[10];
913 char *ns_cv (void)
914 {
915 char a[33];
916 TRASH_SOME_CR;
917 TRASH_SOME_VR;
918 USE_SOME_CR;
919 USE_SOME_VR;
920 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "v26", "v27", "v31");
921 return b;
922 }
923 if (ns_cv () != b)
924 abort ();
925 }
926
927 void ws_v (void)
928 {
929 char b[10];
930 char *ns_v (void)
931 {
932 char a[33];
933 TRASH_SOME_VR;
934 USE_SOME_VR;
935 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "v26", "v27", "v31");
936 return b;
937 }
938 if (ns_v () != b)
939 abort ();
940 }
941 #endif
942
943 #ifndef __NO_FPRS__
944 void ws_cfr (void)
945 {
946 char b[10];
947 char *ns_cfr (void)
948 {
949 char a[33];
950 TRASH_SOME_CR;
951 TRASH_SOME_FPR;
952 TRASH_SOME_GPR;
953 USE_SOME_CR;
954 USE_SOME_FPR;
955 USE_SOME_GPR;
956 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "fr28", "fr31", "r30", "r31");
957 return b;
958 }
959 if (ns_cfr () != b)
960 abort ();
961 }
962
963 void ws_fr (void)
964 {
965 char b[10];
966 char *ns_fr (void)
967 {
968 char a[33];
969 TRASH_SOME_FPR;
970 TRASH_SOME_GPR;
971 USE_SOME_FPR;
972 USE_SOME_GPR;
973 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "fr28", "fr31", "r30", "r31");
974 return b;
975 }
976 if (ns_fr () != b)
977 abort ();
978 }
979
980 void ws_cf (void)
981 {
982 char b[10];
983 char *ns_cf (void)
984 {
985 char a[33];
986 TRASH_SOME_CR;
987 TRASH_SOME_FPR;
988 USE_SOME_CR;
989 USE_SOME_FPR;
990 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "fr28", "fr31");
991 return b;
992 }
993 if (ns_cf () != b)
994 abort ();
995 }
996
997 void ws_f (void)
998 {
999 char b[10];
1000 char *ns_f (void)
1001 {
1002 char a[33];
1003 TRASH_SOME_FPR;
1004 USE_SOME_FPR;
1005 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "fr28", "fr31");
1006 return b;
1007 }
1008 if (ns_f () != b)
1009 abort ();
1010 }
1011 #endif
1012
1013 void ws_cr (void)
1014 {
1015 char b[10];
1016 char *ns_cr (void)
1017 {
1018 char a[33];
1019 TRASH_SOME_CR;
1020 TRASH_SOME_GPR;
1021 USE_SOME_CR;
1022 USE_SOME_GPR;
1023 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "r30", "r31");
1024 return b;
1025 }
1026 if (ns_cr () != b)
1027 abort ();
1028 }
1029
1030 void ws_r (void)
1031 {
1032 char b[10];
1033 char *ns_r (void)
1034 {
1035 char a[33];
1036 TRASH_SOME_GPR;
1037 USE_SOME_GPR;
1038 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "r30", "r31");
1039 return b;
1040 }
1041 if (ns_r () != b)
1042 abort ();
1043 }
1044
1045 void ws_c (void)
1046 {
1047 char b[10];
1048 char *ns_c (void)
1049 {
1050 char a[33];
1051 TRASH_SOME_CR;
1052 USE_SOME_CR;
1053 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2");
1054 return b;
1055 }
1056 if (ns_c () != b)
1057 abort ();
1058 }
1059
1060 void ws_0 (void)
1061 {
1062 char b[10];
1063 char *ns_0 (void)
1064 {
1065 char a[33];
1066 __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) );
1067 return b;
1068 }
1069 if (ns_0 () != b)
1070 abort ();
1071 }
1072
1073 /* We'd like to compile main with
1074 __attribute__ ((__optimize__ ("fixed-cr2,fixed-cr3,fixed-cr4")))
1075 but that doesn't do anything currently. Obviously we don't want to
1076 compile the whole file with -ffixed-cr2 -ffixed-cr3 -ffixed-cr4 as
1077 that would also tell gcc not to save/restore cr, and we're trying
1078 to check that the above functions do save/restore cr.
1079 __attribute__ ((__optimize__ ("no-rename-registers,omit-frame-pointer")))
1080 works, but it seems odd to need omit-frame-pointer and raises the
1081 question of whether darwin would need -mdynamic-no-pic.
1082 So for now use -fno-rename-registers over the whole test. */
1083 int
1084 main (void)
1085 {
1086 INIT_REGS;
1087 USE_ALL_CR;
1088 #ifdef __ALTIVEC__
1089 USE_ALL_VR;
1090 #ifndef __NO_FPRS__
1091 USE_ALL_FPR;
1092 #endif
1093 #endif
1094 USE_ALL_GPR;
1095 #ifdef __ALTIVEC__
1096 #ifndef __NO_FPRS__
1097 b_all ();
1098 VERIFY_REGS;
1099 b_cvfr ();
1100 VERIFY_REGS;
1101 b_vfr ();
1102 VERIFY_REGS;
1103 b_cvf ();
1104 VERIFY_REGS;
1105 b_vf ();
1106 VERIFY_REGS;
1107 #endif
1108 b_cvr ();
1109 VERIFY_REGS;
1110 b_vr ();
1111 VERIFY_REGS;
1112 b_cv ();
1113 VERIFY_REGS;
1114 b_v ();
1115 VERIFY_REGS;
1116 #endif
1117 #ifndef __NO_FPRS__
1118 b_cfr ();
1119 VERIFY_REGS;
1120 b_fr ();
1121 VERIFY_REGS;
1122 b_cf ();
1123 VERIFY_REGS;
1124 b_f ();
1125 VERIFY_REGS;
1126 #endif
1127 b_cr ();
1128 VERIFY_REGS;
1129 b_r ();
1130 VERIFY_REGS;
1131 b_c ();
1132 VERIFY_REGS;
1133 b_0 ();
1134 VERIFY_REGS;
1135 #ifdef __ALTIVEC__
1136 #ifndef __NO_FPRS__
1137 s_all ();
1138 VERIFY_REGS;
1139 s_cvfr ();
1140 VERIFY_REGS;
1141 s_vfr ();
1142 VERIFY_REGS;
1143 s_cvf ();
1144 VERIFY_REGS;
1145 s_vf ();
1146 VERIFY_REGS;
1147 #endif
1148 s_cvr ();
1149 VERIFY_REGS;
1150 s_vr ();
1151 VERIFY_REGS;
1152 s_cv ();
1153 VERIFY_REGS;
1154 s_v ();
1155 VERIFY_REGS;
1156 #endif
1157 #ifndef __NO_FPRS__
1158 s_cfr ();
1159 VERIFY_REGS;
1160 s_fr ();
1161 VERIFY_REGS;
1162 s_cf ();
1163 VERIFY_REGS;
1164 s_f ();
1165 VERIFY_REGS;
1166 #endif
1167 s_cr ();
1168 VERIFY_REGS;
1169 s_r ();
1170 VERIFY_REGS;
1171 s_r31 ();
1172 VERIFY_REGS;
1173 s_c ();
1174 VERIFY_REGS;
1175 s_0 ();
1176 VERIFY_REGS;
1177 #ifdef __ALTIVEC__
1178 #ifndef __NO_FPRS__
1179 wb_all ();
1180 VERIFY_REGS;
1181 wb_cvfr ();
1182 VERIFY_REGS;
1183 wb_vfr ();
1184 VERIFY_REGS;
1185 wb_cvf ();
1186 VERIFY_REGS;
1187 wb_vf ();
1188 VERIFY_REGS;
1189 #endif
1190 wb_cvr ();
1191 VERIFY_REGS;
1192 wb_vr ();
1193 VERIFY_REGS;
1194 wb_cv ();
1195 VERIFY_REGS;
1196 wb_v ();
1197 VERIFY_REGS;
1198 #endif
1199 #ifndef __NO_FPRS__
1200 wb_cfr ();
1201 VERIFY_REGS;
1202 wb_fr ();
1203 VERIFY_REGS;
1204 wb_cf ();
1205 VERIFY_REGS;
1206 wb_f ();
1207 VERIFY_REGS;
1208 #endif
1209 wb_cr ();
1210 VERIFY_REGS;
1211 wb_r ();
1212 VERIFY_REGS;
1213 wb_c ();
1214 VERIFY_REGS;
1215 wb_0 ();
1216 VERIFY_REGS;
1217 #ifdef __ALTIVEC__
1218 #ifndef __NO_FPRS__
1219 ws_all ();
1220 VERIFY_REGS;
1221 ws_cvfr ();
1222 VERIFY_REGS;
1223 ws_vfr ();
1224 VERIFY_REGS;
1225 ws_cvf ();
1226 VERIFY_REGS;
1227 ws_vf ();
1228 VERIFY_REGS;
1229 #endif
1230 ws_cvr ();
1231 VERIFY_REGS;
1232 ws_vr ();
1233 VERIFY_REGS;
1234 ws_cv ();
1235 VERIFY_REGS;
1236 ws_v ();
1237 VERIFY_REGS;
1238 #endif
1239 #ifndef __NO_FPRS__
1240 ws_cfr ();
1241 VERIFY_REGS;
1242 ws_fr ();
1243 VERIFY_REGS;
1244 ws_cf ();
1245 VERIFY_REGS;
1246 ws_f ();
1247 VERIFY_REGS;
1248 #endif
1249 ws_cr ();
1250 VERIFY_REGS;
1251 ws_r ();
1252 VERIFY_REGS;
1253 ws_c ();
1254 VERIFY_REGS;
1255 ws_0 ();
1256 VERIFY_REGS;
1257 return 0;
1258 }