| /* { dg-do run } */ |
| /* { dg-options "-fno-inline -fomit-frame-pointer -fno-rename-registers" } */ |
| /* { dg-additional-options "-mdynamic-no-pic" { target *-*-darwin* } } */ |
| |
| /* -fno-inline -maltivec -m32/-m64 -mmultiple/no-multiple -Os/-O2. */ |
| #ifndef NO_BODY |
| #define abort() __builtin_abort () |
| #define vec_all_eq(v1,v2) __builtin_vec_vcmpeq_p (2, v1, v2) |
| #define SET(T,R,V) register T R __asm__ (#R) = V |
| #define SET_GPR(R,V) SET (long, R, V) |
| #define SET_FPR(R,V) SET (double, R, V) |
| #define SET_VR(R,V) SET (__attribute__ ((vector_size (16))) int, R, V) |
| /* There doesn't seem to be a way of letting gcc know that cr2, cr3 |
| and cr4 are being used, and therefore should not be touched by |
| gcc. Unlike gpr, fpr and vr we can't do something like |
| register __attribute__ ((__mode__ ("__CC__"))) int cr2 __asm__ ("cr2"); |
| This makes the test somewhat fragile, dependent on gcc not using |
| any of cr2, cr3 and cr4 in main(), and is why -fno-rename-registers |
| is required. */ |
| #define SET_CR(R,V) __asm__ __volatile__ ("mtcrf %0,%1" : : "n" (1<<(7-R)), "r" (V<<(4*(7-R))) : "cr" #R) |
| #define TRASH_GPR(R) SET_GPR (R, 0) |
| #define TRASH_FPR(R) SET_FPR (R, 0) |
| #define TRASH_VR(R) SET_VR (R, val0) |
| #define TRASH_CR(R) SET_CR (R, 0) |
| #define TRASH_SOME_GPR TRASH_GPR (r30); TRASH_GPR (r31) |
| #define TRASH_SOME_FPR TRASH_FPR (fr28); TRASH_FPR (fr31) |
| #define TRASH_SOME_VR TRASH_VR (v26); TRASH_VR (v27); TRASH_VR (v31) |
| #define TRASH_SOME_CR TRASH_CR (2) |
| #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) |
| #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) |
| #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) |
| #define TRASH_ALL_CR TRASH_CR (2); TRASH_CR (3); TRASH_CR (4) |
| #define USE_SOME_GPR __asm__ __volatile__ ("#%0 %1" : : "r" (r30), "r" (r31)) |
| #define USE_SOME_FPR __asm__ __volatile__ ("#%0 %1" : : "f" (fr28), "f" (fr31)) |
| #define USE_SOME_VR __asm__ __volatile__ ("#%0 %1 %2" : : "v" (v26), "v" (v27), "v" (v31)) |
| #define USE_SOME_CR |
| #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)) |
| #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)) |
| #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)) |
| #define USE_ALL_CR |
| |
| #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) |
| #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) |
| #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) |
| #define INIT_CR SET_CR (2, 6); SET_CR (3, 7); SET_CR (4, 8) |
| #ifdef __ALTIVEC__ |
| __attribute__ ((vector_size (16))) int val0 = {0,0,0,0}; |
| __attribute__ ((vector_size (16))) int val20 = {-201,-202,-203,-204}; |
| __attribute__ ((vector_size (16))) int val21 = {-211,-212,-213,-214}; |
| __attribute__ ((vector_size (16))) int val22 = {-221,-222,-223,-224}; |
| __attribute__ ((vector_size (16))) int val23 = {-231,-232,-233,-234}; |
| __attribute__ ((vector_size (16))) int val24 = {-241,-242,-243,-244}; |
| __attribute__ ((vector_size (16))) int val25 = {-251,-252,-253,-254}; |
| __attribute__ ((vector_size (16))) int val26 = {-261,-262,-263,-264}; |
| __attribute__ ((vector_size (16))) int val27 = {-271,-272,-273,-274}; |
| __attribute__ ((vector_size (16))) int val28 = {-281,-282,-283,-284}; |
| __attribute__ ((vector_size (16))) int val29 = {-291,-292,-293,-294}; |
| __attribute__ ((vector_size (16))) int val30 = {-301,-302,-303,-304}; |
| __attribute__ ((vector_size (16))) int val31 = {-311,-312,-313,-314}; |
| #define INIT_REGS INIT_VR; INIT_FPR; INIT_GPR; INIT_CR |
| #else |
| #ifndef __NO_FPRS__ |
| #define INIT_REGS INIT_FPR; INIT_GPR; INIT_CR |
| #else |
| #define INIT_REGS INIT_GPR; INIT_CR |
| #endif |
| #endif |
| #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 () |
| #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 () |
| #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 () |
| #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 (); }) |
| #ifdef __ALTIVEC__ |
| #define VERIFY_REGS VERIFY_VR; VERIFY_FPR; VERIFY_GPR; VERIFY_CR |
| #else |
| #ifndef __NO_FPRS__ |
| #define VERIFY_REGS VERIFY_FPR; VERIFY_GPR; VERIFY_CR |
| #else |
| #define VERIFY_REGS VERIFY_GPR; VERIFY_CR |
| #endif |
| #endif |
| |
| #else /* NO_BODY */ |
| /* For looking at prologue and epilogue code without distractions. */ |
| #define abort() |
| #define TRASH_ALL_CR |
| #define TRASH_ALL_VR |
| #define TRASH_ALL_FPR |
| #define TRASH_ALL_GPR |
| #define USE_ALL_CR |
| #define USE_ALL_VR |
| #define USE_ALL_FPR |
| #define USE_ALL_GPR |
| #define TRASH_SOME_CR |
| #define TRASH_SOME_VR |
| #define TRASH_SOME_FPR |
| #define TRASH_SOME_GPR |
| #define USE_SOME_CR |
| #define USE_SOME_VR |
| #define USE_SOME_FPR |
| #define USE_SOME_GPR |
| #define INIT_REGS |
| #define VERIFY_REGS |
| #endif |
| |
| #ifdef __ALTIVEC__ |
| #ifndef __NO_FPRS__ |
| void b_all (void) |
| { |
| char a[33000]; |
| TRASH_ALL_CR; |
| TRASH_ALL_VR; |
| TRASH_ALL_FPR; |
| TRASH_ALL_GPR; |
| USE_ALL_CR; |
| USE_ALL_VR; |
| USE_ALL_FPR; |
| USE_ALL_GPR; |
| __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"); |
| } |
| |
| void b_cvfr (void) |
| { |
| char a[33000]; |
| TRASH_SOME_CR; |
| TRASH_SOME_VR; |
| TRASH_SOME_FPR; |
| TRASH_SOME_GPR; |
| USE_SOME_CR; |
| USE_SOME_VR; |
| USE_SOME_FPR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0" : "=m" (a) : : "cr2", "v26", "v27", "v31", "fr28", "fr31", "r30", "r31"); |
| } |
| |
| void b_vfr (void) |
| { |
| char a[33000]; |
| TRASH_SOME_VR; |
| TRASH_SOME_FPR; |
| TRASH_SOME_GPR; |
| USE_SOME_VR; |
| USE_SOME_FPR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0" : "=m" (a) : : "v26", "v27", "v31", "fr28", "fr31", "r30", "r31"); |
| } |
| |
| void b_cvf (void) |
| { |
| char a[33000]; |
| TRASH_SOME_CR; |
| TRASH_SOME_VR; |
| TRASH_SOME_FPR; |
| USE_SOME_CR; |
| USE_SOME_VR; |
| USE_SOME_FPR; |
| __asm __volatile ("#%0" : "=m" (a) : : "cr2", "v26", "v27", "v31", "fr28", "fr31"); |
| } |
| |
| void b_vf (void) |
| { |
| char a[33000]; |
| TRASH_SOME_VR; |
| TRASH_SOME_FPR; |
| USE_SOME_VR; |
| USE_SOME_FPR; |
| __asm __volatile ("#%0" : "=m" (a) : : "v26", "v27", "v31", "fr28", "fr31"); |
| } |
| #endif |
| |
| void b_cvr (void) |
| { |
| char a[33000]; |
| TRASH_SOME_CR; |
| TRASH_SOME_VR; |
| TRASH_SOME_GPR; |
| USE_SOME_CR; |
| USE_SOME_VR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0" : "=m" (a) : : "cr2", "v26", "v27", "v31", "r30", "r31"); |
| } |
| |
| void b_vr (void) |
| { |
| char a[33000]; |
| TRASH_SOME_VR; |
| TRASH_SOME_GPR; |
| USE_SOME_VR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0" : "=m" (a) : : "v26", "v27", "v31", "r30", "r31"); |
| } |
| |
| void b_cv (void) |
| { |
| char a[33000]; |
| TRASH_SOME_CR; |
| TRASH_SOME_VR; |
| USE_SOME_CR; |
| USE_SOME_VR; |
| __asm __volatile ("#%0" : "=m" (a) : : "cr2", "v26", "v27", "v31"); |
| } |
| |
| void b_v (void) |
| { |
| char a[33000]; |
| TRASH_SOME_VR; |
| USE_SOME_VR; |
| __asm __volatile ("#%0" : "=m" (a) : : "v26", "v27", "v31"); |
| } |
| #endif |
| |
| #ifndef __NO_FPRS__ |
| void b_cfr (void) |
| { |
| char a[33000]; |
| TRASH_SOME_CR; |
| TRASH_SOME_FPR; |
| TRASH_SOME_GPR; |
| USE_SOME_CR; |
| USE_SOME_FPR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0" : "=m" (a) : : "cr2", "fr28", "fr31", "r30", "r31"); |
| } |
| |
| void b_fr (void) |
| { |
| char a[33000]; |
| TRASH_SOME_FPR; |
| TRASH_SOME_GPR; |
| USE_SOME_FPR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0" : "=m" (a) : : "fr28", "fr31", "r30", "r31"); |
| } |
| |
| void b_cf (void) |
| { |
| char a[33000]; |
| TRASH_SOME_CR; |
| TRASH_SOME_FPR; |
| USE_SOME_CR; |
| USE_SOME_FPR; |
| __asm __volatile ("#%0" : "=m" (a) : : "cr2", "fr28", "fr31"); |
| } |
| |
| void b_f (void) |
| { |
| char a[33000]; |
| TRASH_SOME_FPR; |
| USE_SOME_FPR; |
| __asm __volatile ("#%0" : "=m" (a) : : "fr28", "fr31"); |
| } |
| #endif |
| |
| void b_cr (void) |
| { |
| char a[33000]; |
| TRASH_SOME_CR; |
| TRASH_SOME_GPR; |
| USE_SOME_CR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0" : "=m" (a) : : "cr2", "r30", "r31"); |
| } |
| |
| void b_r (void) |
| { |
| char a[33000]; |
| TRASH_SOME_GPR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0" : "=m" (a) : : "r30", "r31"); |
| } |
| |
| void b_c (void) |
| { |
| char a[33000]; |
| TRASH_SOME_CR; |
| USE_SOME_CR; |
| __asm __volatile ("#%0" : "=m" (a) : : "cr2"); |
| } |
| |
| void b_0 (void) |
| { |
| char a[33000]; |
| __asm __volatile ("#%0" : "=m" (a) ); |
| } |
| |
| #ifdef __ALTIVEC__ |
| #ifndef __NO_FPRS__ |
| void s_all (void) |
| { |
| char a[33]; |
| TRASH_ALL_CR; |
| TRASH_ALL_VR; |
| TRASH_ALL_FPR; |
| TRASH_ALL_GPR; |
| USE_ALL_CR; |
| USE_ALL_VR; |
| USE_ALL_FPR; |
| USE_ALL_GPR; |
| __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"); |
| } |
| |
| void s_cvfr (void) |
| { |
| char a[33]; |
| TRASH_SOME_CR; |
| TRASH_SOME_VR; |
| TRASH_SOME_FPR; |
| TRASH_SOME_GPR; |
| USE_SOME_CR; |
| USE_SOME_VR; |
| USE_SOME_FPR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0" : "=m" (a) : : "cr2", "v26", "v27", "v31", "fr28", "fr31", "r30", "r31"); |
| } |
| |
| void s_vfr (void) |
| { |
| char a[33]; |
| TRASH_SOME_VR; |
| TRASH_SOME_FPR; |
| TRASH_SOME_GPR; |
| USE_SOME_VR; |
| USE_SOME_FPR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0" : "=m" (a) : : "v26", "v27", "v31", "fr28", "fr31", "r30", "r31"); |
| } |
| |
| void s_cvf (void) |
| { |
| char a[33]; |
| TRASH_SOME_CR; |
| TRASH_SOME_VR; |
| TRASH_SOME_FPR; |
| USE_SOME_CR; |
| USE_SOME_VR; |
| USE_SOME_FPR; |
| __asm __volatile ("#%0" : "=m" (a) : : "cr2", "v26", "v27", "v31", "fr28", "fr31"); |
| } |
| |
| void s_vf (void) |
| { |
| char a[33]; |
| TRASH_SOME_VR; |
| TRASH_SOME_FPR; |
| USE_SOME_VR; |
| USE_SOME_FPR; |
| __asm __volatile ("#%0" : "=m" (a) : : "v26", "v27", "v31", "fr28", "fr31"); |
| } |
| #endif |
| |
| void s_cvr (void) |
| { |
| char a[33]; |
| TRASH_SOME_CR; |
| TRASH_SOME_VR; |
| TRASH_SOME_GPR; |
| USE_SOME_CR; |
| USE_SOME_VR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0" : "=m" (a) : : "cr2", "v26", "v27", "v31", "r30", "r31"); |
| } |
| |
| void s_vr (void) |
| { |
| char a[33]; |
| TRASH_SOME_VR; |
| TRASH_SOME_GPR; |
| USE_SOME_VR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0" : "=m" (a) : : "v26", "v27", "v31", "r30", "r31"); |
| } |
| |
| void s_cv (void) |
| { |
| char a[33]; |
| TRASH_SOME_CR; |
| TRASH_SOME_VR; |
| USE_SOME_CR; |
| USE_SOME_VR; |
| __asm __volatile ("#%0" : "=m" (a) : : "cr2", "v26", "v27", "v31"); |
| } |
| |
| void s_v (void) |
| { |
| char a[33]; |
| TRASH_SOME_VR; |
| USE_SOME_VR; |
| __asm __volatile ("#%0" : "=m" (a) : : "v26", "v27", "v31"); |
| } |
| #endif |
| |
| #ifndef __NO_FPRS__ |
| void s_cfr (void) |
| { |
| char a[33]; |
| TRASH_SOME_CR; |
| TRASH_SOME_FPR; |
| TRASH_SOME_GPR; |
| USE_SOME_CR; |
| USE_SOME_FPR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0" : "=m" (a) : : "cr2", "fr28", "fr31", "r30", "r31"); |
| } |
| |
| void s_fr (void) |
| { |
| char a[33]; |
| TRASH_SOME_FPR; |
| TRASH_SOME_GPR; |
| USE_SOME_FPR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0" : "=m" (a) : : "fr28", "fr31", "r30", "r31"); |
| } |
| |
| void s_cf (void) |
| { |
| char a[33]; |
| TRASH_SOME_CR; |
| TRASH_SOME_FPR; |
| USE_SOME_CR; |
| USE_SOME_FPR; |
| __asm __volatile ("#%0" : "=m" (a) : : "cr2", "fr28", "fr31"); |
| } |
| |
| void s_f (void) |
| { |
| char a[33]; |
| TRASH_SOME_FPR; |
| USE_SOME_FPR; |
| __asm __volatile ("#%0" : "=m" (a) : : "fr28", "fr31"); |
| } |
| #endif |
| |
| void s_cr (void) |
| { |
| char a[33]; |
| TRASH_SOME_CR; |
| TRASH_SOME_GPR; |
| USE_SOME_CR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0" : "=m" (a) : : "cr2", "r30", "r31"); |
| } |
| |
| void s_r (void) |
| { |
| char a[33]; |
| TRASH_SOME_GPR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0" : "=m" (a) : : "r30", "r31"); |
| } |
| |
| void s_r31 (void) |
| { |
| char a[33]; |
| #ifndef NO_BODY |
| TRASH_GPR (r31); |
| __asm__ __volatile__ ("#%0" : : "r" (r31)); |
| #endif |
| __asm __volatile ("#%0" : "=m" (a) : : "r31"); |
| } |
| |
| void s_c (void) |
| { |
| char a[33]; |
| TRASH_SOME_CR; |
| USE_SOME_CR; |
| __asm __volatile ("#%0" : "=m" (a) : : "cr2"); |
| } |
| |
| void s_0 (void) |
| { |
| char a[33]; |
| __asm __volatile ("#%0" : "=m" (a) ); |
| } |
| |
| #ifdef __ALTIVEC__ |
| #ifndef __NO_FPRS__ |
| void wb_all (void) |
| { |
| char b[10]; |
| char *nb_all (void) |
| { |
| char a[33000]; |
| TRASH_ALL_CR; |
| TRASH_ALL_VR; |
| TRASH_ALL_FPR; |
| TRASH_ALL_GPR; |
| USE_ALL_CR; |
| USE_ALL_VR; |
| USE_ALL_FPR; |
| USE_ALL_GPR; |
| __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"); |
| return b; |
| } |
| if (nb_all() != b) |
| abort (); |
| } |
| |
| void wb_cvfr (void) |
| { |
| char b[10]; |
| char *nb_cvfr (void) |
| { |
| char a[33000]; |
| TRASH_SOME_CR; |
| TRASH_SOME_VR; |
| TRASH_SOME_FPR; |
| TRASH_SOME_GPR; |
| USE_SOME_CR; |
| USE_SOME_VR; |
| USE_SOME_FPR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "v26", "v27", "v31", "fr28", "fr31", "r30", "r31"); |
| return b; |
| } |
| if (nb_cvfr () != b) |
| abort (); |
| } |
| |
| void wb_vfr (void) |
| { |
| char b[10]; |
| char *nb_vfr (void) |
| { |
| char a[33000]; |
| TRASH_SOME_VR; |
| TRASH_SOME_FPR; |
| TRASH_SOME_GPR; |
| USE_SOME_VR; |
| USE_SOME_FPR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "v26", "v27", "v31", "fr28", "fr31", "r30", "r31"); |
| return b; |
| } |
| if (nb_vfr () != b) |
| abort (); |
| } |
| |
| void wb_cvf (void) |
| { |
| char b[10]; |
| char *nb_cvf (void) |
| { |
| char a[33000]; |
| TRASH_SOME_CR; |
| TRASH_SOME_VR; |
| TRASH_SOME_FPR; |
| USE_SOME_CR; |
| USE_SOME_VR; |
| USE_SOME_FPR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "v26", "v27", "v31", "fr28", "fr31"); |
| return b; |
| } |
| if (nb_cvf () != b) |
| abort (); |
| } |
| |
| void wb_vf (void) |
| { |
| char b[10]; |
| char *nb_vf (void) |
| { |
| char a[33000]; |
| TRASH_SOME_VR; |
| TRASH_SOME_FPR; |
| USE_SOME_VR; |
| USE_SOME_FPR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "v26", "v27", "v31", "fr28", "fr31"); |
| return b; |
| } |
| if (nb_vf () != b) |
| abort (); |
| } |
| #endif |
| |
| void wb_cvr (void) |
| { |
| char b[10]; |
| char *nb_cvr (void) |
| { |
| char a[33000]; |
| TRASH_SOME_CR; |
| TRASH_SOME_VR; |
| TRASH_SOME_GPR; |
| USE_SOME_CR; |
| USE_SOME_VR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "v26", "v27", "v31", "r30", "r31"); |
| return b; |
| } |
| if (nb_cvr () != b) |
| abort (); |
| } |
| |
| void wb_vr (void) |
| { |
| char b[10]; |
| char *nb_vr (void) |
| { |
| char a[33000]; |
| TRASH_SOME_VR; |
| TRASH_SOME_GPR; |
| USE_SOME_VR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "v26", "v27", "v31", "r30", "r31"); |
| return b; |
| } |
| if (nb_vr () != b) |
| abort (); |
| } |
| |
| void wb_cv (void) |
| { |
| char b[10]; |
| char *nb_cv (void) |
| { |
| char a[33000]; |
| TRASH_SOME_CR; |
| TRASH_SOME_VR; |
| USE_SOME_CR; |
| USE_SOME_VR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "v26", "v27", "v31"); |
| return b; |
| } |
| if (nb_cv () != b) |
| abort (); |
| } |
| |
| void wb_v (void) |
| { |
| char b[10]; |
| char *nb_v (void) |
| { |
| char a[33000]; |
| TRASH_SOME_VR; |
| USE_SOME_VR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "v26", "v27", "v31"); |
| return b; |
| } |
| if (nb_v () != b) |
| abort (); |
| } |
| #endif |
| |
| #ifndef __NO_FPRS__ |
| void wb_cfr (void) |
| { |
| char b[10]; |
| char *nb_cfr (void) |
| { |
| char a[33000]; |
| TRASH_SOME_CR; |
| TRASH_SOME_FPR; |
| TRASH_SOME_GPR; |
| USE_SOME_CR; |
| USE_SOME_FPR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "fr28", "fr31", "r30", "r31"); |
| return b; |
| } |
| if (nb_cfr () != b) |
| abort (); |
| } |
| |
| void wb_fr (void) |
| { |
| char b[10]; |
| char *nb_fr (void) |
| { |
| char a[33000]; |
| TRASH_SOME_FPR; |
| TRASH_SOME_GPR; |
| USE_SOME_FPR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "fr28", "fr31", "r30", "r31"); |
| return b; |
| } |
| if (nb_fr () != b) |
| abort (); |
| } |
| |
| void wb_cf (void) |
| { |
| char b[10]; |
| char *nb_cf (void) |
| { |
| char a[33000]; |
| TRASH_SOME_CR; |
| TRASH_SOME_FPR; |
| USE_SOME_CR; |
| USE_SOME_FPR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "fr28", "fr31"); |
| return b; |
| } |
| if (nb_cf () != b) |
| abort (); |
| } |
| |
| void wb_f (void) |
| { |
| char b[10]; |
| char *nb_f (void) |
| { |
| char a[33000]; |
| TRASH_SOME_FPR; |
| USE_SOME_FPR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "fr28", "fr31"); |
| return b; |
| } |
| if (nb_f () != b) |
| abort (); |
| } |
| #endif |
| |
| void wb_cr (void) |
| { |
| char b[10]; |
| char *nb_cr (void) |
| { |
| char a[33000]; |
| TRASH_SOME_CR; |
| TRASH_SOME_GPR; |
| USE_SOME_CR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "r30", "r31"); |
| return b; |
| } |
| if (nb_cr () != b) |
| abort (); |
| } |
| |
| void wb_r (void) |
| { |
| char b[10]; |
| char *nb_r (void) |
| { |
| char a[33000]; |
| TRASH_SOME_GPR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "r30", "r31"); |
| return b; |
| } |
| if (nb_r () != b) |
| abort (); |
| } |
| |
| void wb_c (void) |
| { |
| char b[10]; |
| char *nb_c (void) |
| { |
| char a[33000]; |
| TRASH_SOME_CR; |
| USE_SOME_CR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2"); |
| return b; |
| } |
| if (nb_c () != b) |
| abort (); |
| } |
| |
| void wb_0 (void) |
| { |
| char b[10]; |
| char *nb_0 (void) |
| { |
| char a[33000]; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) ); |
| return b; |
| } |
| if (nb_0 () != b) |
| abort (); |
| } |
| |
| #ifdef __ALTIVEC__ |
| #ifndef __NO_FPRS__ |
| void ws_all (void) |
| { |
| char b[10]; |
| char *ns_all (void) |
| { |
| char a[33]; |
| TRASH_ALL_CR; |
| TRASH_ALL_VR; |
| TRASH_ALL_FPR; |
| TRASH_ALL_GPR; |
| USE_ALL_CR; |
| USE_ALL_VR; |
| USE_ALL_FPR; |
| USE_ALL_GPR; |
| __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"); |
| return b; |
| } |
| if (ns_all() != b) |
| abort (); |
| } |
| |
| void ws_cvfr (void) |
| { |
| char b[10]; |
| char *ns_cvfr (void) |
| { |
| char a[33]; |
| TRASH_SOME_CR; |
| TRASH_SOME_VR; |
| TRASH_SOME_FPR; |
| TRASH_SOME_GPR; |
| USE_SOME_CR; |
| USE_SOME_VR; |
| USE_SOME_FPR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "v26", "v27", "v31", "fr28", "fr31", "r30", "r31"); |
| return b; |
| } |
| if (ns_cvfr () != b) |
| abort (); |
| } |
| |
| void ws_vfr (void) |
| { |
| char b[10]; |
| char *ns_vfr (void) |
| { |
| char a[33]; |
| TRASH_SOME_VR; |
| TRASH_SOME_FPR; |
| TRASH_SOME_GPR; |
| USE_SOME_VR; |
| USE_SOME_FPR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "v26", "v27", "v31", "fr28", "fr31", "r30", "r31"); |
| return b; |
| } |
| if (ns_vfr () != b) |
| abort (); |
| } |
| |
| void ws_cvf (void) |
| { |
| char b[10]; |
| char *ns_cvf (void) |
| { |
| char a[33]; |
| TRASH_SOME_CR; |
| TRASH_SOME_VR; |
| TRASH_SOME_FPR; |
| USE_SOME_CR; |
| USE_SOME_VR; |
| USE_SOME_FPR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "v26", "v27", "v31", "fr28", "fr31"); |
| return b; |
| } |
| if (ns_cvf () != b) |
| abort (); |
| } |
| |
| void ws_vf (void) |
| { |
| char b[10]; |
| char *ns_vf (void) |
| { |
| char a[33]; |
| TRASH_SOME_VR; |
| TRASH_SOME_FPR; |
| USE_SOME_VR; |
| USE_SOME_FPR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "v26", "v27", "v31", "fr28", "fr31"); |
| return b; |
| } |
| if (ns_vf () != b) |
| abort (); |
| } |
| #endif |
| |
| void ws_cvr (void) |
| { |
| char b[10]; |
| char *ns_cvr (void) |
| { |
| char a[33]; |
| TRASH_SOME_CR; |
| TRASH_SOME_VR; |
| TRASH_SOME_GPR; |
| USE_SOME_CR; |
| USE_SOME_VR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "v26", "v27", "v31", "r30", "r31"); |
| return b; |
| } |
| if (ns_cvr () != b) |
| abort (); |
| } |
| |
| void ws_vr (void) |
| { |
| char b[10]; |
| char *ns_vr (void) |
| { |
| char a[33]; |
| TRASH_SOME_VR; |
| TRASH_SOME_FPR; |
| USE_SOME_VR; |
| USE_SOME_FPR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "v26", "v27", "v31", "r30", "r31"); |
| return b; |
| } |
| if (ns_vr () != b) |
| abort (); |
| } |
| |
| void ws_cv (void) |
| { |
| char b[10]; |
| char *ns_cv (void) |
| { |
| char a[33]; |
| TRASH_SOME_CR; |
| TRASH_SOME_VR; |
| USE_SOME_CR; |
| USE_SOME_VR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "v26", "v27", "v31"); |
| return b; |
| } |
| if (ns_cv () != b) |
| abort (); |
| } |
| |
| void ws_v (void) |
| { |
| char b[10]; |
| char *ns_v (void) |
| { |
| char a[33]; |
| TRASH_SOME_VR; |
| USE_SOME_VR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "v26", "v27", "v31"); |
| return b; |
| } |
| if (ns_v () != b) |
| abort (); |
| } |
| #endif |
| |
| #ifndef __NO_FPRS__ |
| void ws_cfr (void) |
| { |
| char b[10]; |
| char *ns_cfr (void) |
| { |
| char a[33]; |
| TRASH_SOME_CR; |
| TRASH_SOME_FPR; |
| TRASH_SOME_GPR; |
| USE_SOME_CR; |
| USE_SOME_FPR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "fr28", "fr31", "r30", "r31"); |
| return b; |
| } |
| if (ns_cfr () != b) |
| abort (); |
| } |
| |
| void ws_fr (void) |
| { |
| char b[10]; |
| char *ns_fr (void) |
| { |
| char a[33]; |
| TRASH_SOME_FPR; |
| TRASH_SOME_GPR; |
| USE_SOME_FPR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "fr28", "fr31", "r30", "r31"); |
| return b; |
| } |
| if (ns_fr () != b) |
| abort (); |
| } |
| |
| void ws_cf (void) |
| { |
| char b[10]; |
| char *ns_cf (void) |
| { |
| char a[33]; |
| TRASH_SOME_CR; |
| TRASH_SOME_FPR; |
| USE_SOME_CR; |
| USE_SOME_FPR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "fr28", "fr31"); |
| return b; |
| } |
| if (ns_cf () != b) |
| abort (); |
| } |
| |
| void ws_f (void) |
| { |
| char b[10]; |
| char *ns_f (void) |
| { |
| char a[33]; |
| TRASH_SOME_FPR; |
| USE_SOME_FPR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "fr28", "fr31"); |
| return b; |
| } |
| if (ns_f () != b) |
| abort (); |
| } |
| #endif |
| |
| void ws_cr (void) |
| { |
| char b[10]; |
| char *ns_cr (void) |
| { |
| char a[33]; |
| TRASH_SOME_CR; |
| TRASH_SOME_GPR; |
| USE_SOME_CR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "r30", "r31"); |
| return b; |
| } |
| if (ns_cr () != b) |
| abort (); |
| } |
| |
| void ws_r (void) |
| { |
| char b[10]; |
| char *ns_r (void) |
| { |
| char a[33]; |
| TRASH_SOME_GPR; |
| USE_SOME_GPR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "r30", "r31"); |
| return b; |
| } |
| if (ns_r () != b) |
| abort (); |
| } |
| |
| void ws_c (void) |
| { |
| char b[10]; |
| char *ns_c (void) |
| { |
| char a[33]; |
| TRASH_SOME_CR; |
| USE_SOME_CR; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2"); |
| return b; |
| } |
| if (ns_c () != b) |
| abort (); |
| } |
| |
| void ws_0 (void) |
| { |
| char b[10]; |
| char *ns_0 (void) |
| { |
| char a[33]; |
| __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) ); |
| return b; |
| } |
| if (ns_0 () != b) |
| abort (); |
| } |
| |
| /* We'd like to compile main with |
| __attribute__ ((__optimize__ ("fixed-cr2,fixed-cr3,fixed-cr4"))) |
| but that doesn't do anything currently. Obviously we don't want to |
| compile the whole file with -ffixed-cr2 -ffixed-cr3 -ffixed-cr4 as |
| that would also tell gcc not to save/restore cr, and we're trying |
| to check that the above functions do save/restore cr. |
| __attribute__ ((__optimize__ ("no-rename-registers,omit-frame-pointer"))) |
| works, but it seems odd to need omit-frame-pointer and raises the |
| question of whether darwin would need -mdynamic-no-pic. |
| So for now use -fno-rename-registers over the whole test. */ |
| int |
| main (void) |
| { |
| INIT_REGS; |
| USE_ALL_CR; |
| #ifdef __ALTIVEC__ |
| USE_ALL_VR; |
| #ifndef __NO_FPRS__ |
| USE_ALL_FPR; |
| #endif |
| #endif |
| USE_ALL_GPR; |
| #ifdef __ALTIVEC__ |
| #ifndef __NO_FPRS__ |
| b_all (); |
| VERIFY_REGS; |
| b_cvfr (); |
| VERIFY_REGS; |
| b_vfr (); |
| VERIFY_REGS; |
| b_cvf (); |
| VERIFY_REGS; |
| b_vf (); |
| VERIFY_REGS; |
| #endif |
| b_cvr (); |
| VERIFY_REGS; |
| b_vr (); |
| VERIFY_REGS; |
| b_cv (); |
| VERIFY_REGS; |
| b_v (); |
| VERIFY_REGS; |
| #endif |
| #ifndef __NO_FPRS__ |
| b_cfr (); |
| VERIFY_REGS; |
| b_fr (); |
| VERIFY_REGS; |
| b_cf (); |
| VERIFY_REGS; |
| b_f (); |
| VERIFY_REGS; |
| #endif |
| b_cr (); |
| VERIFY_REGS; |
| b_r (); |
| VERIFY_REGS; |
| b_c (); |
| VERIFY_REGS; |
| b_0 (); |
| VERIFY_REGS; |
| #ifdef __ALTIVEC__ |
| #ifndef __NO_FPRS__ |
| s_all (); |
| VERIFY_REGS; |
| s_cvfr (); |
| VERIFY_REGS; |
| s_vfr (); |
| VERIFY_REGS; |
| s_cvf (); |
| VERIFY_REGS; |
| s_vf (); |
| VERIFY_REGS; |
| #endif |
| s_cvr (); |
| VERIFY_REGS; |
| s_vr (); |
| VERIFY_REGS; |
| s_cv (); |
| VERIFY_REGS; |
| s_v (); |
| VERIFY_REGS; |
| #endif |
| #ifndef __NO_FPRS__ |
| s_cfr (); |
| VERIFY_REGS; |
| s_fr (); |
| VERIFY_REGS; |
| s_cf (); |
| VERIFY_REGS; |
| s_f (); |
| VERIFY_REGS; |
| #endif |
| s_cr (); |
| VERIFY_REGS; |
| s_r (); |
| VERIFY_REGS; |
| s_r31 (); |
| VERIFY_REGS; |
| s_c (); |
| VERIFY_REGS; |
| s_0 (); |
| VERIFY_REGS; |
| #ifdef __ALTIVEC__ |
| #ifndef __NO_FPRS__ |
| wb_all (); |
| VERIFY_REGS; |
| wb_cvfr (); |
| VERIFY_REGS; |
| wb_vfr (); |
| VERIFY_REGS; |
| wb_cvf (); |
| VERIFY_REGS; |
| wb_vf (); |
| VERIFY_REGS; |
| #endif |
| wb_cvr (); |
| VERIFY_REGS; |
| wb_vr (); |
| VERIFY_REGS; |
| wb_cv (); |
| VERIFY_REGS; |
| wb_v (); |
| VERIFY_REGS; |
| #endif |
| #ifndef __NO_FPRS__ |
| wb_cfr (); |
| VERIFY_REGS; |
| wb_fr (); |
| VERIFY_REGS; |
| wb_cf (); |
| VERIFY_REGS; |
| wb_f (); |
| VERIFY_REGS; |
| #endif |
| wb_cr (); |
| VERIFY_REGS; |
| wb_r (); |
| VERIFY_REGS; |
| wb_c (); |
| VERIFY_REGS; |
| wb_0 (); |
| VERIFY_REGS; |
| #ifdef __ALTIVEC__ |
| #ifndef __NO_FPRS__ |
| ws_all (); |
| VERIFY_REGS; |
| ws_cvfr (); |
| VERIFY_REGS; |
| ws_vfr (); |
| VERIFY_REGS; |
| ws_cvf (); |
| VERIFY_REGS; |
| ws_vf (); |
| VERIFY_REGS; |
| #endif |
| ws_cvr (); |
| VERIFY_REGS; |
| ws_vr (); |
| VERIFY_REGS; |
| ws_cv (); |
| VERIFY_REGS; |
| ws_v (); |
| VERIFY_REGS; |
| #endif |
| #ifndef __NO_FPRS__ |
| ws_cfr (); |
| VERIFY_REGS; |
| ws_fr (); |
| VERIFY_REGS; |
| ws_cf (); |
| VERIFY_REGS; |
| ws_f (); |
| VERIFY_REGS; |
| #endif |
| ws_cr (); |
| VERIFY_REGS; |
| ws_r (); |
| VERIFY_REGS; |
| ws_c (); |
| VERIFY_REGS; |
| ws_0 (); |
| VERIFY_REGS; |
| return 0; |
| } |
