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