Debian Codegraph @

share/libc/__fc_gcc_builtins.h

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 // This file contains some GCC builtins which are not already hardcoded in
24 // Frama-C, and which can be expressed using ACSL.
25
26 #ifndef __FC_GCC_BUILTINS
27 #define __FC_GCC_BUILTINS
28 #include "features.h"
29 #include "__fc_machdep.h"
30
31 __PUSH_FC_STDLIB
32
33 __BEGIN_DECLS
34
35 /*@
36 requires valid_res: \valid(res);
37 assigns \result, *res \from a, b;
38 ensures initialization:res: \initialized(res);
39 ensures res_wrapped: *res == (int)(a + b);
40 ensures result_overflow: a + b == (int)(a + b) ? \result == 0 : \result == 1;
41 */
42 _Bool __builtin_sadd_overflow (int a, int b, int *res);
43
44 /*@
45 requires valid_res: \valid(res);
46 assigns \result, *res \from a, b;
47 ensures initialization:res: \initialized(res);
48 ensures res_wrapped: *res == (long)(a + b);
49 ensures result_overflow: a + b == (long)(a + b) ? \result == 0 : \result == 1;
50 */
51 _Bool __builtin_saddl_overflow (long a, long b, long *res);
52
53 /*@
54 requires valid_res: \valid(res);
55 assigns \result, *res \from a, b;
56 ensures initialization:res: \initialized(res);
57 ensures res_wrapped: *res == (long long)(a + b);
58 ensures result_overflow: a + b == (long long)(a + b) ? \result == 0 : \result == 1;
59 */
60 _Bool __builtin_saddll_overflow (long long a, long long b, long long *res);
61
62 /*@
63 requires valid_res: \valid(res);
64 assigns \result, *res \from a, b;
65 ensures initialization:res: \initialized(res);
66 ensures res_wrapped: *res == (unsigned)(a + b);
67 ensures result_overflow: a + b == (unsigned)(a + b) ? \result == 0 : \result == 1;
68 */
69 _Bool __builtin_uadd_overflow (unsigned a, unsigned b, unsigned *res);
70
71 /*@
72 requires valid_res: \valid(res);
73 assigns \result, *res \from a, b;
74 ensures initialization:res: \initialized(res);
75 ensures res_wrapped: *res == (unsigned long)(a + b);
76 ensures result_overflow: a + b == (unsigned long)(a + b) ? \result == 0 : \result == 1;
77 */
78 _Bool __builtin_uaddl_overflow (unsigned long a, unsigned long b, unsigned long *res);
79
80 /*@
81 requires valid_res: \valid(res);
82 assigns \result, *res \from a, b;
83 ensures initialization:res: \initialized(res);
84 ensures res_wrapped: *res == (unsigned long long)(a + b);
85 ensures result_overflow: a + b == (unsigned long long)(a + b) ? \result == 0 : \result == 1;
86 */
87 _Bool __builtin_uaddll_overflow (unsigned long long a, unsigned long long b, unsigned long long *res);
88
89 /*@
90 requires valid_res: \valid(res);
91 assigns \result, *res \from a, b;
92 ensures initialization:res: \initialized(res);
93 ensures res_wrapped: *res == (int)(a - b);
94 ensures result_overflow: a - b == (int)(a - b) ? \result == 0 : \result == 1;
95 */
96 _Bool __builtin_ssub_overflow (int a, int b, int *res);
97
98 /*@
99 requires valid_res: \valid(res);
100 assigns \result, *res \from a, b;
101 ensures initialization:res: \initialized(res);
102 ensures res_wrapped: *res == (long)(a - b);
103 ensures result_overflow: a - b == (long)(a - b) ? \result == 0 : \result == 1;
104 */
105 _Bool __builtin_ssubl_overflow (long a, long b, long *res);
106
107 /*@
108 requires valid_res: \valid(res);
109 assigns \result, *res \from a, b;
110 ensures initialization:res: \initialized(res);
111 ensures res_wrapped: *res == (long long)(a - b);
112 ensures result_overflow: a - b == (long long)(a - b) ? \result == 0 : \result == 1;
113 */
114 _Bool __builtin_ssubll_overflow (long long a, long long b, long long *res);
115
116 /*@
117 requires valid_res: \valid(res);
118 assigns \result, *res \from a, b;
119 ensures initialization:res: \initialized(res);
120 ensures res_wrapped: *res == (unsigned)(a - b);
121 ensures result_overflow: a - b == (unsigned)(a - b) ? \result == 0 : \result == 1;
122 */
123 _Bool __builtin_usub_overflow (unsigned a, unsigned b, unsigned *res);
124
125 /*@
126 requires valid_res: \valid(res);
127 assigns \result, *res \from a, b;
128 ensures initialization:res: \initialized(res);
129 ensures res_wrapped: *res == (unsigned long)(a - b);
130 ensures result_overflow: a - b == (unsigned long)(a - b) ? \result == 0 : \result == 1;
131 */
132 _Bool __builtin_usubl_overflow (unsigned long a, unsigned long b, unsigned long *res);
133
134 /*@
135 requires valid_res: \valid(res);
136 assigns \result, *res \from a, b;
137 ensures initialization:res: \initialized(res);
138 ensures res_wrapped: *res == (unsigned long long)(a - b);
139 ensures result_overflow: a - b == (unsigned long long)(a - b) ? \result == 0 : \result == 1;
140 */
141 _Bool __builtin_usubll_overflow (unsigned long long a, unsigned long long b, unsigned long long *res);
142
143 /*@
144 requires valid_res: \valid(res);
145 assigns \result, *res \from a, b;
146 ensures initialization:res: \initialized(res);
147 ensures res_wrapped: *res == (int)(a * b);
148 ensures result_overflow: a * b == (int)(a * b) ? \result == 0 : \result == 1;
149 */
150 _Bool __builtin_smul_overflow (int a, int b, int *res);
151
152 /*@
153 requires valid_res: \valid(res);
154 assigns \result, *res \from a, b;
155 ensures initialization:res: \initialized(res);
156 ensures res_wrapped: *res == (long)(a * b);
157 ensures result_overflow: a * b == (long)(a * b) ? \result == 0 : \result == 1;
158 */
159 _Bool __builtin_smull_overflow (long a, long b, long *res);
160
161 /*@
162 requires valid_res: \valid(res);
163 assigns \result, *res \from a, b;
164 ensures initialization:res: \initialized(res);
165 ensures res_wrapped: *res == (long long)(a * b);
166 ensures result_overflow: a * b == (long long)(a * b) ? \result == 0 : \result == 1;
167 */
168 _Bool __builtin_smulll_overflow (long long a, long long b, long long *res);
169
170 /*@
171 requires valid_res: \valid(res);
172 assigns \result, *res \from a, b;
173 ensures initialization:res: \initialized(res);
174 ensures res_wrapped: *res == (unsigned)(a * b);
175 ensures result_overflow: a * b == (unsigned)(a * b) ? \result == 0 : \result == 1;
176 */
177 _Bool __builtin_umul_overflow (unsigned a, unsigned b, unsigned *res);
178
179 /*@
180 requires valid_res: \valid(res);
181 assigns \result, *res \from a, b;
182 ensures initialization:res: \initialized(res);
183 ensures res_wrapped: *res == (unsigned long)(a * b);
184 ensures result_overflow: a * b == (unsigned long)(a * b) ? \result == 0 : \result == 1;
185 */
186 _Bool __builtin_umull_overflow (unsigned long a, unsigned long b, unsigned long *res);
187
188 /*@
189 requires valid_res: \valid(res);
190 assigns \result, *res \from a, b;
191 ensures initialization:res: \initialized(res);
192 ensures res_wrapped: *res == (unsigned long long)(a * b);
193 ensures result_overflow: a * b == (unsigned long long)(a * b) ? \result == 0 : \result == 1;
194 */
195 _Bool __builtin_umulll_overflow (unsigned long long a, unsigned long long b, unsigned long long *res);
196
197 /*@
198 requires x_nonzero: x != 0;
199 assigns \result \from indirect:x;
200 ensures result_is_bit_count: 0 <= \result < __CHAR_BIT * sizeof(x);
201 */
202 int __builtin_clz (unsigned int x);
203
204 /*@
205 requires x_nonzero: x != 0;
206 assigns \result \from indirect:x;
207 ensures result_is_bit_count: 0 <= \result < __CHAR_BIT * sizeof(x);
208 */
209 int __builtin_clzl (unsigned long x);
210
211 /*@
212 requires x_nonzero: x != 0;
213 assigns \result \from indirect:x;
214 ensures result_is_bit_count: 0 <= \result < __CHAR_BIT * sizeof(x);
215 */
216 int __builtin_clzll (unsigned long long x);
217
218 /*@
219 requires x_nonzero: x != 0;
220 assigns \result \from indirect:x;
221 ensures result_is_bit_count: 0 <= \result < __CHAR_BIT * sizeof(x);
222 */
223 int __builtin_ctz (unsigned int x);
224
225 /*@
226 requires x_nonzero: x != 0;
227 assigns \result \from indirect:x;
228 ensures result_is_bit_count: 0 <= \result < __CHAR_BIT * sizeof(x);
229 */
230 int __builtin_ctzl (unsigned long x);
231
232 /*@
233 requires x_nonzero: x != 0;
234 assigns \result \from indirect:x;
235 ensures result_is_bit_count: 0 <= \result < __CHAR_BIT * sizeof(x);
236 */
237 int __builtin_ctzll (unsigned long long x);
238
239 /*@
240 assigns \result \from indirect:x;
241 ensures result_is_bit_count: 0 <= \result <= __CHAR_BIT * sizeof(x);
242 */
243 int __builtin_popcount (unsigned int x);
244
245 /*@
246 assigns \result \from indirect:x;
247 ensures result_is_bit_count: 0 <= \result <= __CHAR_BIT * sizeof(x);
248 */
249 int __builtin_popcountl (unsigned long x);
250
251 /*@
252 assigns \result \from indirect:x;
253 ensures result_is_bit_count: 0 <= \result <= __CHAR_BIT * sizeof(x);
254 */
255 int __builtin_popcountll (unsigned long long x);
256
257 // According to the GCC docs
258 // (https://gcc.gnu.org/onlinedocs/gcc/_005f_005fsync-Builtins.html),
259 // this creates a 'full memory barrier'; we do not model the concurrency
260 // aspects yet.
261 /*@ assigns \nothing; */
262 void __sync_synchronize(void);
263
264 __END_DECLS
265
266 __POP_FC_STDLIB
267 #endif