7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 * THE SOFTWARE.
24 */
25
26 #include "expression.h"
27 #include "expand.h"
28 #include "symbol.h"
29 #include "compat/bswap.h"
30
31 static int evaluate_to_int_const_expr(struct expression *expr)
32 {
33 expr->ctype = &int_ctype;
34 expr->flags |= CEF_SET_ICE;
35 return 1;
36 }
37
38 static int evaluate_pure_unop(struct expression *expr)
39 {
40 struct expression *arg = first_expression(expr->args);
41 int flags = arg->flags;
42
43 /*
44 * Allow such functions with a constant integer expression
45 * argument to be treated as a *constant* integer.
46 * This allow us to use them in switch() { case ...:
47 */
48 flags |= (flags & CEF_ICE) ? CEF_SET_INT : 0;
49 expr->flags = flags;
50 return 1;
51 }
52
53
54 static int evaluate_expect(struct expression *expr)
55 {
56 /* Should we evaluate it to return the type of the first argument? */
57 expr->ctype = &int_ctype;
58 return 1;
59 }
60
61 static int arguments_choose(struct expression *expr)
62 {
63 struct expression_list *arglist = expr->args;
64 struct expression *arg;
65 int i = 0;
66
67 FOR_EACH_PTR (arglist, arg) {
68 if (!evaluate_expression(arg))
69 return 0;
70 i++;
71 } END_FOR_EACH_PTR(arg);
72 if (i < 3) {
73 sparse_error(expr->pos,
74 "not enough arguments for __builtin_choose_expr");
75 return 0;
76 } if (i > 3) {
77 sparse_error(expr->pos,
78 "too many arguments for __builtin_choose_expr");
79 return 0;
80 }
81 return 1;
82 }
83
84 static int evaluate_choose(struct expression *expr)
85 {
86 struct expression_list *list = expr->args;
87 struct expression *arg, *args[3];
88 int n = 0;
89
90 /* there will be exactly 3; we'd already verified that */
91 FOR_EACH_PTR(list, arg) {
92 args[n++] = arg;
93 } END_FOR_EACH_PTR(arg);
94
95 *expr = get_expression_value(args[0]) ? *args[1] : *args[2];
96
97 return 1;
98 }
99
100 static int expand_expect(struct expression *expr, int cost)
101 {
102 struct expression *arg = first_ptr_list((struct ptr_list *) expr->args);
103
168 expr->taint = 0;
169 return 0;
170 }
171
172 static struct symbol_op constant_p_op = {
173 .evaluate = evaluate_to_int_const_expr,
174 .expand = expand_constant_p
175 };
176
177 static struct symbol_op safe_p_op = {
178 .evaluate = evaluate_to_int_const_expr,
179 .expand = expand_safe_p
180 };
181
182 static struct symbol_op warning_op = {
183 .evaluate = evaluate_to_int_const_expr,
184 .expand = expand_warning
185 };
186
187 static struct symbol_op expect_op = {
188 .evaluate = evaluate_expect,
189 .expand = expand_expect
190 };
191
192 static struct symbol_op choose_op = {
193 .evaluate = evaluate_choose,
194 .args = arguments_choose,
195 };
196
197 /* The argument is constant and valid if the cost is zero */
198 static int expand_bswap(struct expression *expr, int cost)
199 {
200 struct expression *arg;
201 long long val;
202
203 if (cost)
204 return cost;
205
206 /* the arguments number & type have already been checked */
207 arg = first_expression(expr->args);
208 val = get_expression_value_silent(arg);
209 switch (expr->ctype->bit_size) {
210 case 16: expr->value = bswap16(val); break;
211 case 32: expr->value = bswap32(val); break;
212 case 64: expr->value = bswap64(val); break;
213 default: /* impossible error */
214 return SIDE_EFFECTS;
215 }
216
217 expr->type = EXPR_VALUE;
218 expr->taint = 0;
219 return 0;
220 }
221
222 static struct symbol_op bswap_op = {
223 .evaluate = evaluate_pure_unop,
224 .expand = expand_bswap,
225 };
226
227
228 /*
229 * Builtin functions
230 */
231 static struct symbol builtin_fn_type = { .type = SYM_FN /* , .variadic =1 */ };
232 static struct sym_init {
233 const char *name;
234 struct symbol *base_type;
235 unsigned int modifiers;
236 struct symbol_op *op;
237 } builtins_table[] = {
238 { "__builtin_constant_p", &builtin_fn_type, MOD_TOPLEVEL, &constant_p_op },
239 { "__builtin_safe_p", &builtin_fn_type, MOD_TOPLEVEL, &safe_p_op },
240 { "__builtin_warning", &builtin_fn_type, MOD_TOPLEVEL, &warning_op },
241 { "__builtin_expect", &builtin_fn_type, MOD_TOPLEVEL, &expect_op },
242 { "__builtin_choose_expr", &builtin_fn_type, MOD_TOPLEVEL, &choose_op },
243 { "__builtin_bswap16", NULL, MOD_TOPLEVEL, &bswap_op },
244 { "__builtin_bswap32", NULL, MOD_TOPLEVEL, &bswap_op },
245 { "__builtin_bswap64", NULL, MOD_TOPLEVEL, &bswap_op },
246 { NULL, NULL, 0 }
247 };
248
249 void init_builtins(int stream)
250 {
251 struct sym_init *ptr;
252
253 builtin_fn_type.variadic = 1;
254 for (ptr = builtins_table; ptr->name; ptr++) {
255 struct symbol *sym;
256 sym = create_symbol(stream, ptr->name, SYM_NODE, NS_SYMBOL);
257 sym->ctype.base_type = ptr->base_type;
258 sym->ctype.modifiers = ptr->modifiers;
259 sym->op = ptr->op;
260 }
261 }
|
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 * THE SOFTWARE.
24 */
25
26 #include "expression.h"
27 #include "evaluate.h"
28 #include "expand.h"
29 #include "symbol.h"
30 #include "compat/bswap.h"
31 #include <stdarg.h>
32
33 static int evaluate_to_int_const_expr(struct expression *expr)
34 {
35 expr->ctype = &int_ctype;
36 expr->flags |= CEF_SET_ICE;
37 return 1;
38 }
39
40 static int evaluate_pure_unop(struct expression *expr)
41 {
42 struct expression *arg = first_expression(expr->args);
43 int flags = arg->flags;
44
45 /*
46 * Allow such functions with a constant integer expression
47 * argument to be treated as a *constant* integer.
48 * This allow us to use them in switch() { case ...:
49 */
50 flags |= (flags & CEF_ICE) ? CEF_SET_INT : 0;
51 expr->flags = flags;
52 return 1;
53 }
54
55 /*
56 * eval_args - check the number of arguments and evaluate them.
57 */
58 static int eval_args(struct expression *expr, int n)
59 {
60 struct expression *arg;
61 struct symbol *sym;
62 const char *msg;
63 int rc = 1;
64
65 FOR_EACH_PTR(expr->args, arg) {
66 if (n-- == 0) {
67 msg = "too many arguments";
68 goto error;
69 }
70 if (!evaluate_expression(arg))
71 rc = 0;
72 } END_FOR_EACH_PTR(arg);
73 if (n > 0) {
74 msg = "not enough arguments";
75 goto error;
76 }
77 return rc;
78
79 error:
80 sym = expr->fn->ctype;
81 expression_error(expr, "%s for %s", msg, show_ident(sym->ident));
82 return 0;
83 }
84
85 static int args_triadic(struct expression *expr)
86 {
87 return eval_args(expr, 3);
88 }
89
90 static int evaluate_choose(struct expression *expr)
91 {
92 struct expression_list *list = expr->args;
93 struct expression *arg, *args[3];
94 int n = 0;
95
96 /* there will be exactly 3; we'd already verified that */
97 FOR_EACH_PTR(list, arg) {
98 args[n++] = arg;
99 } END_FOR_EACH_PTR(arg);
100
101 *expr = get_expression_value(args[0]) ? *args[1] : *args[2];
102
103 return 1;
104 }
105
106 static int expand_expect(struct expression *expr, int cost)
107 {
108 struct expression *arg = first_ptr_list((struct ptr_list *) expr->args);
109
174 expr->taint = 0;
175 return 0;
176 }
177
178 static struct symbol_op constant_p_op = {
179 .evaluate = evaluate_to_int_const_expr,
180 .expand = expand_constant_p
181 };
182
183 static struct symbol_op safe_p_op = {
184 .evaluate = evaluate_to_int_const_expr,
185 .expand = expand_safe_p
186 };
187
188 static struct symbol_op warning_op = {
189 .evaluate = evaluate_to_int_const_expr,
190 .expand = expand_warning
191 };
192
193 static struct symbol_op expect_op = {
194 .expand = expand_expect
195 };
196
197 static struct symbol_op choose_op = {
198 .args = args_triadic,
199 .evaluate = evaluate_choose,
200 };
201
202 /* The argument is constant and valid if the cost is zero */
203 static int expand_bswap(struct expression *expr, int cost)
204 {
205 struct expression *arg;
206 long long val;
207
208 if (cost)
209 return cost;
210
211 /* the arguments number & type have already been checked */
212 arg = first_expression(expr->args);
213 val = get_expression_value_silent(arg);
214 switch (expr->ctype->bit_size) {
215 case 16: expr->value = bswap16(val); break;
216 case 32: expr->value = bswap32(val); break;
217 case 64: expr->value = bswap64(val); break;
218 default: /* impossible error */
219 return SIDE_EFFECTS;
220 }
221
222 expr->type = EXPR_VALUE;
223 expr->taint = 0;
224 return 0;
225 }
226
227 static struct symbol_op bswap_op = {
228 .evaluate = evaluate_pure_unop,
229 .expand = expand_bswap,
230 };
231
232
233 static int evaluate_fp_unop(struct expression *expr)
234 {
235 struct expression *arg;
236
237 if (!eval_args(expr, 1))
238 return 0;
239
240 arg = first_expression(expr->args);
241 if (!is_float_type(arg->ctype)) {
242 expression_error(expr, "non-floating-point argument in call to %s()",
243 show_ident(expr->fn->ctype->ident));
244 return 0;
245 }
246 return 1;
247 }
248
249 static struct symbol_op fp_unop_op = {
250 .evaluate = evaluate_fp_unop,
251 };
252
253
254 static int evaluate_overflow_gen(struct expression *expr, int ptr)
255 {
256 struct expression *arg;
257 int n = 0;
258
259 /* there will be exactly 3; we'd already verified that */
260 FOR_EACH_PTR(expr->args, arg) {
261 struct symbol *type;
262
263 n++;
264 if (!arg || !(type = arg->ctype))
265 return 0;
266 // 1st & 2nd args must be a basic integer type
267 // 3rd arg must be a pointer to such a type.
268 if (n == 3 && ptr) {
269 if (type->type == SYM_NODE)
270 type = type->ctype.base_type;
271 if (!type)
272 return 0;
273 if (type->type != SYM_PTR)
274 goto err;
275 type = type->ctype.base_type;
276 if (!type)
277 return 0;
278 }
279 if (type->type == SYM_NODE)
280 type = type->ctype.base_type;
281 if (!type)
282 return 0;
283 if (type->ctype.base_type != &int_type || type == &bool_ctype)
284 goto err;
285 } END_FOR_EACH_PTR(arg);
286
287 // the builtin returns a bool
288 expr->ctype = &bool_ctype;
289 return 1;
290
291 err:
292 sparse_error(arg->pos, "invalid type for argument %d:", n);
293 info(arg->pos, " %s", show_typename(arg->ctype));
294 expr->ctype = &bad_ctype;
295 return 0;
296 }
297
298 static int evaluate_overflow(struct expression *expr)
299 {
300 return evaluate_overflow_gen(expr, 1);
301 }
302
303 static struct symbol_op overflow_op = {
304 .args = args_triadic,
305 .evaluate = evaluate_overflow,
306 };
307
308 static int evaluate_overflow_p(struct expression *expr)
309 {
310 return evaluate_overflow_gen(expr, 0);
311 }
312
313 static struct symbol_op overflow_p_op = {
314 .args = args_triadic,
315 .evaluate = evaluate_overflow_p,
316 };
317
318
319 /*
320 * Builtin functions
321 */
322 static struct symbol builtin_fn_type = { .type = SYM_FN /* , .variadic =1 */ };
323 static struct sym_init {
324 const char *name;
325 struct symbol *base_type;
326 unsigned int modifiers;
327 struct symbol_op *op;
328 } builtins_table[] = {
329 { "__builtin_constant_p", &builtin_fn_type, MOD_TOPLEVEL, &constant_p_op },
330 { "__builtin_safe_p", &builtin_fn_type, MOD_TOPLEVEL, &safe_p_op },
331 { "__builtin_warning", &builtin_fn_type, MOD_TOPLEVEL, &warning_op },
332 { "__builtin_expect", &builtin_fn_type, MOD_TOPLEVEL, &expect_op },
333 { "__builtin_choose_expr", &builtin_fn_type, MOD_TOPLEVEL, &choose_op },
334 { "__builtin_bswap16", &builtin_fn_type, MOD_TOPLEVEL, &bswap_op },
335 { "__builtin_bswap32", &builtin_fn_type, MOD_TOPLEVEL, &bswap_op },
336 { "__builtin_bswap64", &builtin_fn_type, MOD_TOPLEVEL, &bswap_op },
337 { "__builtin_isfinite", &builtin_fn_type, MOD_TOPLEVEL, &fp_unop_op },
338 { "__builtin_isinf", &builtin_fn_type, MOD_TOPLEVEL, &fp_unop_op },
339 { "__builtin_isinf_sign", &builtin_fn_type, MOD_TOPLEVEL, &fp_unop_op },
340 { "__builtin_isnan", &builtin_fn_type, MOD_TOPLEVEL, &fp_unop_op },
341 { "__builtin_isnormal", &builtin_fn_type, MOD_TOPLEVEL, &fp_unop_op },
342 { "__builtin_signbit", &builtin_fn_type, MOD_TOPLEVEL, &fp_unop_op },
343 { "__builtin_add_overflow", &builtin_fn_type, MOD_TOPLEVEL, &overflow_op },
344 { "__builtin_sub_overflow", &builtin_fn_type, MOD_TOPLEVEL, &overflow_op },
345 { "__builtin_mul_overflow", &builtin_fn_type, MOD_TOPLEVEL, &overflow_op },
346 { "__builtin_add_overflow_p", &builtin_fn_type, MOD_TOPLEVEL, &overflow_p_op },
347 { "__builtin_sub_overflow_p", &builtin_fn_type, MOD_TOPLEVEL, &overflow_p_op },
348 { "__builtin_mul_overflow_p", &builtin_fn_type, MOD_TOPLEVEL, &overflow_p_op },
349 { NULL, NULL, 0 }
350 };
351
352 void init_builtins(int stream)
353 {
354 struct sym_init *ptr;
355
356 builtin_fn_type.variadic = 1;
357 for (ptr = builtins_table; ptr->name; ptr++) {
358 struct symbol *sym;
359 sym = create_symbol(stream, ptr->name, SYM_NODE, NS_SYMBOL);
360 sym->ctype.base_type = ptr->base_type;
361 sym->ctype.modifiers = ptr->modifiers;
362 sym->op = ptr->op;
363 sym->builtin = 1;
364 }
365 }
366
367 static void declare_builtin(const char *name, struct symbol *rtype, int variadic, ...)
368 {
369 int stream = 0; // FIXME
370 struct symbol *sym = create_symbol(stream, name, SYM_NODE, NS_SYMBOL);
371 struct symbol *fun = alloc_symbol(sym->pos, SYM_FN);
372 struct symbol *arg;
373 va_list args;
374
375 sym->ctype.base_type = fun;
376 sym->ctype.modifiers = MOD_TOPLEVEL;
377 sym->builtin = 1;
378
379 fun->ctype.base_type = rtype;
380 fun->variadic = variadic;
381
382 va_start(args, variadic);
383 while ((arg = va_arg(args, struct symbol *))) {
384 struct symbol *anode = alloc_symbol(sym->pos, SYM_NODE);
385 anode->ctype.base_type = arg;
386 add_symbol(&fun->arguments, anode);
387 }
388 va_end(args);
389 }
390
391 void declare_builtins(void)
392 {
393 struct symbol *va_list_ctype = &ptr_ctype;
394
395 declare_builtin("__builtin_abort", &void_ctype, 0, NULL);
396 declare_builtin("__builtin_abs", &int_ctype , 0, &int_ctype, NULL);
397 declare_builtin("__builtin_alloca", &ptr_ctype, 0, size_t_ctype, NULL);
398 declare_builtin("__builtin_alpha_cmpbge", &long_ctype, 0, &long_ctype, &long_ctype, NULL);
399 declare_builtin("__builtin_alpha_extbl", &long_ctype, 0, &long_ctype, &long_ctype, NULL);
400 declare_builtin("__builtin_alpha_extwl", &long_ctype, 0, &long_ctype, &long_ctype, NULL);
401 declare_builtin("__builtin_alpha_insbl", &long_ctype, 0, &long_ctype, &long_ctype, NULL);
402 declare_builtin("__builtin_alpha_inslh", &long_ctype, 0, &long_ctype, &long_ctype, NULL);
403 declare_builtin("__builtin_alpha_insql", &long_ctype, 0, &long_ctype, &long_ctype, NULL);
404 declare_builtin("__builtin_alpha_inswl", &long_ctype, 0, &long_ctype, &long_ctype, NULL);
405 declare_builtin("__builtin_bcmp", &int_ctype , 0, &const_ptr_ctype, &const_ptr_ctype, size_t_ctype, NULL);
406 declare_builtin("__builtin_bcopy", &void_ctype, 0, &const_ptr_ctype, &ptr_ctype, size_t_ctype, NULL);
407 declare_builtin("__builtin_bswap16", &ushort_ctype, 0, &ushort_ctype, NULL);
408 declare_builtin("__builtin_bswap32", &uint_ctype, 0, &uint_ctype, NULL);
409 declare_builtin("__builtin_bswap64", &ullong_ctype, 0, &ullong_ctype, NULL);
410 declare_builtin("__builtin_bzero", &void_ctype, 0, &ptr_ctype, size_t_ctype, NULL);
411 declare_builtin("__builtin_calloc", &ptr_ctype, 0, size_t_ctype, size_t_ctype, NULL);
412 declare_builtin("__builtin_clrsb", &int_ctype, 0, &int_ctype, NULL);
413 declare_builtin("__builtin_clrsbl", &int_ctype, 0, &long_ctype, NULL);
414 declare_builtin("__builtin_clrsbll", &int_ctype, 0, &llong_ctype, NULL);
415 declare_builtin("__builtin_clz", &int_ctype, 0, &int_ctype, NULL);
416 declare_builtin("__builtin_clzl", &int_ctype, 0, &long_ctype, NULL);
417 declare_builtin("__builtin_clzll", &int_ctype, 0, &llong_ctype, NULL);
418 declare_builtin("__builtin_ctz", &int_ctype, 0, &int_ctype, NULL);
419 declare_builtin("__builtin_ctzl", &int_ctype, 0, &long_ctype, NULL);
420 declare_builtin("__builtin_ctzll", &int_ctype, 0, &llong_ctype, NULL);
421 declare_builtin("__builtin_exit", &void_ctype, 0, &int_ctype, NULL);
422 declare_builtin("__builtin_expect", &long_ctype, 0, &long_ctype ,&long_ctype, NULL);
423 declare_builtin("__builtin_extract_return_addr", &ptr_ctype, 0, &ptr_ctype, NULL);
424 declare_builtin("__builtin_fabs", &double_ctype, 0, &double_ctype, NULL);
425 declare_builtin("__builtin_ffs", &int_ctype, 0, &int_ctype, NULL);
426 declare_builtin("__builtin_ffsl", &int_ctype, 0, &long_ctype, NULL);
427 declare_builtin("__builtin_ffsll", &int_ctype, 0, &llong_ctype, NULL);
428 declare_builtin("__builtin_frame_address", &ptr_ctype, 0, &uint_ctype, NULL);
429 declare_builtin("__builtin_free", &void_ctype, 0, &ptr_ctype, NULL);
430 declare_builtin("__builtin_huge_val", &double_ctype, 0, NULL);
431 declare_builtin("__builtin_huge_valf", &float_ctype, 0, NULL);
432 declare_builtin("__builtin_huge_vall", &ldouble_ctype, 0, NULL);
433 declare_builtin("__builtin_index", &string_ctype, 0, &const_string_ctype, &int_ctype, NULL);
434 declare_builtin("__builtin_inf", &double_ctype, 0, NULL);
435 declare_builtin("__builtin_inff", &float_ctype, 0, NULL);
436 declare_builtin("__builtin_infl", &ldouble_ctype, 0, NULL);
437 declare_builtin("__builtin_isfinite", &int_ctype, 1, NULL);
438 declare_builtin("__builtin_isgreater", &int_ctype, 0, &float_ctype, &float_ctype, NULL);
439 declare_builtin("__builtin_isgreaterequal", &int_ctype, 0, &float_ctype, &float_ctype, NULL);
440 declare_builtin("__builtin_isinf", &int_ctype, 1, NULL);
441 declare_builtin("__builtin_isinf_sign", &int_ctype, 1, NULL);
442 declare_builtin("__builtin_isless", &int_ctype, 0, &float_ctype, &float_ctype, NULL);
443 declare_builtin("__builtin_islessequal", &int_ctype, 0, &float_ctype, &float_ctype, NULL);
444 declare_builtin("__builtin_islessgreater", &int_ctype, 0, &float_ctype, &float_ctype, NULL);
445 declare_builtin("__builtin_isnan", &int_ctype, 1, NULL);
446 declare_builtin("__builtin_isnormal", &int_ctype, 1, NULL);
447 declare_builtin("__builtin_isunordered", &int_ctype, 0, &float_ctype, &float_ctype, NULL);
448 declare_builtin("__builtin_labs", &long_ctype, 0, &long_ctype, NULL);
449 declare_builtin("__builtin_llabs", &llong_ctype, 0, &llong_ctype, NULL);
450 declare_builtin("__builtin_malloc", &ptr_ctype, 0, size_t_ctype, NULL);
451 declare_builtin("__builtin_memchr", &ptr_ctype, 0, &const_ptr_ctype, &int_ctype, size_t_ctype, NULL);
452 declare_builtin("__builtin_memcmp", &int_ctype, 0, &const_ptr_ctype, &const_ptr_ctype, size_t_ctype, NULL);
453 declare_builtin("__builtin_memcpy", &ptr_ctype, 0, &ptr_ctype, &const_ptr_ctype, size_t_ctype, NULL);
454 declare_builtin("__builtin_memmove", &ptr_ctype, 0, &ptr_ctype, &const_ptr_ctype, size_t_ctype, NULL);
455 declare_builtin("__builtin_mempcpy", &ptr_ctype, 0, &ptr_ctype, &const_ptr_ctype, size_t_ctype, NULL);
456 declare_builtin("__builtin_memset", &ptr_ctype, 0, &ptr_ctype, &int_ctype, size_t_ctype, NULL);
457 declare_builtin("__builtin_nan", &double_ctype, 0, &const_string_ctype, NULL);
458 declare_builtin("__builtin_nanf", &float_ctype, 0, &const_string_ctype, NULL);
459 declare_builtin("__builtin_nanl", &ldouble_ctype, 0, &const_string_ctype, NULL);
460 declare_builtin("__builtin_object_size", size_t_ctype, 0, &const_ptr_ctype, &int_ctype, NULL);
461 declare_builtin("__builtin_parity", &int_ctype, 0, &uint_ctype, NULL);
462 declare_builtin("__builtin_parityl", &int_ctype, 0, &ulong_ctype, NULL);
463 declare_builtin("__builtin_parityll", &int_ctype, 0, &ullong_ctype, NULL);
464 declare_builtin("__builtin_popcount", &int_ctype, 0, &uint_ctype, NULL);
465 declare_builtin("__builtin_popcountl", &int_ctype, 0, &ulong_ctype, NULL);
466 declare_builtin("__builtin_popcountll", &int_ctype, 0, &ullong_ctype, NULL);
467 declare_builtin("__builtin_prefetch", &void_ctype, 1, &const_ptr_ctype, NULL);
468 declare_builtin("__builtin_printf", &int_ctype, 1, &const_string_ctype, NULL);
469 declare_builtin("__builtin_puts", &int_ctype, 0, &const_string_ctype, NULL);
470 declare_builtin("__builtin_realloc", &ptr_ctype, 0, &ptr_ctype, size_t_ctype, NULL);
471 declare_builtin("__builtin_return_address", &ptr_ctype, 0, &uint_ctype, NULL);
472 declare_builtin("__builtin_rindex", &string_ctype, 0, &const_string_ctype, &int_ctype, NULL);
473 declare_builtin("__builtin_sadd_overflow", &bool_ctype, 0, &int_ctype, &int_ctype, &int_ptr_ctype, NULL);
474 declare_builtin("__builtin_saddl_overflow", &bool_ctype, 0, &long_ctype, &long_ctype, &long_ptr_ctype, NULL);
475 declare_builtin("__builtin_saddll_overflow", &bool_ctype, 0, &llong_ctype, &llong_ctype, &llong_ptr_ctype, NULL);
476 declare_builtin("__builtin_signbit", &int_ctype, 1, NULL);
477 declare_builtin("__builtin_smul_overflow", &bool_ctype, 0, &int_ctype, &int_ctype, &int_ptr_ctype, NULL);
478 declare_builtin("__builtin_smull_overflow", &bool_ctype, 0, &long_ctype, &long_ctype, &long_ptr_ctype, NULL);
479 declare_builtin("__builtin_smulll_overflow", &bool_ctype, 0, &llong_ctype, &llong_ctype, &llong_ptr_ctype, NULL);
480 declare_builtin("__builtin_snprintf", &int_ctype, 1, &string_ctype, size_t_ctype, &const_string_ctype, NULL);
481 declare_builtin("__builtin_sprintf", &int_ctype, 1, &string_ctype, &const_string_ctype, NULL);
482 declare_builtin("__builtin_ssub_overflow", &bool_ctype, 0, &int_ctype, &int_ctype, &int_ptr_ctype, NULL);
483 declare_builtin("__builtin_ssubl_overflow", &bool_ctype, 0, &long_ctype, &long_ctype, &long_ptr_ctype, NULL);
484 declare_builtin("__builtin_ssubll_overflow", &bool_ctype, 0, &llong_ctype, &llong_ctype, &llong_ptr_ctype, NULL);
485 declare_builtin("__builtin_stpcpy", &string_ctype, 0, &const_string_ctype, &const_string_ctype, NULL);
486 declare_builtin("__builtin_stpncpy", &string_ctype, 0, &const_string_ctype, &const_string_ctype, size_t_ctype, NULL);
487 declare_builtin("__builtin_strcasecmp", &int_ctype, 0, &const_string_ctype, &const_string_ctype, NULL);
488 declare_builtin("__builtin_strcasestr", &string_ctype, 0, &const_string_ctype, &const_string_ctype, NULL);
489 declare_builtin("__builtin_strcat", &string_ctype, 0, &string_ctype, &const_string_ctype, NULL);
490 declare_builtin("__builtin_strchr", &string_ctype, 0, &const_string_ctype, &int_ctype, NULL);
491 declare_builtin("__builtin_strcmp", &int_ctype, 0, &const_string_ctype, &const_string_ctype, NULL);
492 declare_builtin("__builtin_strcpy", &string_ctype, 0, &string_ctype, &const_string_ctype, NULL);
493 declare_builtin("__builtin_strcspn", size_t_ctype, 0, &const_string_ctype, &const_string_ctype, NULL);
494 declare_builtin("__builtin_strdup", &string_ctype, 0, &const_string_ctype, NULL);
495 declare_builtin("__builtin_strlen", size_t_ctype, 0, &const_string_ctype, NULL);
496 declare_builtin("__builtin_strncasecmp", &int_ctype, 0, &const_string_ctype, &const_string_ctype, size_t_ctype, NULL);
497 declare_builtin("__builtin_strncat", &string_ctype, 0, &string_ctype, &const_string_ctype, size_t_ctype, NULL);
498 declare_builtin("__builtin_strncmp", &int_ctype, 0, &const_string_ctype, &const_string_ctype, size_t_ctype, NULL);
499 declare_builtin("__builtin_strncpy", &string_ctype, 0, &string_ctype, &const_string_ctype, size_t_ctype, NULL);
500 declare_builtin("__builtin_strndup", &string_ctype, 0, &const_string_ctype, size_t_ctype, NULL);
501 declare_builtin("__builtin_strnstr", &string_ctype, 0, &const_string_ctype, &const_string_ctype, size_t_ctype, NULL);
502 declare_builtin("__builtin_strpbrk", &string_ctype, 0, &const_string_ctype, &const_string_ctype, NULL);
503 declare_builtin("__builtin_strrchr", &string_ctype, 0, &const_string_ctype, &int_ctype, NULL);
504 declare_builtin("__builtin_strspn", size_t_ctype, 0, &const_string_ctype, &const_string_ctype, NULL);
505 declare_builtin("__builtin_strstr", &string_ctype, 0, &const_string_ctype, &const_string_ctype, NULL);
506 declare_builtin("__builtin_trap", &void_ctype, 0, NULL);
507 declare_builtin("__builtin_uadd_overflow", &bool_ctype, 0, &uint_ctype, &uint_ctype, &uint_ptr_ctype, NULL);
508 declare_builtin("__builtin_uaddl_overflow", &bool_ctype, 0, &ulong_ctype, &ulong_ctype, &ulong_ptr_ctype, NULL);
509 declare_builtin("__builtin_uaddll_overflow", &bool_ctype, 0, &ullong_ctype, &ullong_ctype, &ullong_ptr_ctype, NULL);
510 declare_builtin("__builtin_umul_overflow", &bool_ctype, 0, &uint_ctype, &uint_ctype, &uint_ptr_ctype, NULL);
511 declare_builtin("__builtin_umull_overflow", &bool_ctype, 0, &ulong_ctype, &ulong_ctype, &ulong_ptr_ctype, NULL);
512 declare_builtin("__builtin_umulll_overflow", &bool_ctype, 0, &ullong_ctype, &ullong_ctype, &ullong_ptr_ctype, NULL);
513 declare_builtin("__builtin_unreachable", &void_ctype, 0, NULL);
514 declare_builtin("__builtin_usub_overflow", &bool_ctype, 0, &uint_ctype, &uint_ctype, &uint_ptr_ctype, NULL);
515 declare_builtin("__builtin_usubl_overflow", &bool_ctype, 0, &ulong_ctype, &ulong_ctype, &ulong_ptr_ctype, NULL);
516 declare_builtin("__builtin_usubll_overflow", &bool_ctype, 0, &ullong_ctype, &ullong_ctype, &ullong_ptr_ctype, NULL);
517 declare_builtin("__builtin_va_arg_pack_len", size_t_ctype, 0, NULL);
518 declare_builtin("__builtin_vprintf", &int_ctype, 0, &const_string_ctype, va_list_ctype, NULL);
519 declare_builtin("__builtin_vsnprintf", &int_ctype, 0, &string_ctype, size_t_ctype, &const_string_ctype, va_list_ctype, NULL);
520 declare_builtin("__builtin_vsprintf", &int_ctype, 0, &string_ctype, &const_string_ctype, va_list_ctype, NULL);
521
522 declare_builtin("__builtin___memcpy_chk", &ptr_ctype, 0, &ptr_ctype, &const_ptr_ctype, size_t_ctype, size_t_ctype, NULL);
523 declare_builtin("__builtin___memmove_chk", &ptr_ctype, 0, &ptr_ctype, &const_ptr_ctype, size_t_ctype, size_t_ctype, NULL);
524 declare_builtin("__builtin___mempcpy_chk", &ptr_ctype, 0, &ptr_ctype, &const_ptr_ctype, size_t_ctype, size_t_ctype, NULL);
525 declare_builtin("__builtin___memset_chk", &ptr_ctype, 0, &ptr_ctype, &int_ctype, size_t_ctype, size_t_ctype, NULL);
526 declare_builtin("__builtin___snprintf_chk", &int_ctype, 1, &string_ctype, size_t_ctype, &int_ctype , size_t_ctype, &const_string_ctype, NULL);
527 declare_builtin("__builtin___sprintf_chk", &int_ctype, 1, &string_ctype, &int_ctype, size_t_ctype, &const_string_ctype, NULL);
528 declare_builtin("__builtin___stpcpy_chk", &string_ctype, 0, &string_ctype, &const_string_ctype, size_t_ctype, NULL);
529 declare_builtin("__builtin___strcat_chk", &string_ctype, 0, &string_ctype, &const_string_ctype, size_t_ctype, NULL);
530 declare_builtin("__builtin___strcpy_chk", &string_ctype, 0, &string_ctype, &const_string_ctype, size_t_ctype, NULL);
531 declare_builtin("__builtin___strncat_chk", &string_ctype, 0, &string_ctype, &const_string_ctype, size_t_ctype, size_t_ctype, NULL);
532 declare_builtin("__builtin___strncpy_chk", &string_ctype, 0, &string_ctype, &const_string_ctype, size_t_ctype, size_t_ctype, NULL);
533 declare_builtin("__builtin___vsnprintf_chk", &int_ctype, 0, &string_ctype, size_t_ctype, &int_ctype, size_t_ctype, &const_string_ctype, va_list_ctype, NULL);
534 declare_builtin("__builtin___vsprintf_chk", &int_ctype, 0, &string_ctype, &int_ctype, size_t_ctype, &const_string_ctype, va_list_ctype, NULL);
535
536 declare_builtin("__sync_add_and_fetch", &int_ctype, 1, &ptr_ctype, NULL);
537 declare_builtin("__sync_and_and_fetch", &int_ctype, 1, &ptr_ctype, NULL);
538 declare_builtin("__sync_bool_compare_and_swap", &int_ctype, 1, &ptr_ctype, NULL);
539 declare_builtin("__sync_fetch_and_add", &int_ctype, 1, &ptr_ctype, NULL);
540 declare_builtin("__sync_fetch_and_and", &int_ctype, 1, &ptr_ctype, NULL);
541 declare_builtin("__sync_fetch_and_nand", &int_ctype, 1, &ptr_ctype, NULL);
542 declare_builtin("__sync_fetch_and_or", &int_ctype, 1, &ptr_ctype, NULL);
543 declare_builtin("__sync_fetch_and_sub", &int_ctype, 1, &ptr_ctype, NULL);
544 declare_builtin("__sync_fetch_and_xor", &int_ctype, 1, &ptr_ctype, NULL);
545 declare_builtin("__sync_lock_release", &void_ctype, 1, &ptr_ctype, NULL);
546 declare_builtin("__sync_lock_test_and_set", &int_ctype, 1, &ptr_ctype, NULL);
547 declare_builtin("__sync_nand_and_fetch", &int_ctype, 1, &ptr_ctype, NULL);
548 declare_builtin("__sync_or_and_fetch", &int_ctype, 1, &ptr_ctype, NULL);
549 declare_builtin("__sync_sub_and_fetch", &int_ctype, 1, &ptr_ctype, NULL);
550 declare_builtin("__sync_synchronize", &void_ctype, 0, NULL);
551 declare_builtin("__sync_val_compare_and_swap", &int_ctype, 1, &ptr_ctype, NULL);
552 declare_builtin("__sync_xor_and_fetch", &int_ctype, 1, &ptr_ctype, NULL);
553
554 // Blackfin-specific stuff
555 declare_builtin("__builtin_bfin_csync", &void_ctype, 0, NULL);
556 declare_builtin("__builtin_bfin_ssync", &void_ctype, 0, NULL);
557 declare_builtin("__builtin_bfin_norm_fr1x32", &int_ctype, 0, &int_ctype, NULL);
558 }
|