Debian Codegraph @

gcc/testsuite/gcc.target/riscv/rvv/autovec/binop/vrolr-run.c

raw
1 /* { dg-do run } */
2 /* { dg-require-effective-target "riscv_zvbb_ok" } */
3 /* { dg-add-options "riscv_v" } */
4 /* { dg-add-options "riscv_zvbb" } */
5 /* { dg-additional-options "-std=c99 -fno-vect-cost-model" } */
6
7 #include <stdint-gcc.h>
8 #include <assert.h>
9
10 #include <stdio.h>
11 #include <stdint.h>
12 #include <assert.h>
13
14 #define ARRAY_SIZE 512
15
16 #define CIRCULAR_LEFT_SHIFT_ARRAY(arr, shifts, bit_size, size) \
17 for (int i = 0; i < size; i++) { \
18 (arr)[i] = (((arr)[i] << (shifts)[i]) | ((arr)[i] >> (bit_size - (shifts)[i]))); \
19 }
20
21 #define CIRCULAR_RIGHT_SHIFT_ARRAY(arr, shifts, bit_size, size) \
22 for (int i = 0; i < size; i++) { \
23 (arr)[i] = (((arr)[i] >> (shifts)[i]) | ((arr)[i] << (bit_size - (shifts)[i]))); \
24 }
25
26 void __attribute__((optimize("no-tree-vectorize"))) compare_results8(
27 uint8_t *result_left, uint8_t *result_right,
28 int bit_size, uint8_t *shift_values)
29 {
30 for (int i = 0; i < ARRAY_SIZE; i++) {
31 assert(result_left[i] == (i << shift_values[i]) | (i >> (bit_size - shift_values[i])));
32 assert(result_right[i] == (i >> shift_values[i]) | (i << (bit_size - shift_values[i])));
33 }
34 }
35
36 void __attribute__((optimize("no-tree-vectorize"))) compare_results16(
37 uint16_t *result_left, uint16_t *result_right,
38 int bit_size, uint16_t *shift_values)
39 {
40 for (int i = 0; i < ARRAY_SIZE; i++) {
41 assert(result_left[i] == (i << shift_values[i]) | (i >> (bit_size - shift_values[i])));
42 assert(result_right[i] == (i >> shift_values[i]) | (i << (bit_size - shift_values[i])));
43 }
44 }
45
46 void __attribute__((optimize("no-tree-vectorize"))) compare_results32(
47 uint32_t *result_left, uint32_t *result_right,
48 int bit_size, uint32_t *shift_values)
49 {
50 for (int i = 0; i < ARRAY_SIZE; i++) {
51 assert(result_left[i] == (i << shift_values[i]) | (i >> (bit_size - shift_values[i])));
52 assert(result_right[i] == (i >> shift_values[i]) | (i << (bit_size - shift_values[i])));
53 }
54 }
55
56 void __attribute__((optimize("no-tree-vectorize"))) compare_results64(
57 uint64_t *result_left, uint64_t *result_right,
58 int bit_size, uint64_t *shift_values)
59 {
60 for (int i = 0; i < ARRAY_SIZE; i++) {
61 assert(result_left[i] == ((uint64_t)i << shift_values[i]) | ((uint64_t)i >> (bit_size - shift_values[i])));
62 assert(result_right[i] == ((uint64_t)i >> shift_values[i]) | ((uint64_t)i << (bit_size - shift_values[i])));
63 }
64 }
65
66 #define TEST_SHIFT_OPERATIONS(TYPE, bit_size) \
67 TYPE shift_val##bit_size[ARRAY_SIZE];\
68 TYPE result_left##bit_size[ARRAY_SIZE];\
69 TYPE result_right##bit_size[ARRAY_SIZE];\
70 do { \
71 for (int i = 0; i < ARRAY_SIZE; i++) { \
72 result_left##bit_size[i] = i;\
73 result_right##bit_size[i] = i;\
74 shift_val##bit_size[i] = i % bit_size; \
75 } \
76 CIRCULAR_LEFT_SHIFT_ARRAY(result_left##bit_size, shift_val##bit_size, bit_size, ARRAY_SIZE)\
77 CIRCULAR_RIGHT_SHIFT_ARRAY(result_right##bit_size, shift_val##bit_size, bit_size, ARRAY_SIZE)\
78 compare_results##bit_size(result_left##bit_size, result_right##bit_size, bit_size, shift_val##bit_size); \
79 } while(0)
80
81
82 int main() {
83 TEST_SHIFT_OPERATIONS(uint8_t, 8);
84 TEST_SHIFT_OPERATIONS(uint16_t, 16);
85 TEST_SHIFT_OPERATIONS(uint32_t, 32);
86 TEST_SHIFT_OPERATIONS(uint64_t, 64);
87 return 0;
88 }