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

   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__
 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
 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
 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
 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
 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
 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
 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
 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
 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__
 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
 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
 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
 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
 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
 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
 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
 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__
 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
 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
 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
 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
 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
 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
 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
 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
 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__
 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
 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
 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
 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
 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
 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
 444 void s_r31 (void)
 445 {
 446   char a[33];
 447 #ifndef NO_BODY
 448   TRASH_GPR (r31);
 449   __asm__ __volatile__ ("#%0" : : "r" (r31));
 450 #endif
 451   __asm __volatile ("#%0" : "=m" (a) : : "r31");
 452 }
 453
 454 void s_c (void)
 455 {
 456   char a[33];
 457   TRASH_SOME_CR;
 458   USE_SOME_CR;
 459   __asm __volatile ("#%0" : "=m" (a) : : "cr2");
 460 }
 461
 462 void s_0 (void)
 463 {
 464   char a[33];
 465   __asm __volatile ("#%0" : "=m" (a) );
 466 }
 467
 468 #ifdef __ALTIVEC__
 469 #ifndef __NO_FPRS__
 470 void wb_all (void)
 471 {
 472   char b[10];
 473   char *nb_all (void)
 474   {
 475     char a[33000];
 476     TRASH_ALL_CR;
 477     TRASH_ALL_VR;
 478     TRASH_ALL_FPR;
 479     TRASH_ALL_GPR;
 480     USE_ALL_CR;
 481     USE_ALL_VR;
 482     USE_ALL_FPR;
 483     USE_ALL_GPR;
 484     __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");
 485     return b;
 486   }
 487   if (nb_all() != b)
 488     abort ();
 489 }
 490
 491 void wb_cvfr (void)
 492 {
 493   char b[10];
 494   char *nb_cvfr (void)
 495   {
 496     char a[33000];
 497     TRASH_SOME_CR;
 498     TRASH_SOME_VR;
 499     TRASH_SOME_FPR;
 500     TRASH_SOME_GPR;
 501     USE_SOME_CR;
 502     USE_SOME_VR;
 503     USE_SOME_FPR;
 504     USE_SOME_GPR;
 505     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "v26", "v27", "v31", "fr28", "fr31", "r30", "r31");
 506     return b;
 507   }
 508   if (nb_cvfr () != b)
 509     abort ();
 510 }
 511
 512 void wb_vfr (void)
 513 {
 514   char b[10];
 515   char *nb_vfr (void)
 516   {
 517     char a[33000];
 518     TRASH_SOME_VR;
 519     TRASH_SOME_FPR;
 520     TRASH_SOME_GPR;
 521     USE_SOME_VR;
 522     USE_SOME_FPR;
 523     USE_SOME_GPR;
 524     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "v26", "v27", "v31", "fr28", "fr31", "r30", "r31");
 525     return b;
 526   }
 527   if (nb_vfr () != b)
 528     abort ();
 529 }
 530
 531 void wb_cvf (void)
 532 {
 533   char b[10];
 534   char *nb_cvf (void)
 535   {
 536     char a[33000];
 537     TRASH_SOME_CR;
 538     TRASH_SOME_VR;
 539     TRASH_SOME_FPR;
 540     USE_SOME_CR;
 541     USE_SOME_VR;
 542     USE_SOME_FPR;
 543     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "v26", "v27", "v31", "fr28", "fr31");
 544     return b;
 545   }
 546   if (nb_cvf () != b)
 547     abort ();
 548 }
 549
 550 void wb_vf (void)
 551 {
 552   char b[10];
 553   char *nb_vf (void)
 554   {
 555     char a[33000];
 556     TRASH_SOME_VR;
 557     TRASH_SOME_FPR;
 558     USE_SOME_VR;
 559     USE_SOME_FPR;
 560     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "v26", "v27", "v31", "fr28", "fr31");
 561     return b;
 562   }
 563   if (nb_vf () != b)
 564     abort ();
 565 }
 566 #endif
 567
 568 void wb_cvr (void)
 569 {
 570   char b[10];
 571   char *nb_cvr (void)
 572   {
 573     char a[33000];
 574     TRASH_SOME_CR;
 575     TRASH_SOME_VR;
 576     TRASH_SOME_GPR;
 577     USE_SOME_CR;
 578     USE_SOME_VR;
 579     USE_SOME_GPR;
 580     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "v26", "v27", "v31", "r30", "r31");
 581     return b;
 582   }
 583   if (nb_cvr () != b)
 584     abort ();
 585 }
 586
 587 void wb_vr (void)
 588 {
 589   char b[10];
 590   char *nb_vr (void)
 591   {
 592     char a[33000];
 593     TRASH_SOME_VR;
 594     TRASH_SOME_GPR;
 595     USE_SOME_VR;
 596     USE_SOME_GPR;
 597     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "v26", "v27", "v31", "r30", "r31");
 598     return b;
 599   }
 600   if (nb_vr () != b)
 601     abort ();
 602 }
 603
 604 void wb_cv (void)
 605 {
 606   char b[10];
 607   char *nb_cv (void)
 608   {
 609     char a[33000];
 610     TRASH_SOME_CR;
 611     TRASH_SOME_VR;
 612     USE_SOME_CR;
 613     USE_SOME_VR;
 614     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "v26", "v27", "v31");
 615     return b;
 616   }
 617   if (nb_cv () != b)
 618     abort ();
 619 }
 620
 621 void wb_v (void)
 622 {
 623   char b[10];
 624   char *nb_v (void)
 625   {
 626     char a[33000];
 627     TRASH_SOME_VR;
 628     USE_SOME_VR;
 629     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "v26", "v27", "v31");
 630     return b;
 631   }
 632   if (nb_v () != b)
 633     abort ();
 634 }
 635 #endif
 636
 637 #ifndef __NO_FPRS__
 638 void wb_cfr (void)
 639 {
 640   char b[10];
 641   char *nb_cfr (void)
 642   {
 643     char a[33000];
 644     TRASH_SOME_CR;
 645     TRASH_SOME_FPR;
 646     TRASH_SOME_GPR;
 647     USE_SOME_CR;
 648     USE_SOME_FPR;
 649     USE_SOME_GPR;
 650     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "fr28", "fr31", "r30", "r31");
 651     return b;
 652   }
 653   if (nb_cfr () != b)
 654     abort ();
 655 }
 656
 657 void wb_fr (void)
 658 {
 659   char b[10];
 660   char *nb_fr (void)
 661   {
 662     char a[33000];
 663     TRASH_SOME_FPR;
 664     TRASH_SOME_GPR;
 665     USE_SOME_FPR;
 666     USE_SOME_GPR;
 667     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "fr28", "fr31", "r30", "r31");
 668     return b;
 669   }
 670   if (nb_fr () != b)
 671     abort ();
 672 }
 673
 674 void wb_cf (void)
 675 {
 676   char b[10];
 677   char *nb_cf (void)
 678   {
 679     char a[33000];
 680     TRASH_SOME_CR;
 681     TRASH_SOME_FPR;
 682     USE_SOME_CR;
 683     USE_SOME_FPR;
 684     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "fr28", "fr31");
 685     return b;
 686   }
 687   if (nb_cf () != b)
 688     abort ();
 689 }
 690
 691 void wb_f (void)
 692 {
 693   char b[10];
 694   char *nb_f (void)
 695   {
 696     char a[33000];
 697     TRASH_SOME_FPR;
 698     USE_SOME_FPR;
 699     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "fr28", "fr31");
 700     return b;
 701   }
 702   if (nb_f () != b)
 703     abort ();
 704 }
 705 #endif
 706
 707 void wb_cr (void)
 708 {
 709   char b[10];
 710   char *nb_cr (void)
 711   {
 712     char a[33000];
 713     TRASH_SOME_CR;
 714     TRASH_SOME_GPR;
 715     USE_SOME_CR;
 716     USE_SOME_GPR;
 717     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "r30", "r31");
 718     return b;
 719   }
 720   if (nb_cr () != b)
 721     abort ();
 722 }
 723
 724 void wb_r (void)
 725 {
 726   char b[10];
 727   char *nb_r (void)
 728   {
 729     char a[33000];
 730     TRASH_SOME_GPR;
 731     USE_SOME_GPR;
 732     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "r30", "r31");
 733     return b;
 734   }
 735   if (nb_r () != b)
 736     abort ();
 737 }
 738
 739 void wb_c (void)
 740 {
 741   char b[10];
 742   char *nb_c (void)
 743   {
 744     char a[33000];
 745     TRASH_SOME_CR;
 746     USE_SOME_CR;
 747     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2");
 748     return b;
 749   }
 750   if (nb_c () != b)
 751     abort ();
 752 }
 753
 754 void wb_0 (void)
 755 {
 756   char b[10];
 757   char *nb_0 (void)
 758   {
 759     char a[33000];
 760     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) );
 761     return b;
 762   }
 763   if (nb_0 () != b)
 764     abort ();
 765 }
 766
 767 #ifdef __ALTIVEC__
 768 #ifndef __NO_FPRS__
 769 void ws_all (void)
 770 {
 771   char b[10];
 772   char *ns_all (void)
 773   {
 774     char a[33];
 775     TRASH_ALL_CR;
 776     TRASH_ALL_VR;
 777     TRASH_ALL_FPR;
 778     TRASH_ALL_GPR;
 779     USE_ALL_CR;
 780     USE_ALL_VR;
 781     USE_ALL_FPR;
 782     USE_ALL_GPR;
 783     __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");
 784     return b;
 785   }
 786   if (ns_all() != b)
 787     abort ();
 788 }
 789
 790 void ws_cvfr (void)
 791 {
 792   char b[10];
 793   char *ns_cvfr (void)
 794   {
 795     char a[33];
 796     TRASH_SOME_CR;
 797     TRASH_SOME_VR;
 798     TRASH_SOME_FPR;
 799     TRASH_SOME_GPR;
 800     USE_SOME_CR;
 801     USE_SOME_VR;
 802     USE_SOME_FPR;
 803     USE_SOME_GPR;
 804     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "v26", "v27", "v31", "fr28", "fr31", "r30", "r31");
 805     return b;
 806   }
 807   if (ns_cvfr () != b)
 808     abort ();
 809 }
 810
 811 void ws_vfr (void)
 812 {
 813   char b[10];
 814   char *ns_vfr (void)
 815   {
 816     char a[33];
 817     TRASH_SOME_VR;
 818     TRASH_SOME_FPR;
 819     TRASH_SOME_GPR;
 820     USE_SOME_VR;
 821     USE_SOME_FPR;
 822     USE_SOME_GPR;
 823     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "v26", "v27", "v31", "fr28", "fr31", "r30", "r31");
 824     return b;
 825   }
 826   if (ns_vfr () != b)
 827     abort ();
 828 }
 829
 830 void ws_cvf (void)
 831 {
 832   char b[10];
 833   char *ns_cvf (void)
 834   {
 835     char a[33];
 836     TRASH_SOME_CR;
 837     TRASH_SOME_VR;
 838     TRASH_SOME_FPR;
 839     USE_SOME_CR;
 840     USE_SOME_VR;
 841     USE_SOME_FPR;
 842     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "v26", "v27", "v31", "fr28", "fr31");
 843     return b;
 844   }
 845   if (ns_cvf () != b)
 846     abort ();
 847 }
 848
 849 void ws_vf (void)
 850 {
 851   char b[10];
 852   char *ns_vf (void)
 853   {
 854     char a[33];
 855     TRASH_SOME_VR;
 856     TRASH_SOME_FPR;
 857     USE_SOME_VR;
 858     USE_SOME_FPR;
 859     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "v26", "v27", "v31", "fr28", "fr31");
 860     return b;
 861   }
 862   if (ns_vf () != b)
 863     abort ();
 864 }
 865 #endif
 866
 867 void ws_cvr (void)
 868 {
 869   char b[10];
 870   char *ns_cvr (void)
 871   {
 872     char a[33];
 873     TRASH_SOME_CR;
 874     TRASH_SOME_VR;
 875     TRASH_SOME_GPR;
 876     USE_SOME_CR;
 877     USE_SOME_VR;
 878     USE_SOME_GPR;
 879     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "v26", "v27", "v31", "r30", "r31");
 880     return b;
 881   }
 882   if (ns_cvr () != b)
 883     abort ();
 884 }
 885
 886 void ws_vr (void)
 887 {
 888   char b[10];
 889   char *ns_vr (void)
 890   {
 891     char a[33];
 892     TRASH_SOME_VR;
 893     TRASH_SOME_FPR;
 894     USE_SOME_VR;
 895     USE_SOME_FPR;
 896     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "v26", "v27", "v31", "r30", "r31");
 897     return b;
 898   }
 899   if (ns_vr () != b)
 900     abort ();
 901 }
 902
 903 void ws_cv (void)
 904 {
 905   char b[10];
 906   char *ns_cv (void)
 907   {
 908     char a[33];
 909     TRASH_SOME_CR;
 910     TRASH_SOME_VR;
 911     USE_SOME_CR;
 912     USE_SOME_VR;
 913     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "v26", "v27", "v31");
 914     return b;
 915   }
 916   if (ns_cv () != b)
 917     abort ();
 918 }
 919
 920 void ws_v (void)
 921 {
 922   char b[10];
 923   char *ns_v (void)
 924   {
 925     char a[33];
 926     TRASH_SOME_VR;
 927     USE_SOME_VR;
 928     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "v26", "v27", "v31");
 929     return b;
 930   }
 931   if (ns_v () != b)
 932     abort ();
 933 }
 934 #endif
 935
 936 #ifndef __NO_FPRS__
 937 void ws_cfr (void)
 938 {
 939   char b[10];
 940   char *ns_cfr (void)
 941   {
 942     char a[33];
 943     TRASH_SOME_CR;
 944     TRASH_SOME_FPR;
 945     TRASH_SOME_GPR;
 946     USE_SOME_CR;
 947     USE_SOME_FPR;
 948     USE_SOME_GPR;
 949     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "fr28", "fr31", "r30", "r31");
 950     return b;
 951   }
 952   if (ns_cfr () != b)
 953     abort ();
 954 }
 955
 956 void ws_fr (void)
 957 {
 958   char b[10];
 959   char *ns_fr (void)
 960   {
 961     char a[33];
 962     TRASH_SOME_FPR;
 963     TRASH_SOME_GPR;
 964     USE_SOME_FPR;
 965     USE_SOME_GPR;
 966     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "fr28", "fr31", "r30", "r31");
 967     return b;
 968   }
 969   if (ns_fr () != b)
 970     abort ();
 971 }
 972
 973 void ws_cf (void)
 974 {
 975   char b[10];
 976   char *ns_cf (void)
 977   {
 978     char a[33];
 979     TRASH_SOME_CR;
 980     TRASH_SOME_FPR;
 981     USE_SOME_CR;
 982     USE_SOME_FPR;
 983     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "fr28", "fr31");
 984     return b;
 985   }
 986   if (ns_cf () != b)
 987     abort ();
 988 }
 989
 990 void ws_f (void)
 991 {
 992   char b[10];
 993   char *ns_f (void)
 994   {
 995     char a[33];
 996     TRASH_SOME_FPR;
 997     USE_SOME_FPR;
 998     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "fr28", "fr31");
 999     return b;
1000   }
1001   if (ns_f () != b)
1002     abort ();
1003 }
1004 #endif
1005
1006 void ws_cr (void)
1007 {
1008   char b[10];
1009   char *ns_cr (void)
1010   {
1011     char a[33];
1012     TRASH_SOME_CR;
1013     TRASH_SOME_GPR;
1014     USE_SOME_CR;
1015     USE_SOME_GPR;
1016     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2", "r30", "r31");
1017     return b;
1018   }
1019   if (ns_cr () != b)
1020     abort ();
1021 }
1022
1023 void ws_r (void)
1024 {
1025   char b[10];
1026   char *ns_r (void)
1027   {
1028     char a[33];
1029     TRASH_SOME_GPR;
1030     USE_SOME_GPR;
1031     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "r30", "r31");
1032     return b;
1033   }
1034   if (ns_r () != b)
1035     abort ();
1036 }
1037
1038 void ws_c (void)
1039 {
1040   char b[10];
1041   char *ns_c (void)
1042   {
1043     char a[33];
1044     TRASH_SOME_CR;
1045     USE_SOME_CR;
1046     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) : : "cr2");
1047     return b;
1048   }
1049   if (ns_c () != b)
1050     abort ();
1051 }
1052
1053 void ws_0 (void)
1054 {
1055   char b[10];
1056   char *ns_0 (void)
1057   {
1058     char a[33];
1059     __asm __volatile ("#%0 %1" : "=m" (a), "=m" (b) );
1060     return b;
1061   }
1062   if (ns_0 () != b)
1063     abort ();
1064 }
1065
1066 int main (void)
1067 {
1068   INIT_REGS;
1069   USE_ALL_CR;
1070 #ifdef __ALTIVEC__
1071   USE_ALL_VR;
1072 #ifndef __NO_FPRS__
1073   USE_ALL_FPR;
1074 #endif
1075 #endif
1076   USE_ALL_GPR;
1077 #ifdef __ALTIVEC__
1078 #ifndef __NO_FPRS__
1079   b_all ();
1080   VERIFY_REGS;
1081   b_cvfr ();
1082   VERIFY_REGS;
1083   b_vfr ();
1084   VERIFY_REGS;
1085   b_cvf ();
1086   VERIFY_REGS;
1087   b_vf ();
1088   VERIFY_REGS;
1089 #endif
1090   b_cvr ();
1091   VERIFY_REGS;
1092   b_vr ();
1093   VERIFY_REGS;
1094   b_cv ();
1095   VERIFY_REGS;
1096   b_v ();
1097   VERIFY_REGS;
1098 #endif
1099 #ifndef __NO_FPRS__
1100   b_cfr ();
1101   VERIFY_REGS;
1102   b_fr ();
1103   VERIFY_REGS;
1104   b_cf ();
1105   VERIFY_REGS;
1106   b_f ();
1107   VERIFY_REGS;
1108 #endif
1109   b_cr ();
1110   VERIFY_REGS;
1111   b_r ();
1112   VERIFY_REGS;
1113   b_c ();
1114   VERIFY_REGS;
1115   b_0 ();
1116   VERIFY_REGS;
1117 #ifdef __ALTIVEC__
1118 #ifndef __NO_FPRS__
1119   s_all ();
1120   VERIFY_REGS;
1121   s_cvfr ();
1122   VERIFY_REGS;
1123   s_vfr ();
1124   VERIFY_REGS;
1125   s_cvf ();
1126   VERIFY_REGS;
1127   s_vf ();
1128   VERIFY_REGS;
1129 #endif
1130   s_cvr ();
1131   VERIFY_REGS;
1132   s_vr ();
1133   VERIFY_REGS;
1134   s_cv ();
1135   VERIFY_REGS;
1136   s_v ();
1137   VERIFY_REGS;
1138 #endif
1139 #ifndef __NO_FPRS__
1140   s_cfr ();
1141   VERIFY_REGS;
1142   s_fr ();
1143   VERIFY_REGS;
1144   s_cf ();
1145   VERIFY_REGS;
1146   s_f ();
1147   VERIFY_REGS;
1148 #endif
1149   s_cr ();
1150   VERIFY_REGS;
1151   s_r ();
1152   VERIFY_REGS;
1153   s_r31 ();
1154   VERIFY_REGS;
1155   s_c ();
1156   VERIFY_REGS;
1157   s_0 ();
1158   VERIFY_REGS;
1159 #ifdef __ALTIVEC__
1160 #ifndef __NO_FPRS__
1161   wb_all ();
1162   VERIFY_REGS;
1163   wb_cvfr ();
1164   VERIFY_REGS;
1165   wb_vfr ();
1166   VERIFY_REGS;
1167   wb_cvf ();
1168   VERIFY_REGS;
1169   wb_vf ();
1170   VERIFY_REGS;
1171 #endif
1172   wb_cvr ();
1173   VERIFY_REGS;
1174   wb_vr ();
1175   VERIFY_REGS;
1176   wb_cv ();
1177   VERIFY_REGS;
1178   wb_v ();
1179   VERIFY_REGS;
1180 #endif
1181 #ifndef __NO_FPRS__
1182   wb_cfr ();
1183   VERIFY_REGS;
1184   wb_fr ();
1185   VERIFY_REGS;
1186   wb_cf ();
1187   VERIFY_REGS;
1188   wb_f ();
1189   VERIFY_REGS;
1190 #endif
1191   wb_cr ();
1192   VERIFY_REGS;
1193   wb_r ();
1194   VERIFY_REGS;
1195   wb_c ();
1196   VERIFY_REGS;
1197   wb_0 ();
1198   VERIFY_REGS;
1199 #ifdef __ALTIVEC__
1200 #ifndef __NO_FPRS__
1201   ws_all ();
1202   VERIFY_REGS;
1203   ws_cvfr ();
1204   VERIFY_REGS;
1205   ws_vfr ();
1206   VERIFY_REGS;
1207   ws_cvf ();
1208   VERIFY_REGS;
1209   ws_vf ();
1210   VERIFY_REGS;
1211 #endif
1212   ws_cvr ();
1213   VERIFY_REGS;
1214   ws_vr ();
1215   VERIFY_REGS;
1216   ws_cv ();
1217   VERIFY_REGS;
1218   ws_v ();
1219   VERIFY_REGS;
1220 #endif
1221 #ifndef __NO_FPRS__
1222   ws_cfr ();
1223   VERIFY_REGS;
1224   ws_fr ();
1225   VERIFY_REGS;
1226   ws_cf ();
1227   VERIFY_REGS;
1228   ws_f ();
1229   VERIFY_REGS;
1230 #endif
1231   ws_cr ();
1232   VERIFY_REGS;
1233   ws_r ();
1234   VERIFY_REGS;
1235   ws_c ();
1236   VERIFY_REGS;
1237   ws_0 ();
1238   VERIFY_REGS;
1239   return 0;
1240 }