xref: /qemu/tests/tcg/loongarch64/test_bit.c (revision 76eb88b1)
1 #include <assert.h>
2 #include <inttypes.h>
3 
4 #define ARRAY_SIZE(X) (sizeof(X) / sizeof(*(X)))
5 #define TEST_CLO(N)                                     \
6 static uint64_t test_clo_##N(uint64_t rj)               \
7 {                                                       \
8     uint64_t rd = 0;                                    \
9                                                         \
10     asm volatile("clo."#N" %0, %1\n\t"                  \
11                  : "=r"(rd)                             \
12                  : "r"(rj)                              \
13                  : );                                   \
14     return rd;                                          \
15 }
16 
17 #define TEST_CLZ(N)                                     \
18 static uint64_t test_clz_##N(uint64_t rj)               \
19 {                                                       \
20     uint64_t rd = 0;                                    \
21                                                         \
22     asm volatile("clz."#N" %0, %1\n\t"                  \
23                  : "=r"(rd)                             \
24                  : "r"(rj)                              \
25                  : );                                   \
26     return rd;                                          \
27 }
28 
29 #define TEST_CTO(N)                                     \
30 static uint64_t test_cto_##N(uint64_t rj)               \
31 {                                                       \
32     uint64_t rd = 0;                                    \
33                                                         \
34     asm volatile("cto."#N" %0, %1\n\t"                  \
35                  : "=r"(rd)                             \
36                  : "r"(rj)                              \
37                  : );                                   \
38     return rd;                                          \
39 }
40 
41 #define TEST_CTZ(N)                                     \
42 static uint64_t test_ctz_##N(uint64_t rj)               \
43 {                                                       \
44     uint64_t rd = 0;                                    \
45                                                         \
46     asm volatile("ctz."#N" %0, %1\n\t"                  \
47                  : "=r"(rd)                             \
48                  : "r"(rj)                              \
49                  : );                                   \
50     return rd;                                          \
51 }
52 
53 TEST_CLO(w)
54 TEST_CLO(d)
55 TEST_CLZ(w)
56 TEST_CLZ(d)
57 TEST_CTO(w)
58 TEST_CTO(d)
59 TEST_CTZ(w)
60 TEST_CTZ(d)
61 
62 struct vector {
63     uint64_t (*func)(uint64_t);
64     uint64_t u;
65     uint64_t r;
66 };
67 
68 static struct vector vectors[] = {
69     {test_clo_w, 0xfff11fff392476ab, 0},
70     {test_clo_d, 0xabd28a64000000, 0},
71     {test_clz_w, 0xfaffff42392476ab, 2},
72     {test_clz_d, 0xabd28a64000000, 8},
73     {test_cto_w, 0xfff11fff392476ab, 2},
74     {test_cto_d, 0xabd28a64000000, 0},
75     {test_ctz_w, 0xfaffff42392476ab, 0},
76     {test_ctz_d, 0xabd28a64000000, 26},
77 };
78 
79 int main()
80 {
81     int i;
82 
83     for (i = 0; i < ARRAY_SIZE(vectors); i++) {
84         assert((*vectors[i].func)(vectors[i].u) == vectors[i].r);
85     }
86 
87     return 0;
88 }
89