cleanup mbstowcs wrapper
[musl] / arch / microblaze / atomic.h
1 #ifndef _INTERNAL_ATOMIC_H
2 #define _INTERNAL_ATOMIC_H
3
4 #include <stdint.h>
5
6 static inline int a_ctz_l(unsigned long x)
7 {
8         static const char debruijn32[32] = {
9                 0, 1, 23, 2, 29, 24, 19, 3, 30, 27, 25, 11, 20, 8, 4, 13,
10                 31, 22, 28, 18, 26, 10, 7, 12, 21, 17, 9, 6, 16, 5, 15, 14
11         };
12         return debruijn32[(x&-x)*0x076be629 >> 27];
13 }
14
15 static inline int a_ctz_64(uint64_t x)
16 {
17         uint32_t y = x;
18         if (!y) {
19                 y = x>>32;
20                 return 32 + a_ctz_l(y);
21         }
22         return a_ctz_l(y);
23 }
24
25 static inline int a_cas_1(volatile int *p, int t, int s)
26 {
27         register int tmp;
28         do {
29                 __asm__ __volatile__ ("lwx %0, %1, r0"
30                         : "=r"(tmp) : "r"(p) : "memory");
31                 if (tmp != t) return tmp;
32                 __asm__ __volatile__ ("swx %2, %1, r0 ; addic %0, r0, 0"
33                         : "=r"(tmp) : "r"(p), "r"(s) : "cc", "memory");
34         } while (tmp);
35         return t;
36 }
37
38 static inline int a_cas(volatile int *p, int t, int s)
39 {
40         register int old, tmp;
41         __asm__ __volatile__ (
42                 "       addi %0, r0, 0\n"
43                 "1:     lwx %0, %2, r0\n"
44                 "       rsubk %1, %0, %3\n"
45                 "       bnei %1, 1f\n"
46                 "       swx %4, %2, r0\n"
47                 "       addic %1, r0, 0\n"
48                 "       bnei %1, 1b\n"
49                 "1:     "
50                 : "=&r"(old), "=&r"(tmp)
51                 : "r"(p), "r"(t), "r"(s)
52                 : "cc", "memory" );
53         return old;
54 }
55
56 static inline void *a_cas_p(volatile void *p, void *t, void *s)
57 {
58         return (void *)a_cas(p, (int)t, (int)s);
59 }
60
61 static inline long a_cas_l(volatile void *p, long t, long s)
62 {
63         return a_cas(p, t, s);
64 }
65
66 static inline int a_swap(volatile int *x, int v)
67 {
68         register int old, tmp;
69         __asm__ __volatile__ (
70                 "       addi %0, r0, 0\n"
71                 "1:     lwx %0, %2, r0\n"
72                 "       swx %3, %2, r0\n"
73                 "       addic %1, r0, 0\n"
74                 "       bnei %1, 1b\n"
75                 "1:     "
76                 : "=&r"(old), "=&r"(tmp)
77                 : "r"(x), "r"(v)
78                 : "cc", "memory" );
79         return old;
80 }
81
82 static inline int a_fetch_add(volatile int *x, int v)
83 {
84         register int new, tmp;
85         __asm__ __volatile__ (
86                 "       addi %0, r0, 0\n"
87                 "1:     lwx %0, %2, r0\n"
88                 "       addk %0, %0, %3\n"
89                 "       swx %0, %2, r0\n"
90                 "       addic %1, r0, 0\n"
91                 "       bnei %1, 1b\n"
92                 "1:     "
93                 : "=&r"(new), "=&r"(tmp)
94                 : "r"(x), "r"(v)
95                 : "cc", "memory" );
96         return new-v;
97 }
98
99 static inline void a_inc(volatile int *x)
100 {
101         a_fetch_add(x, 1);
102 }
103
104 static inline void a_dec(volatile int *x)
105 {
106         a_fetch_add(x, -1);
107 }
108
109 static inline void a_store(volatile int *p, int x)
110 {
111         *p=x;
112 }
113
114 static inline void a_spin()
115 {
116 }
117
118 static inline void a_crash()
119 {
120         *(volatile char *)0=0;
121 }
122
123 static inline void a_and(volatile int *p, int v)
124 {
125         int old;
126         do old = *p;
127         while (a_cas(p, old, old&v) != old);
128 }
129
130 static inline void a_or(volatile int *p, int v)
131 {
132         int old;
133         do old = *p;
134         while (a_cas(p, old, old|v) != old);
135 }
136
137 static inline void a_and_64(volatile uint64_t *p, uint64_t v)
138 {
139         union { uint64_t v; uint32_t r[2]; } u = { v };
140         a_and((int *)p, u.r[0]);
141         a_and((int *)p+1, u.r[1]);
142 }
143
144 static inline void a_or_64(volatile uint64_t *p, uint64_t v)
145 {
146         union { uint64_t v; uint32_t r[2]; } u = { v };
147         a_or((int *)p, u.r[0]);
148         a_or((int *)p+1, u.r[1]);
149 }
150
151 #endif