Debian Codegraph @

gcc/testsuite/gcc.target/s390/htm-builtins-2.c

raw
1 /* Functional tests of the htm __TM_... macros. */
2
3 /* { dg-do run } */
4 /* { dg-require-effective-target htm } */
5 /* { dg-options "-O3 -march=zEC12 -mzarch" } */
6
7 /* ---------------------------- included header files ---------------------- */
8
9 #include <stdio.h>
10 #include <string.h>
11 #include <inttypes.h>
12 #include <htmxlintrin.h>
13
14 /* ---------------------------- local definitions -------------------------- */
15
16 #define DEFAULT_MAX_REPETITIONS 7
17 #define DEFAULT_REQUIRED_QUORUM 4
18 #define DEFAULT_ABORT_ADDRESS (0x12345678u)
19
20 /* ---------------------------- local macros ------------------------------- */
21
22 #define TEST_DF_REP(name) \
23 { #name, name, DEFAULT_MAX_REPETITIONS, DEFAULT_REQUIRED_QUORUM }
24 #define TEST_NO_REP(name) { #name, name, 1, 1 }
25
26 /* ---------------------------- local types -------------------------------- */
27
28 typedef int (*test_func_t)(void);
29
30 typedef struct
31 {
32 const char *name;
33 test_func_t test_func;
34 int max_repetitions;
35 int required_quorum;
36 } test_table_entry_t;
37
38 typedef enum
39 {
40 ABORT_T_SYSTEM = 0,
41 ABORT_T_USER = 1,
42 } abort_user_t;
43
44 typedef enum
45 {
46 ABORT_T_NONE = 0,
47 ABORT_T_ILLEGAL,
48 ABORT_T_FOOTPRINT_EXCEEDED,
49 ABORT_T_NESTED_TOO_DEEP,
50 ABORT_T_CONFLICT,
51
52 ABORT_T_INVALID_ABORT_CODE
53 } abort_t;
54
55 /* ---------------------------- local variables ---------------------------- */
56
57 __attribute__ ((aligned(256))) static struct __htm_tdb local_tdb256;
58 static struct __htm_tdb local_tdb;
59
60 static abort_t const abort_classes[] =
61 {
62 ABORT_T_INVALID_ABORT_CODE,
63 ABORT_T_NONE,
64 ABORT_T_NONE,
65 ABORT_T_NONE,
66
67 ABORT_T_ILLEGAL,
68 ABORT_T_NONE,
69 ABORT_T_NONE,
70 ABORT_T_FOOTPRINT_EXCEEDED,
71
72 ABORT_T_FOOTPRINT_EXCEEDED,
73 ABORT_T_CONFLICT,
74 ABORT_T_CONFLICT,
75 ABORT_T_ILLEGAL,
76
77 ABORT_T_NONE,
78 ABORT_T_NESTED_TOO_DEEP,
79 ABORT_T_NONE,
80 ABORT_T_NONE,
81
82 ABORT_T_NONE
83 };
84
85 static size_t num_abort_classes = sizeof(abort_classes) / sizeof(abort_t);
86
87 /* ---------------------------- exported variables (globals) --------------- */
88
89 int global_int = 0;
90 uint64_t global_u64 = 0;
91 float global_float_1 = 1.0;
92 float global_float_2 = 2.5;
93 float global_float_3 = 0.0;
94 __attribute__ ((aligned(256))) struct
95 {
96 volatile uint64_t c1;
97 char pad1[256 - sizeof(uint64_t)];
98 volatile uint64_t c2;
99 char pad2[256 - sizeof(uint64_t)];
100 volatile uint64_t c3;
101 } counters = { 0 };
102
103 /* ---------------------------- local helper functions --------------------- */
104
105 static void dump_tdb(struct __htm_tdb *tdb)
106 {
107 unsigned char *p;
108 int i;
109 int j;
110
111 p = (unsigned char *)tdb;
112 for (i = 0; i < 16; i++)
113 {
114 fprintf(stderr, "0x%02x ", i * 16);
115 for (j = 0; j < 16; j++)
116 {
117 fprintf(stderr, "%02x", (int)p[i * 16 + j]);
118 if (j < 15)
119 {
120 fprintf(stderr, " ");
121 }
122 if (j == 7)
123 {
124 fprintf(stderr, " ");
125 }
126 }
127 fprintf(stderr, "\n");
128 }
129
130 return;
131 }
132
133 static void make_fake_tdb(struct __htm_tdb *tdb)
134 {
135 memset(tdb, 0, sizeof(*tdb));
136 tdb->format = 1;
137 tdb->nesting_depth = 1;
138 tdb->atia = DEFAULT_ABORT_ADDRESS;
139 tdb->abort_code = 11;
140
141 return;
142 }
143
144 static int check_abort_code_in_tdb(struct __htm_tdb *tdb, uint64_t abort_code)
145 {
146 long expect_rc;
147 long rc;
148
149 if (abort_code != 0)
150 {
151 long addr;
152
153 addr = __TM_failure_address(&local_tdb);
154 if (addr != DEFAULT_ABORT_ADDRESS)
155 {
156 return 11;
157 }
158 }
159 {
160 long long tdb_abort_code;
161
162 tdb_abort_code = __TM_failure_code(tdb);
163 if ((uint64_t)tdb_abort_code != abort_code)
164 {
165 fprintf(
166 stderr, "tm_ac %" PRIu64 ", ac %" PRIu64
167 ", tdb_ac %" PRIu64 "\n",
168 (uint64_t)tdb_abort_code, abort_code,
169 (uint64_t)tdb->abort_code);
170 return 10;
171 }
172 }
173 expect_rc = (abort_code >= 256) ? 1 : 0;
174 rc = __TM_is_user_abort(tdb);
175 if (rc != expect_rc)
176 {
177 fprintf(stderr, "rc %ld, expect_rc %ld\n", rc, expect_rc);
178 return 1;
179 }
180 {
181 unsigned char code;
182
183 code = 0xffu;
184 rc = __TM_is_named_user_abort(tdb, &code);
185 if (rc != expect_rc)
186 {
187 fprintf(
188 stderr, "rc %ld, expect_rc %ld\n", rc,
189 expect_rc);
190 return 2;
191 }
192 if (expect_rc == 1 && code != abort_code - 256)
193 {
194 return 3;
195 }
196 }
197 if (abort_code > (uint64_t)num_abort_classes)
198 {
199 abort_code = (uint64_t)num_abort_classes;
200 }
201 expect_rc = (abort_classes[abort_code] == ABORT_T_ILLEGAL) ? 1 : 0;
202 rc = __TM_is_illegal(tdb);
203 if (rc != expect_rc)
204 {
205 dump_tdb(tdb);
206 fprintf(stderr, "rc %ld, expect_rc %ld\n", rc, expect_rc);
207 return 4;
208 }
209 expect_rc =
210 (abort_classes[abort_code] == ABORT_T_FOOTPRINT_EXCEEDED) ?
211 1 : 0;
212 rc = __TM_is_footprint_exceeded(tdb);
213 if (rc != expect_rc)
214 {
215 dump_tdb(tdb);
216 fprintf(stderr, "rc %ld, expect_rc %ld\n", rc, expect_rc);
217 return 5;
218 }
219 expect_rc =
220 (abort_classes[abort_code] == ABORT_T_NESTED_TOO_DEEP) ? 1 : 0;
221 rc = __TM_is_nested_too_deep(tdb);
222 if (rc != expect_rc)
223 {
224 dump_tdb(tdb);
225 fprintf(stderr, "rc %ld, expect_rc %ld\n", rc, expect_rc);
226 return 6;
227 }
228 expect_rc = (abort_classes[abort_code] == ABORT_T_CONFLICT) ? 1 : 0;
229 rc = __TM_is_conflict(tdb);
230 if (rc != expect_rc)
231 {
232 dump_tdb(tdb);
233 fprintf(stderr, "rc %ld, expect_rc %ld\n", rc, expect_rc);
234 return 7;
235 }
236
237 return 0;
238 }
239
240 /* ---------------------------- local test functions ----------------------- */
241
242 /* Not a test; make sure that the involved global cachelines are reserved for
243 * writing. */
244 static int init_cache(void)
245 {
246 make_fake_tdb(&local_tdb);
247 make_fake_tdb(&local_tdb256);
248 global_int = 0;
249 global_u64 = 0;
250 global_float_1 = 1.0;
251 global_float_2 = 2.5;
252 global_float_3 = 0.0;
253 counters.c1 = 0;
254 counters.c2 = 0;
255 counters.c3 = 0;
256
257 return 0;
258 }
259
260 static int test_abort_classification(void)
261 {
262 int i;
263
264 make_fake_tdb(&local_tdb);
265 for (i = 0; i <= 256; i++)
266 {
267 int rc;
268
269 local_tdb.abort_code = (uint64_t)i;
270 rc = check_abort_code_in_tdb(&local_tdb, (uint64_t)i);
271 if (rc != 0)
272 {
273 return 100 * i + rc;
274 }
275 }
276
277 return 0;
278 }
279
280 static int test_cc_classification(void)
281 {
282 long rc;
283
284 rc = __TM_is_failure_persistent(0);
285 if (rc != 0)
286 {
287 return 1;
288 }
289 rc = __TM_is_failure_persistent(1);
290 if (rc != 0)
291 {
292 return 2;
293 }
294 rc = __TM_is_failure_persistent(2);
295 if (rc != 0)
296 {
297 return 3;
298 }
299 rc = __TM_is_failure_persistent(3);
300 if (rc != 1)
301 {
302 return 4;
303 }
304
305 return 0;
306 }
307
308 static int test_tbegin_ntstg_tend(void)
309 {
310 long rc;
311
312 counters.c1 = 0;
313 counters.c2 = 0;
314 if ((rc = __TM_simple_begin()) == 0)
315 {
316 __TM_non_transactional_store((uint64_t *)&counters.c1, 1);
317 counters.c2 = 2;
318 rc = __TM_end();
319 if (rc != 0)
320 {
321 return 100 * rc + 5;
322 }
323 if (counters.c1 != 1)
324 {
325 return 100 * counters.c1 + 2;
326 }
327 if (counters.c2 != 2)
328 {
329 return 100 * counters.c2 + 3;
330 }
331 }
332 else
333 {
334 return 100 * rc + 4;
335 }
336
337 return 0;
338 }
339
340 static int test_tbegin_ntstg_tabort(void)
341 {
342 register float f;
343
344 counters.c1 = 0;
345 counters.c2 = 0;
346 f = 0;
347 if (__TM_simple_begin() == 0)
348 {
349 __TM_non_transactional_store((uint64_t *)&counters.c1, 1);
350 counters.c2 = 2;
351 f = 1;
352 __TM_named_abort(0);
353 return 1;
354 }
355 if (counters.c1 != 1)
356 {
357 return 100 * counters.c1 + 2;
358 }
359 if (counters.c2 != 0)
360 {
361 return 100 * counters.c2 + 3;
362 }
363 if (f != 0)
364 {
365 return 100 * f + 4;
366 }
367
368 return 0;
369 }
370
371 static int test_tbegin_aborts(void)
372 {
373 float f;
374 long rc;
375
376 f = 77;
377 if ((rc = __TM_simple_begin()) == 0)
378 {
379 f = 88;
380 __TM_abort();
381 return 2;
382 }
383 else if (rc != 2)
384 {
385 return 3;
386 }
387 if (f != 77)
388 {
389 return 4;
390 }
391 f = 66;
392 if ((rc = __TM_simple_begin()) == 0)
393 {
394 f = 99;
395 __TM_named_abort(3);
396 return 5;
397 }
398 else if (rc != 3)
399 {
400 return 100 * rc + 6;
401 }
402 if (f != 66)
403 {
404 return 100 * f + 7;
405 }
406 if ((rc = __TM_simple_begin()) == 0)
407 {
408 global_float_3 = global_float_1 + global_float_2;
409 rc = __TM_end();
410 if (rc != 0)
411 {
412 return 100 * rc + 8;
413 }
414 }
415 else
416 {
417 return 100 * rc + 9;
418 }
419 if (global_float_3 != global_float_1 + global_float_2)
420 {
421 return 100 * rc + 10;
422 }
423
424 return 0;
425 }
426
427 static int test_tbegin_tdb(void)
428 {
429 long rc;
430
431 local_tdb.format = 0;
432 if ((rc = __TM_begin(&local_tdb)) == 0)
433 {
434 rc = __TM_end();
435 if (rc != 0)
436 {
437 return 100 * rc + 1;
438 }
439 if (local_tdb.format != 0)
440 {
441 dump_tdb(&local_tdb);
442 return 100 * local_tdb.format + 2;
443 }
444 }
445 else
446 {
447 return 100 * rc + 3;
448 }
449 local_tdb.format = 0;
450 if ((rc = __TM_begin(&local_tdb)) == 0)
451 {
452 __TM_named_abort(1);
453 return 4;
454 }
455 else
456 {
457 if (rc != 3)
458 {
459 return 100 * rc + 5;
460 }
461 if (local_tdb.format != 1)
462 {
463 dump_tdb(&local_tdb);
464 return 100 * local_tdb.format + 6;
465 }
466 }
467 local_tdb256.format = 0;
468 if ((rc = __TM_begin(&local_tdb256)) == 0)
469 {
470 rc = __TM_end();
471 if (rc != 0)
472 {
473 return 1100 * rc + 1;
474 }
475 if (local_tdb256.format != 0)
476 {
477 dump_tdb(&local_tdb256);
478 return 1100 * local_tdb256.format + 2;
479 }
480 }
481 else
482 {
483 return 1100 * rc + 3;
484 }
485 #if 1 /*!!!does not work*/
486 local_tdb256.format = 0;
487 if ((rc = __TM_begin(&local_tdb256)) == 0)
488 {
489 __TM_named_abort(1);
490 return 2004;
491 }
492 else
493 {
494 if (rc != 3)
495 {
496 return 2100 * rc + 5;
497 }
498 if (local_tdb256.format != 1)
499 {
500 dump_tdb(&local_tdb256);
501 return 2100 * local_tdb256.format + 6;
502 }
503 }
504 #endif
505
506 return 0;
507 }
508
509 static int test_etnd(void)
510 {
511 long rc;
512
513 {
514 long nd;
515
516 make_fake_tdb(&local_tdb);
517 local_tdb.nesting_depth = 0;
518 nd = __TM_nesting_depth(&local_tdb);
519 if (nd != 0)
520 {
521 return 1;
522 }
523 local_tdb.nesting_depth = 7;
524 nd = __TM_nesting_depth(&local_tdb);
525 if (nd != 7)
526 {
527 return 7;
528 }
529 local_tdb.format = 0;
530 nd = __TM_nesting_depth(&local_tdb);
531 if (nd != 0)
532 {
533 return 2;
534 }
535 }
536 counters.c1 = 0;
537 counters.c1 = 0;
538 counters.c2 = 0;
539 counters.c3 = 0;
540 if ((rc = __TM_simple_begin()) == 0)
541 {
542 counters.c1 = __TM_nesting_depth(0);
543 if (__TM_simple_begin() == 0)
544 {
545 counters.c2 = __TM_nesting_depth(0);
546 if (__TM_simple_begin() == 0)
547 {
548 counters.c3 = __TM_nesting_depth(0);
549 __TM_end();
550 }
551 __TM_end();
552 }
553 __TM_end();
554 }
555 else
556 {
557 return 100 * rc + 1;
558 }
559 if (counters.c1 != 1)
560 {
561 return 100 * counters.c1 + 2;
562 }
563 if (counters.c2 != 2)
564 {
565 return 100 * counters.c2 + 3;
566 }
567 if (counters.c3 != 3)
568 {
569 return 100 * counters.c3 + 4;
570 }
571
572 return 0;
573 }
574
575 /* ---------------------------- local testing framework functions ---------- */
576
577 static int run_one_test(const test_table_entry_t *test_entry)
578 {
579 int do_print_passes;
580 int succeeded;
581 int rc;
582 int i;
583
584 do_print_passes = (
585 test_entry->required_quorum != 1 ||
586 test_entry->max_repetitions != 1);
587 printf("RRR RUN %s\n", test_entry->name);
588 if (do_print_passes == 1)
589 {
590 printf(
591 " (requires %d successful out of %d runs)\n",
592 test_entry->required_quorum,
593 test_entry->max_repetitions);
594 }
595 succeeded = 0;
596 rc = 0;
597 for (rc = 0, i = 0; i < test_entry->max_repetitions; i++)
598 {
599 if (do_print_passes == 1)
600 {
601 if (i == 0)
602 {
603 printf(" ");
604 }
605 else
606 {
607 printf(",");
608 }
609 }
610 rc = test_entry->test_func();
611 if (rc == 0)
612 {
613 if (do_print_passes == 1)
614 {
615 printf(" success");
616 }
617 succeeded++;
618 if (succeeded >= test_entry->required_quorum)
619 {
620 break;
621 }
622 }
623 else
624 {
625 printf(" failed (rc = %d)", rc);
626 }
627 }
628 if (do_print_passes == 1 || rc != 0)
629 {
630 printf("\n");
631 }
632 if (succeeded >= test_entry->required_quorum)
633 {
634 printf("+++ OK %s\n", test_entry->name);
635
636 return 0;
637 }
638 else
639 {
640 printf("--- FAIL %s\n", test_entry->name);
641
642 return (rc != 0) ? rc : -1;
643 }
644 }
645
646 static int run_all_tests(const test_table_entry_t *test_table)
647 {
648 const test_table_entry_t *test;
649 int rc;
650
651 for (
652 rc = 0, test = &test_table[0];
653 test->test_func != NULL && rc == 0; test++)
654 {
655 rc = run_one_test(test);
656 }
657
658 return rc;
659 }
660
661 /* ---------------------------- interface functions ------------------------ */
662
663 int main(void)
664 {
665 const test_table_entry_t test_table[] = {
666 TEST_NO_REP(init_cache),
667 TEST_NO_REP(test_abort_classification),
668 TEST_NO_REP(test_cc_classification),
669 TEST_DF_REP(test_tbegin_ntstg_tend),
670 TEST_DF_REP(test_tbegin_ntstg_tabort),
671 TEST_DF_REP(test_tbegin_aborts),
672 TEST_DF_REP(test_tbegin_tdb),
673 TEST_DF_REP(test_etnd),
674 { (void *)0, 0, 0 }
675 };
676
677 {
678 int rc;
679
680 rc = run_all_tests(test_table);
681
682 return rc;
683 }
684 }