gcc/testsuite/gcc.target/powerpc/savres.c

   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 }