tools/testing/selftests/powerpc/alignment/alignment_handler.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Test the powerpc alignment handler on POWER8/POWER9
   4  *
   5  * Copyright (C) 2017 IBM Corporation (Michael Neuling, Andrew Donnellan)
   6  */
   7
   8 /*
   9  * This selftest exercises the powerpc alignment fault handler.
  10  *
  11  * We create two sets of source and destination buffers, one in regular memory,
  12  * the other cache-inhibited (by default we use /dev/fb0 for this, but an
  13  * alterative path for cache-inhibited memory may be provided, e.g. memtrace).
  14  *
  15  * We initialise the source buffers, then use whichever set of load/store
  16  * instructions is under test to copy bytes from the source buffers to the
  17  * destination buffers. For the regular buffers, these instructions will
  18  * execute normally. For the cache-inhibited buffers, these instructions
  19  * will trap and cause an alignment fault, and the alignment fault handler
  20  * will emulate the particular instruction under test. We then compare the
  21  * destination buffers to ensure that the native and emulated cases give the
  22  * same result.
  23  *
  24  * TODO:
  25  *   - Any FIXMEs below
  26  *   - Test VSX regs < 32 and > 32
  27  *   - Test all loads and stores
  28  *   - Check update forms do update register
  29  *   - Test alignment faults over page boundary
  30  *
  31  * Some old binutils may not support all the instructions.
  32  */
  33
  34
  35 #include <sys/mman.h>
  36 #include <sys/types.h>
  37 #include <sys/stat.h>
  38 #include <fcntl.h>
  39 #include <unistd.h>
  40 #include <stdbool.h>
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include <assert.h>
  45 #include <getopt.h>
  46 #include <setjmp.h>
  47 #include <signal.h>
  48
  49 #include "utils.h"
  50 #include "instructions.h"
  51
  52 int bufsize;
  53 int debug;
  54 int testing;
  55 volatile int gotsig;
  56 bool prefixes_enabled;
  57 char *cipath = "/dev/fb0";
  58 long cioffset;
  59
  60 void sighandler(int sig, siginfo_t *info, void *ctx)
  61 {
  62         ucontext_t *ucp = ctx;
  63
  64         if (!testing) {
  65                 signal(sig, SIG_DFL);
  66                 kill(0, sig);
  67         }
  68         gotsig = sig;
  69 #ifdef __powerpc64__
  70         if (prefixes_enabled) {
  71                 u32 inst = *(u32 *)ucp->uc_mcontext.gp_regs[PT_NIP];
  72                 ucp->uc_mcontext.gp_regs[PT_NIP] += ((inst >> 26 == 1) ? 8 : 4);
  73         } else {
  74                 ucp->uc_mcontext.gp_regs[PT_NIP] += 4;
  75         }
  76 #else
  77         ucp->uc_mcontext.uc_regs->gregs[PT_NIP] += 4;
  78 #endif
  79 }
  80
  81 #define XFORM(reg, n)  " " #reg " ,%"#n",%2 ;"
  82 #define DFORM(reg, n)  " " #reg " ,0(%"#n") ;"
  83
  84 #define TEST(name, ld_op, st_op, form, ld_reg, st_reg)          \
  85         void test_##name(char *s, char *d)                      \
  86         {                                                       \
  87                 asm volatile(                                   \
  88                         #ld_op form(ld_reg, 0)                  \
  89                         #st_op form(st_reg, 1)                  \
  90                         :: "r"(s), "r"(d), "r"(0)               \
  91                         : "memory", "vs0", "vs32", "r31");      \
  92         }                                                       \
  93         rc |= do_test(#name, test_##name)
  94
  95 #define TESTP(name, ld_op, st_op, ld_reg, st_reg)               \
  96         void test_##name(char *s, char *d)                      \
  97         {                                                       \
  98                 asm volatile(                                   \
  99                         ld_op(ld_reg, %0, 0, 0)                 \
 100                         st_op(st_reg, %1, 0, 0)                 \
 101                         :: "r"(s), "r"(d), "r"(0)               \
 102                         : "memory", "vs0", "vs32", "r31");      \
 103         }                                                       \
 104         rc |= do_test(#name, test_##name)
 105
 106 #define LOAD_VSX_XFORM_TEST(op) TEST(op, op, stxvd2x, XFORM, 32, 32)
 107 #define STORE_VSX_XFORM_TEST(op) TEST(op, lxvd2x, op, XFORM, 32, 32)
 108 #define LOAD_VSX_DFORM_TEST(op) TEST(op, op, stxv, DFORM, 32, 32)
 109 #define STORE_VSX_DFORM_TEST(op) TEST(op, lxv, op, DFORM, 32, 32)
 110 #define LOAD_VMX_XFORM_TEST(op) TEST(op, op, stxvd2x, XFORM, 0, 32)
 111 #define STORE_VMX_XFORM_TEST(op) TEST(op, lxvd2x, op, XFORM, 32, 0)
 112 #define LOAD_VMX_DFORM_TEST(op) TEST(op, op, stxv, DFORM, 0, 32)
 113 #define STORE_VMX_DFORM_TEST(op) TEST(op, lxv, op, DFORM, 32, 0)
 114
 115 #define LOAD_XFORM_TEST(op) TEST(op, op, stdx, XFORM, 31, 31)
 116 #define STORE_XFORM_TEST(op) TEST(op, ldx, op, XFORM, 31, 31)
 117 #define LOAD_DFORM_TEST(op) TEST(op, op, std, DFORM, 31, 31)
 118 #define STORE_DFORM_TEST(op) TEST(op, ld, op, DFORM, 31, 31)
 119
 120 #define LOAD_FLOAT_DFORM_TEST(op)  TEST(op, op, stfd, DFORM, 0, 0)
 121 #define STORE_FLOAT_DFORM_TEST(op) TEST(op, lfd, op, DFORM, 0, 0)
 122 #define LOAD_FLOAT_XFORM_TEST(op)  TEST(op, op, stfdx, XFORM, 0, 0)
 123 #define STORE_FLOAT_XFORM_TEST(op) TEST(op, lfdx, op, XFORM, 0, 0)
 124
 125 #define LOAD_MLS_PREFIX_TEST(op) TESTP(op, op, PSTD, 31, 31)
 126 #define STORE_MLS_PREFIX_TEST(op) TESTP(op, PLD, op, 31, 31)
 127
 128 #define LOAD_8LS_PREFIX_TEST(op) TESTP(op, op, PSTD, 31, 31)
 129 #define STORE_8LS_PREFIX_TEST(op) TESTP(op, PLD, op, 31, 31)
 130
 131 #define LOAD_FLOAT_MLS_PREFIX_TEST(op) TESTP(op, op, PSTFD, 0, 0)
 132 #define STORE_FLOAT_MLS_PREFIX_TEST(op) TESTP(op, PLFD, op, 0, 0)
 133
 134 #define LOAD_VSX_8LS_PREFIX_TEST(op, tail) TESTP(op, op, PSTXV ## tail, 0, 32)
 135 #define STORE_VSX_8LS_PREFIX_TEST(op, tail) TESTP(op, PLXV ## tail, op, 32, 0)
 136
 137 /* FIXME: Unimplemented tests: */
 138 // STORE_DFORM_TEST(stq)   /* FIXME: need two registers for quad */
 139 // STORE_DFORM_TEST(stswi) /* FIXME: string instruction */
 140
 141 // STORE_XFORM_TEST(stwat) /* AMO can't emulate or run on CI */
 142 // STORE_XFORM_TEST(stdat) /* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ */
 143
 144
 145 /* preload byte by byte */
 146 void preload_data(void *dst, int offset, int width)
 147 {
 148         char *c = dst;
 149         int i;
 150
 151         c += offset;
 152
 153         for (i = 0 ; i < width ; i++)
 154                 c[i] = i;
 155 }
 156
 157 int test_memcpy(void *dst, void *src, int size, int offset,
 158                 void (*test_func)(char *, char *))
 159 {
 160         char *s, *d;
 161
 162         s = src;
 163         s += offset;
 164         d = dst;
 165         d += offset;
 166
 167         assert(size == 16);
 168         gotsig = 0;
 169         testing = 1;
 170
 171         test_func(s, d); /* run the actual test */
 172
 173         testing = 0;
 174         if (gotsig) {
 175                 if (debug)
 176                         printf("  Got signal %i\n", gotsig);
 177                 return 1;
 178         }
 179         return 0;
 180 }
 181
 182 void dumpdata(char *s1, char *s2, int n, char *test_name)
 183 {
 184         int i;
 185
 186         printf("  %s: unexpected result:\n", test_name);
 187         printf("    mem:");
 188         for (i = 0; i < n; i++)
 189                 printf(" %02x", s1[i]);
 190         printf("\n");
 191         printf("    ci: ");
 192         for (i = 0; i < n; i++)
 193                 printf(" %02x", s2[i]);
 194         printf("\n");
 195 }
 196
 197 int test_memcmp(void *s1, void *s2, int n, int offset, char *test_name)
 198 {
 199         char *s1c, *s2c;
 200
 201         s1c = s1;
 202         s1c += offset;
 203         s2c = s2;
 204         s2c += offset;
 205
 206         if (memcmp(s1c, s2c, n)) {
 207                 if (debug) {
 208                         printf("\n  Compare failed. Offset:%i length:%i\n",
 209                                offset, n);
 210                         dumpdata(s1c, s2c, n, test_name);
 211                 }
 212                 return 1;
 213         }
 214         return 0;
 215 }
 216
 217 /*
 218  * Do two memcpy tests using the same instructions. One cachable
 219  * memory and the other doesn't.
 220  */
 221 int do_test(char *test_name, void (*test_func)(char *, char *))
 222 {
 223         int offset, width, fd, rc, r;
 224         void *mem0, *mem1, *ci0, *ci1;
 225
 226         printf("\tDoing %s:\t", test_name);
 227
 228         fd = open(cipath, O_RDWR);
 229         if (fd < 0) {
 230                 printf("\n");
 231                 perror("Can't open ci file now?");
 232                 return 1;
 233         }
 234
 235         ci0 = mmap(NULL, bufsize, PROT_WRITE | PROT_READ, MAP_SHARED,
 236                    fd, cioffset);
 237         ci1 = mmap(NULL, bufsize, PROT_WRITE | PROT_READ, MAP_SHARED,
 238                    fd, cioffset + bufsize);
 239
 240         if ((ci0 == MAP_FAILED) || (ci1 == MAP_FAILED)) {
 241                 printf("\n");
 242                 perror("mmap failed");
 243                 SKIP_IF(1);
 244         }
 245
 246         rc = posix_memalign(&mem0, bufsize, bufsize);
 247         if (rc) {
 248                 printf("\n");
 249                 return rc;
 250         }
 251
 252         rc = posix_memalign(&mem1, bufsize, bufsize);
 253         if (rc) {
 254                 printf("\n");
 255                 free(mem0);
 256                 return rc;
 257         }
 258
 259         rc = 0;
 260         /*
 261          * offset = 0 is aligned but tests the workaround for the P9N
 262          * DD2.1 vector CI load issue (see 5080332c2c89 "powerpc/64s:
 263          * Add workaround for P9 vector CI load issue")
 264          */
 265         for (offset = 0; offset < 16; offset++) {
 266                 width = 16; /* vsx == 16 bytes */
 267                 r = 0;
 268
 269                 /* load pattern into memory byte by byte */
 270                 preload_data(ci0, offset, width);
 271                 preload_data(mem0, offset, width); // FIXME: remove??
 272                 memcpy(ci0, mem0, bufsize);
 273                 memcpy(ci1, mem1, bufsize); /* initialise output to the same */
 274
 275                 /* sanity check */
 276                 test_memcmp(mem0, ci0, width, offset, test_name);
 277
 278                 r |= test_memcpy(ci1,  ci0,  width, offset, test_func);
 279                 r |= test_memcpy(mem1, mem0, width, offset, test_func);
 280                 if (r && !debug) {
 281                         printf("FAILED: Got signal");
 282                         rc = 1;
 283                         break;
 284                 }
 285
 286                 r |= test_memcmp(mem1, ci1, width, offset, test_name);
 287                 if (r && !debug) {
 288                         printf("FAILED: Wrong Data");
 289                         rc = 1;
 290                         break;
 291                 }
 292         }
 293
 294         if (rc == 0)
 295                 printf("PASSED");
 296
 297         printf("\n");
 298
 299         munmap(ci0, bufsize);
 300         munmap(ci1, bufsize);
 301         free(mem0);
 302         free(mem1);
 303         close(fd);
 304
 305         return rc;
 306 }
 307
 308 static bool can_open_cifile(void)
 309 {
 310         int fd;
 311
 312         fd = open(cipath, O_RDWR);
 313         if (fd < 0)
 314                 return false;
 315
 316         close(fd);
 317         return true;
 318 }
 319
 320 int test_alignment_handler_vsx_206(void)
 321 {
 322         int rc = 0;
 323
 324         SKIP_IF(!can_open_cifile());
 325         SKIP_IF(!have_hwcap(PPC_FEATURE_ARCH_2_06));
 326
 327         printf("VSX: 2.06B\n");
 328         LOAD_VSX_XFORM_TEST(lxvd2x);
 329         LOAD_VSX_XFORM_TEST(lxvw4x);
 330         LOAD_VSX_XFORM_TEST(lxsdx);
 331         LOAD_VSX_XFORM_TEST(lxvdsx);
 332         STORE_VSX_XFORM_TEST(stxvd2x);
 333         STORE_VSX_XFORM_TEST(stxvw4x);
 334         STORE_VSX_XFORM_TEST(stxsdx);
 335         return rc;
 336 }
 337
 338 int test_alignment_handler_vsx_207(void)
 339 {
 340         int rc = 0;
 341
 342         SKIP_IF(!can_open_cifile());
 343         SKIP_IF(!have_hwcap2(PPC_FEATURE2_ARCH_2_07));
 344
 345         printf("VSX: 2.07B\n");
 346         LOAD_VSX_XFORM_TEST(lxsspx);
 347         LOAD_VSX_XFORM_TEST(lxsiwax);
 348         LOAD_VSX_XFORM_TEST(lxsiwzx);
 349         STORE_VSX_XFORM_TEST(stxsspx);
 350         STORE_VSX_XFORM_TEST(stxsiwx);
 351         return rc;
 352 }
 353
 354 int test_alignment_handler_vsx_300(void)
 355 {
 356         int rc = 0;
 357
 358         SKIP_IF(!can_open_cifile());
 359
 360         SKIP_IF(!have_hwcap2(PPC_FEATURE2_ARCH_3_00));
 361         printf("VSX: 3.00B\n");
 362         LOAD_VMX_DFORM_TEST(lxsd);
 363         LOAD_VSX_XFORM_TEST(lxsibzx);
 364         LOAD_VSX_XFORM_TEST(lxsihzx);
 365         LOAD_VMX_DFORM_TEST(lxssp);
 366         LOAD_VSX_DFORM_TEST(lxv);
 367         LOAD_VSX_XFORM_TEST(lxvb16x);
 368         LOAD_VSX_XFORM_TEST(lxvh8x);
 369         LOAD_VSX_XFORM_TEST(lxvx);
 370         LOAD_VSX_XFORM_TEST(lxvwsx);
 371         LOAD_VSX_XFORM_TEST(lxvl);
 372         LOAD_VSX_XFORM_TEST(lxvll);
 373         STORE_VMX_DFORM_TEST(stxsd);
 374         STORE_VSX_XFORM_TEST(stxsibx);
 375         STORE_VSX_XFORM_TEST(stxsihx);
 376         STORE_VMX_DFORM_TEST(stxssp);
 377         STORE_VSX_DFORM_TEST(stxv);
 378         STORE_VSX_XFORM_TEST(stxvb16x);
 379         STORE_VSX_XFORM_TEST(stxvh8x);
 380         STORE_VSX_XFORM_TEST(stxvx);
 381         STORE_VSX_XFORM_TEST(stxvl);
 382         STORE_VSX_XFORM_TEST(stxvll);
 383         return rc;
 384 }
 385
 386 int test_alignment_handler_vsx_prefix(void)
 387 {
 388         int rc = 0;
 389
 390         SKIP_IF(!can_open_cifile());
 391         SKIP_IF(!have_hwcap2(PPC_FEATURE2_ARCH_3_1));
 392
 393         printf("VSX: PREFIX\n");
 394         LOAD_VSX_8LS_PREFIX_TEST(PLXSD, 0);
 395         LOAD_VSX_8LS_PREFIX_TEST(PLXSSP, 0);
 396         LOAD_VSX_8LS_PREFIX_TEST(PLXV0, 0);
 397         LOAD_VSX_8LS_PREFIX_TEST(PLXV1, 1);
 398         STORE_VSX_8LS_PREFIX_TEST(PSTXSD, 0);
 399         STORE_VSX_8LS_PREFIX_TEST(PSTXSSP, 0);
 400         STORE_VSX_8LS_PREFIX_TEST(PSTXV0, 0);
 401         STORE_VSX_8LS_PREFIX_TEST(PSTXV1, 1);
 402         return rc;
 403 }
 404
 405 int test_alignment_handler_integer(void)
 406 {
 407         int rc = 0;
 408
 409         SKIP_IF(!can_open_cifile());
 410
 411         printf("Integer\n");
 412         LOAD_DFORM_TEST(lbz);
 413         LOAD_DFORM_TEST(lbzu);
 414         LOAD_XFORM_TEST(lbzx);
 415         LOAD_XFORM_TEST(lbzux);
 416         LOAD_DFORM_TEST(lhz);
 417         LOAD_DFORM_TEST(lhzu);
 418         LOAD_XFORM_TEST(lhzx);
 419         LOAD_XFORM_TEST(lhzux);
 420         LOAD_DFORM_TEST(lha);
 421         LOAD_DFORM_TEST(lhau);
 422         LOAD_XFORM_TEST(lhax);
 423         LOAD_XFORM_TEST(lhaux);
 424         LOAD_XFORM_TEST(lhbrx);
 425         LOAD_DFORM_TEST(lwz);
 426         LOAD_DFORM_TEST(lwzu);
 427         LOAD_XFORM_TEST(lwzx);
 428         LOAD_XFORM_TEST(lwzux);
 429         LOAD_DFORM_TEST(lwa);
 430         LOAD_XFORM_TEST(lwax);
 431         LOAD_XFORM_TEST(lwaux);
 432         LOAD_XFORM_TEST(lwbrx);
 433         LOAD_DFORM_TEST(ld);
 434         LOAD_DFORM_TEST(ldu);
 435         LOAD_XFORM_TEST(ldx);
 436         LOAD_XFORM_TEST(ldux);
 437         STORE_DFORM_TEST(stb);
 438         STORE_XFORM_TEST(stbx);
 439         STORE_DFORM_TEST(stbu);
 440         STORE_XFORM_TEST(stbux);
 441         STORE_DFORM_TEST(sth);
 442         STORE_XFORM_TEST(sthx);
 443         STORE_DFORM_TEST(sthu);
 444         STORE_XFORM_TEST(sthux);
 445         STORE_XFORM_TEST(sthbrx);
 446         STORE_DFORM_TEST(stw);
 447         STORE_XFORM_TEST(stwx);
 448         STORE_DFORM_TEST(stwu);
 449         STORE_XFORM_TEST(stwux);
 450         STORE_XFORM_TEST(stwbrx);
 451         STORE_DFORM_TEST(std);
 452         STORE_XFORM_TEST(stdx);
 453         STORE_DFORM_TEST(stdu);
 454         STORE_XFORM_TEST(stdux);
 455
 456 #ifdef __BIG_ENDIAN__
 457         LOAD_DFORM_TEST(lmw);
 458         STORE_DFORM_TEST(stmw);
 459 #endif
 460
 461         return rc;
 462 }
 463
 464 int test_alignment_handler_integer_206(void)
 465 {
 466         int rc = 0;
 467
 468         SKIP_IF(!can_open_cifile());
 469         SKIP_IF(!have_hwcap(PPC_FEATURE_ARCH_2_06));
 470
 471         printf("Integer: 2.06\n");
 472
 473         LOAD_XFORM_TEST(ldbrx);
 474         STORE_XFORM_TEST(stdbrx);
 475
 476         return rc;
 477 }
 478
 479 int test_alignment_handler_integer_prefix(void)
 480 {
 481         int rc = 0;
 482
 483         SKIP_IF(!can_open_cifile());
 484         SKIP_IF(!have_hwcap2(PPC_FEATURE2_ARCH_3_1));
 485
 486         printf("Integer: PREFIX\n");
 487         LOAD_MLS_PREFIX_TEST(PLBZ);
 488         LOAD_MLS_PREFIX_TEST(PLHZ);
 489         LOAD_MLS_PREFIX_TEST(PLHA);
 490         LOAD_MLS_PREFIX_TEST(PLWZ);
 491         LOAD_8LS_PREFIX_TEST(PLWA);
 492         LOAD_8LS_PREFIX_TEST(PLD);
 493         STORE_MLS_PREFIX_TEST(PSTB);
 494         STORE_MLS_PREFIX_TEST(PSTH);
 495         STORE_MLS_PREFIX_TEST(PSTW);
 496         STORE_8LS_PREFIX_TEST(PSTD);
 497         return rc;
 498 }
 499
 500 int test_alignment_handler_vmx(void)
 501 {
 502         int rc = 0;
 503
 504         SKIP_IF(!can_open_cifile());
 505         SKIP_IF(!have_hwcap(PPC_FEATURE_HAS_ALTIVEC));
 506
 507         printf("VMX\n");
 508         LOAD_VMX_XFORM_TEST(lvx);
 509
 510         /*
 511          * FIXME: These loads only load part of the register, so our
 512          * testing method doesn't work. Also they don't take alignment
 513          * faults, so it's kinda pointless anyway
 514          *
 515          LOAD_VMX_XFORM_TEST(lvebx)
 516          LOAD_VMX_XFORM_TEST(lvehx)
 517          LOAD_VMX_XFORM_TEST(lvewx)
 518          LOAD_VMX_XFORM_TEST(lvxl)
 519         */
 520         STORE_VMX_XFORM_TEST(stvx);
 521         STORE_VMX_XFORM_TEST(stvebx);
 522         STORE_VMX_XFORM_TEST(stvehx);
 523         STORE_VMX_XFORM_TEST(stvewx);
 524         STORE_VMX_XFORM_TEST(stvxl);
 525         return rc;
 526 }
 527
 528 int test_alignment_handler_fp(void)
 529 {
 530         int rc = 0;
 531
 532         SKIP_IF(!can_open_cifile());
 533
 534         printf("Floating point\n");
 535         LOAD_FLOAT_DFORM_TEST(lfd);
 536         LOAD_FLOAT_XFORM_TEST(lfdx);
 537         LOAD_FLOAT_DFORM_TEST(lfdu);
 538         LOAD_FLOAT_XFORM_TEST(lfdux);
 539         LOAD_FLOAT_DFORM_TEST(lfs);
 540         LOAD_FLOAT_XFORM_TEST(lfsx);
 541         LOAD_FLOAT_DFORM_TEST(lfsu);
 542         LOAD_FLOAT_XFORM_TEST(lfsux);
 543         STORE_FLOAT_DFORM_TEST(stfd);
 544         STORE_FLOAT_XFORM_TEST(stfdx);
 545         STORE_FLOAT_DFORM_TEST(stfdu);
 546         STORE_FLOAT_XFORM_TEST(stfdux);
 547         STORE_FLOAT_DFORM_TEST(stfs);
 548         STORE_FLOAT_XFORM_TEST(stfsx);
 549         STORE_FLOAT_DFORM_TEST(stfsu);
 550         STORE_FLOAT_XFORM_TEST(stfsux);
 551         STORE_FLOAT_XFORM_TEST(stfiwx);
 552
 553         return rc;
 554 }
 555
 556 int test_alignment_handler_fp_205(void)
 557 {
 558         int rc = 0;
 559
 560         SKIP_IF(!can_open_cifile());
 561         SKIP_IF(!have_hwcap(PPC_FEATURE_ARCH_2_05));
 562
 563         printf("Floating point: 2.05\n");
 564
 565         LOAD_FLOAT_DFORM_TEST(lfdp);
 566         LOAD_FLOAT_XFORM_TEST(lfdpx);
 567         LOAD_FLOAT_XFORM_TEST(lfiwax);
 568         STORE_FLOAT_DFORM_TEST(stfdp);
 569         STORE_FLOAT_XFORM_TEST(stfdpx);
 570
 571         return rc;
 572 }
 573
 574 int test_alignment_handler_fp_206(void)
 575 {
 576         int rc = 0;
 577
 578         SKIP_IF(!can_open_cifile());
 579         SKIP_IF(!have_hwcap(PPC_FEATURE_ARCH_2_06));
 580
 581         printf("Floating point: 2.06\n");
 582
 583         LOAD_FLOAT_XFORM_TEST(lfiwzx);
 584
 585         return rc;
 586 }
 587
 588
 589 int test_alignment_handler_fp_prefix(void)
 590 {
 591         int rc = 0;
 592
 593         SKIP_IF(!can_open_cifile());
 594         SKIP_IF(!have_hwcap2(PPC_FEATURE2_ARCH_3_1));
 595
 596         printf("Floating point: PREFIX\n");
 597         LOAD_FLOAT_DFORM_TEST(lfs);
 598         LOAD_FLOAT_MLS_PREFIX_TEST(PLFS);
 599         LOAD_FLOAT_MLS_PREFIX_TEST(PLFD);
 600         STORE_FLOAT_MLS_PREFIX_TEST(PSTFS);
 601         STORE_FLOAT_MLS_PREFIX_TEST(PSTFD);
 602         return rc;
 603 }
 604
 605 void usage(char *prog)
 606 {
 607         printf("Usage: %s [options] [path [offset]]\n", prog);
 608         printf("  -d    Enable debug error output\n");
 609         printf("\n");
 610         printf("This test requires a POWER8, POWER9 or POWER10 CPU ");
 611         printf("and either a usable framebuffer at /dev/fb0 or ");
 612         printf("the path to usable cache inhibited memory and optional ");
 613         printf("offset to be provided\n");
 614 }
 615
 616 int main(int argc, char *argv[])
 617 {
 618
 619         struct sigaction sa;
 620         int rc = 0;
 621         int option = 0;
 622
 623         while ((option = getopt(argc, argv, "d")) != -1) {
 624                 switch (option) {
 625                 case 'd':
 626                         debug++;
 627                         break;
 628                 default:
 629                         usage(argv[0]);
 630                         exit(1);
 631                 }
 632         }
 633         argc -= optind;
 634         argv += optind;
 635
 636         if (argc > 0)
 637                 cipath = argv[0];
 638         if (argc > 1)
 639                 cioffset = strtol(argv[1], 0, 0x10);
 640
 641         bufsize = getpagesize();
 642
 643         sa.sa_sigaction = sighandler;
 644         sigemptyset(&sa.sa_mask);
 645         sa.sa_flags = SA_SIGINFO;
 646         if (sigaction(SIGSEGV, &sa, NULL) == -1
 647             || sigaction(SIGBUS, &sa, NULL) == -1
 648             || sigaction(SIGILL, &sa, NULL) == -1) {
 649                 perror("sigaction");
 650                 exit(1);
 651         }
 652
 653         prefixes_enabled = have_hwcap2(PPC_FEATURE2_ARCH_3_1);
 654
 655         rc |= test_harness(test_alignment_handler_vsx_206,
 656                            "test_alignment_handler_vsx_206");
 657         rc |= test_harness(test_alignment_handler_vsx_207,
 658                            "test_alignment_handler_vsx_207");
 659         rc |= test_harness(test_alignment_handler_vsx_300,
 660                            "test_alignment_handler_vsx_300");
 661         rc |= test_harness(test_alignment_handler_vsx_prefix,
 662                            "test_alignment_handler_vsx_prefix");
 663         rc |= test_harness(test_alignment_handler_integer,
 664                            "test_alignment_handler_integer");
 665         rc |= test_harness(test_alignment_handler_integer_206,
 666                            "test_alignment_handler_integer_206");
 667         rc |= test_harness(test_alignment_handler_integer_prefix,
 668                            "test_alignment_handler_integer_prefix");
 669         rc |= test_harness(test_alignment_handler_vmx,
 670                            "test_alignment_handler_vmx");
 671         rc |= test_harness(test_alignment_handler_fp,
 672                            "test_alignment_handler_fp");
 673         rc |= test_harness(test_alignment_handler_fp_205,
 674                            "test_alignment_handler_fp_205");
 675         rc |= test_harness(test_alignment_handler_fp_206,
 676                            "test_alignment_handler_fp_206");
 677         rc |= test_harness(test_alignment_handler_fp_prefix,
 678                            "test_alignment_handler_fp_prefix");
 679         return rc;
 680 }