| 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 |
} |