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 }
681
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.