Debian Codegraph @

share/libc/stdatomic.c

raw
1 /**************************************************************************/
2 /* */
3 /* This file is part of Frama-C. */
4 /* */
5 /* Copyright (C) 2007-2022 */
6 /* CEA (Commissariat à l'énergie atomique et aux énergies */
7 /* alternatives) */
8 /* */
9 /* you can redistribute it and/or modify it under the terms of the GNU */
10 /* Lesser General Public License as published by the Free Software */
11 /* Foundation, version 2.1. */
12 /* */
13 /* It is distributed in the hope that it will be useful, */
14 /* but WITHOUT ANY WARRANTY; without even the implied warranty of */
15 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
16 /* GNU Lesser General Public License for more details. */
17 /* */
18 /* See the GNU Lesser General Public License version 2.1 */
19 /* for more details (enclosed in the file licenses/LGPLv2.1). */
20 /* */
21 /**************************************************************************/
22
23 #include "__fc_builtin.h"
24 #include "stdatomic.h"
25 #include "assert.h"
26 #include "string.h"
27 __PUSH_FC_STDLIB
28
29 void __fc_atomic_init_marker(void *obj, unsigned long long value) {}
30
31 void atomic_thread_fence(memory_order order) {}
32
33 void atomic_signal_fence(memory_order order) {}
34
35 _Bool __fc_atomic_is_lock_free(void *obj) { return Frama_C_nondet(0, 1); }
36
37 void __fc_atomic_store_marker(void *object, unsigned long long desired) {}
38
39 void __fc_atomic_store_explicit_marker(void *object,
40 unsigned long long desired,
41 memory_order order) {}
42
43 unsigned long long __fc_atomic_load(void *obj, size_t obj_size) {
44 if (obj_size == sizeof(char)) return *((volatile atomic_uchar *)obj);
45 else if (obj_size == sizeof(short)) return *((volatile atomic_ushort *)obj);
46 else if (obj_size == sizeof(int)) return *((volatile atomic_uint *)obj);
47 else if (obj_size == sizeof(long)) return *((volatile atomic_ulong *)obj);
48 else if (obj_size == sizeof(long long))
49 return *((volatile atomic_ullong *)obj);
50 else assert(0);
51 return 0;
52 }
53
54 unsigned long long __fc_atomic_load_explicit(void *object,
55 memory_order order,
56 size_t obj_size) {
57 return __fc_atomic_load(object, obj_size);
58 }
59
60 unsigned long long __fc_atomic_exchange(void *obj,
61 unsigned long long desired,
62 size_t obj_size) {
63 unsigned long long r = 0;
64 if (obj_size == sizeof(char)) {
65 r = *((volatile atomic_uchar *)obj);
66 *((volatile atomic_uchar *)obj) = desired;
67 } else if (obj_size == sizeof(short)) {
68 r = *((volatile atomic_ushort *)obj);
69 *((volatile atomic_ushort *)obj) = desired;
70 } else if (obj_size == sizeof(int)) {
71 r = *((volatile atomic_uint *)obj);
72 *((volatile atomic_uint *)obj) = desired;
73 } else if (obj_size == sizeof(long)) {
74 r = *((volatile atomic_ulong *)obj);
75 *((volatile atomic_ulong *)obj) = desired;
76 } else if (obj_size == sizeof(long long)) {
77 r = *((volatile atomic_ullong *)obj);
78 *((volatile atomic_ullong *)obj) = desired;
79 } else assert(0);
80 return r;
81 }
82
83 unsigned long long __fc_atomic_exchange_explicit(void *object,
84 unsigned long long desired,
85 memory_order order,
86 size_t obj_size) {
87 return __fc_atomic_exchange(object, desired, obj_size);
88 }
89
90 _Bool __fc_atomic_compare_exchange_strong(void *object, void *expected,
91 unsigned long long desired,
92 size_t obj_size) {
93 int r = memcmp(object, expected, obj_size);
94 if (r == 0) memcpy(object, &desired, obj_size);
95 else memcpy(expected, object, obj_size);
96 return r == 0;
97 }
98
99 _Bool __fc_atomic_compare_exchange_strong_explicit(void *object, void *expected,
100 unsigned long long desired,
101 memory_order success,
102 memory_order failure,
103 size_t obj_size) {
104 return __fc_atomic_compare_exchange_strong(object, expected, desired, obj_size);
105 }
106
107 _Bool __fc_atomic_compare_exchange_weak(void *object, void *expected,
108 unsigned long long desired,
109 size_t obj_size) {
110 return __fc_atomic_compare_exchange_strong(object, expected, desired, obj_size);
111 }
112
113 _Bool __fc_atomic_compare_exchange_weak_explicit(void *object, void *expected,
114 unsigned long long desired,
115 memory_order success,
116 memory_order failure,
117 size_t obj_size) {
118 return __fc_atomic_compare_exchange_strong(object, expected, desired, obj_size);
119 }
120
121 unsigned long long __fc_atomic_fetch_add(void *obj, unsigned long long operand,
122 size_t obj_size) {
123 unsigned long long r = 0;
124 if (obj_size == sizeof(char)) {
125 r = *((volatile atomic_uchar *)obj);
126 *((volatile atomic_uchar *)obj) += operand;
127 } else if (obj_size == sizeof(short)) {
128 r = *((volatile atomic_ushort *)obj);
129 *((volatile atomic_ushort *)obj) += operand;
130 } else if (obj_size == sizeof(int)) {
131 r = *((volatile atomic_uint *)obj);
132 *((volatile atomic_uint *)obj) += operand;
133 } else if (obj_size == sizeof(long)) {
134 r = *((volatile atomic_ulong *)obj);
135 *((volatile atomic_ulong *)obj) += operand;
136 } else if (obj_size == sizeof(long long)) {
137 r = *((volatile atomic_ullong *)obj);
138 *((volatile atomic_ullong *)obj) += operand;
139 } else assert(0);
140 return r;
141 }
142
143 unsigned long long __fc_atomic_fetch_add_explicit(void *obj,
144 unsigned long long operand,
145 memory_order order,
146 size_t obj_size) {
147 return __fc_atomic_fetch_add(obj, operand, obj_size);
148 }
149
150 unsigned long long __fc_atomic_fetch_sub(void *obj, unsigned long long operand,
151 size_t obj_size) {
152 unsigned long long r = 0;
153 if (obj_size == sizeof(char)) { r = *((volatile atomic_uchar *)obj);
154 *((volatile atomic_uchar *)obj) -= operand; }
155 else if (obj_size == sizeof(short)) { r = *((volatile atomic_ushort *)obj);
156 *((volatile atomic_ushort *)obj) -= operand; }
157 else if (obj_size == sizeof(int)) { r = *((volatile atomic_uint *)obj);
158 *((volatile atomic_uint *)obj) -= operand; }
159 else if (obj_size == sizeof(long)) { r = *((volatile atomic_ulong *)obj);
160 *((volatile atomic_ulong *)obj) -= operand; }
161 else if (obj_size == sizeof(long long)) { r = *((volatile atomic_ullong *)obj);
162 *((volatile atomic_ullong *)obj) -= operand; }
163 else assert(0);
164 return r;
165 }
166
167 unsigned long long __fc_atomic_fetch_sub_explicit(void *obj,
168 unsigned long long operand,
169 memory_order order,
170 size_t obj_size) {
171 return __fc_atomic_fetch_sub(obj, operand, obj_size);
172 }
173
174 unsigned long long __fc_atomic_fetch_or(void *obj, unsigned long long operand,
175 size_t obj_size) {
176 unsigned long long r = 0;
177 if (obj_size == sizeof(char)) { r = *((volatile atomic_uchar *)obj);
178 *((volatile atomic_uchar *)obj) |= operand; }
179 else if (obj_size == sizeof(short)) { r = *((volatile atomic_ushort *)obj);
180 *((volatile atomic_ushort *)obj) |= operand; }
181 else if (obj_size == sizeof(int)) { r = *((volatile atomic_uint *)obj);
182 *((volatile atomic_uint *)obj) |= operand; }
183 else if (obj_size == sizeof(long)) { r = *((volatile atomic_ulong *)obj);
184 *((volatile atomic_ulong *)obj) |= operand; }
185 else if (obj_size == sizeof(long long)) { r = *((volatile atomic_ullong *)obj);
186 *((volatile atomic_ullong *)obj) |= operand; }
187 else assert(0);
188 return r;
189 }
190
191 unsigned long long __fc_atomic_fetch_or_explicit(void *obj,
192 unsigned long long operand,
193 memory_order order,
194 size_t obj_size) {
195 return __fc_atomic_fetch_or(obj, operand, obj_size);
196 }
197
198 unsigned long long __fc_atomic_fetch_xor(void *obj, unsigned long long operand,
199 size_t obj_size) {
200 unsigned long long r = 0;
201 if (obj_size == sizeof(char)) {
202 r = *((volatile atomic_uchar *)obj);
203 *((volatile atomic_uchar *)obj) ^= operand;
204 } else if (obj_size == sizeof(short)) {
205 r = *((volatile atomic_ushort *)obj);
206 *((volatile atomic_ushort *)obj) ^= operand;
207 } else if (obj_size == sizeof(int)) {
208 r = *((volatile atomic_uint *)obj);
209 *((volatile atomic_uint *)obj) ^= operand;
210 } else if (obj_size == sizeof(long)) {
211 r = *((volatile atomic_ulong *)obj);
212 *((volatile atomic_ulong *)obj) ^= operand;
213 } else if (obj_size == sizeof(long long)) {
214 r = *((volatile atomic_ullong *)obj);
215 *((volatile atomic_ullong *)obj) ^= operand;
216 }
217 else assert(0);
218 return r;
219 }
220
221 unsigned long long __fc_atomic_fetch_xor_explicit(void *obj,
222 unsigned long long operand,
223 memory_order order,
224 size_t obj_size) {
225 return __fc_atomic_fetch_xor(obj, operand, obj_size);
226 }
227
228 unsigned long long __fc_atomic_fetch_and(void *obj,
229 unsigned long long operand,
230 size_t obj_size) {
231 unsigned long long r = 0;
232 if (obj_size == sizeof(char)) {
233 r = *((volatile atomic_uchar *)obj);
234 *((volatile atomic_uchar *)obj) &= operand;
235 } else if (obj_size == sizeof(short)) {
236 r = *((volatile atomic_ushort *)obj);
237 *((volatile atomic_ushort *)obj) &= operand;
238 } else if (obj_size == sizeof(int)) {
239 r = *((volatile atomic_uint *)obj);
240 *((volatile atomic_uint *)obj) &= operand;
241 } else if (obj_size == sizeof(long)) {
242 r = *((volatile atomic_ulong *)obj);
243 *((volatile atomic_ulong *)obj) &= operand;
244 } else if (obj_size == sizeof(long long)) {
245 r = *((volatile atomic_ullong *)obj);
246 *((volatile atomic_ullong *)obj) &= operand;
247 } else assert(0);
248 return r;
249 }
250
251 unsigned long long __fc_atomic_fetch_and_explicit(void *obj,
252 unsigned long long operand,
253 memory_order order,
254 size_t obj_size) {
255 return __fc_atomic_fetch_and(obj, operand, obj_size);
256 }
257
258 _Bool atomic_flag_test_and_set(volatile atomic_flag *object) {
259 _Bool r = object->__fc_val;
260 object->__fc_val = 1;
261 return r;
262 }
263
264 _Bool atomic_flag_test_and_set_explicit(volatile atomic_flag *object,
265 memory_order order) {
266 _Bool r = object->__fc_val;
267 object->__fc_val = 1;
268 return r;
269 }
270
271 void atomic_flag_clear(volatile atomic_flag *object) {
272 object->__fc_val = 0;
273 }
274
275 void atomic_flag_clear_explicit(volatile atomic_flag *object,
276 memory_order order) {
277 object->__fc_val = 0;
278 }
279
280 __POP_FC_STDLIB