1 /* Build expressions with type checking for C compiler.
2 Copyright (C) 1987-2018 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
10
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
19
20
21 /* This file is part of the C front end.
22 It contains routines to build C expressions given their operands,
23 including computing the types of the result, C-specific error checks,
24 and some optimization. */
25
26 #include "config.h"
27 #include "system.h"
28 #include "coretypes.h"
29 #include "memmodel.h"
30 #include "target.h"
31 #include "function.h"
32 #include "bitmap.h"
33 #include "c-tree.h"
34 #include "gimple-expr.h"
35 #include "predict.h"
36 #include "stor-layout.h"
37 #include "trans-mem.h"
38 #include "varasm.h"
39 #include "stmt.h"
40 #include "langhooks.h"
41 #include "c-lang.h"
42 #include "intl.h"
43 #include "tree-iterator.h"
44 #include "gimplify.h"
45 #include "tree-inline.h"
46 #include "omp-general.h"
47 #include "c-family/c-objc.h"
48 #include "c-family/c-ubsan.h"
49 #include "gomp-constants.h"
50 #include "spellcheck-tree.h"
51 #include "gcc-rich-location.h"
52 #include "stringpool.h"
53 #include "attribs.h"
54 #include "asan.h"
55
56 /* Possible cases of implicit bad conversions. Used to select
57 diagnostic messages in convert_for_assignment. */
58 enum impl_conv {
59 ic_argpass,
60 ic_assign,
61 ic_init,
62 ic_return
63 };
64
65 /* The level of nesting inside "__alignof__". */
66 int in_alignof;
67
68 /* The level of nesting inside "sizeof". */
69 int in_sizeof;
70
71 /* The level of nesting inside "typeof". */
72 int in_typeof;
73
74 /* The argument of last parsed sizeof expression, only to be tested
75 if expr.original_code == SIZEOF_EXPR. */
76 tree c_last_sizeof_arg;
77 location_t c_last_sizeof_loc;
78
79 /* Nonzero if we might need to print a "missing braces around
80 initializer" message within this initializer. */
81 static int found_missing_braces;
82
83 static int require_constant_value;
84 static int require_constant_elements;
85
86 static bool null_pointer_constant_p (const_tree);
87 static tree qualify_type (tree, tree);
88 static int tagged_types_tu_compatible_p (const_tree, const_tree, bool *,
89 bool *);
90 static int comp_target_types (location_t, tree, tree);
91 static int function_types_compatible_p (const_tree, const_tree, bool *,
92 bool *);
93 static int type_lists_compatible_p (const_tree, const_tree, bool *, bool *);
94 static tree lookup_field (tree, tree);
95 static int convert_arguments (location_t, vec<location_t>, tree,
96 vec<tree, va_gc> *, vec<tree, va_gc> *, tree,
97 tree);
98 static tree pointer_diff (location_t, tree, tree, tree *);
99 static tree convert_for_assignment (location_t, location_t, tree, tree, tree,
100 enum impl_conv, bool, tree, tree, int);
101 static tree valid_compound_expr_initializer (tree, tree);
102 static void push_string (const char *);
103 static void push_member_name (tree);
104 static int spelling_length (void);
105 static char *print_spelling (char *);
106 static void warning_init (location_t, int, const char *);
107 static tree digest_init (location_t, tree, tree, tree, bool, bool, int);
108 static void output_init_element (location_t, tree, tree, bool, tree, tree, bool,
109 bool, struct obstack *);
110 static void output_pending_init_elements (int, struct obstack *);
111 static bool set_designator (location_t, bool, struct obstack *);
112 static void push_range_stack (tree, struct obstack *);
113 static void add_pending_init (location_t, tree, tree, tree, bool,
114 struct obstack *);
115 static void set_nonincremental_init (struct obstack *);
116 static void set_nonincremental_init_from_string (tree, struct obstack *);
117 static tree find_init_member (tree, struct obstack *);
118 static void readonly_warning (tree, enum lvalue_use);
119 static int lvalue_or_else (location_t, const_tree, enum lvalue_use);
120 static void record_maybe_used_decl (tree);
121 static int comptypes_internal (const_tree, const_tree, bool *, bool *);
122
123 /* Return true if EXP is a null pointer constant, false otherwise. */
124
125 static bool
null_pointer_constant_p(const_tree expr)126 null_pointer_constant_p (const_tree expr)
127 {
128 /* This should really operate on c_expr structures, but they aren't
129 yet available everywhere required. */
130 tree type = TREE_TYPE (expr);
131 return (TREE_CODE (expr) == INTEGER_CST
132 && !TREE_OVERFLOW (expr)
133 && integer_zerop (expr)
134 && (INTEGRAL_TYPE_P (type)
135 || (TREE_CODE (type) == POINTER_TYPE
136 && VOID_TYPE_P (TREE_TYPE (type))
137 && TYPE_QUALS (TREE_TYPE (type)) == TYPE_UNQUALIFIED)));
138 }
139
140 /* EXPR may appear in an unevaluated part of an integer constant
141 expression, but not in an evaluated part. Wrap it in a
142 C_MAYBE_CONST_EXPR, or mark it with TREE_OVERFLOW if it is just an
143 INTEGER_CST and we cannot create a C_MAYBE_CONST_EXPR. */
144
145 static tree
note_integer_operands(tree expr)146 note_integer_operands (tree expr)
147 {
148 tree ret;
149 if (TREE_CODE (expr) == INTEGER_CST && in_late_binary_op)
150 {
151 ret = copy_node (expr);
152 TREE_OVERFLOW (ret) = 1;
153 }
154 else
155 {
156 ret = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (expr), NULL_TREE, expr);
157 C_MAYBE_CONST_EXPR_INT_OPERANDS (ret) = 1;
158 }
159 return ret;
160 }
161
162 /* Having checked whether EXPR may appear in an unevaluated part of an
163 integer constant expression and found that it may, remove any
164 C_MAYBE_CONST_EXPR noting this fact and return the resulting
165 expression. */
166
167 static inline tree
remove_c_maybe_const_expr(tree expr)168 remove_c_maybe_const_expr (tree expr)
169 {
170 if (TREE_CODE (expr) == C_MAYBE_CONST_EXPR)
171 return C_MAYBE_CONST_EXPR_EXPR (expr);
172 else
173 return expr;
174 }
175
176 /* This is a cache to hold if two types are compatible or not. */
177
178 struct tagged_tu_seen_cache {
179 const struct tagged_tu_seen_cache * next;
180 const_tree t1;
181 const_tree t2;
182 /* The return value of tagged_types_tu_compatible_p if we had seen
183 these two types already. */
184 int val;
185 };
186
187 static const struct tagged_tu_seen_cache * tagged_tu_seen_base;
188 static void free_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache *);
189
190 /* Do `exp = require_complete_type (loc, exp);' to make sure exp
191 does not have an incomplete type. (That includes void types.)
192 LOC is the location of the use. */
193
194 tree
require_complete_type(location_t loc,tree value)195 require_complete_type (location_t loc, tree value)
196 {
197 tree type = TREE_TYPE (value);
198
199 if (error_operand_p (value))
200 return error_mark_node;
201
202 /* First, detect a valid value with a complete type. */
203 if (COMPLETE_TYPE_P (type))
204 return value;
205
206 c_incomplete_type_error (loc, value, type);
207 return error_mark_node;
208 }
209
210 /* Print an error message for invalid use of an incomplete type.
211 VALUE is the expression that was used (or 0 if that isn't known)
212 and TYPE is the type that was invalid. LOC is the location for
213 the error. */
214
215 void
c_incomplete_type_error(location_t loc,const_tree value,const_tree type)216 c_incomplete_type_error (location_t loc, const_tree value, const_tree type)
217 {
218 /* Avoid duplicate error message. */
219 if (TREE_CODE (type) == ERROR_MARK)
220 return;
221
222 if (value != NULL_TREE && (VAR_P (value) || TREE_CODE (value) == PARM_DECL))
223 error_at (loc, "%qD has an incomplete type %qT", value, type);
224 else
225 {
226 retry:
227 /* We must print an error message. Be clever about what it says. */
228
229 switch (TREE_CODE (type))
230 {
231 case RECORD_TYPE:
232 case UNION_TYPE:
233 case ENUMERAL_TYPE:
234 break;
235
236 case VOID_TYPE:
237 error_at (loc, "invalid use of void expression");
238 return;
239
240 case ARRAY_TYPE:
241 if (TYPE_DOMAIN (type))
242 {
243 if (TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL)
244 {
245 error_at (loc, "invalid use of flexible array member");
246 return;
247 }
248 type = TREE_TYPE (type);
249 goto retry;
250 }
251 error_at (loc, "invalid use of array with unspecified bounds");
252 return;
253
254 default:
255 gcc_unreachable ();
256 }
257
258 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
259 error_at (loc, "invalid use of undefined type %qT", type);
260 else
261 /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
262 error_at (loc, "invalid use of incomplete typedef %qT", type);
263 }
264 }
265
266 /* Given a type, apply default promotions wrt unnamed function
267 arguments and return the new type. */
268
269 tree
c_type_promotes_to(tree type)270 c_type_promotes_to (tree type)
271 {
272 tree ret = NULL_TREE;
273
274 if (TYPE_MAIN_VARIANT (type) == float_type_node)
275 ret = double_type_node;
276 else if (c_promoting_integer_type_p (type))
277 {
278 /* Preserve unsignedness if not really getting any wider. */
279 if (TYPE_UNSIGNED (type)
280 && (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
281 ret = unsigned_type_node;
282 else
283 ret = integer_type_node;
284 }
285
286 if (ret != NULL_TREE)
287 return (TYPE_ATOMIC (type)
288 ? c_build_qualified_type (ret, TYPE_QUAL_ATOMIC)
289 : ret);
290
291 return type;
292 }
293
294 /* Return true if between two named address spaces, whether there is a superset
295 named address space that encompasses both address spaces. If there is a
296 superset, return which address space is the superset. */
297
298 static bool
addr_space_superset(addr_space_t as1,addr_space_t as2,addr_space_t * common)299 addr_space_superset (addr_space_t as1, addr_space_t as2, addr_space_t *common)
300 {
301 if (as1 == as2)
302 {
303 *common = as1;
304 return true;
305 }
306 else if (targetm.addr_space.subset_p (as1, as2))
307 {
308 *common = as2;
309 return true;
310 }
311 else if (targetm.addr_space.subset_p (as2, as1))
312 {
313 *common = as1;
314 return true;
315 }
316 else
317 return false;
318 }
319
320 /* Return a variant of TYPE which has all the type qualifiers of LIKE
321 as well as those of TYPE. */
322
323 static tree
qualify_type(tree type,tree like)324 qualify_type (tree type, tree like)
325 {
326 addr_space_t as_type = TYPE_ADDR_SPACE (type);
327 addr_space_t as_like = TYPE_ADDR_SPACE (like);
328 addr_space_t as_common;
329
330 /* If the two named address spaces are different, determine the common
331 superset address space. If there isn't one, raise an error. */
332 if (!addr_space_superset (as_type, as_like, &as_common))
333 {
334 as_common = as_type;
335 error ("%qT and %qT are in disjoint named address spaces",
336 type, like);
337 }
338
339 return c_build_qualified_type (type,
340 TYPE_QUALS_NO_ADDR_SPACE (type)
341 | TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC (like)
342 | ENCODE_QUAL_ADDR_SPACE (as_common));
343 }
344
345 /* Return true iff the given tree T is a variable length array. */
346
347 bool
c_vla_type_p(const_tree t)348 c_vla_type_p (const_tree t)
349 {
350 if (TREE_CODE (t) == ARRAY_TYPE
351 && C_TYPE_VARIABLE_SIZE (t))
352 return true;
353 return false;
354 }
355
356 /* Return the composite type of two compatible types.
357
358 We assume that comptypes has already been done and returned
359 nonzero; if that isn't so, this may crash. In particular, we
360 assume that qualifiers match. */
361
362 tree
composite_type(tree t1,tree t2)363 composite_type (tree t1, tree t2)
364 {
365 enum tree_code code1;
366 enum tree_code code2;
367 tree attributes;
368
369 /* Save time if the two types are the same. */
370
371 if (t1 == t2) return t1;
372
373 /* If one type is nonsense, use the other. */
374 if (t1 == error_mark_node)
375 return t2;
376 if (t2 == error_mark_node)
377 return t1;
378
379 code1 = TREE_CODE (t1);
380 code2 = TREE_CODE (t2);
381
382 /* Merge the attributes. */
383 attributes = targetm.merge_type_attributes (t1, t2);
384
385 /* If one is an enumerated type and the other is the compatible
386 integer type, the composite type might be either of the two
387 (DR#013 question 3). For consistency, use the enumerated type as
388 the composite type. */
389
390 if (code1 == ENUMERAL_TYPE && code2 == INTEGER_TYPE)
391 return t1;
392 if (code2 == ENUMERAL_TYPE && code1 == INTEGER_TYPE)
393 return t2;
394
395 gcc_assert (code1 == code2);
396
397 switch (code1)
398 {
399 case POINTER_TYPE:
400 /* For two pointers, do this recursively on the target type. */
401 {
402 tree pointed_to_1 = TREE_TYPE (t1);
403 tree pointed_to_2 = TREE_TYPE (t2);
404 tree target = composite_type (pointed_to_1, pointed_to_2);
405 t1 = build_pointer_type_for_mode (target, TYPE_MODE (t1), false);
406 t1 = build_type_attribute_variant (t1, attributes);
407 return qualify_type (t1, t2);
408 }
409
410 case ARRAY_TYPE:
411 {
412 tree elt = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
413 int quals;
414 tree unqual_elt;
415 tree d1 = TYPE_DOMAIN (t1);
416 tree d2 = TYPE_DOMAIN (t2);
417 bool d1_variable, d2_variable;
418 bool d1_zero, d2_zero;
419 bool t1_complete, t2_complete;
420
421 /* We should not have any type quals on arrays at all. */
422 gcc_assert (!TYPE_QUALS_NO_ADDR_SPACE (t1)
423 && !TYPE_QUALS_NO_ADDR_SPACE (t2));
424
425 t1_complete = COMPLETE_TYPE_P (t1);
426 t2_complete = COMPLETE_TYPE_P (t2);
427
428 d1_zero = d1 == NULL_TREE || !TYPE_MAX_VALUE (d1);
429 d2_zero = d2 == NULL_TREE || !TYPE_MAX_VALUE (d2);
430
431 d1_variable = (!d1_zero
432 && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
433 || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
434 d2_variable = (!d2_zero
435 && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
436 || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
437 d1_variable = d1_variable || (d1_zero && c_vla_type_p (t1));
438 d2_variable = d2_variable || (d2_zero && c_vla_type_p (t2));
439
440 /* Save space: see if the result is identical to one of the args. */
441 if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1)
442 && (d2_variable || d2_zero || !d1_variable))
443 return build_type_attribute_variant (t1, attributes);
444 if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2)
445 && (d1_variable || d1_zero || !d2_variable))
446 return build_type_attribute_variant (t2, attributes);
447
448 if (elt == TREE_TYPE (t1) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1))
449 return build_type_attribute_variant (t1, attributes);
450 if (elt == TREE_TYPE (t2) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1))
451 return build_type_attribute_variant (t2, attributes);
452
453 /* Merge the element types, and have a size if either arg has
454 one. We may have qualifiers on the element types. To set
455 up TYPE_MAIN_VARIANT correctly, we need to form the
456 composite of the unqualified types and add the qualifiers
457 back at the end. */
458 quals = TYPE_QUALS (strip_array_types (elt));
459 unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
460 t1 = build_array_type (unqual_elt,
461 TYPE_DOMAIN ((TYPE_DOMAIN (t1)
462 && (d2_variable
463 || d2_zero
464 || !d1_variable))
465 ? t1
466 : t2));
467 /* Ensure a composite type involving a zero-length array type
468 is a zero-length type not an incomplete type. */
469 if (d1_zero && d2_zero
470 && (t1_complete || t2_complete)
471 && !COMPLETE_TYPE_P (t1))
472 {
473 TYPE_SIZE (t1) = bitsize_zero_node;
474 TYPE_SIZE_UNIT (t1) = size_zero_node;
475 }
476 t1 = c_build_qualified_type (t1, quals);
477 return build_type_attribute_variant (t1, attributes);
478 }
479
480 case ENUMERAL_TYPE:
481 case RECORD_TYPE:
482 case UNION_TYPE:
483 if (attributes != NULL)
484 {
485 /* Try harder not to create a new aggregate type. */
486 if (attribute_list_equal (TYPE_ATTRIBUTES (t1), attributes))
487 return t1;
488 if (attribute_list_equal (TYPE_ATTRIBUTES (t2), attributes))
489 return t2;
490 }
491 return build_type_attribute_variant (t1, attributes);
492
493 case FUNCTION_TYPE:
494 /* Function types: prefer the one that specified arg types.
495 If both do, merge the arg types. Also merge the return types. */
496 {
497 tree valtype = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
498 tree p1 = TYPE_ARG_TYPES (t1);
499 tree p2 = TYPE_ARG_TYPES (t2);
500 int len;
501 tree newargs, n;
502 int i;
503
504 /* Save space: see if the result is identical to one of the args. */
505 if (valtype == TREE_TYPE (t1) && !TYPE_ARG_TYPES (t2))
506 return build_type_attribute_variant (t1, attributes);
507 if (valtype == TREE_TYPE (t2) && !TYPE_ARG_TYPES (t1))
508 return build_type_attribute_variant (t2, attributes);
509
510 /* Simple way if one arg fails to specify argument types. */
511 if (TYPE_ARG_TYPES (t1) == NULL_TREE)
512 {
513 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2));
514 t1 = build_type_attribute_variant (t1, attributes);
515 return qualify_type (t1, t2);
516 }
517 if (TYPE_ARG_TYPES (t2) == NULL_TREE)
518 {
519 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1));
520 t1 = build_type_attribute_variant (t1, attributes);
521 return qualify_type (t1, t2);
522 }
523
524 /* If both args specify argument types, we must merge the two
525 lists, argument by argument. */
526
527 for (len = 0, newargs = p1;
528 newargs && newargs != void_list_node;
529 len++, newargs = TREE_CHAIN (newargs))
530 ;
531
532 for (i = 0; i < len; i++)
533 newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
534
535 n = newargs;
536
537 for (; p1 && p1 != void_list_node;
538 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n))
539 {
540 /* A null type means arg type is not specified.
541 Take whatever the other function type has. */
542 if (TREE_VALUE (p1) == NULL_TREE)
543 {
544 TREE_VALUE (n) = TREE_VALUE (p2);
545 goto parm_done;
546 }
547 if (TREE_VALUE (p2) == NULL_TREE)
548 {
549 TREE_VALUE (n) = TREE_VALUE (p1);
550 goto parm_done;
551 }
552
553 /* Given wait (union {union wait *u; int *i} *)
554 and wait (union wait *),
555 prefer union wait * as type of parm. */
556 if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE
557 && TREE_VALUE (p1) != TREE_VALUE (p2))
558 {
559 tree memb;
560 tree mv2 = TREE_VALUE (p2);
561 if (mv2 && mv2 != error_mark_node
562 && TREE_CODE (mv2) != ARRAY_TYPE)
563 mv2 = TYPE_MAIN_VARIANT (mv2);
564 for (memb = TYPE_FIELDS (TREE_VALUE (p1));
565 memb; memb = DECL_CHAIN (memb))
566 {
567 tree mv3 = TREE_TYPE (memb);
568 if (mv3 && mv3 != error_mark_node
569 && TREE_CODE (mv3) != ARRAY_TYPE)
570 mv3 = TYPE_MAIN_VARIANT (mv3);
571 if (comptypes (mv3, mv2))
572 {
573 TREE_VALUE (n) = composite_type (TREE_TYPE (memb),
574 TREE_VALUE (p2));
575 pedwarn (input_location, OPT_Wpedantic,
576 "function types not truly compatible in ISO C");
577 goto parm_done;
578 }
579 }
580 }
581 if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE
582 && TREE_VALUE (p2) != TREE_VALUE (p1))
583 {
584 tree memb;
585 tree mv1 = TREE_VALUE (p1);
586 if (mv1 && mv1 != error_mark_node
587 && TREE_CODE (mv1) != ARRAY_TYPE)
588 mv1 = TYPE_MAIN_VARIANT (mv1);
589 for (memb = TYPE_FIELDS (TREE_VALUE (p2));
590 memb; memb = DECL_CHAIN (memb))
591 {
592 tree mv3 = TREE_TYPE (memb);
593 if (mv3 && mv3 != error_mark_node
594 && TREE_CODE (mv3) != ARRAY_TYPE)
595 mv3 = TYPE_MAIN_VARIANT (mv3);
596 if (comptypes (mv3, mv1))
597 {
598 TREE_VALUE (n) = composite_type (TREE_TYPE (memb),
599 TREE_VALUE (p1));
600 pedwarn (input_location, OPT_Wpedantic,
601 "function types not truly compatible in ISO C");
602 goto parm_done;
603 }
604 }
605 }
606 TREE_VALUE (n) = composite_type (TREE_VALUE (p1), TREE_VALUE (p2));
607 parm_done: ;
608 }
609
610 t1 = build_function_type (valtype, newargs);
611 t1 = qualify_type (t1, t2);
612 }
613 /* FALLTHRU */
614
615 default:
616 return build_type_attribute_variant (t1, attributes);
617 }
618
619 }
620
621 /* Return the type of a conditional expression between pointers to
622 possibly differently qualified versions of compatible types.
623
624 We assume that comp_target_types has already been done and returned
625 nonzero; if that isn't so, this may crash. */
626
627 static tree
common_pointer_type(tree t1,tree t2)628 common_pointer_type (tree t1, tree t2)
629 {
630 tree attributes;
631 tree pointed_to_1, mv1;
632 tree pointed_to_2, mv2;
633 tree target;
634 unsigned target_quals;
635 addr_space_t as1, as2, as_common;
636 int quals1, quals2;
637
638 /* Save time if the two types are the same. */
639
640 if (t1 == t2) return t1;
641
642 /* If one type is nonsense, use the other. */
643 if (t1 == error_mark_node)
644 return t2;
645 if (t2 == error_mark_node)
646 return t1;
647
648 gcc_assert (TREE_CODE (t1) == POINTER_TYPE
649 && TREE_CODE (t2) == POINTER_TYPE);
650
651 /* Merge the attributes. */
652 attributes = targetm.merge_type_attributes (t1, t2);
653
654 /* Find the composite type of the target types, and combine the
655 qualifiers of the two types' targets. Do not lose qualifiers on
656 array element types by taking the TYPE_MAIN_VARIANT. */
657 mv1 = pointed_to_1 = TREE_TYPE (t1);
658 mv2 = pointed_to_2 = TREE_TYPE (t2);
659 if (TREE_CODE (mv1) != ARRAY_TYPE)
660 mv1 = TYPE_MAIN_VARIANT (pointed_to_1);
661 if (TREE_CODE (mv2) != ARRAY_TYPE)
662 mv2 = TYPE_MAIN_VARIANT (pointed_to_2);
663 target = composite_type (mv1, mv2);
664
665 /* Strip array types to get correct qualifier for pointers to arrays */
666 quals1 = TYPE_QUALS_NO_ADDR_SPACE (strip_array_types (pointed_to_1));
667 quals2 = TYPE_QUALS_NO_ADDR_SPACE (strip_array_types (pointed_to_2));
668
669 /* For function types do not merge const qualifiers, but drop them
670 if used inconsistently. The middle-end uses these to mark const
671 and noreturn functions. */
672 if (TREE_CODE (pointed_to_1) == FUNCTION_TYPE)
673 target_quals = (quals1 & quals2);
674 else
675 target_quals = (quals1 | quals2);
676
677 /* If the two named address spaces are different, determine the common
678 superset address space. This is guaranteed to exist due to the
679 assumption that comp_target_type returned non-zero. */
680 as1 = TYPE_ADDR_SPACE (pointed_to_1);
681 as2 = TYPE_ADDR_SPACE (pointed_to_2);
682 if (!addr_space_superset (as1, as2, &as_common))
683 gcc_unreachable ();
684
685 target_quals |= ENCODE_QUAL_ADDR_SPACE (as_common);
686
687 t1 = build_pointer_type (c_build_qualified_type (target, target_quals));
688 return build_type_attribute_variant (t1, attributes);
689 }
690
691 /* Return the common type for two arithmetic types under the usual
692 arithmetic conversions. The default conversions have already been
693 applied, and enumerated types converted to their compatible integer
694 types. The resulting type is unqualified and has no attributes.
695
696 This is the type for the result of most arithmetic operations
697 if the operands have the given two types. */
698
699 static tree
c_common_type(tree t1,tree t2)700 c_common_type (tree t1, tree t2)
701 {
702 enum tree_code code1;
703 enum tree_code code2;
704
705 /* If one type is nonsense, use the other. */
706 if (t1 == error_mark_node)
707 return t2;
708 if (t2 == error_mark_node)
709 return t1;
710
711 if (TYPE_QUALS (t1) != TYPE_UNQUALIFIED)
712 t1 = TYPE_MAIN_VARIANT (t1);
713
714 if (TYPE_QUALS (t2) != TYPE_UNQUALIFIED)
715 t2 = TYPE_MAIN_VARIANT (t2);
716
717 if (TYPE_ATTRIBUTES (t1) != NULL_TREE)
718 t1 = build_type_attribute_variant (t1, NULL_TREE);
719
720 if (TYPE_ATTRIBUTES (t2) != NULL_TREE)
721 t2 = build_type_attribute_variant (t2, NULL_TREE);
722
723 /* Save time if the two types are the same. */
724
725 if (t1 == t2) return t1;
726
727 code1 = TREE_CODE (t1);
728 code2 = TREE_CODE (t2);
729
730 gcc_assert (code1 == VECTOR_TYPE || code1 == COMPLEX_TYPE
731 || code1 == FIXED_POINT_TYPE || code1 == REAL_TYPE
732 || code1 == INTEGER_TYPE);
733 gcc_assert (code2 == VECTOR_TYPE || code2 == COMPLEX_TYPE
734 || code2 == FIXED_POINT_TYPE || code2 == REAL_TYPE
735 || code2 == INTEGER_TYPE);
736
737 /* When one operand is a decimal float type, the other operand cannot be
738 a generic float type or a complex type. We also disallow vector types
739 here. */
740 if ((DECIMAL_FLOAT_TYPE_P (t1) || DECIMAL_FLOAT_TYPE_P (t2))
741 && !(DECIMAL_FLOAT_TYPE_P (t1) && DECIMAL_FLOAT_TYPE_P (t2)))
742 {
743 if (code1 == VECTOR_TYPE || code2 == VECTOR_TYPE)
744 {
745 error ("can%'t mix operands of decimal float and vector types");
746 return error_mark_node;
747 }
748 if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
749 {
750 error ("can%'t mix operands of decimal float and complex types");
751 return error_mark_node;
752 }
753 if (code1 == REAL_TYPE && code2 == REAL_TYPE)
754 {
755 error ("can%'t mix operands of decimal float and other float types");
756 return error_mark_node;
757 }
758 }
759
760 /* If one type is a vector type, return that type. (How the usual
761 arithmetic conversions apply to the vector types extension is not
762 precisely specified.) */
763 if (code1 == VECTOR_TYPE)
764 return t1;
765
766 if (code2 == VECTOR_TYPE)
767 return t2;
768
769 /* If one type is complex, form the common type of the non-complex
770 components, then make that complex. Use T1 or T2 if it is the
771 required type. */
772 if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
773 {
774 tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
775 tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
776 tree subtype = c_common_type (subtype1, subtype2);
777
778 if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
779 return t1;
780 else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
781 return t2;
782 else
783 return build_complex_type (subtype);
784 }
785
786 /* If only one is real, use it as the result. */
787
788 if (code1 == REAL_TYPE && code2 != REAL_TYPE)
789 return t1;
790
791 if (code2 == REAL_TYPE && code1 != REAL_TYPE)
792 return t2;
793
794 /* If both are real and either are decimal floating point types, use
795 the decimal floating point type with the greater precision. */
796
797 if (code1 == REAL_TYPE && code2 == REAL_TYPE)
798 {
799 if (TYPE_MAIN_VARIANT (t1) == dfloat128_type_node
800 || TYPE_MAIN_VARIANT (t2) == dfloat128_type_node)
801 return dfloat128_type_node;
802 else if (TYPE_MAIN_VARIANT (t1) == dfloat64_type_node
803 || TYPE_MAIN_VARIANT (t2) == dfloat64_type_node)
804 return dfloat64_type_node;
805 else if (TYPE_MAIN_VARIANT (t1) == dfloat32_type_node
806 || TYPE_MAIN_VARIANT (t2) == dfloat32_type_node)
807 return dfloat32_type_node;
808 }
809
810 /* Deal with fixed-point types. */
811 if (code1 == FIXED_POINT_TYPE || code2 == FIXED_POINT_TYPE)
812 {
813 unsigned int unsignedp = 0, satp = 0;
814 scalar_mode m1, m2;
815 unsigned int fbit1, ibit1, fbit2, ibit2, max_fbit, max_ibit;
816
817 m1 = SCALAR_TYPE_MODE (t1);
818 m2 = SCALAR_TYPE_MODE (t2);
819
820 /* If one input type is saturating, the result type is saturating. */
821 if (TYPE_SATURATING (t1) || TYPE_SATURATING (t2))
822 satp = 1;
823
824 /* If both fixed-point types are unsigned, the result type is unsigned.
825 When mixing fixed-point and integer types, follow the sign of the
826 fixed-point type.
827 Otherwise, the result type is signed. */
828 if ((TYPE_UNSIGNED (t1) && TYPE_UNSIGNED (t2)
829 && code1 == FIXED_POINT_TYPE && code2 == FIXED_POINT_TYPE)
830 || (code1 == FIXED_POINT_TYPE && code2 != FIXED_POINT_TYPE
831 && TYPE_UNSIGNED (t1))
832 || (code1 != FIXED_POINT_TYPE && code2 == FIXED_POINT_TYPE
833 && TYPE_UNSIGNED (t2)))
834 unsignedp = 1;
835
836 /* The result type is signed. */
837 if (unsignedp == 0)
838 {
839 /* If the input type is unsigned, we need to convert to the
840 signed type. */
841 if (code1 == FIXED_POINT_TYPE && TYPE_UNSIGNED (t1))
842 {
843 enum mode_class mclass = (enum mode_class) 0;
844 if (GET_MODE_CLASS (m1) == MODE_UFRACT)
845 mclass = MODE_FRACT;
846 else if (GET_MODE_CLASS (m1) == MODE_UACCUM)
847 mclass = MODE_ACCUM;
848 else
849 gcc_unreachable ();
850 m1 = as_a <scalar_mode>
851 (mode_for_size (GET_MODE_PRECISION (m1), mclass, 0));
852 }
853 if (code2 == FIXED_POINT_TYPE && TYPE_UNSIGNED (t2))
854 {
855 enum mode_class mclass = (enum mode_class) 0;
856 if (GET_MODE_CLASS (m2) == MODE_UFRACT)
857 mclass = MODE_FRACT;
858 else if (GET_MODE_CLASS (m2) == MODE_UACCUM)
859 mclass = MODE_ACCUM;
860 else
861 gcc_unreachable ();
862 m2 = as_a <scalar_mode>
863 (mode_for_size (GET_MODE_PRECISION (m2), mclass, 0));
864 }
865 }
866
867 if (code1 == FIXED_POINT_TYPE)
868 {
869 fbit1 = GET_MODE_FBIT (m1);
870 ibit1 = GET_MODE_IBIT (m1);
871 }
872 else
873 {
874 fbit1 = 0;
875 /* Signed integers need to subtract one sign bit. */
876 ibit1 = TYPE_PRECISION (t1) - (!TYPE_UNSIGNED (t1));
877 }
878
879 if (code2 == FIXED_POINT_TYPE)
880 {
881 fbit2 = GET_MODE_FBIT (m2);
882 ibit2 = GET_MODE_IBIT (m2);
883 }
884 else
885 {
886 fbit2 = 0;
887 /* Signed integers need to subtract one sign bit. */
888 ibit2 = TYPE_PRECISION (t2) - (!TYPE_UNSIGNED (t2));
889 }
890
891 max_ibit = ibit1 >= ibit2 ? ibit1 : ibit2;
892 max_fbit = fbit1 >= fbit2 ? fbit1 : fbit2;
893 return c_common_fixed_point_type_for_size (max_ibit, max_fbit, unsignedp,
894 satp);
895 }
896
897 /* Both real or both integers; use the one with greater precision. */
898
899 if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
900 return t1;
901 else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
902 return t2;
903
904 /* Same precision. Prefer long longs to longs to ints when the
905 same precision, following the C99 rules on integer type rank
906 (which are equivalent to the C90 rules for C90 types). */
907
908 if (TYPE_MAIN_VARIANT (t1) == long_long_unsigned_type_node
909 || TYPE_MAIN_VARIANT (t2) == long_long_unsigned_type_node)
910 return long_long_unsigned_type_node;
911
912 if (TYPE_MAIN_VARIANT (t1) == long_long_integer_type_node
913 || TYPE_MAIN_VARIANT (t2) == long_long_integer_type_node)
914 {
915 if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
916 return long_long_unsigned_type_node;
917 else
918 return long_long_integer_type_node;
919 }
920
921 if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
922 || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
923 return long_unsigned_type_node;
924
925 if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
926 || TYPE_MAIN_VARIANT (t2) == long_integer_type_node)
927 {
928 /* But preserve unsignedness from the other type,
929 since long cannot hold all the values of an unsigned int. */
930 if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
931 return long_unsigned_type_node;
932 else
933 return long_integer_type_node;
934 }
935
936 /* For floating types of the same TYPE_PRECISION (which we here
937 assume means either the same set of values, or sets of values
938 neither a subset of the other, with behavior being undefined in
939 the latter case), follow the rules from TS 18661-3: prefer
940 interchange types _FloatN, then standard types long double,
941 double, float, then extended types _FloatNx. For extended types,
942 check them starting with _Float128x as that seems most consistent
943 in spirit with preferring long double to double; for interchange
944 types, also check in that order for consistency although it's not
945 possible for more than one of them to have the same
946 precision. */
947 tree mv1 = TYPE_MAIN_VARIANT (t1);
948 tree mv2 = TYPE_MAIN_VARIANT (t2);
949
950 for (int i = NUM_FLOATN_TYPES - 1; i >= 0; i--)
951 if (mv1 == FLOATN_TYPE_NODE (i) || mv2 == FLOATN_TYPE_NODE (i))
952 return FLOATN_TYPE_NODE (i);
953
954 /* Likewise, prefer long double to double even if same size. */
955 if (mv1 == long_double_type_node || mv2 == long_double_type_node)
956 return long_double_type_node;
957
958 /* Likewise, prefer double to float even if same size.
959 We got a couple of embedded targets with 32 bit doubles, and the
960 pdp11 might have 64 bit floats. */
961 if (mv1 == double_type_node || mv2 == double_type_node)
962 return double_type_node;
963
964 if (mv1 == float_type_node || mv2 == float_type_node)
965 return float_type_node;
966
967 for (int i = NUM_FLOATNX_TYPES - 1; i >= 0; i--)
968 if (mv1 == FLOATNX_TYPE_NODE (i) || mv2 == FLOATNX_TYPE_NODE (i))
969 return FLOATNX_TYPE_NODE (i);
970
971 /* Otherwise prefer the unsigned one. */
972
973 if (TYPE_UNSIGNED (t1))
974 return t1;
975 else
976 return t2;
977 }
978
979 /* Wrapper around c_common_type that is used by c-common.c and other
980 front end optimizations that remove promotions. ENUMERAL_TYPEs
981 are allowed here and are converted to their compatible integer types.
982 BOOLEAN_TYPEs are allowed here and return either boolean_type_node or
983 preferably a non-Boolean type as the common type. */
984 tree
common_type(tree t1,tree t2)985 common_type (tree t1, tree t2)
986 {
987 if (TREE_CODE (t1) == ENUMERAL_TYPE)
988 t1 = c_common_type_for_size (TYPE_PRECISION (t1), 1);
989 if (TREE_CODE (t2) == ENUMERAL_TYPE)
990 t2 = c_common_type_for_size (TYPE_PRECISION (t2), 1);
991
992 /* If both types are BOOLEAN_TYPE, then return boolean_type_node. */
993 if (TREE_CODE (t1) == BOOLEAN_TYPE
994 && TREE_CODE (t2) == BOOLEAN_TYPE)
995 return boolean_type_node;
996
997 /* If either type is BOOLEAN_TYPE, then return the other. */
998 if (TREE_CODE (t1) == BOOLEAN_TYPE)
999 return t2;
1000 if (TREE_CODE (t2) == BOOLEAN_TYPE)
1001 return t1;
1002
1003 return c_common_type (t1, t2);
1004 }
1005
1006 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
1007 or various other operations. Return 2 if they are compatible
1008 but a warning may be needed if you use them together. */
1009
1010 int
comptypes(tree type1,tree type2)1011 comptypes (tree type1, tree type2)
1012 {
1013 const struct tagged_tu_seen_cache * tagged_tu_seen_base1 = tagged_tu_seen_base;
1014 int val;
1015
1016 val = comptypes_internal (type1, type2, NULL, NULL);
1017 free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1);
1018
1019 return val;
1020 }
1021
1022 /* Like comptypes, but if it returns non-zero because enum and int are
1023 compatible, it sets *ENUM_AND_INT_P to true. */
1024
1025 static int
comptypes_check_enum_int(tree type1,tree type2,bool * enum_and_int_p)1026 comptypes_check_enum_int (tree type1, tree type2, bool *enum_and_int_p)
1027 {
1028 const struct tagged_tu_seen_cache * tagged_tu_seen_base1 = tagged_tu_seen_base;
1029 int val;
1030
1031 val = comptypes_internal (type1, type2, enum_and_int_p, NULL);
1032 free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1);
1033
1034 return val;
1035 }
1036
1037 /* Like comptypes, but if it returns nonzero for different types, it
1038 sets *DIFFERENT_TYPES_P to true. */
1039
1040 int
comptypes_check_different_types(tree type1,tree type2,bool * different_types_p)1041 comptypes_check_different_types (tree type1, tree type2,
1042 bool *different_types_p)
1043 {
1044 const struct tagged_tu_seen_cache * tagged_tu_seen_base1 = tagged_tu_seen_base;
1045 int val;
1046
1047 val = comptypes_internal (type1, type2, NULL, different_types_p);
1048 free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1);
1049
1050 return val;
1051 }
1052
1053 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
1054 or various other operations. Return 2 if they are compatible
1055 but a warning may be needed if you use them together. If
1056 ENUM_AND_INT_P is not NULL, and one type is an enum and the other a
1057 compatible integer type, then this sets *ENUM_AND_INT_P to true;
1058 *ENUM_AND_INT_P is never set to false. If DIFFERENT_TYPES_P is not
1059 NULL, and the types are compatible but different enough not to be
1060 permitted in C11 typedef redeclarations, then this sets
1061 *DIFFERENT_TYPES_P to true; *DIFFERENT_TYPES_P is never set to
1062 false, but may or may not be set if the types are incompatible.
1063 This differs from comptypes, in that we don't free the seen
1064 types. */
1065
1066 static int
comptypes_internal(const_tree type1,const_tree type2,bool * enum_and_int_p,bool * different_types_p)1067 comptypes_internal (const_tree type1, const_tree type2, bool *enum_and_int_p,
1068 bool *different_types_p)
1069 {
1070 const_tree t1 = type1;
1071 const_tree t2 = type2;
1072 int attrval, val;
1073
1074 /* Suppress errors caused by previously reported errors. */
1075
1076 if (t1 == t2 || !t1 || !t2
1077 || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK)
1078 return 1;
1079
1080 /* Enumerated types are compatible with integer types, but this is
1081 not transitive: two enumerated types in the same translation unit
1082 are compatible with each other only if they are the same type. */
1083
1084 if (TREE_CODE (t1) == ENUMERAL_TYPE && TREE_CODE (t2) != ENUMERAL_TYPE)
1085 {
1086 t1 = c_common_type_for_size (TYPE_PRECISION (t1), TYPE_UNSIGNED (t1));
1087 if (TREE_CODE (t2) != VOID_TYPE)
1088 {
1089 if (enum_and_int_p != NULL)
1090 *enum_and_int_p = true;
1091 if (different_types_p != NULL)
1092 *different_types_p = true;
1093 }
1094 }
1095 else if (TREE_CODE (t2) == ENUMERAL_TYPE && TREE_CODE (t1) != ENUMERAL_TYPE)
1096 {
1097 t2 = c_common_type_for_size (TYPE_PRECISION (t2), TYPE_UNSIGNED (t2));
1098 if (TREE_CODE (t1) != VOID_TYPE)
1099 {
1100 if (enum_and_int_p != NULL)
1101 *enum_and_int_p = true;
1102 if (different_types_p != NULL)
1103 *different_types_p = true;
1104 }
1105 }
1106
1107 if (t1 == t2)
1108 return 1;
1109
1110 /* Different classes of types can't be compatible. */
1111
1112 if (TREE_CODE (t1) != TREE_CODE (t2))
1113 return 0;
1114
1115 /* Qualifiers must match. C99 6.7.3p9 */
1116
1117 if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
1118 return 0;
1119
1120 /* Allow for two different type nodes which have essentially the same
1121 definition. Note that we already checked for equality of the type
1122 qualifiers (just above). */
1123
1124 if (TREE_CODE (t1) != ARRAY_TYPE
1125 && TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
1126 return 1;
1127
1128 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1129 if (!(attrval = comp_type_attributes (t1, t2)))
1130 return 0;
1131
1132 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1133 val = 0;
1134
1135 switch (TREE_CODE (t1))
1136 {
1137 case INTEGER_TYPE:
1138 case FIXED_POINT_TYPE:
1139 case REAL_TYPE:
1140 /* With these nodes, we can't determine type equivalence by
1141 looking at what is stored in the nodes themselves, because
1142 two nodes might have different TYPE_MAIN_VARIANTs but still
1143 represent the same type. For example, wchar_t and int could
1144 have the same properties (TYPE_PRECISION, TYPE_MIN_VALUE,
1145 TYPE_MAX_VALUE, etc.), but have different TYPE_MAIN_VARIANTs
1146 and are distinct types. On the other hand, int and the
1147 following typedef
1148
1149 typedef int INT __attribute((may_alias));
1150
1151 have identical properties, different TYPE_MAIN_VARIANTs, but
1152 represent the same type. The canonical type system keeps
1153 track of equivalence in this case, so we fall back on it. */
1154 return TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2);
1155
1156 case POINTER_TYPE:
1157 /* Do not remove mode information. */
1158 if (TYPE_MODE (t1) != TYPE_MODE (t2))
1159 break;
1160 val = (TREE_TYPE (t1) == TREE_TYPE (t2)
1161 ? 1 : comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2),
1162 enum_and_int_p, different_types_p));
1163 break;
1164
1165 case FUNCTION_TYPE:
1166 val = function_types_compatible_p (t1, t2, enum_and_int_p,
1167 different_types_p);
1168 break;
1169
1170 case ARRAY_TYPE:
1171 {
1172 tree d1 = TYPE_DOMAIN (t1);
1173 tree d2 = TYPE_DOMAIN (t2);
1174 bool d1_variable, d2_variable;
1175 bool d1_zero, d2_zero;
1176 val = 1;
1177
1178 /* Target types must match incl. qualifiers. */
1179 if (TREE_TYPE (t1) != TREE_TYPE (t2)
1180 && (val = comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2),
1181 enum_and_int_p,
1182 different_types_p)) == 0)
1183 return 0;
1184
1185 if (different_types_p != NULL
1186 && (d1 == NULL_TREE) != (d2 == NULL_TREE))
1187 *different_types_p = true;
1188 /* Sizes must match unless one is missing or variable. */
1189 if (d1 == NULL_TREE || d2 == NULL_TREE || d1 == d2)
1190 break;
1191
1192 d1_zero = !TYPE_MAX_VALUE (d1);
1193 d2_zero = !TYPE_MAX_VALUE (d2);
1194
1195 d1_variable = (!d1_zero
1196 && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
1197 || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
1198 d2_variable = (!d2_zero
1199 && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
1200 || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
1201 d1_variable = d1_variable || (d1_zero && c_vla_type_p (t1));
1202 d2_variable = d2_variable || (d2_zero && c_vla_type_p (t2));
1203
1204 if (different_types_p != NULL
1205 && d1_variable != d2_variable)
1206 *different_types_p = true;
1207 if (d1_variable || d2_variable)
1208 break;
1209 if (d1_zero && d2_zero)
1210 break;
1211 if (d1_zero || d2_zero
1212 || !tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2))
1213 || !tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2)))
1214 val = 0;
1215
1216 break;
1217 }
1218
1219 case ENUMERAL_TYPE:
1220 case RECORD_TYPE:
1221 case UNION_TYPE:
1222 if (val != 1 && !same_translation_unit_p (t1, t2))
1223 {
1224 tree a1 = TYPE_ATTRIBUTES (t1);
1225 tree a2 = TYPE_ATTRIBUTES (t2);
1226
1227 if (! attribute_list_contained (a1, a2)
1228 && ! attribute_list_contained (a2, a1))
1229 break;
1230
1231 if (attrval != 2)
1232 return tagged_types_tu_compatible_p (t1, t2, enum_and_int_p,
1233 different_types_p);
1234 val = tagged_types_tu_compatible_p (t1, t2, enum_and_int_p,
1235 different_types_p);
1236 }
1237 break;
1238
1239 case VECTOR_TYPE:
1240 val = (known_eq (TYPE_VECTOR_SUBPARTS (t1), TYPE_VECTOR_SUBPARTS (t2))
1241 && comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2),
1242 enum_and_int_p, different_types_p));
1243 break;
1244
1245 default:
1246 break;
1247 }
1248 return attrval == 2 && val == 1 ? 2 : val;
1249 }
1250
1251 /* Return 1 if TTL and TTR are pointers to types that are equivalent, ignoring
1252 their qualifiers, except for named address spaces. If the pointers point to
1253 different named addresses, then we must determine if one address space is a
1254 subset of the other. */
1255
1256 static int
comp_target_types(location_t location,tree ttl,tree ttr)1257 comp_target_types (location_t location, tree ttl, tree ttr)
1258 {
1259 int val;
1260 int val_ped;
1261 tree mvl = TREE_TYPE (ttl);
1262 tree mvr = TREE_TYPE (ttr);
1263 addr_space_t asl = TYPE_ADDR_SPACE (mvl);
1264 addr_space_t asr = TYPE_ADDR_SPACE (mvr);
1265 addr_space_t as_common;
1266 bool enum_and_int_p;
1267
1268 /* Fail if pointers point to incompatible address spaces. */
1269 if (!addr_space_superset (asl, asr, &as_common))
1270 return 0;
1271
1272 /* For pedantic record result of comptypes on arrays before losing
1273 qualifiers on the element type below. */
1274 val_ped = 1;
1275
1276 if (TREE_CODE (mvl) == ARRAY_TYPE
1277 && TREE_CODE (mvr) == ARRAY_TYPE)
1278 val_ped = comptypes (mvl, mvr);
1279
1280 /* Qualifiers on element types of array types that are
1281 pointer targets are lost by taking their TYPE_MAIN_VARIANT. */
1282
1283 mvl = (TYPE_ATOMIC (strip_array_types (mvl))
1284 ? c_build_qualified_type (TYPE_MAIN_VARIANT (mvl), TYPE_QUAL_ATOMIC)
1285 : TYPE_MAIN_VARIANT (mvl));
1286
1287 mvr = (TYPE_ATOMIC (strip_array_types (mvr))
1288 ? c_build_qualified_type (TYPE_MAIN_VARIANT (mvr), TYPE_QUAL_ATOMIC)
1289 : TYPE_MAIN_VARIANT (mvr));
1290
1291 enum_and_int_p = false;
1292 val = comptypes_check_enum_int (mvl, mvr, &enum_and_int_p);
1293
1294 if (val == 1 && val_ped != 1)
1295 pedwarn (location, OPT_Wpedantic, "pointers to arrays with different qualifiers "
1296 "are incompatible in ISO C");
1297
1298 if (val == 2)
1299 pedwarn (location, OPT_Wpedantic, "types are not quite compatible");
1300
1301 if (val == 1 && enum_and_int_p && warn_cxx_compat)
1302 warning_at (location, OPT_Wc___compat,
1303 "pointer target types incompatible in C++");
1304
1305 return val;
1306 }
1307
1308 /* Subroutines of `comptypes'. */
1309
1310 /* Determine whether two trees derive from the same translation unit.
1311 If the CONTEXT chain ends in a null, that tree's context is still
1312 being parsed, so if two trees have context chains ending in null,
1313 they're in the same translation unit. */
1314
1315 bool
same_translation_unit_p(const_tree t1,const_tree t2)1316 same_translation_unit_p (const_tree t1, const_tree t2)
1317 {
1318 while (t1 && TREE_CODE (t1) != TRANSLATION_UNIT_DECL)
1319 switch (TREE_CODE_CLASS (TREE_CODE (t1)))
1320 {
1321 case tcc_declaration:
1322 t1 = DECL_CONTEXT (t1); break;
1323 case tcc_type:
1324 t1 = TYPE_CONTEXT (t1); break;
1325 case tcc_exceptional:
1326 t1 = BLOCK_SUPERCONTEXT (t1); break; /* assume block */
1327 default: gcc_unreachable ();
1328 }
1329
1330 while (t2 && TREE_CODE (t2) != TRANSLATION_UNIT_DECL)
1331 switch (TREE_CODE_CLASS (TREE_CODE (t2)))
1332 {
1333 case tcc_declaration:
1334 t2 = DECL_CONTEXT (t2); break;
1335 case tcc_type:
1336 t2 = TYPE_CONTEXT (t2); break;
1337 case tcc_exceptional:
1338 t2 = BLOCK_SUPERCONTEXT (t2); break; /* assume block */
1339 default: gcc_unreachable ();
1340 }
1341
1342 return t1 == t2;
1343 }
1344
1345 /* Allocate the seen two types, assuming that they are compatible. */
1346
1347 static struct tagged_tu_seen_cache *
alloc_tagged_tu_seen_cache(const_tree t1,const_tree t2)1348 alloc_tagged_tu_seen_cache (const_tree t1, const_tree t2)
1349 {
1350 struct tagged_tu_seen_cache *tu = XNEW (struct tagged_tu_seen_cache);
1351 tu->next = tagged_tu_seen_base;
1352 tu->t1 = t1;
1353 tu->t2 = t2;
1354
1355 tagged_tu_seen_base = tu;
1356
1357 /* The C standard says that two structures in different translation
1358 units are compatible with each other only if the types of their
1359 fields are compatible (among other things). We assume that they
1360 are compatible until proven otherwise when building the cache.
1361 An example where this can occur is:
1362 struct a
1363 {
1364 struct a *next;
1365 };
1366 If we are comparing this against a similar struct in another TU,
1367 and did not assume they were compatible, we end up with an infinite
1368 loop. */
1369 tu->val = 1;
1370 return tu;
1371 }
1372
1373 /* Free the seen types until we get to TU_TIL. */
1374
1375 static void
free_all_tagged_tu_seen_up_to(const struct tagged_tu_seen_cache * tu_til)1376 free_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache *tu_til)
1377 {
1378 const struct tagged_tu_seen_cache *tu = tagged_tu_seen_base;
1379 while (tu != tu_til)
1380 {
1381 const struct tagged_tu_seen_cache *const tu1
1382 = (const struct tagged_tu_seen_cache *) tu;
1383 tu = tu1->next;
1384 free (CONST_CAST (struct tagged_tu_seen_cache *, tu1));
1385 }
1386 tagged_tu_seen_base = tu_til;
1387 }
1388
1389 /* Return 1 if two 'struct', 'union', or 'enum' types T1 and T2 are
1390 compatible. If the two types are not the same (which has been
1391 checked earlier), this can only happen when multiple translation
1392 units are being compiled. See C99 6.2.7 paragraph 1 for the exact
1393 rules. ENUM_AND_INT_P and DIFFERENT_TYPES_P are as in
1394 comptypes_internal. */
1395
1396 static int
tagged_types_tu_compatible_p(const_tree t1,const_tree t2,bool * enum_and_int_p,bool * different_types_p)1397 tagged_types_tu_compatible_p (const_tree t1, const_tree t2,
1398 bool *enum_and_int_p, bool *different_types_p)
1399 {
1400 tree s1, s2;
1401 bool needs_warning = false;
1402
1403 /* We have to verify that the tags of the types are the same. This
1404 is harder than it looks because this may be a typedef, so we have
1405 to go look at the original type. It may even be a typedef of a
1406 typedef...
1407 In the case of compiler-created builtin structs the TYPE_DECL
1408 may be a dummy, with no DECL_ORIGINAL_TYPE. Don't fault. */
1409 while (TYPE_NAME (t1)
1410 && TREE_CODE (TYPE_NAME (t1)) == TYPE_DECL
1411 && DECL_ORIGINAL_TYPE (TYPE_NAME (t1)))
1412 t1 = DECL_ORIGINAL_TYPE (TYPE_NAME (t1));
1413
1414 while (TYPE_NAME (t2)
1415 && TREE_CODE (TYPE_NAME (t2)) == TYPE_DECL
1416 && DECL_ORIGINAL_TYPE (TYPE_NAME (t2)))
1417 t2 = DECL_ORIGINAL_TYPE (TYPE_NAME (t2));
1418
1419 /* C90 didn't have the requirement that the two tags be the same. */
1420 if (flag_isoc99 && TYPE_NAME (t1) != TYPE_NAME (t2))
1421 return 0;
1422
1423 /* C90 didn't say what happened if one or both of the types were
1424 incomplete; we choose to follow C99 rules here, which is that they
1425 are compatible. */
1426 if (TYPE_SIZE (t1) == NULL
1427 || TYPE_SIZE (t2) == NULL)
1428 return 1;
1429
1430 {
1431 const struct tagged_tu_seen_cache * tts_i;
1432 for (tts_i = tagged_tu_seen_base; tts_i != NULL; tts_i = tts_i->next)
1433 if (tts_i->t1 == t1 && tts_i->t2 == t2)
1434 return tts_i->val;
1435 }
1436
1437 switch (TREE_CODE (t1))
1438 {
1439 case ENUMERAL_TYPE:
1440 {
1441 struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2);
1442 /* Speed up the case where the type values are in the same order. */
1443 tree tv1 = TYPE_VALUES (t1);
1444 tree tv2 = TYPE_VALUES (t2);
1445
1446 if (tv1 == tv2)
1447 {
1448 return 1;
1449 }
1450
1451 for (;tv1 && tv2; tv1 = TREE_CHAIN (tv1), tv2 = TREE_CHAIN (tv2))
1452 {
1453 if (TREE_PURPOSE (tv1) != TREE_PURPOSE (tv2))
1454 break;
1455 if (simple_cst_equal (TREE_VALUE (tv1), TREE_VALUE (tv2)) != 1)
1456 {
1457 tu->val = 0;
1458 return 0;
1459 }
1460 }
1461
1462 if (tv1 == NULL_TREE && tv2 == NULL_TREE)
1463 {
1464 return 1;
1465 }
1466 if (tv1 == NULL_TREE || tv2 == NULL_TREE)
1467 {
1468 tu->val = 0;
1469 return 0;
1470 }
1471
1472 if (list_length (TYPE_VALUES (t1)) != list_length (TYPE_VALUES (t2)))
1473 {
1474 tu->val = 0;
1475 return 0;
1476 }
1477
1478 for (s1 = TYPE_VALUES (t1); s1; s1 = TREE_CHAIN (s1))
1479 {
1480 s2 = purpose_member (TREE_PURPOSE (s1), TYPE_VALUES (t2));
1481 if (s2 == NULL
1482 || simple_cst_equal (TREE_VALUE (s1), TREE_VALUE (s2)) != 1)
1483 {
1484 tu->val = 0;
1485 return 0;
1486 }
1487 }
1488 return 1;
1489 }
1490
1491 case UNION_TYPE:
1492 {
1493 struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2);
1494 if (list_length (TYPE_FIELDS (t1)) != list_length (TYPE_FIELDS (t2)))
1495 {
1496 tu->val = 0;
1497 return 0;
1498 }
1499
1500 /* Speed up the common case where the fields are in the same order. */
1501 for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2); s1 && s2;
1502 s1 = DECL_CHAIN (s1), s2 = DECL_CHAIN (s2))
1503 {
1504 int result;
1505
1506 if (DECL_NAME (s1) != DECL_NAME (s2))
1507 break;
1508 result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2),
1509 enum_and_int_p, different_types_p);
1510
1511 if (result != 1 && !DECL_NAME (s1))
1512 break;
1513 if (result == 0)
1514 {
1515 tu->val = 0;
1516 return 0;
1517 }
1518 if (result == 2)
1519 needs_warning = true;
1520
1521 if (TREE_CODE (s1) == FIELD_DECL
1522 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
1523 DECL_FIELD_BIT_OFFSET (s2)) != 1)
1524 {
1525 tu->val = 0;
1526 return 0;
1527 }
1528 }
1529 if (!s1 && !s2)
1530 {
1531 tu->val = needs_warning ? 2 : 1;
1532 return tu->val;
1533 }
1534
1535 for (s1 = TYPE_FIELDS (t1); s1; s1 = DECL_CHAIN (s1))
1536 {
1537 bool ok = false;
1538
1539 for (s2 = TYPE_FIELDS (t2); s2; s2 = DECL_CHAIN (s2))
1540 if (DECL_NAME (s1) == DECL_NAME (s2))
1541 {
1542 int result;
1543
1544 result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2),
1545 enum_and_int_p,
1546 different_types_p);
1547
1548 if (result != 1 && !DECL_NAME (s1))
1549 continue;
1550 if (result == 0)
1551 {
1552 tu->val = 0;
1553 return 0;
1554 }
1555 if (result == 2)
1556 needs_warning = true;
1557
1558 if (TREE_CODE (s1) == FIELD_DECL
1559 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
1560 DECL_FIELD_BIT_OFFSET (s2)) != 1)
1561 break;
1562
1563 ok = true;
1564 break;
1565 }
1566 if (!ok)
1567 {
1568 tu->val = 0;
1569 return 0;
1570 }
1571 }
1572 tu->val = needs_warning ? 2 : 10;
1573 return tu->val;
1574 }
1575
1576 case RECORD_TYPE:
1577 {
1578 struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2);
1579
1580 for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2);
1581 s1 && s2;
1582 s1 = DECL_CHAIN (s1), s2 = DECL_CHAIN (s2))
1583 {
1584 int result;
1585 if (TREE_CODE (s1) != TREE_CODE (s2)
1586 || DECL_NAME (s1) != DECL_NAME (s2))
1587 break;
1588 result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2),
1589 enum_and_int_p, different_types_p);
1590 if (result == 0)
1591 break;
1592 if (result == 2)
1593 needs_warning = true;
1594
1595 if (TREE_CODE (s1) == FIELD_DECL
1596 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
1597 DECL_FIELD_BIT_OFFSET (s2)) != 1)
1598 break;
1599 }
1600 if (s1 && s2)
1601 tu->val = 0;
1602 else
1603 tu->val = needs_warning ? 2 : 1;
1604 return tu->val;
1605 }
1606
1607 default:
1608 gcc_unreachable ();
1609 }
1610 }
1611
1612 /* Return 1 if two function types F1 and F2 are compatible.
1613 If either type specifies no argument types,
1614 the other must specify a fixed number of self-promoting arg types.
1615 Otherwise, if one type specifies only the number of arguments,
1616 the other must specify that number of self-promoting arg types.
1617 Otherwise, the argument types must match.
1618 ENUM_AND_INT_P and DIFFERENT_TYPES_P are as in comptypes_internal. */
1619
1620 static int
function_types_compatible_p(const_tree f1,const_tree f2,bool * enum_and_int_p,bool * different_types_p)1621 function_types_compatible_p (const_tree f1, const_tree f2,
1622 bool *enum_and_int_p, bool *different_types_p)
1623 {
1624 tree args1, args2;
1625 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1626 int val = 1;
1627 int val1;
1628 tree ret1, ret2;
1629
1630 ret1 = TREE_TYPE (f1);
1631 ret2 = TREE_TYPE (f2);
1632
1633 /* 'volatile' qualifiers on a function's return type used to mean
1634 the function is noreturn. */
1635 if (TYPE_VOLATILE (ret1) != TYPE_VOLATILE (ret2))
1636 pedwarn (input_location, 0, "function return types not compatible due to %<volatile%>");
1637 if (TYPE_VOLATILE (ret1))
1638 ret1 = build_qualified_type (TYPE_MAIN_VARIANT (ret1),
1639 TYPE_QUALS (ret1) & ~TYPE_QUAL_VOLATILE);
1640 if (TYPE_VOLATILE (ret2))
1641 ret2 = build_qualified_type (TYPE_MAIN_VARIANT (ret2),
1642 TYPE_QUALS (ret2) & ~TYPE_QUAL_VOLATILE);
1643 val = comptypes_internal (ret1, ret2, enum_and_int_p, different_types_p);
1644 if (val == 0)
1645 return 0;
1646
1647 args1 = TYPE_ARG_TYPES (f1);
1648 args2 = TYPE_ARG_TYPES (f2);
1649
1650 if (different_types_p != NULL
1651 && (args1 == NULL_TREE) != (args2 == NULL_TREE))
1652 *different_types_p = true;
1653
1654 /* An unspecified parmlist matches any specified parmlist
1655 whose argument types don't need default promotions. */
1656
1657 if (args1 == NULL_TREE)
1658 {
1659 if (!self_promoting_args_p (args2))
1660 return 0;
1661 /* If one of these types comes from a non-prototype fn definition,
1662 compare that with the other type's arglist.
1663 If they don't match, ask for a warning (but no error). */
1664 if (TYPE_ACTUAL_ARG_TYPES (f1)
1665 && type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1),
1666 enum_and_int_p, different_types_p) != 1)
1667 val = 2;
1668 return val;
1669 }
1670 if (args2 == NULL_TREE)
1671 {
1672 if (!self_promoting_args_p (args1))
1673 return 0;
1674 if (TYPE_ACTUAL_ARG_TYPES (f2)
1675 && type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2),
1676 enum_and_int_p, different_types_p) != 1)
1677 val = 2;
1678 return val;
1679 }
1680
1681 /* Both types have argument lists: compare them and propagate results. */
1682 val1 = type_lists_compatible_p (args1, args2, enum_and_int_p,
1683 different_types_p);
1684 return val1 != 1 ? val1 : val;
1685 }
1686
1687 /* Check two lists of types for compatibility, returning 0 for
1688 incompatible, 1 for compatible, or 2 for compatible with
1689 warning. ENUM_AND_INT_P and DIFFERENT_TYPES_P are as in
1690 comptypes_internal. */
1691
1692 static int
type_lists_compatible_p(const_tree args1,const_tree args2,bool * enum_and_int_p,bool * different_types_p)1693 type_lists_compatible_p (const_tree args1, const_tree args2,
1694 bool *enum_and_int_p, bool *different_types_p)
1695 {
1696 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1697 int val = 1;
1698 int newval = 0;
1699
1700 while (1)
1701 {
1702 tree a1, mv1, a2, mv2;
1703 if (args1 == NULL_TREE && args2 == NULL_TREE)
1704 return val;
1705 /* If one list is shorter than the other,
1706 they fail to match. */
1707 if (args1 == NULL_TREE || args2 == NULL_TREE)
1708 return 0;
1709 mv1 = a1 = TREE_VALUE (args1);
1710 mv2 = a2 = TREE_VALUE (args2);
1711 if (mv1 && mv1 != error_mark_node && TREE_CODE (mv1) != ARRAY_TYPE)
1712 mv1 = (TYPE_ATOMIC (mv1)
1713 ? c_build_qualified_type (TYPE_MAIN_VARIANT (mv1),
1714 TYPE_QUAL_ATOMIC)
1715 : TYPE_MAIN_VARIANT (mv1));
1716 if (mv2 && mv2 != error_mark_node && TREE_CODE (mv2) != ARRAY_TYPE)
1717 mv2 = (TYPE_ATOMIC (mv2)
1718 ? c_build_qualified_type (TYPE_MAIN_VARIANT (mv2),
1719 TYPE_QUAL_ATOMIC)
1720 : TYPE_MAIN_VARIANT (mv2));
1721 /* A null pointer instead of a type
1722 means there is supposed to be an argument
1723 but nothing is specified about what type it has.
1724 So match anything that self-promotes. */
1725 if (different_types_p != NULL
1726 && (a1 == NULL_TREE) != (a2 == NULL_TREE))
1727 *different_types_p = true;
1728 if (a1 == NULL_TREE)
1729 {
1730 if (c_type_promotes_to (a2) != a2)
1731 return 0;
1732 }
1733 else if (a2 == NULL_TREE)
1734 {
1735 if (c_type_promotes_to (a1) != a1)
1736 return 0;
1737 }
1738 /* If one of the lists has an error marker, ignore this arg. */
1739 else if (TREE_CODE (a1) == ERROR_MARK
1740 || TREE_CODE (a2) == ERROR_MARK)
1741 ;
1742 else if (!(newval = comptypes_internal (mv1, mv2, enum_and_int_p,
1743 different_types_p)))
1744 {
1745 if (different_types_p != NULL)
1746 *different_types_p = true;
1747 /* Allow wait (union {union wait *u; int *i} *)
1748 and wait (union wait *) to be compatible. */
1749 if (TREE_CODE (a1) == UNION_TYPE
1750 && (TYPE_NAME (a1) == NULL_TREE
1751 || TYPE_TRANSPARENT_AGGR (a1))
1752 && TREE_CODE (TYPE_SIZE (a1)) == INTEGER_CST
1753 && tree_int_cst_equal (TYPE_SIZE (a1),
1754 TYPE_SIZE (a2)))
1755 {
1756 tree memb;
1757 for (memb = TYPE_FIELDS (a1);
1758 memb; memb = DECL_CHAIN (memb))
1759 {
1760 tree mv3 = TREE_TYPE (memb);
1761 if (mv3 && mv3 != error_mark_node
1762 && TREE_CODE (mv3) != ARRAY_TYPE)
1763 mv3 = (TYPE_ATOMIC (mv3)
1764 ? c_build_qualified_type (TYPE_MAIN_VARIANT (mv3),
1765 TYPE_QUAL_ATOMIC)
1766 : TYPE_MAIN_VARIANT (mv3));
1767 if (comptypes_internal (mv3, mv2, enum_and_int_p,
1768 different_types_p))
1769 break;
1770 }
1771 if (memb == NULL_TREE)
1772 return 0;
1773 }
1774 else if (TREE_CODE (a2) == UNION_TYPE
1775 && (TYPE_NAME (a2) == NULL_TREE
1776 || TYPE_TRANSPARENT_AGGR (a2))
1777 && TREE_CODE (TYPE_SIZE (a2)) == INTEGER_CST
1778 && tree_int_cst_equal (TYPE_SIZE (a2),
1779 TYPE_SIZE (a1)))
1780 {
1781 tree memb;
1782 for (memb = TYPE_FIELDS (a2);
1783 memb; memb = DECL_CHAIN (memb))
1784 {
1785 tree mv3 = TREE_TYPE (memb);
1786 if (mv3 && mv3 != error_mark_node
1787 && TREE_CODE (mv3) != ARRAY_TYPE)
1788 mv3 = (TYPE_ATOMIC (mv3)
1789 ? c_build_qualified_type (TYPE_MAIN_VARIANT (mv3),
1790 TYPE_QUAL_ATOMIC)
1791 : TYPE_MAIN_VARIANT (mv3));
1792 if (comptypes_internal (mv3, mv1, enum_and_int_p,
1793 different_types_p))
1794 break;
1795 }
1796 if (memb == NULL_TREE)
1797 return 0;
1798 }
1799 else
1800 return 0;
1801 }
1802
1803 /* comptypes said ok, but record if it said to warn. */
1804 if (newval > val)
1805 val = newval;
1806
1807 args1 = TREE_CHAIN (args1);
1808 args2 = TREE_CHAIN (args2);
1809 }
1810 }
1811
1812 /* Compute the size to increment a pointer by. When a function type or void
1813 type or incomplete type is passed, size_one_node is returned.
1814 This function does not emit any diagnostics; the caller is responsible
1815 for that. */
1816
1817 static tree
c_size_in_bytes(const_tree type)1818 c_size_in_bytes (const_tree type)
1819 {
1820 enum tree_code code = TREE_CODE (type);
1821
1822 if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK
1823 || !COMPLETE_TYPE_P (type))
1824 return size_one_node;
1825
1826 /* Convert in case a char is more than one unit. */
1827 return size_binop_loc (input_location, CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
1828 size_int (TYPE_PRECISION (char_type_node)
1829 / BITS_PER_UNIT));
1830 }
1831
1832 /* Return either DECL or its known constant value (if it has one). */
1833
1834 tree
decl_constant_value_1(tree decl,bool in_init)1835 decl_constant_value_1 (tree decl, bool in_init)
1836 {
1837 if (/* Note that DECL_INITIAL isn't valid for a PARM_DECL. */
1838 TREE_CODE (decl) != PARM_DECL
1839 && !TREE_THIS_VOLATILE (decl)
1840 && TREE_READONLY (decl)
1841 && DECL_INITIAL (decl) != NULL_TREE
1842 && !error_operand_p (DECL_INITIAL (decl))
1843 /* This is invalid if initial value is not constant.
1844 If it has either a function call, a memory reference,
1845 or a variable, then re-evaluating it could give different results. */
1846 && TREE_CONSTANT (DECL_INITIAL (decl))
1847 /* Check for cases where this is sub-optimal, even though valid. */
1848 && (in_init || TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR))
1849 return DECL_INITIAL (decl);
1850 return decl;
1851 }
1852
1853 /* Return either DECL or its known constant value (if it has one).
1854 Like the above, but always return decl outside of functions. */
1855
1856 tree
decl_constant_value(tree decl)1857 decl_constant_value (tree decl)
1858 {
1859 /* Don't change a variable array bound or initial value to a constant
1860 in a place where a variable is invalid. */
1861 return current_function_decl ? decl_constant_value_1 (decl, false) : decl;
1862 }
1863
1864 /* Convert the array expression EXP to a pointer. */
1865 static tree
array_to_pointer_conversion(location_t loc,tree exp)1866 array_to_pointer_conversion (location_t loc, tree exp)
1867 {
1868 tree orig_exp = exp;
1869 tree type = TREE_TYPE (exp);
1870 tree adr;
1871 tree restype = TREE_TYPE (type);
1872 tree ptrtype;
1873
1874 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
1875
1876 STRIP_TYPE_NOPS (exp);
1877
1878 if (TREE_NO_WARNING (orig_exp))
1879 TREE_NO_WARNING (exp) = 1;
1880
1881 ptrtype = build_pointer_type (restype);
1882
1883 if (INDIRECT_REF_P (exp))
1884 return convert (ptrtype, TREE_OPERAND (exp, 0));
1885
1886 /* In C++ array compound literals are temporary objects unless they are
1887 const or appear in namespace scope, so they are destroyed too soon
1888 to use them for much of anything (c++/53220). */
1889 if (warn_cxx_compat && TREE_CODE (exp) == COMPOUND_LITERAL_EXPR)
1890 {
1891 tree decl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
1892 if (!TREE_READONLY (decl) && !TREE_STATIC (decl))
1893 warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat,
1894 "converting an array compound literal to a pointer "
1895 "is ill-formed in C++");
1896 }
1897
1898 adr = build_unary_op (loc, ADDR_EXPR, exp, true);
1899 return convert (ptrtype, adr);
1900 }
1901
1902 /* Convert the function expression EXP to a pointer. */
1903 static tree
function_to_pointer_conversion(location_t loc,tree exp)1904 function_to_pointer_conversion (location_t loc, tree exp)
1905 {
1906 tree orig_exp = exp;
1907
1908 gcc_assert (TREE_CODE (TREE_TYPE (exp)) == FUNCTION_TYPE);
1909
1910 STRIP_TYPE_NOPS (exp);
1911
1912 if (TREE_NO_WARNING (orig_exp))
1913 TREE_NO_WARNING (exp) = 1;
1914
1915 return build_unary_op (loc, ADDR_EXPR, exp, false);
1916 }
1917
1918 /* Mark EXP as read, not just set, for set but not used -Wunused
1919 warning purposes. */
1920
1921 void
mark_exp_read(tree exp)1922 mark_exp_read (tree exp)
1923 {
1924 switch (TREE_CODE (exp))
1925 {
1926 case VAR_DECL:
1927 case PARM_DECL:
1928 DECL_READ_P (exp) = 1;
1929 break;
1930 case ARRAY_REF:
1931 case COMPONENT_REF:
1932 case MODIFY_EXPR:
1933 case REALPART_EXPR:
1934 case IMAGPART_EXPR:
1935 CASE_CONVERT:
1936 case ADDR_EXPR:
1937 case VIEW_CONVERT_EXPR:
1938 mark_exp_read (TREE_OPERAND (exp, 0));
1939 break;
1940 case COMPOUND_EXPR:
1941 case C_MAYBE_CONST_EXPR:
1942 mark_exp_read (TREE_OPERAND (exp, 1));
1943 break;
1944 default:
1945 break;
1946 }
1947 }
1948
1949 /* Perform the default conversion of arrays and functions to pointers.
1950 Return the result of converting EXP. For any other expression, just
1951 return EXP.
1952
1953 LOC is the location of the expression. */
1954
1955 struct c_expr
default_function_array_conversion(location_t loc,struct c_expr exp)1956 default_function_array_conversion (location_t loc, struct c_expr exp)
1957 {
1958 tree orig_exp = exp.value;
1959 tree type = TREE_TYPE (exp.value);
1960 enum tree_code code = TREE_CODE (type);
1961
1962 switch (code)
1963 {
1964 case ARRAY_TYPE:
1965 {
1966 bool not_lvalue = false;
1967 bool lvalue_array_p;
1968
1969 while ((TREE_CODE (exp.value) == NON_LVALUE_EXPR
1970 || CONVERT_EXPR_P (exp.value))
1971 && TREE_TYPE (TREE_OPERAND (exp.value, 0)) == type)
1972 {
1973 if (TREE_CODE (exp.value) == NON_LVALUE_EXPR)
1974 not_lvalue = true;
1975 exp.value = TREE_OPERAND (exp.value, 0);
1976 }
1977
1978 if (TREE_NO_WARNING (orig_exp))
1979 TREE_NO_WARNING (exp.value) = 1;
1980
1981 lvalue_array_p = !not_lvalue && lvalue_p (exp.value);
1982 if (!flag_isoc99 && !lvalue_array_p)
1983 {
1984 /* Before C99, non-lvalue arrays do not decay to pointers.
1985 Normally, using such an array would be invalid; but it can
1986 be used correctly inside sizeof or as a statement expression.
1987 Thus, do not give an error here; an error will result later. */
1988 return exp;
1989 }
1990
1991 exp.value = array_to_pointer_conversion (loc, exp.value);
1992 }
1993 break;
1994 case FUNCTION_TYPE:
1995 exp.value = function_to_pointer_conversion (loc, exp.value);
1996 break;
1997 default:
1998 break;
1999 }
2000
2001 return exp;
2002 }
2003
2004 struct c_expr
default_function_array_read_conversion(location_t loc,struct c_expr exp)2005 default_function_array_read_conversion (location_t loc, struct c_expr exp)
2006 {
2007 mark_exp_read (exp.value);
2008 return default_function_array_conversion (loc, exp);
2009 }
2010
2011 /* Return whether EXPR should be treated as an atomic lvalue for the
2012 purposes of load and store handling. */
2013
2014 static bool
really_atomic_lvalue(tree expr)2015 really_atomic_lvalue (tree expr)
2016 {
2017 if (error_operand_p (expr))
2018 return false;
2019 if (!TYPE_ATOMIC (TREE_TYPE (expr)))
2020 return false;
2021 if (!lvalue_p (expr))
2022 return false;
2023
2024 /* Ignore _Atomic on register variables, since their addresses can't
2025 be taken so (a) atomicity is irrelevant and (b) the normal atomic
2026 sequences wouldn't work. Ignore _Atomic on structures containing
2027 bit-fields, since accessing elements of atomic structures or
2028 unions is undefined behavior (C11 6.5.2.3#5), but it's unclear if
2029 it's undefined at translation time or execution time, and the
2030 normal atomic sequences again wouldn't work. */
2031 while (handled_component_p (expr))
2032 {
2033 if (TREE_CODE (expr) == COMPONENT_REF
2034 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2035 return false;
2036 expr = TREE_OPERAND (expr, 0);
2037 }
2038 if (DECL_P (expr) && C_DECL_REGISTER (expr))
2039 return false;
2040 return true;
2041 }
2042
2043 /* Convert expression EXP (location LOC) from lvalue to rvalue,
2044 including converting functions and arrays to pointers if CONVERT_P.
2045 If READ_P, also mark the expression as having been read. */
2046
2047 struct c_expr
convert_lvalue_to_rvalue(location_t loc,struct c_expr exp,bool convert_p,bool read_p)2048 convert_lvalue_to_rvalue (location_t loc, struct c_expr exp,
2049 bool convert_p, bool read_p)
2050 {
2051 if (read_p)
2052 mark_exp_read (exp.value);
2053 if (convert_p)
2054 exp = default_function_array_conversion (loc, exp);
2055 if (really_atomic_lvalue (exp.value))
2056 {
2057 vec<tree, va_gc> *params;
2058 tree nonatomic_type, tmp, tmp_addr, fndecl, func_call;
2059 tree expr_type = TREE_TYPE (exp.value);
2060 tree expr_addr = build_unary_op (loc, ADDR_EXPR, exp.value, false);
2061 tree seq_cst = build_int_cst (integer_type_node, MEMMODEL_SEQ_CST);
2062
2063 gcc_assert (TYPE_ATOMIC (expr_type));
2064
2065 /* Expansion of a generic atomic load may require an addition
2066 element, so allocate enough to prevent a resize. */
2067 vec_alloc (params, 4);
2068
2069 /* Remove the qualifiers for the rest of the expressions and
2070 create the VAL temp variable to hold the RHS. */
2071 nonatomic_type = build_qualified_type (expr_type, TYPE_UNQUALIFIED);
2072 tmp = create_tmp_var_raw (nonatomic_type);
2073 tmp_addr = build_unary_op (loc, ADDR_EXPR, tmp, false);
2074 TREE_ADDRESSABLE (tmp) = 1;
2075 TREE_NO_WARNING (tmp) = 1;
2076
2077 /* Issue __atomic_load (&expr, &tmp, SEQ_CST); */
2078 fndecl = builtin_decl_explicit (BUILT_IN_ATOMIC_LOAD);
2079 params->quick_push (expr_addr);
2080 params->quick_push (tmp_addr);
2081 params->quick_push (seq_cst);
2082 func_call = c_build_function_call_vec (loc, vNULL, fndecl, params, NULL);
2083
2084 /* EXPR is always read. */
2085 mark_exp_read (exp.value);
2086
2087 /* Return tmp which contains the value loaded. */
2088 exp.value = build4 (TARGET_EXPR, nonatomic_type, tmp, func_call,
2089 NULL_TREE, NULL_TREE);
2090 }
2091 return exp;
2092 }
2093
2094 /* EXP is an expression of integer type. Apply the integer promotions
2095 to it and return the promoted value. */
2096
2097 tree
perform_integral_promotions(tree exp)2098 perform_integral_promotions (tree exp)
2099 {
2100 tree type = TREE_TYPE (exp);
2101 enum tree_code code = TREE_CODE (type);
2102
2103 gcc_assert (INTEGRAL_TYPE_P (type));
2104
2105 /* Normally convert enums to int,
2106 but convert wide enums to something wider. */
2107 if (code == ENUMERAL_TYPE)
2108 {
2109 type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
2110 TYPE_PRECISION (integer_type_node)),
2111 ((TYPE_PRECISION (type)
2112 >= TYPE_PRECISION (integer_type_node))
2113 && TYPE_UNSIGNED (type)));
2114
2115 return convert (type, exp);
2116 }
2117
2118 /* ??? This should no longer be needed now bit-fields have their
2119 proper types. */
2120 if (TREE_CODE (exp) == COMPONENT_REF
2121 && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1))
2122 /* If it's thinner than an int, promote it like a
2123 c_promoting_integer_type_p, otherwise leave it alone. */
2124 && compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
2125 TYPE_PRECISION (integer_type_node)) < 0)
2126 return convert (integer_type_node, exp);
2127
2128 if (c_promoting_integer_type_p (type))
2129 {
2130 /* Preserve unsignedness if not really getting any wider. */
2131 if (TYPE_UNSIGNED (type)
2132 && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
2133 return convert (unsigned_type_node, exp);
2134
2135 return convert (integer_type_node, exp);
2136 }
2137
2138 return exp;
2139 }
2140
2141
2142 /* Perform default promotions for C data used in expressions.
2143 Enumeral types or short or char are converted to int.
2144 In addition, manifest constants symbols are replaced by their values. */
2145
2146 tree
default_conversion(tree exp)2147 default_conversion (tree exp)
2148 {
2149 tree orig_exp;
2150 tree type = TREE_TYPE (exp);
2151 enum tree_code code = TREE_CODE (type);
2152 tree promoted_type;
2153
2154 mark_exp_read (exp);
2155
2156 /* Functions and arrays have been converted during parsing. */
2157 gcc_assert (code != FUNCTION_TYPE);
2158 if (code == ARRAY_TYPE)
2159 return exp;
2160
2161 /* Constants can be used directly unless they're not loadable. */
2162 if (TREE_CODE (exp) == CONST_DECL)
2163 exp = DECL_INITIAL (exp);
2164
2165 /* Strip no-op conversions. */
2166 orig_exp = exp;
2167 STRIP_TYPE_NOPS (exp);
2168
2169 if (TREE_NO_WARNING (orig_exp))
2170 TREE_NO_WARNING (exp) = 1;
2171
2172 if (code == VOID_TYPE)
2173 {
2174 error_at (EXPR_LOC_OR_LOC (exp, input_location),
2175 "void value not ignored as it ought to be");
2176 return error_mark_node;
2177 }
2178
2179 exp = require_complete_type (EXPR_LOC_OR_LOC (exp, input_location), exp);
2180 if (exp == error_mark_node)
2181 return error_mark_node;
2182
2183 promoted_type = targetm.promoted_type (type);
2184 if (promoted_type)
2185 return convert (promoted_type, exp);
2186
2187 if (INTEGRAL_TYPE_P (type))
2188 return perform_integral_promotions (exp);
2189
2190 return exp;
2191 }
2192
2193 /* Look up COMPONENT in a structure or union TYPE.
2194
2195 If the component name is not found, returns NULL_TREE. Otherwise,
2196 the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL
2197 stepping down the chain to the component, which is in the last
2198 TREE_VALUE of the list. Normally the list is of length one, but if
2199 the component is embedded within (nested) anonymous structures or
2200 unions, the list steps down the chain to the component. */
2201
2202 static tree
lookup_field(tree type,tree component)2203 lookup_field (tree type, tree component)
2204 {
2205 tree field;
2206
2207 /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
2208 to the field elements. Use a binary search on this array to quickly
2209 find the element. Otherwise, do a linear search. TYPE_LANG_SPECIFIC
2210 will always be set for structures which have many elements. */
2211
2212 if (TYPE_LANG_SPECIFIC (type) && TYPE_LANG_SPECIFIC (type)->s)
2213 {
2214 int bot, top, half;
2215 tree *field_array = &TYPE_LANG_SPECIFIC (type)->s->elts[0];
2216
2217 field = TYPE_FIELDS (type);
2218 bot = 0;
2219 top = TYPE_LANG_SPECIFIC (type)->s->len;
2220 while (top - bot > 1)
2221 {
2222 half = (top - bot + 1) >> 1;
2223 field = field_array[bot+half];
2224
2225 if (DECL_NAME (field) == NULL_TREE)
2226 {
2227 /* Step through all anon unions in linear fashion. */
2228 while (DECL_NAME (field_array[bot]) == NULL_TREE)
2229 {
2230 field = field_array[bot++];
2231 if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (field)))
2232 {
2233 tree anon = lookup_field (TREE_TYPE (field), component);
2234
2235 if (anon)
2236 return tree_cons (NULL_TREE, field, anon);
2237
2238 /* The Plan 9 compiler permits referring
2239 directly to an anonymous struct/union field
2240 using a typedef name. */
2241 if (flag_plan9_extensions
2242 && TYPE_NAME (TREE_TYPE (field)) != NULL_TREE
2243 && (TREE_CODE (TYPE_NAME (TREE_TYPE (field)))
2244 == TYPE_DECL)
2245 && (DECL_NAME (TYPE_NAME (TREE_TYPE (field)))
2246 == component))
2247 break;
2248 }
2249 }
2250
2251 /* Entire record is only anon unions. */
2252 if (bot > top)
2253 return NULL_TREE;
2254
2255 /* Restart the binary search, with new lower bound. */
2256 continue;
2257 }
2258
2259 if (DECL_NAME (field) == component)
2260 break;
2261 if (DECL_NAME (field) < component)
2262 bot += half;
2263 else
2264 top = bot + half;
2265 }
2266
2267 if (DECL_NAME (field_array[bot]) == component)
2268 field = field_array[bot];
2269 else if (DECL_NAME (field) != component)
2270 return NULL_TREE;
2271 }
2272 else
2273 {
2274 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
2275 {
2276 if (DECL_NAME (field) == NULL_TREE
2277 && RECORD_OR_UNION_TYPE_P (TREE_TYPE (field)))
2278 {
2279 tree anon = lookup_field (TREE_TYPE (field), component);
2280
2281 if (anon)
2282 return tree_cons (NULL_TREE, field, anon);
2283
2284 /* The Plan 9 compiler permits referring directly to an
2285 anonymous struct/union field using a typedef
2286 name. */
2287 if (flag_plan9_extensions
2288 && TYPE_NAME (TREE_TYPE (field)) != NULL_TREE
2289 && TREE_CODE (TYPE_NAME (TREE_TYPE (field))) == TYPE_DECL
2290 && (DECL_NAME (TYPE_NAME (TREE_TYPE (field)))
2291 == component))
2292 break;
2293 }
2294
2295 if (DECL_NAME (field) == component)
2296 break;
2297 }
2298
2299 if (field == NULL_TREE)
2300 return NULL_TREE;
2301 }
2302
2303 return tree_cons (NULL_TREE, field, NULL_TREE);
2304 }
2305
2306 /* Recursively append candidate IDENTIFIER_NODEs to CANDIDATES. */
2307
2308 static void
lookup_field_fuzzy_find_candidates(tree type,tree component,vec<tree> * candidates)2309 lookup_field_fuzzy_find_candidates (tree type, tree component,
2310 vec<tree> *candidates)
2311 {
2312 tree field;
2313 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
2314 {
2315 if (DECL_NAME (field) == NULL_TREE
2316 && RECORD_OR_UNION_TYPE_P (TREE_TYPE (field)))
2317 lookup_field_fuzzy_find_candidates (TREE_TYPE (field), component,
2318 candidates);
2319
2320 if (DECL_NAME (field))
2321 candidates->safe_push (DECL_NAME (field));
2322 }
2323 }
2324
2325 /* Like "lookup_field", but find the closest matching IDENTIFIER_NODE,
2326 rather than returning a TREE_LIST for an exact match. */
2327
2328 static tree
lookup_field_fuzzy(tree type,tree component)2329 lookup_field_fuzzy (tree type, tree component)
2330 {
2331 gcc_assert (TREE_CODE (component) == IDENTIFIER_NODE);
2332
2333 /* First, gather a list of candidates. */
2334 auto_vec <tree> candidates;
2335
2336 lookup_field_fuzzy_find_candidates (type, component,
2337 &candidates);
2338
2339 return find_closest_identifier (component, &candidates);
2340 }
2341
2342 /* Support function for build_component_ref's error-handling.
2343
2344 Given DATUM_TYPE, and "DATUM.COMPONENT", where DATUM is *not* a
2345 struct or union, should we suggest "DATUM->COMPONENT" as a hint? */
2346
2347 static bool
should_suggest_deref_p(tree datum_type)2348 should_suggest_deref_p (tree datum_type)
2349 {
2350 /* We don't do it for Objective-C, since Objective-C 2.0 dot-syntax
2351 allows "." for ptrs; we could be handling a failed attempt
2352 to access a property. */
2353 if (c_dialect_objc ())
2354 return false;
2355
2356 /* Only suggest it for pointers... */
2357 if (TREE_CODE (datum_type) != POINTER_TYPE)
2358 return false;
2359
2360 /* ...to structs/unions. */
2361 tree underlying_type = TREE_TYPE (datum_type);
2362 enum tree_code code = TREE_CODE (underlying_type);
2363 if (code == RECORD_TYPE || code == UNION_TYPE)
2364 return true;
2365 else
2366 return false;
2367 }
2368
2369 /* Make an expression to refer to the COMPONENT field of structure or
2370 union value DATUM. COMPONENT is an IDENTIFIER_NODE. LOC is the
2371 location of the COMPONENT_REF. COMPONENT_LOC is the location
2372 of COMPONENT. */
2373
2374 tree
build_component_ref(location_t loc,tree datum,tree component,location_t component_loc)2375 build_component_ref (location_t loc, tree datum, tree component,
2376 location_t component_loc)
2377 {
2378 tree type = TREE_TYPE (datum);
2379 enum tree_code code = TREE_CODE (type);
2380 tree field = NULL;
2381 tree ref;
2382 bool datum_lvalue = lvalue_p (datum);
2383
2384 if (!objc_is_public (datum, component))
2385 return error_mark_node;
2386
2387 /* Detect Objective-C property syntax object.property. */
2388 if (c_dialect_objc ()
2389 && (ref = objc_maybe_build_component_ref (datum, component)))
2390 return ref;
2391
2392 /* See if there is a field or component with name COMPONENT. */
2393
2394 if (code == RECORD_TYPE || code == UNION_TYPE)
2395 {
2396 if (!COMPLETE_TYPE_P (type))
2397 {
2398 c_incomplete_type_error (loc, NULL_TREE, type);
2399 return error_mark_node;
2400 }
2401
2402 field = lookup_field (type, component);
2403
2404 if (!field)
2405 {
2406 tree guessed_id = lookup_field_fuzzy (type, component);
2407 if (guessed_id)
2408 {
2409 /* Attempt to provide a fixit replacement hint, if
2410 we have a valid range for the component. */
2411 location_t reported_loc
2412 = (component_loc != UNKNOWN_LOCATION) ? component_loc : loc;
2413 gcc_rich_location rich_loc (reported_loc);
2414 if (component_loc != UNKNOWN_LOCATION)
2415 rich_loc.add_fixit_misspelled_id (component_loc, guessed_id);
2416 error_at (&rich_loc,
2417 "%qT has no member named %qE; did you mean %qE?",
2418 type, component, guessed_id);
2419 }
2420 else
2421 error_at (loc, "%qT has no member named %qE", type, component);
2422 return error_mark_node;
2423 }
2424
2425 /* Accessing elements of atomic structures or unions is undefined
2426 behavior (C11 6.5.2.3#5). */
2427 if (TYPE_ATOMIC (type) && c_inhibit_evaluation_warnings == 0)
2428 {
2429 if (code == RECORD_TYPE)
2430 warning_at (loc, 0, "accessing a member %qE of an atomic "
2431 "structure %qE", component, datum);
2432 else
2433 warning_at (loc, 0, "accessing a member %qE of an atomic "
2434 "union %qE", component, datum);
2435 }
2436
2437 /* Chain the COMPONENT_REFs if necessary down to the FIELD.
2438 This might be better solved in future the way the C++ front
2439 end does it - by giving the anonymous entities each a
2440 separate name and type, and then have build_component_ref
2441 recursively call itself. We can't do that here. */
2442 do
2443 {
2444 tree subdatum = TREE_VALUE (field);
2445 int quals;
2446 tree subtype;
2447 bool use_datum_quals;
2448
2449 if (TREE_TYPE (subdatum) == error_mark_node)
2450 return error_mark_node;
2451
2452 /* If this is an rvalue, it does not have qualifiers in C
2453 standard terms and we must avoid propagating such
2454 qualifiers down to a non-lvalue array that is then
2455 converted to a pointer. */
2456 use_datum_quals = (datum_lvalue
2457 || TREE_CODE (TREE_TYPE (subdatum)) != ARRAY_TYPE);
2458
2459 quals = TYPE_QUALS (strip_array_types (TREE_TYPE (subdatum)));
2460 if (use_datum_quals)
2461 quals |= TYPE_QUALS (TREE_TYPE (datum));
2462 subtype = c_build_qualified_type (TREE_TYPE (subdatum), quals);
2463
2464 ref = build3 (COMPONENT_REF, subtype, datum, subdatum,
2465 NULL_TREE);
2466 SET_EXPR_LOCATION (ref, loc);
2467 if (TREE_READONLY (subdatum)
2468 || (use_datum_quals && TREE_READONLY (datum)))
2469 TREE_READONLY (ref) = 1;
2470 if (TREE_THIS_VOLATILE (subdatum)
2471 || (use_datum_quals && TREE_THIS_VOLATILE (datum)))
2472 TREE_THIS_VOLATILE (ref) = 1;
2473
2474 if (TREE_DEPRECATED (subdatum))
2475 warn_deprecated_use (subdatum, NULL_TREE);
2476
2477 datum = ref;
2478
2479 field = TREE_CHAIN (field);
2480 }
2481 while (field);
2482
2483 return ref;
2484 }
2485 else if (should_suggest_deref_p (type))
2486 {
2487 /* Special-case the error message for "ptr.field" for the case
2488 where the user has confused "." vs "->". */
2489 rich_location richloc (line_table, loc);
2490 /* "loc" should be the "." token. */
2491 richloc.add_fixit_replace ("->");
2492 error_at (&richloc,
2493 "%qE is a pointer; did you mean to use %<->%>?",
2494 datum);
2495 return error_mark_node;
2496 }
2497 else if (code != ERROR_MARK)
2498 error_at (loc,
2499 "request for member %qE in something not a structure or union",
2500 component);
2501
2502 return error_mark_node;
2503 }
2504
2505 /* Given an expression PTR for a pointer, return an expression
2506 for the value pointed to.
2507 ERRORSTRING is the name of the operator to appear in error messages.
2508
2509 LOC is the location to use for the generated tree. */
2510
2511 tree
build_indirect_ref(location_t loc,tree ptr,ref_operator errstring)2512 build_indirect_ref (location_t loc, tree ptr, ref_operator errstring)
2513 {
2514 tree pointer = default_conversion (ptr);
2515 tree type = TREE_TYPE (pointer);
2516 tree ref;
2517
2518 if (TREE_CODE (type) == POINTER_TYPE)
2519 {
2520 if (CONVERT_EXPR_P (pointer)
2521 || TREE_CODE (pointer) == VIEW_CONVERT_EXPR)
2522 {
2523 /* If a warning is issued, mark it to avoid duplicates from
2524 the backend. This only needs to be done at
2525 warn_strict_aliasing > 2. */
2526 if (warn_strict_aliasing > 2)
2527 if (strict_aliasing_warning (EXPR_LOCATION (pointer),
2528 type, TREE_OPERAND (pointer, 0)))
2529 TREE_NO_WARNING (pointer) = 1;
2530 }
2531
2532 if (TREE_CODE (pointer) == ADDR_EXPR
2533 && (TREE_TYPE (TREE_OPERAND (pointer, 0))
2534 == TREE_TYPE (type)))
2535 {
2536 ref = TREE_OPERAND (pointer, 0);
2537 protected_set_expr_location (ref, loc);
2538 return ref;
2539 }
2540 else
2541 {
2542 tree t = TREE_TYPE (type);
2543
2544 ref = build1 (INDIRECT_REF, t, pointer);
2545
2546 if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE)
2547 {
2548 if (!C_TYPE_ERROR_REPORTED (TREE_TYPE (ptr)))
2549 {
2550 error_at (loc, "dereferencing pointer to incomplete type "
2551 "%qT", t);
2552 C_TYPE_ERROR_REPORTED (TREE_TYPE (ptr)) = 1;
2553 }
2554 return error_mark_node;
2555 }
2556 if (VOID_TYPE_P (t) && c_inhibit_evaluation_warnings == 0)
2557 warning_at (loc, 0, "dereferencing %<void *%> pointer");
2558
2559 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2560 so that we get the proper error message if the result is used
2561 to assign to. Also, &* is supposed to be a no-op.
2562 And ANSI C seems to specify that the type of the result
2563 should be the const type. */
2564 /* A de-reference of a pointer to const is not a const. It is valid
2565 to change it via some other pointer. */
2566 TREE_READONLY (ref) = TYPE_READONLY (t);
2567 TREE_SIDE_EFFECTS (ref)
2568 = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer);
2569 TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
2570 protected_set_expr_location (ref, loc);
2571 return ref;
2572 }
2573 }
2574 else if (TREE_CODE (pointer) != ERROR_MARK)
2575 invalid_indirection_error (loc, type, errstring);
2576
2577 return error_mark_node;
2578 }
2579
2580 /* This handles expressions of the form "a[i]", which denotes
2581 an array reference.
2582
2583 This is logically equivalent in C to *(a+i), but we may do it differently.
2584 If A is a variable or a member, we generate a primitive ARRAY_REF.
2585 This avoids forcing the array out of registers, and can work on
2586 arrays that are not lvalues (for example, members of structures returned
2587 by functions).
2588
2589 For vector types, allow vector[i] but not i[vector], and create
2590 *(((type*)&vectortype) + i) for the expression.
2591
2592 LOC is the location to use for the returned expression. */
2593
2594 tree
build_array_ref(location_t loc,tree array,tree index)2595 build_array_ref (location_t loc, tree array, tree index)
2596 {
2597 tree ret;
2598 bool swapped = false;
2599 if (TREE_TYPE (array) == error_mark_node
2600 || TREE_TYPE (index) == error_mark_node)
2601 return error_mark_node;
2602
2603 if (TREE_CODE (TREE_TYPE (array)) != ARRAY_TYPE
2604 && TREE_CODE (TREE_TYPE (array)) != POINTER_TYPE
2605 /* Allow vector[index] but not index[vector]. */
2606 && !VECTOR_TYPE_P (TREE_TYPE (array)))
2607 {
2608 if (TREE_CODE (TREE_TYPE (index)) != ARRAY_TYPE
2609 && TREE_CODE (TREE_TYPE (index)) != POINTER_TYPE)
2610 {
2611 error_at (loc,
2612 "subscripted value is neither array nor pointer nor vector");
2613
2614 return error_mark_node;
2615 }
2616 std::swap (array, index);
2617 swapped = true;
2618 }
2619
2620 if (!INTEGRAL_TYPE_P (TREE_TYPE (index)))
2621 {
2622 error_at (loc, "array subscript is not an integer");
2623 return error_mark_node;
2624 }
2625
2626 if (TREE_CODE (TREE_TYPE (TREE_TYPE (array))) == FUNCTION_TYPE)
2627 {
2628 error_at (loc, "subscripted value is pointer to function");
2629 return error_mark_node;
2630 }
2631
2632 /* ??? Existing practice has been to warn only when the char
2633 index is syntactically the index, not for char[array]. */
2634 if (!swapped)
2635 warn_array_subscript_with_type_char (loc, index);
2636
2637 /* Apply default promotions *after* noticing character types. */
2638 index = default_conversion (index);
2639 if (index == error_mark_node)
2640 return error_mark_node;
2641
2642 gcc_assert (TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE);
2643
2644 bool was_vector = VECTOR_TYPE_P (TREE_TYPE (array));
2645 bool non_lvalue = convert_vector_to_array_for_subscript (loc, &array, index);
2646
2647 if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE)
2648 {
2649 tree rval, type;
2650
2651 /* An array that is indexed by a non-constant
2652 cannot be stored in a register; we must be able to do
2653 address arithmetic on its address.
2654 Likewise an array of elements of variable size. */
2655 if (TREE_CODE (index) != INTEGER_CST
2656 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
2657 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
2658 {
2659 if (!c_mark_addressable (array, true))
2660 return error_mark_node;
2661 }
2662 /* An array that is indexed by a constant value which is not within
2663 the array bounds cannot be stored in a register either; because we
2664 would get a crash in store_bit_field/extract_bit_field when trying
2665 to access a non-existent part of the register. */
2666 if (TREE_CODE (index) == INTEGER_CST
2667 && TYPE_DOMAIN (TREE_TYPE (array))
2668 && !int_fits_type_p (index, TYPE_DOMAIN (TREE_TYPE (array))))
2669 {
2670 if (!c_mark_addressable (array))
2671 return error_mark_node;
2672 }
2673
2674 if ((pedantic || warn_c90_c99_compat)
2675 && ! was_vector)
2676 {
2677 tree foo = array;
2678 while (TREE_CODE (foo) == COMPONENT_REF)
2679 foo = TREE_OPERAND (foo, 0);
2680 if (VAR_P (foo) && C_DECL_REGISTER (foo))
2681 pedwarn (loc, OPT_Wpedantic,
2682 "ISO C forbids subscripting %<register%> array");
2683 else if (!lvalue_p (foo))
2684 pedwarn_c90 (loc, OPT_Wpedantic,
2685 "ISO C90 forbids subscripting non-lvalue "
2686 "array");
2687 }
2688
2689 type = TREE_TYPE (TREE_TYPE (array));
2690 rval = build4 (ARRAY_REF, type, array, index, NULL_TREE, NULL_TREE);
2691 /* Array ref is const/volatile if the array elements are
2692 or if the array is. */
2693 TREE_READONLY (rval)
2694 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
2695 | TREE_READONLY (array));
2696 TREE_SIDE_EFFECTS (rval)
2697 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
2698 | TREE_SIDE_EFFECTS (array));
2699 TREE_THIS_VOLATILE (rval)
2700 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
2701 /* This was added by rms on 16 Nov 91.
2702 It fixes vol struct foo *a; a->elts[1]
2703 in an inline function.
2704 Hope it doesn't break something else. */
2705 | TREE_THIS_VOLATILE (array));
2706 ret = require_complete_type (loc, rval);
2707 protected_set_expr_location (ret, loc);
2708 if (non_lvalue)
2709 ret = non_lvalue_loc (loc, ret);
2710 return ret;
2711 }
2712 else
2713 {
2714 tree ar = default_conversion (array);
2715
2716 if (ar == error_mark_node)
2717 return ar;
2718
2719 gcc_assert (TREE_CODE (TREE_TYPE (ar)) == POINTER_TYPE);
2720 gcc_assert (TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) != FUNCTION_TYPE);
2721
2722 ret = build_indirect_ref (loc, build_binary_op (loc, PLUS_EXPR, ar,
2723 index, false),
2724 RO_ARRAY_INDEXING);
2725 if (non_lvalue)
2726 ret = non_lvalue_loc (loc, ret);
2727 return ret;
2728 }
2729 }
2730
2731 /* Build an external reference to identifier ID. FUN indicates
2732 whether this will be used for a function call. LOC is the source
2733 location of the identifier. This sets *TYPE to the type of the
2734 identifier, which is not the same as the type of the returned value
2735 for CONST_DECLs defined as enum constants. If the type of the
2736 identifier is not available, *TYPE is set to NULL. */
2737 tree
build_external_ref(location_t loc,tree id,bool fun,tree * type)2738 build_external_ref (location_t loc, tree id, bool fun, tree *type)
2739 {
2740 tree ref;
2741 tree decl = lookup_name (id);
2742
2743 /* In Objective-C, an instance variable (ivar) may be preferred to
2744 whatever lookup_name() found. */
2745 decl = objc_lookup_ivar (decl, id);
2746
2747 *type = NULL;
2748 if (decl && decl != error_mark_node)
2749 {
2750 ref = decl;
2751 *type = TREE_TYPE (ref);
2752 }
2753 else if (fun)
2754 /* Implicit function declaration. */
2755 ref = implicitly_declare (loc, id);
2756 else if (decl == error_mark_node)
2757 /* Don't complain about something that's already been
2758 complained about. */
2759 return error_mark_node;
2760 else
2761 {
2762 undeclared_variable (loc, id);
2763 return error_mark_node;
2764 }
2765
2766 if (TREE_TYPE (ref) == error_mark_node)
2767 return error_mark_node;
2768
2769 if (TREE_DEPRECATED (ref))
2770 warn_deprecated_use (ref, NULL_TREE);
2771
2772 /* Recursive call does not count as usage. */
2773 if (ref != current_function_decl)
2774 {
2775 TREE_USED (ref) = 1;
2776 }
2777
2778 if (TREE_CODE (ref) == FUNCTION_DECL && !in_alignof)
2779 {
2780 if (!in_sizeof && !in_typeof)
2781 C_DECL_USED (ref) = 1;
2782 else if (DECL_INITIAL (ref) == NULL_TREE
2783 && DECL_EXTERNAL (ref)
2784 && !TREE_PUBLIC (ref))
2785 record_maybe_used_decl (ref);
2786 }
2787
2788 if (TREE_CODE (ref) == CONST_DECL)
2789 {
2790 used_types_insert (TREE_TYPE (ref));
2791
2792 if (warn_cxx_compat
2793 && TREE_CODE (TREE_TYPE (ref)) == ENUMERAL_TYPE
2794 && C_TYPE_DEFINED_IN_STRUCT (TREE_TYPE (ref)))
2795 {
2796 warning_at (loc, OPT_Wc___compat,
2797 ("enum constant defined in struct or union "
2798 "is not visible in C++"));
2799 inform (DECL_SOURCE_LOCATION (ref), "enum constant defined here");
2800 }
2801
2802 ref = DECL_INITIAL (ref);
2803 TREE_CONSTANT (ref) = 1;
2804 }
2805 else if (current_function_decl != NULL_TREE
2806 && !DECL_FILE_SCOPE_P (current_function_decl)
2807 && (VAR_OR_FUNCTION_DECL_P (ref)
2808 || TREE_CODE (ref) == PARM_DECL))
2809 {
2810 tree context = decl_function_context (ref);
2811
2812 if (context != NULL_TREE && context != current_function_decl)
2813 DECL_NONLOCAL (ref) = 1;
2814 }
2815 /* C99 6.7.4p3: An inline definition of a function with external
2816 linkage ... shall not contain a reference to an identifier with
2817 internal linkage. */
2818 else if (current_function_decl != NULL_TREE
2819 && DECL_DECLARED_INLINE_P (current_function_decl)
2820 && DECL_EXTERNAL (current_function_decl)
2821 && VAR_OR_FUNCTION_DECL_P (ref)
2822 && (!VAR_P (ref) || TREE_STATIC (ref))
2823 && ! TREE_PUBLIC (ref)
2824 && DECL_CONTEXT (ref) != current_function_decl)
2825 record_inline_static (loc, current_function_decl, ref,
2826 csi_internal);
2827
2828 return ref;
2829 }
2830
2831 /* Record details of decls possibly used inside sizeof or typeof. */
2832 struct maybe_used_decl
2833 {
2834 /* The decl. */
2835 tree decl;
2836 /* The level seen at (in_sizeof + in_typeof). */
2837 int level;
2838 /* The next one at this level or above, or NULL. */
2839 struct maybe_used_decl *next;
2840 };
2841
2842 static struct maybe_used_decl *maybe_used_decls;
2843
2844 /* Record that DECL, an undefined static function reference seen
2845 inside sizeof or typeof, might be used if the operand of sizeof is
2846 a VLA type or the operand of typeof is a variably modified
2847 type. */
2848
2849 static void
record_maybe_used_decl(tree decl)2850 record_maybe_used_decl (tree decl)
2851 {
2852 struct maybe_used_decl *t = XOBNEW (&parser_obstack, struct maybe_used_decl);
2853 t->decl = decl;
2854 t->level = in_sizeof + in_typeof;
2855 t->next = maybe_used_decls;
2856 maybe_used_decls = t;
2857 }
2858
2859 /* Pop the stack of decls possibly used inside sizeof or typeof. If
2860 USED is false, just discard them. If it is true, mark them used
2861 (if no longer inside sizeof or typeof) or move them to the next
2862 level up (if still inside sizeof or typeof). */
2863
2864 void
pop_maybe_used(bool used)2865 pop_maybe_used (bool used)
2866 {
2867 struct maybe_used_decl *p = maybe_used_decls;
2868 int cur_level = in_sizeof + in_typeof;
2869 while (p && p->level > cur_level)
2870 {
2871 if (used)
2872 {
2873 if (cur_level == 0)
2874 C_DECL_USED (p->decl) = 1;
2875 else
2876 p->level = cur_level;
2877 }
2878 p = p->next;
2879 }
2880 if (!used || cur_level == 0)
2881 maybe_used_decls = p;
2882 }
2883
2884 /* Return the result of sizeof applied to EXPR. */
2885
2886 struct c_expr
c_expr_sizeof_expr(location_t loc,struct c_expr expr)2887 c_expr_sizeof_expr (location_t loc, struct c_expr expr)
2888 {
2889 struct c_expr ret;
2890 if (expr.value == error_mark_node)
2891 {
2892 ret.value = error_mark_node;
2893 ret.original_code = ERROR_MARK;
2894 ret.original_type = NULL;
2895 pop_maybe_used (false);
2896 }
2897 else
2898 {
2899 bool expr_const_operands = true;
2900
2901 if (TREE_CODE (expr.value) == PARM_DECL
2902 && C_ARRAY_PARAMETER (expr.value))
2903 {
2904 if (warning_at (loc, OPT_Wsizeof_array_argument,
2905 "%<sizeof%> on array function parameter %qE will "
2906 "return size of %qT", expr.value,
2907 TREE_TYPE (expr.value)))
2908 inform (DECL_SOURCE_LOCATION (expr.value), "declared here");
2909 }
2910 tree folded_expr = c_fully_fold (expr.value, require_constant_value,
2911 &expr_const_operands);
2912 ret.value = c_sizeof (loc, TREE_TYPE (folded_expr));
2913 c_last_sizeof_arg = expr.value;
2914 c_last_sizeof_loc = loc;
2915 ret.original_code = SIZEOF_EXPR;
2916 ret.original_type = NULL;
2917 if (c_vla_type_p (TREE_TYPE (folded_expr)))
2918 {
2919 /* sizeof is evaluated when given a vla (C99 6.5.3.4p2). */
2920 ret.value = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (ret.value),
2921 folded_expr, ret.value);
2922 C_MAYBE_CONST_EXPR_NON_CONST (ret.value) = !expr_const_operands;
2923 SET_EXPR_LOCATION (ret.value, loc);
2924 }
2925 pop_maybe_used (C_TYPE_VARIABLE_SIZE (TREE_TYPE (folded_expr)));
2926 }
2927 return ret;
2928 }
2929
2930 /* Return the result of sizeof applied to T, a structure for the type
2931 name passed to sizeof (rather than the type itself). LOC is the
2932 location of the original expression. */
2933
2934 struct c_expr
c_expr_sizeof_type(location_t loc,struct c_type_name * t)2935 c_expr_sizeof_type (location_t loc, struct c_type_name *t)
2936 {
2937 tree type;
2938 struct c_expr ret;
2939 tree type_expr = NULL_TREE;
2940 bool type_expr_const = true;
2941 type = groktypename (t, &type_expr, &type_expr_const);
2942 ret.value = c_sizeof (loc, type);
2943 c_last_sizeof_arg = type;
2944 c_last_sizeof_loc = loc;
2945 ret.original_code = SIZEOF_EXPR;
2946 ret.original_type = NULL;
2947 if ((type_expr || TREE_CODE (ret.value) == INTEGER_CST)
2948 && c_vla_type_p (type))
2949 {
2950 /* If the type is a [*] array, it is a VLA but is represented as
2951 having a size of zero. In such a case we must ensure that
2952 the result of sizeof does not get folded to a constant by
2953 c_fully_fold, because if the size is evaluated the result is
2954 not constant and so constraints on zero or negative size
2955 arrays must not be applied when this sizeof call is inside
2956 another array declarator. */
2957 if (!type_expr)
2958 type_expr = integer_zero_node;
2959 ret.value = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (ret.value),
2960 type_expr, ret.value);
2961 C_MAYBE_CONST_EXPR_NON_CONST (ret.value) = !type_expr_const;
2962 }
2963 pop_maybe_used (type != error_mark_node
2964 ? C_TYPE_VARIABLE_SIZE (type) : false);
2965 return ret;
2966 }
2967
2968 /* Build a function call to function FUNCTION with parameters PARAMS.
2969 The function call is at LOC.
2970 PARAMS is a list--a chain of TREE_LIST nodes--in which the
2971 TREE_VALUE of each node is a parameter-expression.
2972 FUNCTION's data type may be a function type or a pointer-to-function. */
2973
2974 tree
build_function_call(location_t loc,tree function,tree params)2975 build_function_call (location_t loc, tree function, tree params)
2976 {
2977 vec<tree, va_gc> *v;
2978 tree ret;
2979
2980 vec_alloc (v, list_length (params));
2981 for (; params; params = TREE_CHAIN (params))
2982 v->quick_push (TREE_VALUE (params));
2983 ret = c_build_function_call_vec (loc, vNULL, function, v, NULL);
2984 vec_free (v);
2985 return ret;
2986 }
2987
2988 /* Give a note about the location of the declaration of DECL. */
2989
2990 static void
inform_declaration(tree decl)2991 inform_declaration (tree decl)
2992 {
2993 if (decl && (TREE_CODE (decl) != FUNCTION_DECL || !DECL_IS_BUILTIN (decl)))
2994 inform (DECL_SOURCE_LOCATION (decl), "declared here");
2995 }
2996
2997 /* Build a function call to function FUNCTION with parameters PARAMS.
2998 ORIGTYPES, if not NULL, is a vector of types; each element is
2999 either NULL or the original type of the corresponding element in
3000 PARAMS. The original type may differ from TREE_TYPE of the
3001 parameter for enums. FUNCTION's data type may be a function type
3002 or pointer-to-function. This function changes the elements of
3003 PARAMS. */
3004
3005 tree
build_function_call_vec(location_t loc,vec<location_t> arg_loc,tree function,vec<tree,va_gc> * params,vec<tree,va_gc> * origtypes)3006 build_function_call_vec (location_t loc, vec<location_t> arg_loc,
3007 tree function, vec<tree, va_gc> *params,
3008 vec<tree, va_gc> *origtypes)
3009 {
3010 tree fntype, fundecl = NULL_TREE;
3011 tree name = NULL_TREE, result;
3012 tree tem;
3013 int nargs;
3014 tree *argarray;
3015
3016
3017 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
3018 STRIP_TYPE_NOPS (function);
3019
3020 /* Convert anything with function type to a pointer-to-function. */
3021 if (TREE_CODE (function) == FUNCTION_DECL)
3022 {
3023 name = DECL_NAME (function);
3024
3025 if (flag_tm)
3026 tm_malloc_replacement (function);
3027 fundecl = function;
3028 /* Atomic functions have type checking/casting already done. They are
3029 often rewritten and don't match the original parameter list. */
3030 if (name && !strncmp (IDENTIFIER_POINTER (name), "__atomic_", 9))
3031 origtypes = NULL;
3032 }
3033 if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE)
3034 function = function_to_pointer_conversion (loc, function);
3035
3036 /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
3037 expressions, like those used for ObjC messenger dispatches. */
3038 if (params && !params->is_empty ())
3039 function = objc_rewrite_function_call (function, (*params)[0]);
3040
3041 function = c_fully_fold (function, false, NULL);
3042
3043 fntype = TREE_TYPE (function);
3044
3045 if (TREE_CODE (fntype) == ERROR_MARK)
3046 return error_mark_node;
3047
3048 if (!(TREE_CODE (fntype) == POINTER_TYPE
3049 && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
3050 {
3051 if (!flag_diagnostics_show_caret)
3052 error_at (loc,
3053 "called object %qE is not a function or function pointer",
3054 function);
3055 else if (DECL_P (function))
3056 {
3057 error_at (loc,
3058 "called object %qD is not a function or function pointer",
3059 function);
3060 inform_declaration (function);
3061 }
3062 else
3063 error_at (loc,
3064 "called object is not a function or function pointer");
3065 return error_mark_node;
3066 }
3067
3068 if (fundecl && TREE_THIS_VOLATILE (fundecl))
3069 current_function_returns_abnormally = 1;
3070
3071 /* fntype now gets the type of function pointed to. */
3072 fntype = TREE_TYPE (fntype);
3073
3074 /* Convert the parameters to the types declared in the
3075 function prototype, or apply default promotions. */
3076
3077 nargs = convert_arguments (loc, arg_loc, TYPE_ARG_TYPES (fntype), params,
3078 origtypes, function, fundecl);
3079 if (nargs < 0)
3080 return error_mark_node;
3081
3082 /* Check that the function is called through a compatible prototype.
3083 If it is not, warn. */
3084 if (CONVERT_EXPR_P (function)
3085 && TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR
3086 && TREE_CODE (tem = TREE_OPERAND (tem, 0)) == FUNCTION_DECL
3087 && !comptypes (fntype, TREE_TYPE (tem)))
3088 {
3089 tree return_type = TREE_TYPE (fntype);
3090
3091 /* This situation leads to run-time undefined behavior. We can't,
3092 therefore, simply error unless we can prove that all possible
3093 executions of the program must execute the code. */
3094 warning_at (loc, 0, "function called through a non-compatible type");
3095
3096 if (VOID_TYPE_P (return_type)
3097 && TYPE_QUALS (return_type) != TYPE_UNQUALIFIED)
3098 pedwarn (loc, 0,
3099 "function with qualified void return type called");
3100 }
3101
3102 argarray = vec_safe_address (params);
3103
3104 /* Check that arguments to builtin functions match the expectations. */
3105 if (fundecl
3106 && DECL_BUILT_IN (fundecl)
3107 && DECL_BUILT_IN_CLASS (fundecl) == BUILT_IN_NORMAL
3108 && !check_builtin_function_arguments (loc, arg_loc, fundecl, nargs,
3109 argarray))
3110 return error_mark_node;
3111
3112 /* Check that the arguments to the function are valid. */
3113 bool warned_p = check_function_arguments (loc, fundecl, fntype,
3114 nargs, argarray, &arg_loc);
3115
3116 if (name != NULL_TREE
3117 && !strncmp (IDENTIFIER_POINTER (name), "__builtin_", 10))
3118 {
3119 if (require_constant_value)
3120 result
3121 = fold_build_call_array_initializer_loc (loc, TREE_TYPE (fntype),
3122 function, nargs, argarray);
3123 else
3124 result = fold_build_call_array_loc (loc, TREE_TYPE (fntype),
3125 function, nargs, argarray);
3126 if (TREE_CODE (result) == NOP_EXPR
3127 && TREE_CODE (TREE_OPERAND (result, 0)) == INTEGER_CST)
3128 STRIP_TYPE_NOPS (result);
3129 }
3130 else
3131 result = build_call_array_loc (loc, TREE_TYPE (fntype),
3132 function, nargs, argarray);
3133 /* If -Wnonnull warning has been diagnosed, avoid diagnosing it again
3134 later. */
3135 if (warned_p && TREE_CODE (result) == CALL_EXPR)
3136 TREE_NO_WARNING (result) = 1;
3137
3138 /* In this improbable scenario, a nested function returns a VM type.
3139 Create a TARGET_EXPR so that the call always has a LHS, much as
3140 what the C++ FE does for functions returning non-PODs. */
3141 if (variably_modified_type_p (TREE_TYPE (fntype), NULL_TREE))
3142 {
3143 tree tmp = create_tmp_var_raw (TREE_TYPE (fntype));
3144 result = build4 (TARGET_EXPR, TREE_TYPE (fntype), tmp, result,
3145 NULL_TREE, NULL_TREE);
3146 }
3147
3148 if (VOID_TYPE_P (TREE_TYPE (result)))
3149 {
3150 if (TYPE_QUALS (TREE_TYPE (result)) != TYPE_UNQUALIFIED)
3151 pedwarn (loc, 0,
3152 "function with qualified void return type called");
3153 return result;
3154 }
3155 return require_complete_type (loc, result);
3156 }
3157
3158 /* Like build_function_call_vec, but call also resolve_overloaded_builtin. */
3159
3160 tree
c_build_function_call_vec(location_t loc,vec<location_t> arg_loc,tree function,vec<tree,va_gc> * params,vec<tree,va_gc> * origtypes)3161 c_build_function_call_vec (location_t loc, vec<location_t> arg_loc,
3162 tree function, vec<tree, va_gc> *params,
3163 vec<tree, va_gc> *origtypes)
3164 {
3165 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
3166 STRIP_TYPE_NOPS (function);
3167
3168 /* Convert anything with function type to a pointer-to-function. */
3169 if (TREE_CODE (function) == FUNCTION_DECL)
3170 {
3171 /* Implement type-directed function overloading for builtins.
3172 resolve_overloaded_builtin and targetm.resolve_overloaded_builtin
3173 handle all the type checking. The result is a complete expression
3174 that implements this function call. */
3175 tree tem = resolve_overloaded_builtin (loc, function, params);
3176 if (tem)
3177 return tem;
3178 }
3179 return build_function_call_vec (loc, arg_loc, function, params, origtypes);
3180 }
3181
3182 /* Convert the argument expressions in the vector VALUES
3183 to the types in the list TYPELIST.
3184
3185 If TYPELIST is exhausted, or when an element has NULL as its type,
3186 perform the default conversions.
3187
3188 ORIGTYPES is the original types of the expressions in VALUES. This
3189 holds the type of enum values which have been converted to integral
3190 types. It may be NULL.
3191
3192 FUNCTION is a tree for the called function. It is used only for
3193 error messages, where it is formatted with %qE.
3194
3195 This is also where warnings about wrong number of args are generated.
3196
3197 ARG_LOC are locations of function arguments (if any).
3198
3199 Returns the actual number of arguments processed (which may be less
3200 than the length of VALUES in some error situations), or -1 on
3201 failure. */
3202
3203 static int
convert_arguments(location_t loc,vec<location_t> arg_loc,tree typelist,vec<tree,va_gc> * values,vec<tree,va_gc> * origtypes,tree function,tree fundecl)3204 convert_arguments (location_t loc, vec<location_t> arg_loc, tree typelist,
3205 vec<tree, va_gc> *values, vec<tree, va_gc> *origtypes,
3206 tree function, tree fundecl)
3207 {
3208 tree typetail, val;
3209 unsigned int parmnum;
3210 bool error_args = false;
3211 const bool type_generic = fundecl
3212 && lookup_attribute ("type generic", TYPE_ATTRIBUTES (TREE_TYPE (fundecl)));
3213 bool type_generic_remove_excess_precision = false;
3214 bool type_generic_overflow_p = false;
3215 tree selector;
3216
3217 /* Change pointer to function to the function itself for
3218 diagnostics. */
3219 if (TREE_CODE (function) == ADDR_EXPR
3220 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
3221 function = TREE_OPERAND (function, 0);
3222
3223 /* Handle an ObjC selector specially for diagnostics. */
3224 selector = objc_message_selector ();
3225
3226 /* For type-generic built-in functions, determine whether excess
3227 precision should be removed (classification) or not
3228 (comparison). */
3229 if (type_generic
3230 && DECL_BUILT_IN (fundecl)
3231 && DECL_BUILT_IN_CLASS (fundecl) == BUILT_IN_NORMAL)
3232 {
3233 switch (DECL_FUNCTION_CODE (fundecl))
3234 {
3235 case BUILT_IN_ISFINITE:
3236 case BUILT_IN_ISINF:
3237 case BUILT_IN_ISINF_SIGN:
3238 case BUILT_IN_ISNAN:
3239 case BUILT_IN_ISNORMAL:
3240 case BUILT_IN_FPCLASSIFY:
3241 type_generic_remove_excess_precision = true;
3242 break;
3243
3244 case BUILT_IN_ADD_OVERFLOW_P:
3245 case BUILT_IN_SUB_OVERFLOW_P:
3246 case BUILT_IN_MUL_OVERFLOW_P:
3247 /* The last argument of these type-generic builtins
3248 should not be promoted. */
3249 type_generic_overflow_p = true;
3250 break;
3251
3252 default:
3253 break;
3254 }
3255 }
3256
3257 /* Scan the given expressions and types, producing individual
3258 converted arguments. */
3259
3260 for (typetail = typelist, parmnum = 0;
3261 values && values->iterate (parmnum, &val);
3262 ++parmnum)
3263 {
3264 tree type = typetail ? TREE_VALUE (typetail) : 0;
3265 tree valtype = TREE_TYPE (val);
3266 tree rname = function;
3267 int argnum = parmnum + 1;
3268 const char *invalid_func_diag;
3269 bool excess_precision = false;
3270 bool npc;
3271 tree parmval;
3272 /* Some __atomic_* builtins have additional hidden argument at
3273 position 0. */
3274 location_t ploc
3275 = !arg_loc.is_empty () && values->length () == arg_loc.length ()
3276 ? expansion_point_location_if_in_system_header (arg_loc[parmnum])
3277 : input_location;
3278
3279 if (type == void_type_node)
3280 {
3281 if (selector)
3282 error_at (loc, "too many arguments to method %qE", selector);
3283 else
3284 error_at (loc, "too many arguments to function %qE", function);
3285 inform_declaration (fundecl);
3286 return error_args ? -1 : (int) parmnum;
3287 }
3288
3289 if (selector && argnum > 2)
3290 {
3291 rname = selector;
3292 argnum -= 2;
3293 }
3294
3295 npc = null_pointer_constant_p (val);
3296
3297 /* If there is excess precision and a prototype, convert once to
3298 the required type rather than converting via the semantic
3299 type. Likewise without a prototype a float value represented
3300 as long double should be converted once to double. But for
3301 type-generic classification functions excess precision must
3302 be removed here. */
3303 if (TREE_CODE (val) == EXCESS_PRECISION_EXPR
3304 && (type || !type_generic || !type_generic_remove_excess_precision))
3305 {
3306 val = TREE_OPERAND (val, 0);
3307 excess_precision = true;
3308 }
3309 val = c_fully_fold (val, false, NULL);
3310 STRIP_TYPE_NOPS (val);
3311
3312 val = require_complete_type (ploc, val);
3313
3314 /* Some floating-point arguments must be promoted to double when
3315 no type is specified by a prototype. This applies to
3316 arguments of type float, and to architecture-specific types
3317 (ARM __fp16), but not to _FloatN or _FloatNx types. */
3318 bool promote_float_arg = false;
3319 if (type == NULL_TREE
3320 && TREE_CODE (valtype) == REAL_TYPE
3321 && (TYPE_PRECISION (valtype)
3322 <= TYPE_PRECISION (double_type_node))
3323 && TYPE_MAIN_VARIANT (valtype) != double_type_node
3324 && TYPE_MAIN_VARIANT (valtype) != long_double_type_node
3325 && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (valtype)))
3326 {
3327 /* Promote this argument, unless it has a _FloatN or
3328 _FloatNx type. */
3329 promote_float_arg = true;
3330 for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
3331 if (TYPE_MAIN_VARIANT (valtype) == FLOATN_NX_TYPE_NODE (i))
3332 {
3333 promote_float_arg = false;
3334 break;
3335 }
3336 }
3337
3338 if (type != NULL_TREE)
3339 {
3340 /* Formal parm type is specified by a function prototype. */
3341
3342 if (type == error_mark_node || !COMPLETE_TYPE_P (type))
3343 {
3344 error_at (ploc, "type of formal parameter %d is incomplete",
3345 parmnum + 1);
3346 parmval = val;
3347 }
3348 else
3349 {
3350 tree origtype;
3351
3352 /* Optionally warn about conversions that
3353 differ from the default conversions. */
3354 if (warn_traditional_conversion || warn_traditional)
3355 {
3356 unsigned int formal_prec = TYPE_PRECISION (type);
3357
3358 if (INTEGRAL_TYPE_P (type)
3359 && TREE_CODE (valtype) == REAL_TYPE)
3360 warning_at (ploc, OPT_Wtraditional_conversion,
3361 "passing argument %d of %qE as integer rather "
3362 "than floating due to prototype",
3363 argnum, rname);
3364 if (INTEGRAL_TYPE_P (type)
3365 && TREE_CODE (valtype) == COMPLEX_TYPE)
3366 warning_at (ploc, OPT_Wtraditional_conversion,
3367 "passing argument %d of %qE as integer rather "
3368 "than complex due to prototype",
3369 argnum, rname);
3370 else if (TREE_CODE (type) == COMPLEX_TYPE
3371 && TREE_CODE (valtype) == REAL_TYPE)
3372 warning_at (ploc, OPT_Wtraditional_conversion,
3373 "passing argument %d of %qE as complex rather "
3374 "than floating due to prototype",
3375 argnum, rname);
3376 else if (TREE_CODE (type) == REAL_TYPE
3377 && INTEGRAL_TYPE_P (valtype))
3378 warning_at (ploc, OPT_Wtraditional_conversion,
3379 "passing argument %d of %qE as floating rather "
3380 "than integer due to prototype",
3381 argnum, rname);
3382 else if (TREE_CODE (type) == COMPLEX_TYPE
3383 && INTEGRAL_TYPE_P (valtype))
3384 warning_at (ploc, OPT_Wtraditional_conversion,
3385 "passing argument %d of %qE as complex rather "
3386 "than integer due to prototype",
3387 argnum, rname);
3388 else if (TREE_CODE (type) == REAL_TYPE
3389 && TREE_CODE (valtype) == COMPLEX_TYPE)
3390 warning_at (ploc, OPT_Wtraditional_conversion,
3391 "passing argument %d of %qE as floating rather "
3392 "than complex due to prototype",
3393 argnum, rname);
3394 /* ??? At some point, messages should be written about
3395 conversions between complex types, but that's too messy
3396 to do now. */
3397 else if (TREE_CODE (type) == REAL_TYPE
3398 && TREE_CODE (valtype) == REAL_TYPE)
3399 {
3400 /* Warn if any argument is passed as `float',
3401 since without a prototype it would be `double'. */
3402 if (formal_prec == TYPE_PRECISION (float_type_node)
3403 && type != dfloat32_type_node)
3404 warning_at (ploc, 0,
3405 "passing argument %d of %qE as %<float%> "
3406 "rather than %<double%> due to prototype",
3407 argnum, rname);
3408
3409 /* Warn if mismatch between argument and prototype
3410 for decimal float types. Warn of conversions with
3411 binary float types and of precision narrowing due to
3412 prototype. */
3413 else if (type != valtype
3414 && (type == dfloat32_type_node
3415 || type == dfloat64_type_node
3416 || type == dfloat128_type_node
3417 || valtype == dfloat32_type_node
3418 || valtype == dfloat64_type_node
3419 || valtype == dfloat128_type_node)
3420 && (formal_prec
3421 <= TYPE_PRECISION (valtype)
3422 || (type == dfloat128_type_node
3423 && (valtype
3424 != dfloat64_type_node
3425 && (valtype
3426 != dfloat32_type_node)))
3427 || (type == dfloat64_type_node
3428 && (valtype
3429 != dfloat32_type_node))))
3430 warning_at (ploc, 0,
3431 "passing argument %d of %qE as %qT "
3432 "rather than %qT due to prototype",
3433 argnum, rname, type, valtype);
3434
3435 }
3436 /* Detect integer changing in width or signedness.
3437 These warnings are only activated with
3438 -Wtraditional-conversion, not with -Wtraditional. */
3439 else if (warn_traditional_conversion
3440 && INTEGRAL_TYPE_P (type)
3441 && INTEGRAL_TYPE_P (valtype))
3442 {
3443 tree would_have_been = default_conversion (val);
3444 tree type1 = TREE_TYPE (would_have_been);
3445
3446 if (val == error_mark_node)
3447 /* VAL could have been of incomplete type. */;
3448 else if (TREE_CODE (type) == ENUMERAL_TYPE
3449 && (TYPE_MAIN_VARIANT (type)
3450 == TYPE_MAIN_VARIANT (valtype)))
3451 /* No warning if function asks for enum
3452 and the actual arg is that enum type. */
3453 ;
3454 else if (formal_prec != TYPE_PRECISION (type1))
3455 warning_at (ploc, OPT_Wtraditional_conversion,
3456 "passing argument %d of %qE "
3457 "with different width due to prototype",
3458 argnum, rname);
3459 else if (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (type1))
3460 ;
3461 /* Don't complain if the formal parameter type
3462 is an enum, because we can't tell now whether
3463 the value was an enum--even the same enum. */
3464 else if (TREE_CODE (type) == ENUMERAL_TYPE)
3465 ;
3466 else if (TREE_CODE (val) == INTEGER_CST
3467 && int_fits_type_p (val, type))
3468 /* Change in signedness doesn't matter
3469 if a constant value is unaffected. */
3470 ;
3471 /* If the value is extended from a narrower
3472 unsigned type, it doesn't matter whether we
3473 pass it as signed or unsigned; the value
3474 certainly is the same either way. */
3475 else if (TYPE_PRECISION (valtype) < TYPE_PRECISION (type)
3476 && TYPE_UNSIGNED (valtype))
3477 ;
3478 else if (TYPE_UNSIGNED (type))
3479 warning_at (ploc, OPT_Wtraditional_conversion,
3480 "passing argument %d of %qE "
3481 "as unsigned due to prototype",
3482 argnum, rname);
3483 else
3484 warning_at (ploc, OPT_Wtraditional_conversion,
3485 "passing argument %d of %qE "
3486 "as signed due to prototype",
3487 argnum, rname);
3488 }
3489 }
3490
3491 /* Possibly restore an EXCESS_PRECISION_EXPR for the
3492 sake of better warnings from convert_and_check. */
3493 if (excess_precision)
3494 val = build1 (EXCESS_PRECISION_EXPR, valtype, val);
3495 origtype = (!origtypes) ? NULL_TREE : (*origtypes)[parmnum];
3496 parmval = convert_for_assignment (loc, ploc, type,
3497 val, origtype, ic_argpass,
3498 npc, fundecl, function,
3499 parmnum + 1);
3500
3501 if (targetm.calls.promote_prototypes (fundecl ? TREE_TYPE (fundecl) : 0)
3502 && INTEGRAL_TYPE_P (type)
3503 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
3504 parmval = default_conversion (parmval);
3505 }
3506 }
3507 else if (promote_float_arg)
3508 {
3509 if (type_generic)
3510 parmval = val;
3511 else
3512 {
3513 /* Convert `float' to `double'. */
3514 if (warn_double_promotion && !c_inhibit_evaluation_warnings)
3515 warning_at (ploc, OPT_Wdouble_promotion,
3516 "implicit conversion from %qT to %qT when passing "
3517 "argument to function",
3518 valtype, double_type_node);
3519 parmval = convert (double_type_node, val);
3520 }
3521 }
3522 else if ((excess_precision && !type_generic)
3523 || (type_generic_overflow_p && parmnum == 2))
3524 /* A "double" argument with excess precision being passed
3525 without a prototype or in variable arguments.
3526 The last argument of __builtin_*_overflow_p should not be
3527 promoted. */
3528 parmval = convert (valtype, val);
3529 else if ((invalid_func_diag =
3530 targetm.calls.invalid_arg_for_unprototyped_fn (typelist, fundecl, val)))
3531 {
3532 error (invalid_func_diag);
3533 return -1;
3534 }
3535 else if (TREE_CODE (val) == ADDR_EXPR && reject_gcc_builtin (val))
3536 {
3537 return -1;
3538 }
3539 else
3540 /* Convert `short' and `char' to full-size `int'. */
3541 parmval = default_conversion (val);
3542
3543 (*values)[parmnum] = parmval;
3544 if (parmval == error_mark_node)
3545 error_args = true;
3546
3547 if (typetail)
3548 typetail = TREE_CHAIN (typetail);
3549 }
3550
3551 gcc_assert (parmnum == vec_safe_length (values));
3552
3553 if (typetail != NULL_TREE && TREE_VALUE (typetail) != void_type_node)
3554 {
3555 error_at (loc, "too few arguments to function %qE", function);
3556 inform_declaration (fundecl);
3557 return -1;
3558 }
3559
3560 return error_args ? -1 : (int) parmnum;
3561 }
3562
3563 /* This is the entry point used by the parser to build unary operators
3564 in the input. CODE, a tree_code, specifies the unary operator, and
3565 ARG is the operand. For unary plus, the C parser currently uses
3566 CONVERT_EXPR for code.
3567
3568 LOC is the location to use for the tree generated.
3569 */
3570
3571 struct c_expr
parser_build_unary_op(location_t loc,enum tree_code code,struct c_expr arg)3572 parser_build_unary_op (location_t loc, enum tree_code code, struct c_expr arg)
3573 {
3574 struct c_expr result;
3575
3576 result.original_code = code;
3577 result.original_type = NULL;
3578
3579 if (reject_gcc_builtin (arg.value))
3580 {
3581 result.value = error_mark_node;
3582 }
3583 else
3584 {
3585 result.value = build_unary_op (loc, code, arg.value, false);
3586
3587 if (TREE_OVERFLOW_P (result.value) && !TREE_OVERFLOW_P (arg.value))
3588 overflow_warning (loc, result.value, arg.value);
3589 }
3590
3591 /* We are typically called when parsing a prefix token at LOC acting on
3592 ARG. Reflect this by updating the source range of the result to
3593 start at LOC and end at the end of ARG. */
3594 set_c_expr_source_range (&result,
3595 loc, arg.get_finish ());
3596
3597 return result;
3598 }
3599
3600 /* Returns true if TYPE is a character type, *not* including wchar_t. */
3601
3602 static bool
char_type_p(tree type)3603 char_type_p (tree type)
3604 {
3605 return (type == char_type_node
3606 || type == unsigned_char_type_node
3607 || type == signed_char_type_node
3608 || type == char16_type_node
3609 || type == char32_type_node);
3610 }
3611
3612 /* This is the entry point used by the parser to build binary operators
3613 in the input. CODE, a tree_code, specifies the binary operator, and
3614 ARG1 and ARG2 are the operands. In addition to constructing the
3615 expression, we check for operands that were written with other binary
3616 operators in a way that is likely to confuse the user.
3617
3618 LOCATION is the location of the binary operator. */
3619
3620 struct c_expr
parser_build_binary_op(location_t location,enum tree_code code,struct c_expr arg1,struct c_expr arg2)3621 parser_build_binary_op (location_t location, enum tree_code code,
3622 struct c_expr arg1, struct c_expr arg2)
3623 {
3624 struct c_expr result;
3625
3626 enum tree_code code1 = arg1.original_code;
3627 enum tree_code code2 = arg2.original_code;
3628 tree type1 = (arg1.original_type
3629 ? arg1.original_type
3630 : TREE_TYPE (arg1.value));
3631 tree type2 = (arg2.original_type
3632 ? arg2.original_type
3633 : TREE_TYPE (arg2.value));
3634
3635 result.value = build_binary_op (location, code,
3636 arg1.value, arg2.value, true);
3637 result.original_code = code;
3638 result.original_type = NULL;
3639
3640 if (TREE_CODE (result.value) == ERROR_MARK)
3641 {
3642 set_c_expr_source_range (&result,
3643 arg1.get_start (),
3644 arg2.get_finish ());
3645 return result;
3646 }
3647
3648 if (location != UNKNOWN_LOCATION)
3649 protected_set_expr_location (result.value, location);
3650
3651 set_c_expr_source_range (&result,
3652 arg1.get_start (),
3653 arg2.get_finish ());
3654
3655 /* Check for cases such as x+y<<z which users are likely
3656 to misinterpret. */
3657 if (warn_parentheses)
3658 warn_about_parentheses (location, code, code1, arg1.value, code2,
3659 arg2.value);
3660
3661 if (warn_logical_op)
3662 warn_logical_operator (location, code, TREE_TYPE (result.value),
3663 code1, arg1.value, code2, arg2.value);
3664
3665 if (warn_tautological_compare)
3666 {
3667 tree lhs = arg1.value;
3668 tree rhs = arg2.value;
3669 if (TREE_CODE (lhs) == C_MAYBE_CONST_EXPR)
3670 {
3671 if (C_MAYBE_CONST_EXPR_PRE (lhs) != NULL_TREE
3672 && TREE_SIDE_EFFECTS (C_MAYBE_CONST_EXPR_PRE (lhs)))
3673 lhs = NULL_TREE;
3674 else
3675 lhs = C_MAYBE_CONST_EXPR_EXPR (lhs);
3676 }
3677 if (TREE_CODE (rhs) == C_MAYBE_CONST_EXPR)
3678 {
3679 if (C_MAYBE_CONST_EXPR_PRE (rhs) != NULL_TREE
3680 && TREE_SIDE_EFFECTS (C_MAYBE_CONST_EXPR_PRE (rhs)))
3681 rhs = NULL_TREE;
3682 else
3683 rhs = C_MAYBE_CONST_EXPR_EXPR (rhs);
3684 }
3685 if (lhs != NULL_TREE && rhs != NULL_TREE)
3686 warn_tautological_cmp (location, code, lhs, rhs);
3687 }
3688
3689 if (warn_logical_not_paren
3690 && TREE_CODE_CLASS (code) == tcc_comparison
3691 && code1 == TRUTH_NOT_EXPR
3692 && code2 != TRUTH_NOT_EXPR
3693 /* Avoid warning for !!x == y. */
3694 && (TREE_CODE (arg1.value) != NE_EXPR
3695 || !integer_zerop (TREE_OPERAND (arg1.value, 1))))
3696 {
3697 /* Avoid warning for !b == y where b has _Bool type. */
3698 tree t = integer_zero_node;
3699 if (TREE_CODE (arg1.value) == EQ_EXPR
3700 && integer_zerop (TREE_OPERAND (arg1.value, 1))
3701 && TREE_TYPE (TREE_OPERAND (arg1.value, 0)) == integer_type_node)
3702 {
3703 t = TREE_OPERAND (arg1.value, 0);
3704 do
3705 {
3706 if (TREE_TYPE (t) != integer_type_node)
3707 break;
3708 if (TREE_CODE (t) == C_MAYBE_CONST_EXPR)
3709 t = C_MAYBE_CONST_EXPR_EXPR (t);
3710 else if (CONVERT_EXPR_P (t))
3711 t = TREE_OPERAND (t, 0);
3712 else
3713 break;
3714 }
3715 while (1);
3716 }
3717 if (TREE_CODE (TREE_TYPE (t)) != BOOLEAN_TYPE)
3718 warn_logical_not_parentheses (location, code, arg1.value, arg2.value);
3719 }
3720
3721 /* Warn about comparisons against string literals, with the exception
3722 of testing for equality or inequality of a string literal with NULL. */
3723 if (code == EQ_EXPR || code == NE_EXPR)
3724 {
3725 if ((code1 == STRING_CST
3726 && !integer_zerop (tree_strip_nop_conversions (arg2.value)))
3727 || (code2 == STRING_CST
3728 && !integer_zerop (tree_strip_nop_conversions (arg1.value))))
3729 warning_at (location, OPT_Waddress,
3730 "comparison with string literal results in unspecified behavior");
3731 /* Warn for ptr == '\0', it's likely that it should've been ptr[0]. */
3732 if (POINTER_TYPE_P (type1)
3733 && null_pointer_constant_p (arg2.value)
3734 && char_type_p (type2)
3735 && warning_at (location, OPT_Wpointer_compare,
3736 "comparison between pointer and zero character "
3737 "constant"))
3738 inform (arg1.get_start (), "did you mean to dereference the pointer?");
3739 else if (POINTER_TYPE_P (type2)
3740 && null_pointer_constant_p (arg1.value)
3741 && char_type_p (type1)
3742 && warning_at (location, OPT_Wpointer_compare,
3743 "comparison between pointer and zero character "
3744 "constant"))
3745 inform (arg2.get_start (), "did you mean to dereference the pointer?");
3746 }
3747 else if (TREE_CODE_CLASS (code) == tcc_comparison
3748 && (code1 == STRING_CST || code2 == STRING_CST))
3749 warning_at (location, OPT_Waddress,
3750 "comparison with string literal results in unspecified behavior");
3751
3752 if (TREE_OVERFLOW_P (result.value)
3753 && !TREE_OVERFLOW_P (arg1.value)
3754 && !TREE_OVERFLOW_P (arg2.value))
3755 overflow_warning (location, result.value);
3756
3757 /* Warn about comparisons of different enum types. */
3758 if (warn_enum_compare
3759 && TREE_CODE_CLASS (code) == tcc_comparison
3760 && TREE_CODE (type1) == ENUMERAL_TYPE
3761 && TREE_CODE (type2) == ENUMERAL_TYPE
3762 && TYPE_MAIN_VARIANT (type1) != TYPE_MAIN_VARIANT (type2))
3763 warning_at (location, OPT_Wenum_compare,
3764 "comparison between %qT and %qT",
3765 type1, type2);
3766
3767 return result;
3768 }
3769
3770 /* Return a tree for the difference of pointers OP0 and OP1.
3771 The resulting tree has type ptrdiff_t. If POINTER_SUBTRACT sanitization is
3772 enabled, assign to INSTRUMENT_EXPR call to libsanitizer. */
3773
3774 static tree
pointer_diff(location_t loc,tree op0,tree op1,tree * instrument_expr)3775 pointer_diff (location_t loc, tree op0, tree op1, tree *instrument_expr)
3776 {
3777 tree restype = ptrdiff_type_node;
3778 tree result, inttype;
3779
3780 addr_space_t as0 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op0)));
3781 addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op1)));
3782 tree target_type = TREE_TYPE (TREE_TYPE (op0));
3783 tree orig_op1 = op1;
3784
3785 /* If the operands point into different address spaces, we need to
3786 explicitly convert them to pointers into the common address space
3787 before we can subtract the numerical address values. */
3788 if (as0 != as1)
3789 {
3790 addr_space_t as_common;
3791 tree common_type;
3792
3793 /* Determine the common superset address space. This is guaranteed
3794 to exist because the caller verified that comp_target_types
3795 returned non-zero. */
3796 if (!addr_space_superset (as0, as1, &as_common))
3797 gcc_unreachable ();
3798
3799 common_type = common_pointer_type (TREE_TYPE (op0), TREE_TYPE (op1));
3800 op0 = convert (common_type, op0);
3801 op1 = convert (common_type, op1);
3802 }
3803
3804 /* Determine integer type result of the subtraction. This will usually
3805 be the same as the result type (ptrdiff_t), but may need to be a wider
3806 type if pointers for the address space are wider than ptrdiff_t. */
3807 if (TYPE_PRECISION (restype) < TYPE_PRECISION (TREE_TYPE (op0)))
3808 inttype = c_common_type_for_size (TYPE_PRECISION (TREE_TYPE (op0)), 0);
3809 else
3810 inttype = restype;
3811
3812 if (TREE_CODE (target_type) == VOID_TYPE)
3813 pedwarn (loc, OPT_Wpointer_arith,
3814 "pointer of type %<void *%> used in subtraction");
3815 if (TREE_CODE (target_type) == FUNCTION_TYPE)
3816 pedwarn (loc, OPT_Wpointer_arith,
3817 "pointer to a function used in subtraction");
3818
3819 if (sanitize_flags_p (SANITIZE_POINTER_SUBTRACT))
3820 {
3821 gcc_assert (current_function_decl != NULL_TREE);
3822
3823 op0 = save_expr (op0);
3824 op1 = save_expr (op1);
3825
3826 tree tt = builtin_decl_explicit (BUILT_IN_ASAN_POINTER_SUBTRACT);
3827 *instrument_expr = build_call_expr_loc (loc, tt, 2, op0, op1);
3828 }
3829
3830 /* First do the subtraction, then build the divide operator
3831 and only convert at the very end.
3832 Do not do default conversions in case restype is a short type. */
3833
3834 /* POINTER_DIFF_EXPR requires a signed integer type of the same size as
3835 pointers. If some platform cannot provide that, or has a larger
3836 ptrdiff_type to support differences larger than half the address
3837 space, cast the pointers to some larger integer type and do the
3838 computations in that type. */
3839 if (TYPE_PRECISION (inttype) > TYPE_PRECISION (TREE_TYPE (op0)))
3840 op0 = build_binary_op (loc, MINUS_EXPR, convert (inttype, op0),
3841 convert (inttype, op1), false);
3842 else
3843 {
3844 /* Cast away qualifiers. */
3845 op0 = convert (c_common_type (TREE_TYPE (op0), TREE_TYPE (op0)), op0);
3846 op1 = convert (c_common_type (TREE_TYPE (op1), TREE_TYPE (op1)), op1);
3847 op0 = build2_loc (loc, POINTER_DIFF_EXPR, inttype, op0, op1);
3848 }
3849
3850 /* This generates an error if op1 is pointer to incomplete type. */
3851 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1))))
3852 error_at (loc, "arithmetic on pointer to an incomplete type");
3853
3854 op1 = c_size_in_bytes (target_type);
3855
3856 if (pointer_to_zero_sized_aggr_p (TREE_TYPE (orig_op1)))
3857 error_at (loc, "arithmetic on pointer to an empty aggregate");
3858
3859 /* Divide by the size, in easiest possible way. */
3860 result = fold_build2_loc (loc, EXACT_DIV_EXPR, inttype,
3861 op0, convert (inttype, op1));
3862
3863 /* Convert to final result type if necessary. */
3864 return convert (restype, result);
3865 }
3866
3867 /* Expand atomic compound assignments into an appropriate sequence as
3868 specified by the C11 standard section 6.5.16.2.
3869
3870 _Atomic T1 E1
3871 T2 E2
3872 E1 op= E2
3873
3874 This sequence is used for all types for which these operations are
3875 supported.
3876
3877 In addition, built-in versions of the 'fe' prefixed routines may
3878 need to be invoked for floating point (real, complex or vector) when
3879 floating-point exceptions are supported. See 6.5.16.2 footnote 113.
3880
3881 T1 newval;
3882 T1 old;
3883 T1 *addr
3884 T2 val
3885 fenv_t fenv
3886
3887 addr = &E1;
3888 val = (E2);
3889 __atomic_load (addr, &old, SEQ_CST);
3890 feholdexcept (&fenv);
3891 loop:
3892 newval = old op val;
3893 if (__atomic_compare_exchange_strong (addr, &old, &newval, SEQ_CST,
3894 SEQ_CST))
3895 goto done;
3896 feclearexcept (FE_ALL_EXCEPT);
3897 goto loop:
3898 done:
3899 feupdateenv (&fenv);
3900
3901 The compiler will issue the __atomic_fetch_* built-in when possible,
3902 otherwise it will generate the generic form of the atomic operations.
3903 This requires temp(s) and has their address taken. The atomic processing
3904 is smart enough to figure out when the size of an object can utilize
3905 a lock-free version, and convert the built-in call to the appropriate
3906 lock-free routine. The optimizers will then dispose of any temps that
3907 are no longer required, and lock-free implementations are utilized as
3908 long as there is target support for the required size.
3909
3910 If the operator is NOP_EXPR, then this is a simple assignment, and
3911 an __atomic_store is issued to perform the assignment rather than
3912 the above loop. */
3913
3914 /* Build an atomic assignment at LOC, expanding into the proper
3915 sequence to store LHS MODIFYCODE= RHS. Return a value representing
3916 the result of the operation, unless RETURN_OLD_P, in which case
3917 return the old value of LHS (this is only for postincrement and
3918 postdecrement). */
3919
3920 static tree
build_atomic_assign(location_t loc,tree lhs,enum tree_code modifycode,tree rhs,bool return_old_p)3921 build_atomic_assign (location_t loc, tree lhs, enum tree_code modifycode,
3922 tree rhs, bool return_old_p)
3923 {
3924 tree fndecl, func_call;
3925 vec<tree, va_gc> *params;
3926 tree val, nonatomic_lhs_type, nonatomic_rhs_type, newval, newval_addr;
3927 tree old, old_addr;
3928 tree compound_stmt;
3929 tree stmt, goto_stmt;
3930 tree loop_label, loop_decl, done_label, done_decl;
3931
3932 tree lhs_type = TREE_TYPE (lhs);
3933 tree lhs_addr = build_unary_op (loc, ADDR_EXPR, lhs, false);
3934 tree seq_cst = build_int_cst (integer_type_node, MEMMODEL_SEQ_CST);
3935 tree rhs_semantic_type = TREE_TYPE (rhs);
3936 tree nonatomic_rhs_semantic_type;
3937 tree rhs_type;
3938
3939 gcc_assert (TYPE_ATOMIC (lhs_type));
3940
3941 if (return_old_p)
3942 gcc_assert (modifycode == PLUS_EXPR || modifycode == MINUS_EXPR);
3943
3944 /* Allocate enough vector items for a compare_exchange. */
3945 vec_alloc (params, 6);
3946
3947 /* Create a compound statement to hold the sequence of statements
3948 with a loop. */
3949 compound_stmt = c_begin_compound_stmt (false);
3950
3951 /* Remove any excess precision (which is only present here in the
3952 case of compound assignments). */
3953 if (TREE_CODE (rhs) == EXCESS_PRECISION_EXPR)
3954 {
3955 gcc_assert (modifycode != NOP_EXPR);
3956 rhs = TREE_OPERAND (rhs, 0);
3957 }
3958 rhs_type = TREE_TYPE (rhs);
3959
3960 /* Fold the RHS if it hasn't already been folded. */
3961 if (modifycode != NOP_EXPR)
3962 rhs = c_fully_fold (rhs, false, NULL);
3963
3964 /* Remove the qualifiers for the rest of the expressions and create
3965 the VAL temp variable to hold the RHS. */
3966 nonatomic_lhs_type = build_qualified_type (lhs_type, TYPE_UNQUALIFIED);
3967 nonatomic_rhs_type = build_qualified_type (rhs_type, TYPE_UNQUALIFIED);
3968 nonatomic_rhs_semantic_type = build_qualified_type (rhs_semantic_type,
3969 TYPE_UNQUALIFIED);
3970 val = create_tmp_var_raw (nonatomic_rhs_type);
3971 TREE_ADDRESSABLE (val) = 1;
3972 TREE_NO_WARNING (val) = 1;
3973 rhs = build4 (TARGET_EXPR, nonatomic_rhs_type, val, rhs, NULL_TREE,
3974 NULL_TREE);
3975 SET_EXPR_LOCATION (rhs, loc);
3976 add_stmt (rhs);
3977
3978 /* NOP_EXPR indicates it's a straight store of the RHS. Simply issue
3979 an atomic_store. */
3980 if (modifycode == NOP_EXPR)
3981 {
3982 /* Build __atomic_store (&lhs, &val, SEQ_CST) */
3983 rhs = build_unary_op (loc, ADDR_EXPR, val, false);
3984 fndecl = builtin_decl_explicit (BUILT_IN_ATOMIC_STORE);
3985 params->quick_push (lhs_addr);
3986 params->quick_push (rhs);
3987 params->quick_push (seq_cst);
3988 func_call = c_build_function_call_vec (loc, vNULL, fndecl, params, NULL);
3989 add_stmt (func_call);
3990
3991 /* Finish the compound statement. */
3992 compound_stmt = c_end_compound_stmt (loc, compound_stmt, false);
3993
3994 /* VAL is the value which was stored, return a COMPOUND_STMT of
3995 the statement and that value. */
3996 return build2 (COMPOUND_EXPR, nonatomic_lhs_type, compound_stmt, val);
3997 }
3998
3999 /* Attempt to implement the atomic operation as an __atomic_fetch_* or
4000 __atomic_*_fetch built-in rather than a CAS loop. atomic_bool type
4001 isn't applicable for such builtins. ??? Do we want to handle enums? */
4002 if ((TREE_CODE (lhs_type) == INTEGER_TYPE || POINTER_TYPE_P (lhs_type))
4003 && TREE_CODE (rhs_type) == INTEGER_TYPE)
4004 {
4005 built_in_function fncode;
4006 switch (modifycode)
4007 {
4008 case PLUS_EXPR:
4009 case POINTER_PLUS_EXPR:
4010 fncode = (return_old_p
4011 ? BUILT_IN_ATOMIC_FETCH_ADD_N
4012 : BUILT_IN_ATOMIC_ADD_FETCH_N);
4013 break;
4014 case MINUS_EXPR:
4015 fncode = (return_old_p
4016 ? BUILT_IN_ATOMIC_FETCH_SUB_N
4017 : BUILT_IN_ATOMIC_SUB_FETCH_N);
4018 break;
4019 case BIT_AND_EXPR:
4020 fncode = (return_old_p
4021 ? BUILT_IN_ATOMIC_FETCH_AND_N
4022 : BUILT_IN_ATOMIC_AND_FETCH_N);
4023 break;
4024 case BIT_IOR_EXPR:
4025 fncode = (return_old_p
4026 ? BUILT_IN_ATOMIC_FETCH_OR_N
4027 : BUILT_IN_ATOMIC_OR_FETCH_N);
4028 break;
4029 case BIT_XOR_EXPR:
4030 fncode = (return_old_p
4031 ? BUILT_IN_ATOMIC_FETCH_XOR_N
4032 : BUILT_IN_ATOMIC_XOR_FETCH_N);
4033 break;
4034 default:
4035 goto cas_loop;
4036 }
4037
4038 /* We can only use "_1" through "_16" variants of the atomic fetch
4039 built-ins. */
4040 unsigned HOST_WIDE_INT size = tree_to_uhwi (TYPE_SIZE_UNIT (lhs_type));
4041 if (size != 1 && size != 2 && size != 4 && size != 8 && size != 16)
4042 goto cas_loop;
4043
4044 /* If this is a pointer type, we need to multiply by the size of
4045 the pointer target type. */
4046 if (POINTER_TYPE_P (lhs_type))
4047 {
4048 if (!COMPLETE_TYPE_P (TREE_TYPE (lhs_type))
4049 /* ??? This would introduce -Wdiscarded-qualifiers
4050 warning: __atomic_fetch_* expect volatile void *
4051 type as the first argument. (Assignments between
4052 atomic and non-atomic objects are OK.) */
4053 || TYPE_RESTRICT (lhs_type))
4054 goto cas_loop;
4055 tree sz = TYPE_SIZE_UNIT (TREE_TYPE (lhs_type));
4056 rhs = fold_build2_loc (loc, MULT_EXPR, ptrdiff_type_node,
4057 convert (ptrdiff_type_node, rhs),
4058 convert (ptrdiff_type_node, sz));
4059 }
4060
4061 /* Build __atomic_fetch_* (&lhs, &val, SEQ_CST), or
4062 __atomic_*_fetch (&lhs, &val, SEQ_CST). */
4063 fndecl = builtin_decl_explicit (fncode);
4064 params->quick_push (lhs_addr);
4065 params->quick_push (rhs);
4066 params->quick_push (seq_cst);
4067 func_call = c_build_function_call_vec (loc, vNULL, fndecl, params, NULL);
4068
4069 newval = create_tmp_var_raw (nonatomic_lhs_type);
4070 TREE_ADDRESSABLE (newval) = 1;
4071 TREE_NO_WARNING (newval) = 1;
4072 rhs = build4 (TARGET_EXPR, nonatomic_lhs_type, newval, func_call,
4073 NULL_TREE, NULL_TREE);
4074 SET_EXPR_LOCATION (rhs, loc);
4075 add_stmt (rhs);
4076
4077 /* Finish the compound statement. */
4078 compound_stmt = c_end_compound_stmt (loc, compound_stmt, false);
4079
4080 /* NEWVAL is the value which was stored, return a COMPOUND_STMT of
4081 the statement and that value. */
4082 return build2 (COMPOUND_EXPR, nonatomic_lhs_type, compound_stmt, newval);
4083 }
4084
4085 cas_loop:
4086 /* Create the variables and labels required for the op= form. */
4087 old = create_tmp_var_raw (nonatomic_lhs_type);
4088 old_addr = build_unary_op (loc, ADDR_EXPR, old, false);
4089 TREE_ADDRESSABLE (old) = 1;
4090 TREE_NO_WARNING (old) = 1;
4091
4092 newval = create_tmp_var_raw (nonatomic_lhs_type);
4093 newval_addr = build_unary_op (loc, ADDR_EXPR, newval, false);
4094 TREE_ADDRESSABLE (newval) = 1;
4095 TREE_NO_WARNING (newval) = 1;
4096
4097 loop_decl = create_artificial_label (loc);
4098 loop_label = build1 (LABEL_EXPR, void_type_node, loop_decl);
4099
4100 done_decl = create_artificial_label (loc);
4101 done_label = build1 (LABEL_EXPR, void_type_node, done_decl);
4102
4103 /* __atomic_load (addr, &old, SEQ_CST). */
4104 fndecl = builtin_decl_explicit (BUILT_IN_ATOMIC_LOAD);
4105 params->quick_push (lhs_addr);
4106 params->quick_push (old_addr);
4107 params->quick_push (seq_cst);
4108 func_call = c_build_function_call_vec (loc, vNULL, fndecl, params, NULL);
4109 old = build4 (TARGET_EXPR, nonatomic_lhs_type, old, func_call, NULL_TREE,
4110 NULL_TREE);
4111 add_stmt (old);
4112 params->truncate (0);
4113
4114 /* Create the expressions for floating-point environment
4115 manipulation, if required. */
4116 bool need_fenv = (flag_trapping_math
4117 && (FLOAT_TYPE_P (lhs_type) || FLOAT_TYPE_P (rhs_type)));
4118 tree hold_call = NULL_TREE, clear_call = NULL_TREE, update_call = NULL_TREE;
4119 if (need_fenv)
4120 targetm.atomic_assign_expand_fenv (&hold_call, &clear_call, &update_call);
4121
4122 if (hold_call)
4123 add_stmt (hold_call);
4124
4125 /* loop: */
4126 add_stmt (loop_label);
4127
4128 /* newval = old + val; */
4129 if (rhs_type != rhs_semantic_type)
4130 val = build1 (EXCESS_PRECISION_EXPR, nonatomic_rhs_semantic_type, val);
4131 rhs = build_binary_op (loc, modifycode, old, val, true);
4132 if (TREE_CODE (rhs) == EXCESS_PRECISION_EXPR)
4133 {
4134 tree eptype = TREE_TYPE (rhs);
4135 rhs = c_fully_fold (TREE_OPERAND (rhs, 0), false, NULL);
4136 rhs = build1 (EXCESS_PRECISION_EXPR, eptype, rhs);
4137 }
4138 else
4139 rhs = c_fully_fold (rhs, false, NULL);
4140 rhs = convert_for_assignment (loc, UNKNOWN_LOCATION, nonatomic_lhs_type,
4141 rhs, NULL_TREE, ic_assign, false, NULL_TREE,
4142 NULL_TREE, 0);
4143 if (rhs != error_mark_node)
4144 {
4145 rhs = build4 (TARGET_EXPR, nonatomic_lhs_type, newval, rhs, NULL_TREE,
4146 NULL_TREE);
4147 SET_EXPR_LOCATION (rhs, loc);
4148 add_stmt (rhs);
4149 }
4150
4151 /* if (__atomic_compare_exchange (addr, &old, &new, false, SEQ_CST, SEQ_CST))
4152 goto done; */
4153 fndecl = builtin_decl_explicit (BUILT_IN_ATOMIC_COMPARE_EXCHANGE);
4154 params->quick_push (lhs_addr);
4155 params->quick_push (old_addr);
4156 params->quick_push (newval_addr);
4157 params->quick_push (integer_zero_node);
4158 params->quick_push (seq_cst);
4159 params->quick_push (seq_cst);
4160 func_call = c_build_function_call_vec (loc, vNULL, fndecl, params, NULL);
4161
4162 goto_stmt = build1 (GOTO_EXPR, void_type_node, done_decl);
4163 SET_EXPR_LOCATION (goto_stmt, loc);
4164
4165 stmt = build3 (COND_EXPR, void_type_node, func_call, goto_stmt, NULL_TREE);
4166 SET_EXPR_LOCATION (stmt, loc);
4167 add_stmt (stmt);
4168
4169 if (clear_call)
4170 add_stmt (clear_call);
4171
4172 /* goto loop; */
4173 goto_stmt = build1 (GOTO_EXPR, void_type_node, loop_decl);
4174 SET_EXPR_LOCATION (goto_stmt, loc);
4175 add_stmt (goto_stmt);
4176
4177 /* done: */
4178 add_stmt (done_label);
4179
4180 if (update_call)
4181 add_stmt (update_call);
4182
4183 /* Finish the compound statement. */
4184 compound_stmt = c_end_compound_stmt (loc, compound_stmt, false);
4185
4186 /* NEWVAL is the value that was successfully stored, return a
4187 COMPOUND_EXPR of the statement and the appropriate value. */
4188 return build2 (COMPOUND_EXPR, nonatomic_lhs_type, compound_stmt,
4189 return_old_p ? old : newval);
4190 }
4191
4192 /* Construct and perhaps optimize a tree representation
4193 for a unary operation. CODE, a tree_code, specifies the operation
4194 and XARG is the operand.
4195 For any CODE other than ADDR_EXPR, NOCONVERT suppresses the default
4196 promotions (such as from short to int).
4197 For ADDR_EXPR, the default promotions are not applied; NOCONVERT allows
4198 non-lvalues; this is only used to handle conversion of non-lvalue arrays
4199 to pointers in C99.
4200
4201 LOCATION is the location of the operator. */
4202
4203 tree
build_unary_op(location_t location,enum tree_code code,tree xarg,bool noconvert)4204 build_unary_op (location_t location, enum tree_code code, tree xarg,
4205 bool noconvert)
4206 {
4207 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
4208 tree arg = xarg;
4209 tree argtype = NULL_TREE;
4210 enum tree_code typecode;
4211 tree val;
4212 tree ret = error_mark_node;
4213 tree eptype = NULL_TREE;
4214 const char *invalid_op_diag;
4215 bool int_operands;
4216
4217 int_operands = EXPR_INT_CONST_OPERANDS (xarg);
4218 if (int_operands)
4219 arg = remove_c_maybe_const_expr (arg);
4220
4221 if (code != ADDR_EXPR)
4222 arg = require_complete_type (location, arg);
4223
4224 typecode = TREE_CODE (TREE_TYPE (arg));
4225 if (typecode == ERROR_MARK)
4226 return error_mark_node;
4227 if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE)
4228 typecode = INTEGER_TYPE;
4229
4230 if ((invalid_op_diag
4231 = targetm.invalid_unary_op (code, TREE_TYPE (xarg))))
4232 {
4233 error_at (location, invalid_op_diag);
4234 return error_mark_node;
4235 }
4236
4237 if (TREE_CODE (arg) == EXCESS_PRECISION_EXPR)
4238 {
4239 eptype = TREE_TYPE (arg);
4240 arg = TREE_OPERAND (arg, 0);
4241 }
4242
4243 switch (code)
4244 {
4245 case CONVERT_EXPR:
4246 /* This is used for unary plus, because a CONVERT_EXPR
4247 is enough to prevent anybody from looking inside for
4248 associativity, but won't generate any code. */
4249 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
4250 || typecode == FIXED_POINT_TYPE || typecode == COMPLEX_TYPE
4251 || typecode == VECTOR_TYPE))
4252 {
4253 error_at (location, "wrong type argument to unary plus");
4254 return error_mark_node;
4255 }
4256 else if (!noconvert)
4257 arg = default_conversion (arg);
4258 arg = non_lvalue_loc (location, arg);
4259 break;
4260
4261 case NEGATE_EXPR:
4262 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
4263 || typecode == FIXED_POINT_TYPE || typecode == COMPLEX_TYPE
4264 || typecode == VECTOR_TYPE))
4265 {
4266 error_at (location, "wrong type argument to unary minus");
4267 return error_mark_node;
4268 }
4269 else if (!noconvert)
4270 arg = default_conversion (arg);
4271 break;
4272
4273 case BIT_NOT_EXPR:
4274 /* ~ works on integer types and non float vectors. */
4275 if (typecode == INTEGER_TYPE
4276 || (typecode == VECTOR_TYPE
4277 && !VECTOR_FLOAT_TYPE_P (TREE_TYPE (arg))))
4278 {
4279 tree e = arg;
4280
4281 /* Warn if the expression has boolean value. */
4282 while (TREE_CODE (e) == COMPOUND_EXPR)
4283 e = TREE_OPERAND (e, 1);
4284
4285 if ((TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE
4286 || truth_value_p (TREE_CODE (e)))
4287 && warning_at (location, OPT_Wbool_operation,
4288 "%<~%> on a boolean expression"))
4289 {
4290 gcc_rich_location richloc (location);
4291 richloc.add_fixit_insert_before (location, "!");
4292 inform (&richloc, "did you mean to use logical not?");
4293 }
4294 if (!noconvert)
4295 arg = default_conversion (arg);
4296 }
4297 else if (typecode == COMPLEX_TYPE)
4298 {
4299 code = CONJ_EXPR;
4300 pedwarn (location, OPT_Wpedantic,
4301 "ISO C does not support %<~%> for complex conjugation");
4302 if (!noconvert)
4303 arg = default_conversion (arg);
4304 }
4305 else
4306 {
4307 error_at (location, "wrong type argument to bit-complement");
4308 return error_mark_node;
4309 }
4310 break;
4311
4312 case ABS_EXPR:
4313 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE))
4314 {
4315 error_at (location, "wrong type argument to abs");
4316 return error_mark_node;
4317 }
4318 else if (!noconvert)
4319 arg = default_conversion (arg);
4320 break;
4321
4322 case CONJ_EXPR:
4323 /* Conjugating a real value is a no-op, but allow it anyway. */
4324 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
4325 || typecode == COMPLEX_TYPE))
4326 {
4327 error_at (location, "wrong type argument to conjugation");
4328 return error_mark_node;
4329 }
4330 else if (!noconvert)
4331 arg = default_conversion (arg);
4332 break;
4333
4334 case TRUTH_NOT_EXPR:
4335 if (typecode != INTEGER_TYPE && typecode != FIXED_POINT_TYPE
4336 && typecode != REAL_TYPE && typecode != POINTER_TYPE
4337 && typecode != COMPLEX_TYPE)
4338 {
4339 error_at (location,
4340 "wrong type argument to unary exclamation mark");
4341 return error_mark_node;
4342 }
4343 if (int_operands)
4344 {
4345 arg = c_objc_common_truthvalue_conversion (location, xarg);
4346 arg = remove_c_maybe_const_expr (arg);
4347 }
4348 else
4349 arg = c_objc_common_truthvalue_conversion (location, arg);
4350 ret = invert_truthvalue_loc (location, arg);
4351 /* If the TRUTH_NOT_EXPR has been folded, reset the location. */
4352 if (EXPR_P (ret) && EXPR_HAS_LOCATION (ret))
4353 location = EXPR_LOCATION (ret);
4354 goto return_build_unary_op;
4355
4356 case REALPART_EXPR:
4357 case IMAGPART_EXPR:
4358 ret = build_real_imag_expr (location, code, arg);
4359 if (ret == error_mark_node)
4360 return error_mark_node;
4361 if (eptype && TREE_CODE (eptype) == COMPLEX_TYPE)
4362 eptype = TREE_TYPE (eptype);
4363 goto return_build_unary_op;
4364
4365 case PREINCREMENT_EXPR:
4366 case POSTINCREMENT_EXPR:
4367 case PREDECREMENT_EXPR:
4368 case POSTDECREMENT_EXPR:
4369
4370 if (TREE_CODE (arg) == C_MAYBE_CONST_EXPR)
4371 {
4372 tree inner = build_unary_op (location, code,
4373 C_MAYBE_CONST_EXPR_EXPR (arg),
4374 noconvert);
4375 if (inner == error_mark_node)
4376 return error_mark_node;
4377 ret = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (inner),
4378 C_MAYBE_CONST_EXPR_PRE (arg), inner);
4379 gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (arg));
4380 C_MAYBE_CONST_EXPR_NON_CONST (ret) = 1;
4381 goto return_build_unary_op;
4382 }
4383
4384 /* Complain about anything that is not a true lvalue. In
4385 Objective-C, skip this check for property_refs. */
4386 if (!objc_is_property_ref (arg)
4387 && !lvalue_or_else (location,
4388 arg, ((code == PREINCREMENT_EXPR
4389 || code == POSTINCREMENT_EXPR)
4390 ? lv_increment
4391 : lv_decrement)))
4392 return error_mark_node;
4393
4394 if (warn_cxx_compat && TREE_CODE (TREE_TYPE (arg)) == ENUMERAL_TYPE)
4395 {
4396 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
4397 warning_at (location, OPT_Wc___compat,
4398 "increment of enumeration value is invalid in C++");
4399 else
4400 warning_at (location, OPT_Wc___compat,
4401 "decrement of enumeration value is invalid in C++");
4402 }
4403
4404 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
4405 {
4406 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
4407 warning_at (location, OPT_Wbool_operation,
4408 "increment of a boolean expression");
4409 else
4410 warning_at (location, OPT_Wbool_operation,
4411 "decrement of a boolean expression");
4412 }
4413
4414 /* Ensure the argument is fully folded inside any SAVE_EXPR. */
4415 arg = c_fully_fold (arg, false, NULL, true);
4416
4417 bool atomic_op;
4418 atomic_op = really_atomic_lvalue (arg);
4419
4420 /* Increment or decrement the real part of the value,
4421 and don't change the imaginary part. */
4422 if (typecode == COMPLEX_TYPE)
4423 {
4424 tree real, imag;
4425
4426 pedwarn (location, OPT_Wpedantic,
4427 "ISO C does not support %<++%> and %<--%> on complex types");
4428
4429 if (!atomic_op)
4430 {
4431 arg = stabilize_reference (arg);
4432 real = build_unary_op (EXPR_LOCATION (arg), REALPART_EXPR, arg,
4433 true);
4434 imag = build_unary_op (EXPR_LOCATION (arg), IMAGPART_EXPR, arg,
4435 true);
4436 real = build_unary_op (EXPR_LOCATION (arg), code, real, true);
4437 if (real == error_mark_node || imag == error_mark_node)
4438 return error_mark_node;
4439 ret = build2 (COMPLEX_EXPR, TREE_TYPE (arg),
4440 real, imag);
4441 goto return_build_unary_op;
4442 }
4443 }
4444
4445 /* Report invalid types. */
4446
4447 if (typecode != POINTER_TYPE && typecode != FIXED_POINT_TYPE
4448 && typecode != INTEGER_TYPE && typecode != REAL_TYPE
4449 && typecode != COMPLEX_TYPE && typecode != VECTOR_TYPE)
4450 {
4451 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
4452 error_at (location, "wrong type argument to increment");
4453 else
4454 error_at (location, "wrong type argument to decrement");
4455
4456 return error_mark_node;
4457 }
4458
4459 {
4460 tree inc;
4461
4462 argtype = TREE_TYPE (arg);
4463
4464 /* Compute the increment. */
4465
4466 if (typecode == POINTER_TYPE)
4467 {
4468 /* If pointer target is an incomplete type,
4469 we just cannot know how to do the arithmetic. */
4470 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (argtype)))
4471 {
4472 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
4473 error_at (location,
4474 "increment of pointer to an incomplete type %qT",
4475 TREE_TYPE (argtype));
4476 else
4477 error_at (location,
4478 "decrement of pointer to an incomplete type %qT",
4479 TREE_TYPE (argtype));
4480 }
4481 else if (TREE_CODE (TREE_TYPE (argtype)) == FUNCTION_TYPE
4482 || TREE_CODE (TREE_TYPE (argtype)) == VOID_TYPE)
4483 {
4484 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
4485 pedwarn (location, OPT_Wpointer_arith,
4486 "wrong type argument to increment");
4487 else
4488 pedwarn (location, OPT_Wpointer_arith,
4489 "wrong type argument to decrement");
4490 }
4491
4492 inc = c_size_in_bytes (TREE_TYPE (argtype));
4493 inc = convert_to_ptrofftype_loc (location, inc);
4494 }
4495 else if (FRACT_MODE_P (TYPE_MODE (argtype)))
4496 {
4497 /* For signed fract types, we invert ++ to -- or
4498 -- to ++, and change inc from 1 to -1, because
4499 it is not possible to represent 1 in signed fract constants.
4500 For unsigned fract types, the result always overflows and
4501 we get an undefined (original) or the maximum value. */
4502 if (code == PREINCREMENT_EXPR)
4503 code = PREDECREMENT_EXPR;
4504 else if (code == PREDECREMENT_EXPR)
4505 code = PREINCREMENT_EXPR;
4506 else if (code == POSTINCREMENT_EXPR)
4507 code = POSTDECREMENT_EXPR;
4508 else /* code == POSTDECREMENT_EXPR */
4509 code = POSTINCREMENT_EXPR;
4510
4511 inc = integer_minus_one_node;
4512 inc = convert (argtype, inc);
4513 }
4514 else
4515 {
4516 inc = VECTOR_TYPE_P (argtype)
4517 ? build_one_cst (argtype)
4518 : integer_one_node;
4519 inc = convert (argtype, inc);
4520 }
4521
4522 /* If 'arg' is an Objective-C PROPERTY_REF expression, then we
4523 need to ask Objective-C to build the increment or decrement
4524 expression for it. */
4525 if (objc_is_property_ref (arg))
4526 return objc_build_incr_expr_for_property_ref (location, code,
4527 arg, inc);
4528
4529 /* Report a read-only lvalue. */
4530 if (TYPE_READONLY (argtype))
4531 {
4532 readonly_error (location, arg,
4533 ((code == PREINCREMENT_EXPR
4534 || code == POSTINCREMENT_EXPR)
4535 ? lv_increment : lv_decrement));
4536 return error_mark_node;
4537 }
4538 else if (TREE_READONLY (arg))
4539 readonly_warning (arg,
4540 ((code == PREINCREMENT_EXPR
4541 || code == POSTINCREMENT_EXPR)
4542 ? lv_increment : lv_decrement));
4543
4544 /* If the argument is atomic, use the special code sequences for
4545 atomic compound assignment. */
4546 if (atomic_op)
4547 {
4548 arg = stabilize_reference (arg);
4549 ret = build_atomic_assign (location, arg,
4550 ((code == PREINCREMENT_EXPR
4551 || code == POSTINCREMENT_EXPR)
4552 ? PLUS_EXPR
4553 : MINUS_EXPR),
4554 (FRACT_MODE_P (TYPE_MODE (argtype))
4555 ? inc
4556 : integer_one_node),
4557 (code == POSTINCREMENT_EXPR
4558 || code == POSTDECREMENT_EXPR));
4559 goto return_build_unary_op;
4560 }
4561
4562 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
4563 val = boolean_increment (code, arg);
4564 else
4565 val = build2 (code, TREE_TYPE (arg), arg, inc);
4566 TREE_SIDE_EFFECTS (val) = 1;
4567 if (TREE_CODE (val) != code)
4568 TREE_NO_WARNING (val) = 1;
4569 ret = val;
4570 goto return_build_unary_op;
4571 }
4572
4573 case ADDR_EXPR:
4574 /* Note that this operation never does default_conversion. */
4575
4576 /* The operand of unary '&' must be an lvalue (which excludes
4577 expressions of type void), or, in C99, the result of a [] or
4578 unary '*' operator. */
4579 if (VOID_TYPE_P (TREE_TYPE (arg))
4580 && TYPE_QUALS (TREE_TYPE (arg)) == TYPE_UNQUALIFIED
4581 && (!INDIRECT_REF_P (arg) || !flag_isoc99))
4582 pedwarn (location, 0, "taking address of expression of type %<void%>");
4583
4584 /* Let &* cancel out to simplify resulting code. */
4585 if (INDIRECT_REF_P (arg))
4586 {
4587 /* Don't let this be an lvalue. */
4588 if (lvalue_p (TREE_OPERAND (arg, 0)))
4589 return non_lvalue_loc (location, TREE_OPERAND (arg, 0));
4590 ret = TREE_OPERAND (arg, 0);
4591 goto return_build_unary_op;
4592 }
4593
4594 /* Anything not already handled and not a true memory reference
4595 or a non-lvalue array is an error. */
4596 if (typecode != FUNCTION_TYPE && !noconvert
4597 && !lvalue_or_else (location, arg, lv_addressof))
4598 return error_mark_node;
4599
4600 /* Move address operations inside C_MAYBE_CONST_EXPR to simplify
4601 folding later. */
4602 if (TREE_CODE (arg) == C_MAYBE_CONST_EXPR)
4603 {
4604 tree inner = build_unary_op (location, code,
4605 C_MAYBE_CONST_EXPR_EXPR (arg),
4606 noconvert);
4607 ret = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (inner),
4608 C_MAYBE_CONST_EXPR_PRE (arg), inner);
4609 gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (arg));
4610 C_MAYBE_CONST_EXPR_NON_CONST (ret)
4611 = C_MAYBE_CONST_EXPR_NON_CONST (arg);
4612 goto return_build_unary_op;
4613 }
4614
4615 /* Ordinary case; arg is a COMPONENT_REF or a decl. */
4616 argtype = TREE_TYPE (arg);
4617
4618 /* If the lvalue is const or volatile, merge that into the type
4619 to which the address will point. This is only needed
4620 for function types. */
4621 if ((DECL_P (arg) || REFERENCE_CLASS_P (arg))
4622 && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg))
4623 && TREE_CODE (argtype) == FUNCTION_TYPE)
4624 {
4625 int orig_quals = TYPE_QUALS (strip_array_types (argtype));
4626 int quals = orig_quals;
4627
4628 if (TREE_READONLY (arg))
4629 quals |= TYPE_QUAL_CONST;
4630 if (TREE_THIS_VOLATILE (arg))
4631 quals |= TYPE_QUAL_VOLATILE;
4632
4633 argtype = c_build_qualified_type (argtype, quals);
4634 }
4635
4636 switch (TREE_CODE (arg))
4637 {
4638 case COMPONENT_REF:
4639 if (DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)))
4640 {
4641 error_at (location, "cannot take address of bit-field %qD",
4642 TREE_OPERAND (arg, 1));
4643 return error_mark_node;
4644 }
4645
4646 /* fall through */
4647
4648 case ARRAY_REF:
4649 if (TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (TREE_OPERAND (arg, 0))))
4650 {
4651 if (!AGGREGATE_TYPE_P (TREE_TYPE (arg))
4652 && !VECTOR_TYPE_P (TREE_TYPE (arg)))
4653 {
4654 error_at (location, "cannot take address of scalar with "
4655 "reverse storage order");
4656 return error_mark_node;
4657 }
4658
4659 if (TREE_CODE (TREE_TYPE (arg)) == ARRAY_TYPE
4660 && TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (arg)))
4661 warning_at (location, OPT_Wscalar_storage_order,
4662 "address of array with reverse scalar storage "
4663 "order requested");
4664 }
4665
4666 default:
4667 break;
4668 }
4669
4670 if (!c_mark_addressable (arg))
4671 return error_mark_node;
4672
4673 gcc_assert (TREE_CODE (arg) != COMPONENT_REF
4674 || !DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)));
4675
4676 argtype = build_pointer_type (argtype);
4677
4678 /* ??? Cope with user tricks that amount to offsetof. Delete this
4679 when we have proper support for integer constant expressions. */
4680 val = get_base_address (arg);
4681 if (val && INDIRECT_REF_P (val)
4682 && TREE_CONSTANT (TREE_OPERAND (val, 0)))
4683 {
4684 ret = fold_offsetof (arg, argtype);
4685 goto return_build_unary_op;
4686 }
4687
4688 val = build1 (ADDR_EXPR, argtype, arg);
4689
4690 ret = val;
4691 goto return_build_unary_op;
4692
4693 default:
4694 gcc_unreachable ();
4695 }
4696
4697 if (argtype == NULL_TREE)
4698 argtype = TREE_TYPE (arg);
4699 if (TREE_CODE (arg) == INTEGER_CST)
4700 ret = (require_constant_value
4701 ? fold_build1_initializer_loc (location, code, argtype, arg)
4702 : fold_build1_loc (location, code, argtype, arg));
4703 else
4704 ret = build1 (code, argtype, arg);
4705 return_build_unary_op:
4706 gcc_assert (ret != error_mark_node);
4707 if (TREE_CODE (ret) == INTEGER_CST && !TREE_OVERFLOW (ret)
4708 && !(TREE_CODE (xarg) == INTEGER_CST && !TREE_OVERFLOW (xarg)))
4709 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
4710 else if (TREE_CODE (ret) != INTEGER_CST && int_operands)
4711 ret = note_integer_operands (ret);
4712 if (eptype)
4713 ret = build1 (EXCESS_PRECISION_EXPR, eptype, ret);
4714 protected_set_expr_location (ret, location);
4715 return ret;
4716 }
4717
4718 /* Return nonzero if REF is an lvalue valid for this language.
4719 Lvalues can be assigned, unless their type has TYPE_READONLY.
4720 Lvalues can have their address taken, unless they have C_DECL_REGISTER. */
4721
4722 bool
lvalue_p(const_tree ref)4723 lvalue_p (const_tree ref)
4724 {
4725 const enum tree_code code = TREE_CODE (ref);
4726
4727 switch (code)
4728 {
4729 case REALPART_EXPR:
4730 case IMAGPART_EXPR:
4731 case COMPONENT_REF:
4732 return lvalue_p (TREE_OPERAND (ref, 0));
4733
4734 case C_MAYBE_CONST_EXPR:
4735 return lvalue_p (TREE_OPERAND (ref, 1));
4736
4737 case COMPOUND_LITERAL_EXPR:
4738 case STRING_CST:
4739 return true;
4740
4741 case INDIRECT_REF:
4742 case ARRAY_REF:
4743 case VAR_DECL:
4744 case PARM_DECL:
4745 case RESULT_DECL:
4746 case ERROR_MARK:
4747 return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
4748 && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
4749
4750 case BIND_EXPR:
4751 return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
4752
4753 default:
4754 return false;
4755 }
4756 }
4757
4758 /* Give a warning for storing in something that is read-only in GCC
4759 terms but not const in ISO C terms. */
4760
4761 static void
readonly_warning(tree arg,enum lvalue_use use)4762 readonly_warning (tree arg, enum lvalue_use use)
4763 {
4764 switch (use)
4765 {
4766 case lv_assign:
4767 warning (0, "assignment of read-only location %qE", arg);
4768 break;
4769 case lv_increment:
4770 warning (0, "increment of read-only location %qE", arg);
4771 break;
4772 case lv_decrement:
4773 warning (0, "decrement of read-only location %qE", arg);
4774 break;
4775 default:
4776 gcc_unreachable ();
4777 }
4778 return;
4779 }
4780
4781
4782 /* Return nonzero if REF is an lvalue valid for this language;
4783 otherwise, print an error message and return zero. USE says
4784 how the lvalue is being used and so selects the error message.
4785 LOCATION is the location at which any error should be reported. */
4786
4787 static int
lvalue_or_else(location_t loc,const_tree ref,enum lvalue_use use)4788 lvalue_or_else (location_t loc, const_tree ref, enum lvalue_use use)
4789 {
4790 int win = lvalue_p (ref);
4791
4792 if (!win)
4793 lvalue_error (loc, use);
4794
4795 return win;
4796 }
4797
4798 /* Mark EXP saying that we need to be able to take the
4799 address of it; it should not be allocated in a register.
4800 Returns true if successful. ARRAY_REF_P is true if this
4801 is for ARRAY_REF construction - in that case we don't want
4802 to look through VIEW_CONVERT_EXPR from VECTOR_TYPE to ARRAY_TYPE,
4803 it is fine to use ARRAY_REFs for vector subscripts on vector
4804 register variables. */
4805
4806 bool
c_mark_addressable(tree exp,bool array_ref_p)4807 c_mark_addressable (tree exp, bool array_ref_p)
4808 {
4809 tree x = exp;
4810
4811 while (1)
4812 switch (TREE_CODE (x))
4813 {
4814 case VIEW_CONVERT_EXPR:
4815 if (array_ref_p
4816 && TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
4817 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (x, 0))))
4818 return true;
4819 /* FALLTHRU */
4820 case COMPONENT_REF:
4821 case ADDR_EXPR:
4822 case ARRAY_REF:
4823 case REALPART_EXPR:
4824 case IMAGPART_EXPR:
4825 x = TREE_OPERAND (x, 0);
4826 break;
4827
4828 case COMPOUND_LITERAL_EXPR:
4829 case CONSTRUCTOR:
4830 TREE_ADDRESSABLE (x) = 1;
4831 return true;
4832
4833 case VAR_DECL:
4834 case CONST_DECL:
4835 case PARM_DECL:
4836 case RESULT_DECL:
4837 if (C_DECL_REGISTER (x)
4838 && DECL_NONLOCAL (x))
4839 {
4840 if (TREE_PUBLIC (x) || is_global_var (x))
4841 {
4842 error
4843 ("global register variable %qD used in nested function", x);
4844 return false;
4845 }
4846 pedwarn (input_location, 0, "register variable %qD used in nested function", x);
4847 }
4848 else if (C_DECL_REGISTER (x))
4849 {
4850 if (TREE_PUBLIC (x) || is_global_var (x))
4851 error ("address of global register variable %qD requested", x);
4852 else
4853 error ("address of register variable %qD requested", x);
4854 return false;
4855 }
4856
4857 /* FALLTHRU */
4858 case FUNCTION_DECL:
4859 TREE_ADDRESSABLE (x) = 1;
4860 /* FALLTHRU */
4861 default:
4862 return true;
4863 }
4864 }
4865
4866 /* Convert EXPR to TYPE, warning about conversion problems with
4867 constants. SEMANTIC_TYPE is the type this conversion would use
4868 without excess precision. If SEMANTIC_TYPE is NULL, this function
4869 is equivalent to convert_and_check. This function is a wrapper that
4870 handles conversions that may be different than
4871 the usual ones because of excess precision. */
4872
4873 static tree
ep_convert_and_check(location_t loc,tree type,tree expr,tree semantic_type)4874 ep_convert_and_check (location_t loc, tree type, tree expr,
4875 tree semantic_type)
4876 {
4877 if (TREE_TYPE (expr) == type)
4878 return expr;
4879
4880 /* For C11, integer conversions may have results with excess
4881 precision. */
4882 if (flag_isoc11 || !semantic_type)
4883 return convert_and_check (loc, type, expr);
4884
4885 if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
4886 && TREE_TYPE (expr) != semantic_type)
4887 {
4888 /* For integers, we need to check the real conversion, not
4889 the conversion to the excess precision type. */
4890 expr = convert_and_check (loc, semantic_type, expr);
4891 }
4892 /* Result type is the excess precision type, which should be
4893 large enough, so do not check. */
4894 return convert (type, expr);
4895 }
4896
4897 /* Build and return a conditional expression IFEXP ? OP1 : OP2. If
4898 IFEXP_BCP then the condition is a call to __builtin_constant_p, and
4899 if folded to an integer constant then the unselected half may
4900 contain arbitrary operations not normally permitted in constant
4901 expressions. Set the location of the expression to LOC. */
4902
4903 tree
build_conditional_expr(location_t colon_loc,tree ifexp,bool ifexp_bcp,tree op1,tree op1_original_type,location_t op1_loc,tree op2,tree op2_original_type,location_t op2_loc)4904 build_conditional_expr (location_t colon_loc, tree ifexp, bool ifexp_bcp,
4905 tree op1, tree op1_original_type, location_t op1_loc,
4906 tree op2, tree op2_original_type, location_t op2_loc)
4907 {
4908 tree type1;
4909 tree type2;
4910 enum tree_code code1;
4911 enum tree_code code2;
4912 tree result_type = NULL;
4913 tree semantic_result_type = NULL;
4914 tree orig_op1 = op1, orig_op2 = op2;
4915 bool int_const, op1_int_operands, op2_int_operands, int_operands;
4916 bool ifexp_int_operands;
4917 tree ret;
4918
4919 op1_int_operands = EXPR_INT_CONST_OPERANDS (orig_op1);
4920 if (op1_int_operands)
4921 op1 = remove_c_maybe_const_expr (op1);
4922 op2_int_operands = EXPR_INT_CONST_OPERANDS (orig_op2);
4923 if (op2_int_operands)
4924 op2 = remove_c_maybe_const_expr (op2);
4925 ifexp_int_operands = EXPR_INT_CONST_OPERANDS (ifexp);
4926 if (ifexp_int_operands)
4927 ifexp = remove_c_maybe_const_expr (ifexp);
4928
4929 /* Promote both alternatives. */
4930
4931 if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
4932 op1 = default_conversion (op1);
4933 if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
4934 op2 = default_conversion (op2);
4935
4936 if (TREE_CODE (ifexp) == ERROR_MARK
4937 || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
4938 || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
4939 return error_mark_node;
4940
4941 type1 = TREE_TYPE (op1);
4942 code1 = TREE_CODE (type1);
4943 type2 = TREE_TYPE (op2);
4944 code2 = TREE_CODE (type2);
4945
4946 if (code1 == POINTER_TYPE && reject_gcc_builtin (op1))
4947 return error_mark_node;
4948
4949 if (code2 == POINTER_TYPE && reject_gcc_builtin (op2))
4950 return error_mark_node;
4951
4952 /* C90 does not permit non-lvalue arrays in conditional expressions.
4953 In C99 they will be pointers by now. */
4954 if (code1 == ARRAY_TYPE || code2 == ARRAY_TYPE)
4955 {
4956 error_at (colon_loc, "non-lvalue array in conditional expression");
4957 return error_mark_node;
4958 }
4959
4960 if ((TREE_CODE (op1) == EXCESS_PRECISION_EXPR
4961 || TREE_CODE (op2) == EXCESS_PRECISION_EXPR)
4962 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
4963 || code1 == COMPLEX_TYPE)
4964 && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
4965 || code2 == COMPLEX_TYPE))
4966 {
4967 semantic_result_type = c_common_type (type1, type2);
4968 if (TREE_CODE (op1) == EXCESS_PRECISION_EXPR)
4969 {
4970 op1 = TREE_OPERAND (op1, 0);
4971 type1 = TREE_TYPE (op1);
4972 gcc_assert (TREE_CODE (type1) == code1);
4973 }
4974 if (TREE_CODE (op2) == EXCESS_PRECISION_EXPR)
4975 {
4976 op2 = TREE_OPERAND (op2, 0);
4977 type2 = TREE_TYPE (op2);
4978 gcc_assert (TREE_CODE (type2) == code2);
4979 }
4980 }
4981
4982 if (warn_cxx_compat)
4983 {
4984 tree t1 = op1_original_type ? op1_original_type : TREE_TYPE (orig_op1);
4985 tree t2 = op2_original_type ? op2_original_type : TREE_TYPE (orig_op2);
4986
4987 if (TREE_CODE (t1) == ENUMERAL_TYPE
4988 && TREE_CODE (t2) == ENUMERAL_TYPE
4989 && TYPE_MAIN_VARIANT (t1) != TYPE_MAIN_VARIANT (t2))
4990 warning_at (colon_loc, OPT_Wc___compat,
4991 ("different enum types in conditional is "
4992 "invalid in C++: %qT vs %qT"),
4993 t1, t2);
4994 }
4995
4996 /* Quickly detect the usual case where op1 and op2 have the same type
4997 after promotion. */
4998 if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
4999 {
5000 if (type1 == type2)
5001 result_type = type1;
5002 else
5003 result_type = TYPE_MAIN_VARIANT (type1);
5004 }
5005 else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE
5006 || code1 == COMPLEX_TYPE)
5007 && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
5008 || code2 == COMPLEX_TYPE))
5009 {
5010 /* In C11, a conditional expression between a floating-point
5011 type and an integer type should convert the integer type to
5012 the evaluation format of the floating-point type, with
5013 possible excess precision. */
5014 tree eptype1 = type1;
5015 tree eptype2 = type2;
5016 if (flag_isoc11)
5017 {
5018 tree eptype;
5019 if (ANY_INTEGRAL_TYPE_P (type1)
5020 && (eptype = excess_precision_type (type2)) != NULL_TREE)
5021 {
5022 eptype2 = eptype;
5023 if (!semantic_result_type)
5024 semantic_result_type = c_common_type (type1, type2);
5025 }
5026 else if (ANY_INTEGRAL_TYPE_P (type2)
5027 && (eptype = excess_precision_type (type1)) != NULL_TREE)
5028 {
5029 eptype1 = eptype;
5030 if (!semantic_result_type)
5031 semantic_result_type = c_common_type (type1, type2);
5032 }
5033 }
5034 result_type = c_common_type (eptype1, eptype2);
5035 if (result_type == error_mark_node)
5036 return error_mark_node;
5037 do_warn_double_promotion (result_type, type1, type2,
5038 "implicit conversion from %qT to %qT to "
5039 "match other result of conditional",
5040 colon_loc);
5041
5042 /* If -Wsign-compare, warn here if type1 and type2 have
5043 different signedness. We'll promote the signed to unsigned
5044 and later code won't know it used to be different.
5045 Do this check on the original types, so that explicit casts
5046 will be considered, but default promotions won't. */
5047 if (c_inhibit_evaluation_warnings == 0)
5048 {
5049 int unsigned_op1 = TYPE_UNSIGNED (TREE_TYPE (orig_op1));
5050 int unsigned_op2 = TYPE_UNSIGNED (TREE_TYPE (orig_op2));
5051
5052 if (unsigned_op1 ^ unsigned_op2)
5053 {
5054 bool ovf;
5055
5056 /* Do not warn if the result type is signed, since the
5057 signed type will only be chosen if it can represent
5058 all the values of the unsigned type. */
5059 if (!TYPE_UNSIGNED (result_type))
5060 /* OK */;
5061 else
5062 {
5063 bool op1_maybe_const = true;
5064 bool op2_maybe_const = true;
5065
5066 /* Do not warn if the signed quantity is an
5067 unsuffixed integer literal (or some static
5068 constant expression involving such literals) and
5069 it is non-negative. This warning requires the
5070 operands to be folded for best results, so do
5071 that folding in this case even without
5072 warn_sign_compare to avoid warning options
5073 possibly affecting code generation. */
5074 c_inhibit_evaluation_warnings
5075 += (ifexp == truthvalue_false_node);
5076 op1 = c_fully_fold (op1, require_constant_value,
5077 &op1_maybe_const);
5078 c_inhibit_evaluation_warnings
5079 -= (ifexp == truthvalue_false_node);
5080
5081 c_inhibit_evaluation_warnings
5082 += (ifexp == truthvalue_true_node);
5083 op2 = c_fully_fold (op2, require_constant_value,
5084 &op2_maybe_const);
5085 c_inhibit_evaluation_warnings
5086 -= (ifexp == truthvalue_true_node);
5087
5088 if (warn_sign_compare)
5089 {
5090 if ((unsigned_op2
5091 && tree_expr_nonnegative_warnv_p (op1, &ovf))
5092 || (unsigned_op1
5093 && tree_expr_nonnegative_warnv_p (op2, &ovf)))
5094 /* OK */;
5095 else if (unsigned_op2)
5096 warning_at (op1_loc, OPT_Wsign_compare,
5097 "operand of ?: changes signedness from "
5098 "%qT to %qT due to unsignedness of other "
5099 "operand", TREE_TYPE (orig_op1),
5100 TREE_TYPE (orig_op2));
5101 else
5102 warning_at (op2_loc, OPT_Wsign_compare,
5103 "operand of ?: changes signedness from "
5104 "%qT to %qT due to unsignedness of other "
5105 "operand", TREE_TYPE (orig_op2),
5106 TREE_TYPE (orig_op1));
5107 }
5108 if (!op1_maybe_const || TREE_CODE (op1) != INTEGER_CST)
5109 op1 = c_wrap_maybe_const (op1, !op1_maybe_const);
5110 if (!op2_maybe_const || TREE_CODE (op2) != INTEGER_CST)
5111 op2 = c_wrap_maybe_const (op2, !op2_maybe_const);
5112 }
5113 }
5114 }
5115 }
5116 else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
5117 {
5118 if (code1 != VOID_TYPE || code2 != VOID_TYPE)
5119 pedwarn (colon_loc, OPT_Wpedantic,
5120 "ISO C forbids conditional expr with only one void side");
5121 result_type = void_type_node;
5122 }
5123 else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
5124 {
5125 addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (type1));
5126 addr_space_t as2 = TYPE_ADDR_SPACE (TREE_TYPE (type2));
5127 addr_space_t as_common;
5128
5129 if (comp_target_types (colon_loc, type1, type2))
5130 result_type = common_pointer_type (type1, type2);
5131 else if (null_pointer_constant_p (orig_op1))
5132 result_type = type2;
5133 else if (null_pointer_constant_p (orig_op2))
5134 result_type = type1;
5135 else if (!addr_space_superset (as1, as2, &as_common))
5136 {
5137 error_at (colon_loc, "pointers to disjoint address spaces "
5138 "used in conditional expression");
5139 return error_mark_node;
5140 }
5141 else if (VOID_TYPE_P (TREE_TYPE (type1))
5142 && !TYPE_ATOMIC (TREE_TYPE (type1)))
5143 {
5144 if ((TREE_CODE (TREE_TYPE (type2)) == ARRAY_TYPE)
5145 && (TYPE_QUALS (strip_array_types (TREE_TYPE (type2)))
5146 & ~TYPE_QUALS (TREE_TYPE (type1))))
5147 warning_at (colon_loc, OPT_Wdiscarded_array_qualifiers,
5148 "pointer to array loses qualifier "
5149 "in conditional expression");
5150
5151 if (TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
5152 pedwarn (colon_loc, OPT_Wpedantic,
5153 "ISO C forbids conditional expr between "
5154 "%<void *%> and function pointer");
5155 result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
5156 TREE_TYPE (type2)));
5157 }
5158 else if (VOID_TYPE_P (TREE_TYPE (type2))
5159 && !TYPE_ATOMIC (TREE_TYPE (type2)))
5160 {
5161 if ((TREE_CODE (TREE_TYPE (type1)) == ARRAY_TYPE)
5162 && (TYPE_QUALS (strip_array_types (TREE_TYPE (type1)))
5163 & ~TYPE_QUALS (TREE_TYPE (type2))))
5164 warning_at (colon_loc, OPT_Wdiscarded_array_qualifiers,
5165 "pointer to array loses qualifier "
5166 "in conditional expression");
5167
5168 if (TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
5169 pedwarn (colon_loc, OPT_Wpedantic,
5170 "ISO C forbids conditional expr between "
5171 "%<void *%> and function pointer");
5172 result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
5173 TREE_TYPE (type1)));
5174 }
5175 /* Objective-C pointer comparisons are a bit more lenient. */
5176 else if (objc_have_common_type (type1, type2, -3, NULL_TREE))
5177 result_type = objc_common_type (type1, type2);
5178 else
5179 {
5180 int qual = ENCODE_QUAL_ADDR_SPACE (as_common);
5181
5182 pedwarn (colon_loc, 0,
5183 "pointer type mismatch in conditional expression");
5184 result_type = build_pointer_type
5185 (build_qualified_type (void_type_node, qual));
5186 }
5187 }
5188 else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
5189 {
5190 if (!null_pointer_constant_p (orig_op2))
5191 pedwarn (colon_loc, 0,
5192 "pointer/integer type mismatch in conditional expression");
5193 else
5194 {
5195 op2 = null_pointer_node;
5196 }
5197 result_type = type1;
5198 }
5199 else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
5200 {
5201 if (!null_pointer_constant_p (orig_op1))
5202 pedwarn (colon_loc, 0,
5203 "pointer/integer type mismatch in conditional expression");
5204 else
5205 {
5206 op1 = null_pointer_node;
5207 }
5208 result_type = type2;
5209 }
5210
5211 if (!result_type)
5212 {
5213 if (flag_cond_mismatch)
5214 result_type = void_type_node;
5215 else
5216 {
5217 error_at (colon_loc, "type mismatch in conditional expression");
5218 return error_mark_node;
5219 }
5220 }
5221
5222 /* Merge const and volatile flags of the incoming types. */
5223 result_type
5224 = build_type_variant (result_type,
5225 TYPE_READONLY (type1) || TYPE_READONLY (type2),
5226 TYPE_VOLATILE (type1) || TYPE_VOLATILE (type2));
5227
5228 op1 = ep_convert_and_check (colon_loc, result_type, op1,
5229 semantic_result_type);
5230 op2 = ep_convert_and_check (colon_loc, result_type, op2,
5231 semantic_result_type);
5232
5233 if (ifexp_bcp && ifexp == truthvalue_true_node)
5234 {
5235 op2_int_operands = true;
5236 op1 = c_fully_fold (op1, require_constant_value, NULL);
5237 }
5238 if (ifexp_bcp && ifexp == truthvalue_false_node)
5239 {
5240 op1_int_operands = true;
5241 op2 = c_fully_fold (op2, require_constant_value, NULL);
5242 }
5243 int_const = int_operands = (ifexp_int_operands
5244 && op1_int_operands
5245 && op2_int_operands);
5246 if (int_operands)
5247 {
5248 int_const = ((ifexp == truthvalue_true_node
5249 && TREE_CODE (orig_op1) == INTEGER_CST
5250 && !TREE_OVERFLOW (orig_op1))
5251 || (ifexp == truthvalue_false_node
5252 && TREE_CODE (orig_op2) == INTEGER_CST
5253 && !TREE_OVERFLOW (orig_op2)));
5254 }
5255
5256 /* Need to convert condition operand into a vector mask. */
5257 if (VECTOR_TYPE_P (TREE_TYPE (ifexp)))
5258 {
5259 tree vectype = TREE_TYPE (ifexp);
5260 tree elem_type = TREE_TYPE (vectype);
5261 tree zero = build_int_cst (elem_type, 0);
5262 tree zero_vec = build_vector_from_val (vectype, zero);
5263 tree cmp_type = build_same_sized_truth_vector_type (vectype);
5264 ifexp = build2 (NE_EXPR, cmp_type, ifexp, zero_vec);
5265 }
5266
5267 if (int_const || (ifexp_bcp && TREE_CODE (ifexp) == INTEGER_CST))
5268 ret = fold_build3_loc (colon_loc, COND_EXPR, result_type, ifexp, op1, op2);
5269 else
5270 {
5271 if (int_operands)
5272 {
5273 /* Use c_fully_fold here, since C_MAYBE_CONST_EXPR might be
5274 nested inside of the expression. */
5275 op1 = c_fully_fold (op1, false, NULL);
5276 op2 = c_fully_fold (op2, false, NULL);
5277 }
5278 ret = build3 (COND_EXPR, result_type, ifexp, op1, op2);
5279 if (int_operands)
5280 ret = note_integer_operands (ret);
5281 }
5282 if (semantic_result_type)
5283 ret = build1 (EXCESS_PRECISION_EXPR, semantic_result_type, ret);
5284
5285 protected_set_expr_location (ret, colon_loc);
5286
5287 /* If the OP1 and OP2 are the same and don't have side-effects,
5288 warn here, because the COND_EXPR will be turned into OP1. */
5289 if (warn_duplicated_branches
5290 && TREE_CODE (ret) == COND_EXPR
5291 && (op1 == op2 || operand_equal_p (op1, op2, 0)))
5292 warning_at (EXPR_LOCATION (ret), OPT_Wduplicated_branches,
5293 "this condition has identical branches");
5294
5295 return ret;
5296 }
5297
5298 /* Return a compound expression that performs two expressions and
5299 returns the value of the second of them.
5300
5301 LOC is the location of the COMPOUND_EXPR. */
5302
5303 tree
build_compound_expr(location_t loc,tree expr1,tree expr2)5304 build_compound_expr (location_t loc, tree expr1, tree expr2)
5305 {
5306 bool expr1_int_operands, expr2_int_operands;
5307 tree eptype = NULL_TREE;
5308 tree ret;
5309
5310 expr1_int_operands = EXPR_INT_CONST_OPERANDS (expr1);
5311 if (expr1_int_operands)
5312 expr1 = remove_c_maybe_const_expr (expr1);
5313 expr2_int_operands = EXPR_INT_CONST_OPERANDS (expr2);
5314 if (expr2_int_operands)
5315 expr2 = remove_c_maybe_const_expr (expr2);
5316
5317 if (TREE_CODE (expr1) == EXCESS_PRECISION_EXPR)
5318 expr1 = TREE_OPERAND (expr1, 0);
5319 if (TREE_CODE (expr2) == EXCESS_PRECISION_EXPR)
5320 {
5321 eptype = TREE_TYPE (expr2);
5322 expr2 = TREE_OPERAND (expr2, 0);
5323 }
5324
5325 if (!TREE_SIDE_EFFECTS (expr1))
5326 {
5327 /* The left-hand operand of a comma expression is like an expression
5328 statement: with -Wunused, we should warn if it doesn't have
5329 any side-effects, unless it was explicitly cast to (void). */
5330 if (warn_unused_value)
5331 {
5332 if (VOID_TYPE_P (TREE_TYPE (expr1))
5333 && CONVERT_EXPR_P (expr1))
5334 ; /* (void) a, b */
5335 else if (VOID_TYPE_P (TREE_TYPE (expr1))
5336 && TREE_CODE (expr1) == COMPOUND_EXPR
5337 && CONVERT_EXPR_P (TREE_OPERAND (expr1, 1)))
5338 ; /* (void) a, (void) b, c */
5339 else
5340 warning_at (loc, OPT_Wunused_value,
5341 "left-hand operand of comma expression has no effect");
5342 }
5343 }
5344 else if (TREE_CODE (expr1) == COMPOUND_EXPR
5345 && warn_unused_value)
5346 {
5347 tree r = expr1;
5348 location_t cloc = loc;
5349 while (TREE_CODE (r) == COMPOUND_EXPR)
5350 {
5351 if (EXPR_HAS_LOCATION (r))
5352 cloc = EXPR_LOCATION (r);
5353 r = TREE_OPERAND (r, 1);
5354 }
5355 if (!TREE_SIDE_EFFECTS (r)
5356 && !VOID_TYPE_P (TREE_TYPE (r))
5357 && !CONVERT_EXPR_P (r))
5358 warning_at (cloc, OPT_Wunused_value,
5359 "right-hand operand of comma expression has no effect");
5360 }
5361
5362 /* With -Wunused, we should also warn if the left-hand operand does have
5363 side-effects, but computes a value which is not used. For example, in
5364 `foo() + bar(), baz()' the result of the `+' operator is not used,
5365 so we should issue a warning. */
5366 else if (warn_unused_value)
5367 warn_if_unused_value (expr1, loc);
5368
5369 if (expr2 == error_mark_node)
5370 return error_mark_node;
5371
5372 ret = build2 (COMPOUND_EXPR, TREE_TYPE (expr2), expr1, expr2);
5373
5374 if (flag_isoc99
5375 && expr1_int_operands
5376 && expr2_int_operands)
5377 ret = note_integer_operands (ret);
5378
5379 if (eptype)
5380 ret = build1 (EXCESS_PRECISION_EXPR, eptype, ret);
5381
5382 protected_set_expr_location (ret, loc);
5383 return ret;
5384 }
5385
5386 /* Issue -Wcast-qual warnings when appropriate. TYPE is the type to
5387 which we are casting. OTYPE is the type of the expression being
5388 cast. Both TYPE and OTYPE are pointer types. LOC is the location
5389 of the cast. -Wcast-qual appeared on the command line. Named
5390 address space qualifiers are not handled here, because they result
5391 in different warnings. */
5392
5393 static void
handle_warn_cast_qual(location_t loc,tree type,tree otype)5394 handle_warn_cast_qual (location_t loc, tree type, tree otype)
5395 {
5396 tree in_type = type;
5397 tree in_otype = otype;
5398 int added = 0;
5399 int discarded = 0;
5400 bool is_const;
5401
5402 /* Check that the qualifiers on IN_TYPE are a superset of the
5403 qualifiers of IN_OTYPE. The outermost level of POINTER_TYPE
5404 nodes is uninteresting and we stop as soon as we hit a
5405 non-POINTER_TYPE node on either type. */
5406 do
5407 {
5408 in_otype = TREE_TYPE (in_otype);
5409 in_type = TREE_TYPE (in_type);
5410
5411 /* GNU C allows cv-qualified function types. 'const' means the
5412 function is very pure, 'volatile' means it can't return. We
5413 need to warn when such qualifiers are added, not when they're
5414 taken away. */
5415 if (TREE_CODE (in_otype) == FUNCTION_TYPE
5416 && TREE_CODE (in_type) == FUNCTION_TYPE)
5417 added |= (TYPE_QUALS_NO_ADDR_SPACE (in_type)
5418 & ~TYPE_QUALS_NO_ADDR_SPACE (in_otype));
5419 else
5420 discarded |= (TYPE_QUALS_NO_ADDR_SPACE (in_otype)
5421 & ~TYPE_QUALS_NO_ADDR_SPACE (in_type));
5422 }
5423 while (TREE_CODE (in_type) == POINTER_TYPE
5424 && TREE_CODE (in_otype) == POINTER_TYPE);
5425
5426 if (added)
5427 warning_at (loc, OPT_Wcast_qual,
5428 "cast adds %q#v qualifier to function type", added);
5429
5430 if (discarded)
5431 /* There are qualifiers present in IN_OTYPE that are not present
5432 in IN_TYPE. */
5433 warning_at (loc, OPT_Wcast_qual,
5434 "cast discards %qv qualifier from pointer target type",
5435 discarded);
5436
5437 if (added || discarded)
5438 return;
5439
5440 /* A cast from **T to const **T is unsafe, because it can cause a
5441 const value to be changed with no additional warning. We only
5442 issue this warning if T is the same on both sides, and we only
5443 issue the warning if there are the same number of pointers on
5444 both sides, as otherwise the cast is clearly unsafe anyhow. A
5445 cast is unsafe when a qualifier is added at one level and const
5446 is not present at all outer levels.
5447
5448 To issue this warning, we check at each level whether the cast
5449 adds new qualifiers not already seen. We don't need to special
5450 case function types, as they won't have the same
5451 TYPE_MAIN_VARIANT. */
5452
5453 if (TYPE_MAIN_VARIANT (in_type) != TYPE_MAIN_VARIANT (in_otype))
5454 return;
5455 if (TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE)
5456 return;
5457
5458 in_type = type;
5459 in_otype = otype;
5460 is_const = TYPE_READONLY (TREE_TYPE (in_type));
5461 do
5462 {
5463 in_type = TREE_TYPE (in_type);
5464 in_otype = TREE_TYPE (in_otype);
5465 if ((TYPE_QUALS (in_type) &~ TYPE_QUALS (in_otype)) != 0
5466 && !is_const)
5467 {
5468 warning_at (loc, OPT_Wcast_qual,
5469 "to be safe all intermediate pointers in cast from "
5470 "%qT to %qT must be %<const%> qualified",
5471 otype, type);
5472 break;
5473 }
5474 if (is_const)
5475 is_const = TYPE_READONLY (in_type);
5476 }
5477 while (TREE_CODE (in_type) == POINTER_TYPE);
5478 }
5479
5480 /* Heuristic check if two parameter types can be considered ABI-equivalent. */
5481
5482 static bool
c_safe_arg_type_equiv_p(tree t1,tree t2)5483 c_safe_arg_type_equiv_p (tree t1, tree t2)
5484 {
5485 t1 = TYPE_MAIN_VARIANT (t1);
5486 t2 = TYPE_MAIN_VARIANT (t2);
5487
5488 if (TREE_CODE (t1) == POINTER_TYPE
5489 && TREE_CODE (t2) == POINTER_TYPE)
5490 return true;
5491
5492 /* The signedness of the parameter matters only when an integral
5493 type smaller than int is promoted to int, otherwise only the
5494 precision of the parameter matters.
5495 This check should make sure that the callee does not see
5496 undefined values in argument registers. */
5497 if (INTEGRAL_TYPE_P (t1)
5498 && INTEGRAL_TYPE_P (t2)
5499 && TYPE_PRECISION (t1) == TYPE_PRECISION (t2)
5500 && (TYPE_UNSIGNED (t1) == TYPE_UNSIGNED (t2)
5501 || !targetm.calls.promote_prototypes (NULL_TREE)
5502 || TYPE_PRECISION (t1) >= TYPE_PRECISION (integer_type_node)))
5503 return true;
5504
5505 return comptypes (t1, t2);
5506 }
5507
5508 /* Check if a type cast between two function types can be considered safe. */
5509
5510 static bool
c_safe_function_type_cast_p(tree t1,tree t2)5511 c_safe_function_type_cast_p (tree t1, tree t2)
5512 {
5513 if (TREE_TYPE (t1) == void_type_node &&
5514 TYPE_ARG_TYPES (t1) == void_list_node)
5515 return true;
5516
5517 if (TREE_TYPE (t2) == void_type_node &&
5518 TYPE_ARG_TYPES (t2) == void_list_node)
5519 return true;
5520
5521 if (!c_safe_arg_type_equiv_p (TREE_TYPE (t1), TREE_TYPE (t2)))
5522 return false;
5523
5524 for (t1 = TYPE_ARG_TYPES (t1), t2 = TYPE_ARG_TYPES (t2);
5525 t1 && t2;
5526 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
5527 if (!c_safe_arg_type_equiv_p (TREE_VALUE (t1), TREE_VALUE (t2)))
5528 return false;
5529
5530 return true;
5531 }
5532
5533 /* Build an expression representing a cast to type TYPE of expression EXPR.
5534 LOC is the location of the cast-- typically the open paren of the cast. */
5535
5536 tree
build_c_cast(location_t loc,tree type,tree expr)5537 build_c_cast (location_t loc, tree type, tree expr)
5538 {
5539 tree value;
5540
5541 bool int_operands = EXPR_INT_CONST_OPERANDS (expr);
5542
5543 if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
5544 expr = TREE_OPERAND (expr, 0);
5545
5546 value = expr;
5547 if (int_operands)
5548 value = remove_c_maybe_const_expr (value);
5549
5550 if (type == error_mark_node || expr == error_mark_node)
5551 return error_mark_node;
5552
5553 /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
5554 only in <protocol> qualifications. But when constructing cast expressions,
5555 the protocols do matter and must be kept around. */
5556 if (objc_is_object_ptr (type) && objc_is_object_ptr (TREE_TYPE (expr)))
5557 return build1 (NOP_EXPR, type, expr);
5558
5559 type = TYPE_MAIN_VARIANT (type);
5560
5561 if (TREE_CODE (type) == ARRAY_TYPE)
5562 {
5563 error_at (loc, "cast specifies array type");
5564 return error_mark_node;
5565 }
5566
5567 if (TREE_CODE (type) == FUNCTION_TYPE)
5568 {
5569 error_at (loc, "cast specifies function type");
5570 return error_mark_node;
5571 }
5572
5573 if (!VOID_TYPE_P (type))
5574 {
5575 value = require_complete_type (loc, value);
5576 if (value == error_mark_node)
5577 return error_mark_node;
5578 }
5579
5580 if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
5581 {
5582 if (RECORD_OR_UNION_TYPE_P (type))
5583 pedwarn (loc, OPT_Wpedantic,
5584 "ISO C forbids casting nonscalar to the same type");
5585
5586 /* Convert to remove any qualifiers from VALUE's type. */
5587 value = convert (type, value);
5588 }
5589 else if (TREE_CODE (type) == UNION_TYPE)
5590 {
5591 tree field;
5592
5593 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
5594 if (TREE_TYPE (field) != error_mark_node
5595 && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
5596 TYPE_MAIN_VARIANT (TREE_TYPE (value))))
5597 break;
5598
5599 if (field)
5600 {
5601 tree t;
5602 bool maybe_const = true;
5603
5604 pedwarn (loc, OPT_Wpedantic, "ISO C forbids casts to union type");
5605 t = c_fully_fold (value, false, &maybe_const);
5606 t = build_constructor_single (type, field, t);
5607 if (!maybe_const)
5608 t = c_wrap_maybe_const (t, true);
5609 t = digest_init (loc, type, t,
5610 NULL_TREE, false, true, 0);
5611 TREE_CONSTANT (t) = TREE_CONSTANT (value);
5612 return t;
5613 }
5614 error_at (loc, "cast to union type from type not present in union");
5615 return error_mark_node;
5616 }
5617 else
5618 {
5619 tree otype, ovalue;
5620
5621 if (type == void_type_node)
5622 {
5623 tree t = build1 (CONVERT_EXPR, type, value);
5624 SET_EXPR_LOCATION (t, loc);
5625 return t;
5626 }
5627
5628 otype = TREE_TYPE (value);
5629
5630 /* Optionally warn about potentially worrisome casts. */
5631 if (warn_cast_qual
5632 && TREE_CODE (type) == POINTER_TYPE
5633 && TREE_CODE (otype) == POINTER_TYPE)
5634 handle_warn_cast_qual (loc, type, otype);
5635
5636 /* Warn about conversions between pointers to disjoint
5637 address spaces. */
5638 if (TREE_CODE (type) == POINTER_TYPE
5639 && TREE_CODE (otype) == POINTER_TYPE
5640 && !null_pointer_constant_p (value))
5641 {
5642 addr_space_t as_to = TYPE_ADDR_SPACE (TREE_TYPE (type));
5643 addr_space_t as_from = TYPE_ADDR_SPACE (TREE_TYPE (otype));
5644 addr_space_t as_common;
5645
5646 if (!addr_space_superset (as_to, as_from, &as_common))
5647 {
5648 if (ADDR_SPACE_GENERIC_P (as_from))
5649 warning_at (loc, 0, "cast to %s address space pointer "
5650 "from disjoint generic address space pointer",
5651 c_addr_space_name (as_to));
5652
5653 else if (ADDR_SPACE_GENERIC_P (as_to))
5654 warning_at (loc, 0, "cast to generic address space pointer "
5655 "from disjoint %s address space pointer",
5656 c_addr_space_name (as_from));
5657
5658 else
5659 warning_at (loc, 0, "cast to %s address space pointer "
5660 "from disjoint %s address space pointer",
5661 c_addr_space_name (as_to),
5662 c_addr_space_name (as_from));
5663 }
5664 }
5665
5666 /* Warn about possible alignment problems. */
5667 if ((STRICT_ALIGNMENT || warn_cast_align == 2)
5668 && TREE_CODE (type) == POINTER_TYPE
5669 && TREE_CODE (otype) == POINTER_TYPE
5670 && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
5671 && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
5672 /* Don't warn about opaque types, where the actual alignment
5673 restriction is unknown. */
5674 && !(RECORD_OR_UNION_TYPE_P (TREE_TYPE (otype))
5675 && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
5676 && min_align_of_type (TREE_TYPE (type))
5677 > min_align_of_type (TREE_TYPE (otype)))
5678 warning_at (loc, OPT_Wcast_align,
5679 "cast increases required alignment of target type");
5680
5681 if (TREE_CODE (type) == INTEGER_TYPE
5682 && TREE_CODE (otype) == POINTER_TYPE
5683 && TYPE_PRECISION (type) != TYPE_PRECISION (otype))
5684 /* Unlike conversion of integers to pointers, where the
5685 warning is disabled for converting constants because
5686 of cases such as SIG_*, warn about converting constant
5687 pointers to integers. In some cases it may cause unwanted
5688 sign extension, and a warning is appropriate. */
5689 warning_at (loc, OPT_Wpointer_to_int_cast,
5690 "cast from pointer to integer of different size");
5691
5692 if (TREE_CODE (value) == CALL_EXPR
5693 && TREE_CODE (type) != TREE_CODE (otype))
5694 warning_at (loc, OPT_Wbad_function_cast,
5695 "cast from function call of type %qT "
5696 "to non-matching type %qT", otype, type);
5697
5698 if (TREE_CODE (type) == POINTER_TYPE
5699 && TREE_CODE (otype) == INTEGER_TYPE
5700 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
5701 /* Don't warn about converting any constant. */
5702 && !TREE_CONSTANT (value))
5703 warning_at (loc,
5704 OPT_Wint_to_pointer_cast, "cast to pointer from integer "
5705 "of different size");
5706
5707 if (warn_strict_aliasing <= 2)
5708 strict_aliasing_warning (EXPR_LOCATION (value), type, expr);
5709
5710 /* If pedantic, warn for conversions between function and object
5711 pointer types, except for converting a null pointer constant
5712 to function pointer type. */
5713 if (pedantic
5714 && TREE_CODE (type) == POINTER_TYPE
5715 && TREE_CODE (otype) == POINTER_TYPE
5716 && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE
5717 && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE)
5718 pedwarn (loc, OPT_Wpedantic, "ISO C forbids "
5719 "conversion of function pointer to object pointer type");
5720
5721 if (pedantic
5722 && TREE_CODE (type) == POINTER_TYPE
5723 && TREE_CODE (otype) == POINTER_TYPE
5724 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
5725 && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
5726 && !null_pointer_constant_p (value))
5727 pedwarn (loc, OPT_Wpedantic, "ISO C forbids "
5728 "conversion of object pointer to function pointer type");
5729
5730 if (TREE_CODE (type) == POINTER_TYPE
5731 && TREE_CODE (otype) == POINTER_TYPE
5732 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
5733 && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE
5734 && !c_safe_function_type_cast_p (TREE_TYPE (type),
5735 TREE_TYPE (otype)))
5736 warning_at (loc, OPT_Wcast_function_type,
5737 "cast between incompatible function types"
5738 " from %qT to %qT", otype, type);
5739
5740 ovalue = value;
5741 value = convert (type, value);
5742
5743 /* Ignore any integer overflow caused by the cast. */
5744 if (TREE_CODE (value) == INTEGER_CST && !FLOAT_TYPE_P (otype))
5745 {
5746 if (CONSTANT_CLASS_P (ovalue) && TREE_OVERFLOW (ovalue))
5747 {
5748 if (!TREE_OVERFLOW (value))
5749 {
5750 /* Avoid clobbering a shared constant. */
5751 value = copy_node (value);
5752 TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
5753 }
5754 }
5755 else if (TREE_OVERFLOW (value))
5756 /* Reset VALUE's overflow flags, ensuring constant sharing. */
5757 value = wide_int_to_tree (TREE_TYPE (value), wi::to_wide (value));
5758 }
5759 }
5760
5761 /* Don't let a cast be an lvalue. */
5762 if (lvalue_p (value))
5763 value = non_lvalue_loc (loc, value);
5764
5765 /* Don't allow the results of casting to floating-point or complex
5766 types be confused with actual constants, or casts involving
5767 integer and pointer types other than direct integer-to-integer
5768 and integer-to-pointer be confused with integer constant
5769 expressions and null pointer constants. */
5770 if (TREE_CODE (value) == REAL_CST
5771 || TREE_CODE (value) == COMPLEX_CST
5772 || (TREE_CODE (value) == INTEGER_CST
5773 && !((TREE_CODE (expr) == INTEGER_CST
5774 && INTEGRAL_TYPE_P (TREE_TYPE (expr)))
5775 || TREE_CODE (expr) == REAL_CST
5776 || TREE_CODE (expr) == COMPLEX_CST)))
5777 value = build1 (NOP_EXPR, type, value);
5778
5779 /* If the expression has integer operands and so can occur in an
5780 unevaluated part of an integer constant expression, ensure the
5781 return value reflects this. */
5782 if (int_operands
5783 && INTEGRAL_TYPE_P (type)
5784 && !EXPR_INT_CONST_OPERANDS (value))
5785 value = note_integer_operands (value);
5786
5787 protected_set_expr_location (value, loc);
5788 return value;
5789 }
5790
5791 /* Interpret a cast of expression EXPR to type TYPE. LOC is the
5792 location of the open paren of the cast, or the position of the cast
5793 expr. */
5794 tree
c_cast_expr(location_t loc,struct c_type_name * type_name,tree expr)5795 c_cast_expr (location_t loc, struct c_type_name *type_name, tree expr)
5796 {
5797 tree type;
5798 tree type_expr = NULL_TREE;
5799 bool type_expr_const = true;
5800 tree ret;
5801 int saved_wsp = warn_strict_prototypes;
5802
5803 /* This avoids warnings about unprototyped casts on
5804 integers. E.g. "#define SIG_DFL (void(*)())0". */
5805 if (TREE_CODE (expr) == INTEGER_CST)
5806 warn_strict_prototypes = 0;
5807 type = groktypename (type_name, &type_expr, &type_expr_const);
5808 warn_strict_prototypes = saved_wsp;
5809
5810 if (TREE_CODE (expr) == ADDR_EXPR && !VOID_TYPE_P (type)
5811 && reject_gcc_builtin (expr))
5812 return error_mark_node;
5813
5814 ret = build_c_cast (loc, type, expr);
5815 if (type_expr)
5816 {
5817 bool inner_expr_const = true;
5818 ret = c_fully_fold (ret, require_constant_value, &inner_expr_const);
5819 ret = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (ret), type_expr, ret);
5820 C_MAYBE_CONST_EXPR_NON_CONST (ret) = !(type_expr_const
5821 && inner_expr_const);
5822 SET_EXPR_LOCATION (ret, loc);
5823 }
5824
5825 if (!EXPR_HAS_LOCATION (ret))
5826 protected_set_expr_location (ret, loc);
5827
5828 /* C++ does not permits types to be defined in a cast, but it
5829 allows references to incomplete types. */
5830 if (warn_cxx_compat && type_name->specs->typespec_kind == ctsk_tagdef)
5831 warning_at (loc, OPT_Wc___compat,
5832 "defining a type in a cast is invalid in C++");
5833
5834 return ret;
5835 }
5836
5837 /* Build an assignment expression of lvalue LHS from value RHS.
5838 If LHS_ORIGTYPE is not NULL, it is the original type of LHS, which
5839 may differ from TREE_TYPE (LHS) for an enum bitfield.
5840 MODIFYCODE is the code for a binary operator that we use
5841 to combine the old value of LHS with RHS to get the new value.
5842 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5843 If RHS_ORIGTYPE is not NULL_TREE, it is the original type of RHS,
5844 which may differ from TREE_TYPE (RHS) for an enum value.
5845
5846 LOCATION is the location of the MODIFYCODE operator.
5847 RHS_LOC is the location of the RHS. */
5848
5849 tree
build_modify_expr(location_t location,tree lhs,tree lhs_origtype,enum tree_code modifycode,location_t rhs_loc,tree rhs,tree rhs_origtype)5850 build_modify_expr (location_t location, tree lhs, tree lhs_origtype,
5851 enum tree_code modifycode,
5852 location_t rhs_loc, tree rhs, tree rhs_origtype)
5853 {
5854 tree result;
5855 tree newrhs;
5856 tree rhseval = NULL_TREE;
5857 tree lhstype = TREE_TYPE (lhs);
5858 tree olhstype = lhstype;
5859 bool npc;
5860 bool is_atomic_op;
5861
5862 /* Types that aren't fully specified cannot be used in assignments. */
5863 lhs = require_complete_type (location, lhs);
5864
5865 /* Avoid duplicate error messages from operands that had errors. */
5866 if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
5867 return error_mark_node;
5868
5869 /* Ensure an error for assigning a non-lvalue array to an array in
5870 C90. */
5871 if (TREE_CODE (lhstype) == ARRAY_TYPE)
5872 {
5873 error_at (location, "assignment to expression with array type");
5874 return error_mark_node;
5875 }
5876
5877 /* For ObjC properties, defer this check. */
5878 if (!objc_is_property_ref (lhs) && !lvalue_or_else (location, lhs, lv_assign))
5879 return error_mark_node;
5880
5881 is_atomic_op = really_atomic_lvalue (lhs);
5882
5883 newrhs = rhs;
5884
5885 if (TREE_CODE (lhs) == C_MAYBE_CONST_EXPR)
5886 {
5887 tree inner = build_modify_expr (location, C_MAYBE_CONST_EXPR_EXPR (lhs),
5888 lhs_origtype, modifycode, rhs_loc, rhs,
5889 rhs_origtype);
5890 if (inner == error_mark_node)
5891 return error_mark_node;
5892 result = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (inner),
5893 C_MAYBE_CONST_EXPR_PRE (lhs), inner);
5894 gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (lhs));
5895 C_MAYBE_CONST_EXPR_NON_CONST (result) = 1;
5896 protected_set_expr_location (result, location);
5897 return result;
5898 }
5899
5900 /* If a binary op has been requested, combine the old LHS value with the RHS
5901 producing the value we should actually store into the LHS. */
5902
5903 if (modifycode != NOP_EXPR)
5904 {
5905 lhs = c_fully_fold (lhs, false, NULL, true);
5906 lhs = stabilize_reference (lhs);
5907
5908 /* Construct the RHS for any non-atomic compound assignemnt. */
5909 if (!is_atomic_op)
5910 {
5911 /* If in LHS op= RHS the RHS has side-effects, ensure they
5912 are preevaluated before the rest of the assignment expression's
5913 side-effects, because RHS could contain e.g. function calls
5914 that modify LHS. */
5915 if (TREE_SIDE_EFFECTS (rhs))
5916 {
5917 if (TREE_CODE (rhs) == EXCESS_PRECISION_EXPR)
5918 newrhs = save_expr (TREE_OPERAND (rhs, 0));
5919 else
5920 newrhs = save_expr (rhs);
5921 rhseval = newrhs;
5922 if (TREE_CODE (rhs) == EXCESS_PRECISION_EXPR)
5923 newrhs = build1 (EXCESS_PRECISION_EXPR, TREE_TYPE (rhs),
5924 newrhs);
5925 }
5926 newrhs = build_binary_op (location,
5927 modifycode, lhs, newrhs, true);
5928
5929 /* The original type of the right hand side is no longer
5930 meaningful. */
5931 rhs_origtype = NULL_TREE;
5932 }
5933 }
5934
5935 if (c_dialect_objc ())
5936 {
5937 /* Check if we are modifying an Objective-C property reference;
5938 if so, we need to generate setter calls. */
5939 if (TREE_CODE (newrhs) == EXCESS_PRECISION_EXPR)
5940 result = objc_maybe_build_modify_expr (lhs, TREE_OPERAND (newrhs, 0));
5941 else
5942 result = objc_maybe_build_modify_expr (lhs, newrhs);
5943 if (result)
5944 goto return_result;
5945
5946 /* Else, do the check that we postponed for Objective-C. */
5947 if (!lvalue_or_else (location, lhs, lv_assign))
5948 return error_mark_node;
5949 }
5950
5951 /* Give an error for storing in something that is 'const'. */
5952
5953 if (TYPE_READONLY (lhstype)
5954 || (RECORD_OR_UNION_TYPE_P (lhstype)
5955 && C_TYPE_FIELDS_READONLY (lhstype)))
5956 {
5957 readonly_error (location, lhs, lv_assign);
5958 return error_mark_node;
5959 }
5960 else if (TREE_READONLY (lhs))
5961 readonly_warning (lhs, lv_assign);
5962
5963 /* If storing into a structure or union member,
5964 it has probably been given type `int'.
5965 Compute the type that would go with
5966 the actual amount of storage the member occupies. */
5967
5968 if (TREE_CODE (lhs) == COMPONENT_REF
5969 && (TREE_CODE (lhstype) == INTEGER_TYPE
5970 || TREE_CODE (lhstype) == BOOLEAN_TYPE
5971 || TREE_CODE (lhstype) == REAL_TYPE
5972 || TREE_CODE (lhstype) == ENUMERAL_TYPE))
5973 lhstype = TREE_TYPE (get_unwidened (lhs, 0));
5974
5975 /* If storing in a field that is in actuality a short or narrower than one,
5976 we must store in the field in its actual type. */
5977
5978 if (lhstype != TREE_TYPE (lhs))
5979 {
5980 lhs = copy_node (lhs);
5981 TREE_TYPE (lhs) = lhstype;
5982 }
5983
5984 /* Issue -Wc++-compat warnings about an assignment to an enum type
5985 when LHS does not have its original type. This happens for,
5986 e.g., an enum bitfield in a struct. */
5987 if (warn_cxx_compat
5988 && lhs_origtype != NULL_TREE
5989 && lhs_origtype != lhstype
5990 && TREE_CODE (lhs_origtype) == ENUMERAL_TYPE)
5991 {
5992 tree checktype = (rhs_origtype != NULL_TREE
5993 ? rhs_origtype
5994 : TREE_TYPE (rhs));
5995 if (checktype != error_mark_node
5996 && (TYPE_MAIN_VARIANT (checktype) != TYPE_MAIN_VARIANT (lhs_origtype)
5997 || (is_atomic_op && modifycode != NOP_EXPR)))
5998 warning_at (location, OPT_Wc___compat,
5999 "enum conversion in assignment is invalid in C++");
6000 }
6001
6002 /* If the lhs is atomic, remove that qualifier. */
6003 if (is_atomic_op)
6004 {
6005 lhstype = build_qualified_type (lhstype,
6006 (TYPE_QUALS (lhstype)
6007 & ~TYPE_QUAL_ATOMIC));
6008 olhstype = build_qualified_type (olhstype,
6009 (TYPE_QUALS (lhstype)
6010 & ~TYPE_QUAL_ATOMIC));
6011 }
6012
6013 /* Convert new value to destination type. Fold it first, then
6014 restore any excess precision information, for the sake of
6015 conversion warnings. */
6016
6017 if (!(is_atomic_op && modifycode != NOP_EXPR))
6018 {
6019 tree rhs_semantic_type = NULL_TREE;
6020 if (TREE_CODE (newrhs) == EXCESS_PRECISION_EXPR)
6021 {
6022 rhs_semantic_type = TREE_TYPE (newrhs);
6023 newrhs = TREE_OPERAND (newrhs, 0);
6024 }
6025 npc = null_pointer_constant_p (newrhs);
6026 newrhs = c_fully_fold (newrhs, false, NULL);
6027 if (rhs_semantic_type)
6028 newrhs = build1 (EXCESS_PRECISION_EXPR, rhs_semantic_type, newrhs);
6029 newrhs = convert_for_assignment (location, rhs_loc, lhstype, newrhs,
6030 rhs_origtype, ic_assign, npc,
6031 NULL_TREE, NULL_TREE, 0);
6032 if (TREE_CODE (newrhs) == ERROR_MARK)
6033 return error_mark_node;
6034 }
6035
6036 /* Emit ObjC write barrier, if necessary. */
6037 if (c_dialect_objc () && flag_objc_gc)
6038 {
6039 result = objc_generate_write_barrier (lhs, modifycode, newrhs);
6040 if (result)
6041 {
6042 protected_set_expr_location (result, location);
6043 goto return_result;
6044 }
6045 }
6046
6047 /* Scan operands. */
6048
6049 if (is_atomic_op)
6050 result = build_atomic_assign (location, lhs, modifycode, newrhs, false);
6051 else
6052 {
6053 result = build2 (MODIFY_EXPR, lhstype, lhs, newrhs);
6054 TREE_SIDE_EFFECTS (result) = 1;
6055 protected_set_expr_location (result, location);
6056 }
6057
6058 /* If we got the LHS in a different type for storing in,
6059 convert the result back to the nominal type of LHS
6060 so that the value we return always has the same type
6061 as the LHS argument. */
6062
6063 if (olhstype == TREE_TYPE (result))
6064 goto return_result;
6065
6066 result = convert_for_assignment (location, rhs_loc, olhstype, result,
6067 rhs_origtype, ic_assign, false, NULL_TREE,
6068 NULL_TREE, 0);
6069 protected_set_expr_location (result, location);
6070
6071 return_result:
6072 if (rhseval)
6073 result = build2 (COMPOUND_EXPR, TREE_TYPE (result), rhseval, result);
6074 return result;
6075 }
6076
6077 /* Return whether STRUCT_TYPE has an anonymous field with type TYPE.
6078 This is used to implement -fplan9-extensions. */
6079
6080 static bool
find_anonymous_field_with_type(tree struct_type,tree type)6081 find_anonymous_field_with_type (tree struct_type, tree type)
6082 {
6083 tree field;
6084 bool found;
6085
6086 gcc_assert (RECORD_OR_UNION_TYPE_P (struct_type));
6087 found = false;
6088 for (field = TYPE_FIELDS (struct_type);
6089 field != NULL_TREE;
6090 field = TREE_CHAIN (field))
6091 {
6092 tree fieldtype = (TYPE_ATOMIC (TREE_TYPE (field))
6093 ? c_build_qualified_type (TREE_TYPE (field),
6094 TYPE_QUAL_ATOMIC)
6095 : TYPE_MAIN_VARIANT (TREE_TYPE (field)));
6096 if (DECL_NAME (field) == NULL
6097 && comptypes (type, fieldtype))
6098 {
6099 if (found)
6100 return false;
6101 found = true;
6102 }
6103 else if (DECL_NAME (field) == NULL
6104 && RECORD_OR_UNION_TYPE_P (TREE_TYPE (field))
6105 && find_anonymous_field_with_type (TREE_TYPE (field), type))
6106 {
6107 if (found)
6108 return false;
6109 found = true;
6110 }
6111 }
6112 return found;
6113 }
6114
6115 /* RHS is an expression whose type is pointer to struct. If there is
6116 an anonymous field in RHS with type TYPE, then return a pointer to
6117 that field in RHS. This is used with -fplan9-extensions. This
6118 returns NULL if no conversion could be found. */
6119
6120 static tree
convert_to_anonymous_field(location_t location,tree type,tree rhs)6121 convert_to_anonymous_field (location_t location, tree type, tree rhs)
6122 {
6123 tree rhs_struct_type, lhs_main_type;
6124 tree field, found_field;
6125 bool found_sub_field;
6126 tree ret;
6127
6128 gcc_assert (POINTER_TYPE_P (TREE_TYPE (rhs)));
6129 rhs_struct_type = TREE_TYPE (TREE_TYPE (rhs));
6130 gcc_assert (RECORD_OR_UNION_TYPE_P (rhs_struct_type));
6131
6132 gcc_assert (POINTER_TYPE_P (type));
6133 lhs_main_type = (TYPE_ATOMIC (TREE_TYPE (type))
6134 ? c_build_qualified_type (TREE_TYPE (type),
6135 TYPE_QUAL_ATOMIC)
6136 : TYPE_MAIN_VARIANT (TREE_TYPE (type)));
6137
6138 found_field = NULL_TREE;
6139 found_sub_field = false;
6140 for (field = TYPE_FIELDS (rhs_struct_type);
6141 field != NULL_TREE;
6142 field = TREE_CHAIN (field))
6143 {
6144 if (DECL_NAME (field) != NULL_TREE
6145 || !RECORD_OR_UNION_TYPE_P (TREE_TYPE (field)))
6146 continue;
6147 tree fieldtype = (TYPE_ATOMIC (TREE_TYPE (field))
6148 ? c_build_qualified_type (TREE_TYPE (field),
6149 TYPE_QUAL_ATOMIC)
6150 : TYPE_MAIN_VARIANT (TREE_TYPE (field)));
6151 if (comptypes (lhs_main_type, fieldtype))
6152 {
6153 if (found_field != NULL_TREE)
6154 return NULL_TREE;
6155 found_field = field;
6156 }
6157 else if (find_anonymous_field_with_type (TREE_TYPE (field),
6158 lhs_main_type))
6159 {
6160 if (found_field != NULL_TREE)
6161 return NULL_TREE;
6162 found_field = field;
6163 found_sub_field = true;
6164 }
6165 }
6166
6167 if (found_field == NULL_TREE)
6168 return NULL_TREE;
6169
6170 ret = fold_build3_loc (location, COMPONENT_REF, TREE_TYPE (found_field),
6171 build_fold_indirect_ref (rhs), found_field,
6172 NULL_TREE);
6173 ret = build_fold_addr_expr_loc (location, ret);
6174
6175 if (found_sub_field)
6176 {
6177 ret = convert_to_anonymous_field (location, type, ret);
6178 gcc_assert (ret != NULL_TREE);
6179 }
6180
6181 return ret;
6182 }
6183
6184 /* Issue an error message for a bad initializer component.
6185 GMSGID identifies the message.
6186 The component name is taken from the spelling stack. */
6187
6188 static void
error_init(location_t loc,const char * gmsgid)6189 error_init (location_t loc, const char *gmsgid)
6190 {
6191 char *ofwhat;
6192
6193 /* The gmsgid may be a format string with %< and %>. */
6194 error_at (loc, gmsgid);
6195 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
6196 if (*ofwhat)
6197 inform (loc, "(near initialization for %qs)", ofwhat);
6198 }
6199
6200 /* Issue a pedantic warning for a bad initializer component. OPT is
6201 the option OPT_* (from options.h) controlling this warning or 0 if
6202 it is unconditionally given. GMSGID identifies the message. The
6203 component name is taken from the spelling stack. */
6204
6205 static void ATTRIBUTE_GCC_DIAG (3,0)
pedwarn_init(location_t loc,int opt,const char * gmsgid,...)6206 pedwarn_init (location_t loc, int opt, const char *gmsgid, ...)
6207 {
6208 /* Use the location where a macro was expanded rather than where
6209 it was defined to make sure macros defined in system headers
6210 but used incorrectly elsewhere are diagnosed. */
6211 source_location exploc = expansion_point_location_if_in_system_header (loc);
6212
6213 va_list ap;
6214 va_start (ap, gmsgid);
6215 bool warned = emit_diagnostic_valist (DK_PEDWARN, exploc, opt, gmsgid, &ap);
6216 va_end (ap);
6217 char *ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
6218 if (*ofwhat && warned)
6219 inform (exploc, "(near initialization for %qs)", ofwhat);
6220 }
6221
6222 /* Issue a warning for a bad initializer component.
6223
6224 OPT is the OPT_W* value corresponding to the warning option that
6225 controls this warning. GMSGID identifies the message. The
6226 component name is taken from the spelling stack. */
6227
6228 static void
warning_init(location_t loc,int opt,const char * gmsgid)6229 warning_init (location_t loc, int opt, const char *gmsgid)
6230 {
6231 char *ofwhat;
6232 bool warned;
6233
6234 /* Use the location where a macro was expanded rather than where
6235 it was defined to make sure macros defined in system headers
6236 but used incorrectly elsewhere are diagnosed. */
6237 source_location exploc = expansion_point_location_if_in_system_header (loc);
6238
6239 /* The gmsgid may be a format string with %< and %>. */
6240 warned = warning_at (exploc, opt, gmsgid);
6241 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
6242 if (*ofwhat && warned)
6243 inform (exploc, "(near initialization for %qs)", ofwhat);
6244 }
6245
6246 /* If TYPE is an array type and EXPR is a parenthesized string
6247 constant, warn if pedantic that EXPR is being used to initialize an
6248 object of type TYPE. */
6249
6250 void
maybe_warn_string_init(location_t loc,tree type,struct c_expr expr)6251 maybe_warn_string_init (location_t loc, tree type, struct c_expr expr)
6252 {
6253 if (pedantic
6254 && TREE_CODE (type) == ARRAY_TYPE
6255 && TREE_CODE (expr.value) == STRING_CST
6256 && expr.original_code != STRING_CST)
6257 pedwarn_init (loc, OPT_Wpedantic,
6258 "array initialized from parenthesized string constant");
6259 }
6260
6261 /* Attempt to locate the parameter with the given index within FNDECL,
6262 returning DECL_SOURCE_LOCATION (FNDECL) if it can't be found. */
6263
6264 static location_t
get_fndecl_argument_location(tree fndecl,int argnum)6265 get_fndecl_argument_location (tree fndecl, int argnum)
6266 {
6267 int i;
6268 tree param;
6269
6270 /* Locate param by index within DECL_ARGUMENTS (fndecl). */
6271 for (i = 0, param = DECL_ARGUMENTS (fndecl);
6272 i < argnum && param;
6273 i++, param = TREE_CHAIN (param))
6274 ;
6275
6276 /* If something went wrong (e.g. if we have a builtin and thus no arguments),
6277 return DECL_SOURCE_LOCATION (FNDECL). */
6278 if (param == NULL)
6279 return DECL_SOURCE_LOCATION (fndecl);
6280
6281 return DECL_SOURCE_LOCATION (param);
6282 }
6283
6284 /* Issue a note about a mismatching argument for parameter PARMNUM
6285 to FUNDECL, for types EXPECTED_TYPE and ACTUAL_TYPE.
6286 Attempt to issue the note at the pertinent parameter of the decl;
6287 failing that issue it at the location of FUNDECL; failing that
6288 issue it at PLOC. */
6289
6290 static void
inform_for_arg(tree fundecl,location_t ploc,int parmnum,tree expected_type,tree actual_type)6291 inform_for_arg (tree fundecl, location_t ploc, int parmnum,
6292 tree expected_type, tree actual_type)
6293 {
6294 location_t loc;
6295 if (fundecl && !DECL_IS_BUILTIN (fundecl))
6296 loc = get_fndecl_argument_location (fundecl, parmnum - 1);
6297 else
6298 loc = ploc;
6299
6300 inform (loc,
6301 "expected %qT but argument is of type %qT",
6302 expected_type, actual_type);
6303 }
6304
6305 /* Convert value RHS to type TYPE as preparation for an assignment to
6306 an lvalue of type TYPE. If ORIGTYPE is not NULL_TREE, it is the
6307 original type of RHS; this differs from TREE_TYPE (RHS) for enum
6308 types. NULL_POINTER_CONSTANT says whether RHS was a null pointer
6309 constant before any folding.
6310 The real work of conversion is done by `convert'.
6311 The purpose of this function is to generate error messages
6312 for assignments that are not allowed in C.
6313 ERRTYPE says whether it is argument passing, assignment,
6314 initialization or return.
6315
6316 In the following example, '~' denotes where EXPR_LOC and '^' where
6317 LOCATION point to:
6318
6319 f (var); [ic_argpass]
6320 ^ ~~~
6321 x = var; [ic_assign]
6322 ^ ~~~;
6323 int x = var; [ic_init]
6324 ^^^
6325 return x; [ic_return]
6326 ^
6327
6328 FUNCTION is a tree for the function being called.
6329 PARMNUM is the number of the argument, for printing in error messages. */
6330
6331 static tree
convert_for_assignment(location_t location,location_t expr_loc,tree type,tree rhs,tree origtype,enum impl_conv errtype,bool null_pointer_constant,tree fundecl,tree function,int parmnum)6332 convert_for_assignment (location_t location, location_t expr_loc, tree type,
6333 tree rhs, tree origtype, enum impl_conv errtype,
6334 bool null_pointer_constant, tree fundecl,
6335 tree function, int parmnum)
6336 {
6337 enum tree_code codel = TREE_CODE (type);
6338 tree orig_rhs = rhs;
6339 tree rhstype;
6340 enum tree_code coder;
6341 tree rname = NULL_TREE;
6342 bool objc_ok = false;
6343
6344 /* Use the expansion point location to handle cases such as user's
6345 function returning a wrong-type macro defined in a system header. */
6346 location = expansion_point_location_if_in_system_header (location);
6347
6348 if (errtype == ic_argpass)
6349 {
6350 tree selector;
6351 /* Change pointer to function to the function itself for
6352 diagnostics. */
6353 if (TREE_CODE (function) == ADDR_EXPR
6354 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
6355 function = TREE_OPERAND (function, 0);
6356
6357 /* Handle an ObjC selector specially for diagnostics. */
6358 selector = objc_message_selector ();
6359 rname = function;
6360 if (selector && parmnum > 2)
6361 {
6362 rname = selector;
6363 parmnum -= 2;
6364 }
6365 }
6366
6367 /* This macro is used to emit diagnostics to ensure that all format
6368 strings are complete sentences, visible to gettext and checked at
6369 compile time. */
6370 #define PEDWARN_FOR_ASSIGNMENT(LOCATION, PLOC, OPT, AR, AS, IN, RE) \
6371 do { \
6372 switch (errtype) \
6373 { \
6374 case ic_argpass: \
6375 if (pedwarn (PLOC, OPT, AR, parmnum, rname)) \
6376 inform_for_arg (fundecl, (PLOC), parmnum, type, rhstype); \
6377 break; \
6378 case ic_assign: \
6379 pedwarn (LOCATION, OPT, AS); \
6380 break; \
6381 case ic_init: \
6382 pedwarn_init (LOCATION, OPT, IN); \
6383 break; \
6384 case ic_return: \
6385 pedwarn (LOCATION, OPT, RE); \
6386 break; \
6387 default: \
6388 gcc_unreachable (); \
6389 } \
6390 } while (0)
6391
6392 /* This macro is used to emit diagnostics to ensure that all format
6393 strings are complete sentences, visible to gettext and checked at
6394 compile time. It is the same as PEDWARN_FOR_ASSIGNMENT but with an
6395 extra parameter to enumerate qualifiers. */
6396 #define PEDWARN_FOR_QUALIFIERS(LOCATION, PLOC, OPT, AR, AS, IN, RE, QUALS) \
6397 do { \
6398 switch (errtype) \
6399 { \
6400 case ic_argpass: \
6401 if (pedwarn (PLOC, OPT, AR, parmnum, rname, QUALS)) \
6402 inform_for_arg (fundecl, (PLOC), parmnum, type, rhstype); \
6403 break; \
6404 case ic_assign: \
6405 pedwarn (LOCATION, OPT, AS, QUALS); \
6406 break; \
6407 case ic_init: \
6408 pedwarn (LOCATION, OPT, IN, QUALS); \
6409 break; \
6410 case ic_return: \
6411 pedwarn (LOCATION, OPT, RE, QUALS); \
6412 break; \
6413 default: \
6414 gcc_unreachable (); \
6415 } \
6416 } while (0)
6417
6418 /* This macro is used to emit diagnostics to ensure that all format
6419 strings are complete sentences, visible to gettext and checked at
6420 compile time. It is the same as PEDWARN_FOR_QUALIFIERS but uses
6421 warning_at instead of pedwarn. */
6422 #define WARNING_FOR_QUALIFIERS(LOCATION, PLOC, OPT, AR, AS, IN, RE, QUALS) \
6423 do { \
6424 switch (errtype) \
6425 { \
6426 case ic_argpass: \
6427 if (warning_at (PLOC, OPT, AR, parmnum, rname, QUALS)) \
6428 inform_for_arg (fundecl, (PLOC), parmnum, type, rhstype); \
6429 break; \
6430 case ic_assign: \
6431 warning_at (LOCATION, OPT, AS, QUALS); \
6432 break; \
6433 case ic_init: \
6434 warning_at (LOCATION, OPT, IN, QUALS); \
6435 break; \
6436 case ic_return: \
6437 warning_at (LOCATION, OPT, RE, QUALS); \
6438 break; \
6439 default: \
6440 gcc_unreachable (); \
6441 } \
6442 } while (0)
6443
6444 if (TREE_CODE (rhs) == EXCESS_PRECISION_EXPR)
6445 rhs = TREE_OPERAND (rhs, 0);
6446
6447 rhstype = TREE_TYPE (rhs);
6448 coder = TREE_CODE (rhstype);
6449
6450 if (coder == ERROR_MARK)
6451 return error_mark_node;
6452
6453 if (c_dialect_objc ())
6454 {
6455 int parmno;
6456
6457 switch (errtype)
6458 {
6459 case ic_return:
6460 parmno = 0;
6461 break;
6462
6463 case ic_assign:
6464 parmno = -1;
6465 break;
6466
6467 case ic_init:
6468 parmno = -2;
6469 break;
6470
6471 default:
6472 parmno = parmnum;
6473 break;
6474 }
6475
6476 objc_ok = objc_compare_types (type, rhstype, parmno, rname);
6477 }
6478
6479 if (warn_cxx_compat)
6480 {
6481 tree checktype = origtype != NULL_TREE ? origtype : rhstype;
6482 if (checktype != error_mark_node
6483 && TREE_CODE (type) == ENUMERAL_TYPE
6484 && TYPE_MAIN_VARIANT (checktype) != TYPE_MAIN_VARIANT (type))
6485 switch (errtype)
6486 {
6487 case ic_argpass:
6488 if (pedwarn (expr_loc, OPT_Wc___compat, "enum conversion when "
6489 "passing argument %d of %qE is invalid in C++",
6490 parmnum, rname))
6491 inform ((fundecl && !DECL_IS_BUILTIN (fundecl))
6492 ? DECL_SOURCE_LOCATION (fundecl) : expr_loc,
6493 "expected %qT but argument is of type %qT",
6494 type, rhstype);
6495 break;
6496 case ic_assign:
6497 pedwarn (location, OPT_Wc___compat, "enum conversion from %qT to "
6498 "%qT in assignment is invalid in C++", rhstype, type);
6499 break;
6500 case ic_init:
6501 pedwarn_init (location, OPT_Wc___compat, "enum conversion from "
6502 "%qT to %qT in initialization is invalid in C++",
6503 rhstype, type);
6504 break;
6505 case ic_return:
6506 pedwarn (location, OPT_Wc___compat, "enum conversion from %qT to "
6507 "%qT in return is invalid in C++", rhstype, type);
6508 break;
6509 default:
6510 gcc_unreachable ();
6511 }
6512 }
6513
6514 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
6515 return rhs;
6516
6517 if (coder == VOID_TYPE)
6518 {
6519 /* Except for passing an argument to an unprototyped function,
6520 this is a constraint violation. When passing an argument to
6521 an unprototyped function, it is compile-time undefined;
6522 making it a constraint in that case was rejected in
6523 DR#252. */
6524 error_at (location, "void value not ignored as it ought to be");
6525 return error_mark_node;
6526 }
6527 rhs = require_complete_type (location, rhs);
6528 if (rhs == error_mark_node)
6529 return error_mark_node;
6530
6531 if (coder == POINTER_TYPE && reject_gcc_builtin (rhs))
6532 return error_mark_node;
6533
6534 /* A non-reference type can convert to a reference. This handles
6535 va_start, va_copy and possibly port built-ins. */
6536 if (codel == REFERENCE_TYPE && coder != REFERENCE_TYPE)
6537 {
6538 if (!lvalue_p (rhs))
6539 {
6540 error_at (location, "cannot pass rvalue to reference parameter");
6541 return error_mark_node;
6542 }
6543 if (!c_mark_addressable (rhs))
6544 return error_mark_node;
6545 rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
6546 SET_EXPR_LOCATION (rhs, location);
6547
6548 rhs = convert_for_assignment (location, expr_loc,
6549 build_pointer_type (TREE_TYPE (type)),
6550 rhs, origtype, errtype,
6551 null_pointer_constant, fundecl, function,
6552 parmnum);
6553 if (rhs == error_mark_node)
6554 return error_mark_node;
6555
6556 rhs = build1 (NOP_EXPR, type, rhs);
6557 SET_EXPR_LOCATION (rhs, location);
6558 return rhs;
6559 }
6560 /* Some types can interconvert without explicit casts. */
6561 else if (codel == VECTOR_TYPE && coder == VECTOR_TYPE
6562 && vector_types_convertible_p (type, TREE_TYPE (rhs), true))
6563 return convert (type, rhs);
6564 /* Arithmetic types all interconvert, and enum is treated like int. */
6565 else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
6566 || codel == FIXED_POINT_TYPE
6567 || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
6568 || codel == BOOLEAN_TYPE)
6569 && (coder == INTEGER_TYPE || coder == REAL_TYPE
6570 || coder == FIXED_POINT_TYPE
6571 || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE
6572 || coder == BOOLEAN_TYPE))
6573 {
6574 tree ret;
6575 bool save = in_late_binary_op;
6576 if (codel == BOOLEAN_TYPE || codel == COMPLEX_TYPE
6577 || (coder == REAL_TYPE
6578 && (codel == INTEGER_TYPE || codel == ENUMERAL_TYPE)
6579 && sanitize_flags_p (SANITIZE_FLOAT_CAST)))
6580 in_late_binary_op = true;
6581 ret = convert_and_check (expr_loc != UNKNOWN_LOCATION
6582 ? expr_loc : location, type, orig_rhs);
6583 in_late_binary_op = save;
6584 return ret;
6585 }
6586
6587 /* Aggregates in different TUs might need conversion. */
6588 if ((codel == RECORD_TYPE || codel == UNION_TYPE)
6589 && codel == coder
6590 && comptypes (type, rhstype))
6591 return convert_and_check (expr_loc != UNKNOWN_LOCATION
6592 ? expr_loc : location, type, rhs);
6593
6594 /* Conversion to a transparent union or record from its member types.
6595 This applies only to function arguments. */
6596 if (((codel == UNION_TYPE || codel == RECORD_TYPE)
6597 && TYPE_TRANSPARENT_AGGR (type))
6598 && errtype == ic_argpass)
6599 {
6600 tree memb, marginal_memb = NULL_TREE;
6601
6602 for (memb = TYPE_FIELDS (type); memb ; memb = DECL_CHAIN (memb))
6603 {
6604 tree memb_type = TREE_TYPE (memb);
6605
6606 if (comptypes (TYPE_MAIN_VARIANT (memb_type),
6607 TYPE_MAIN_VARIANT (rhstype)))
6608 break;
6609
6610 if (TREE_CODE (memb_type) != POINTER_TYPE)
6611 continue;
6612
6613 if (coder == POINTER_TYPE)
6614 {
6615 tree ttl = TREE_TYPE (memb_type);
6616 tree ttr = TREE_TYPE (rhstype);
6617
6618 /* Any non-function converts to a [const][volatile] void *
6619 and vice versa; otherwise, targets must be the same.
6620 Meanwhile, the lhs target must have all the qualifiers of
6621 the rhs. */
6622 if ((VOID_TYPE_P (ttl) && !TYPE_ATOMIC (ttl))
6623 || (VOID_TYPE_P (ttr) && !TYPE_ATOMIC (ttr))
6624 || comp_target_types (location, memb_type, rhstype))
6625 {
6626 int lquals = TYPE_QUALS (ttl) & ~TYPE_QUAL_ATOMIC;
6627 int rquals = TYPE_QUALS (ttr) & ~TYPE_QUAL_ATOMIC;
6628 /* If this type won't generate any warnings, use it. */
6629 if (lquals == rquals
6630 || ((TREE_CODE (ttr) == FUNCTION_TYPE
6631 && TREE_CODE (ttl) == FUNCTION_TYPE)
6632 ? ((lquals | rquals) == rquals)
6633 : ((lquals | rquals) == lquals)))
6634 break;
6635
6636 /* Keep looking for a better type, but remember this one. */
6637 if (!marginal_memb)
6638 marginal_memb = memb;
6639 }
6640 }
6641
6642 /* Can convert integer zero to any pointer type. */
6643 if (null_pointer_constant)
6644 {
6645 rhs = null_pointer_node;
6646 break;
6647 }
6648 }
6649
6650 if (memb || marginal_memb)
6651 {
6652 if (!memb)
6653 {
6654 /* We have only a marginally acceptable member type;
6655 it needs a warning. */
6656 tree ttl = TREE_TYPE (TREE_TYPE (marginal_memb));
6657 tree ttr = TREE_TYPE (rhstype);
6658
6659 /* Const and volatile mean something different for function
6660 types, so the usual warnings are not appropriate. */
6661 if (TREE_CODE (ttr) == FUNCTION_TYPE
6662 && TREE_CODE (ttl) == FUNCTION_TYPE)
6663 {
6664 /* Because const and volatile on functions are
6665 restrictions that say the function will not do
6666 certain things, it is okay to use a const or volatile
6667 function where an ordinary one is wanted, but not
6668 vice-versa. */
6669 if (TYPE_QUALS_NO_ADDR_SPACE (ttl)
6670 & ~TYPE_QUALS_NO_ADDR_SPACE (ttr))
6671 PEDWARN_FOR_QUALIFIERS (location, expr_loc,
6672 OPT_Wdiscarded_qualifiers,
6673 G_("passing argument %d of %qE "
6674 "makes %q#v qualified function "
6675 "pointer from unqualified"),
6676 G_("assignment makes %q#v qualified "
6677 "function pointer from "
6678 "unqualified"),
6679 G_("initialization makes %q#v qualified "
6680 "function pointer from "
6681 "unqualified"),
6682 G_("return makes %q#v qualified function "
6683 "pointer from unqualified"),
6684 TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr));
6685 }
6686 else if (TYPE_QUALS_NO_ADDR_SPACE (ttr)
6687 & ~TYPE_QUALS_NO_ADDR_SPACE (ttl))
6688 PEDWARN_FOR_QUALIFIERS (location, expr_loc,
6689 OPT_Wdiscarded_qualifiers,
6690 G_("passing argument %d of %qE discards "
6691 "%qv qualifier from pointer target type"),
6692 G_("assignment discards %qv qualifier "
6693 "from pointer target type"),
6694 G_("initialization discards %qv qualifier "
6695 "from pointer target type"),
6696 G_("return discards %qv qualifier from "
6697 "pointer target type"),
6698 TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl));
6699
6700 memb = marginal_memb;
6701 }
6702
6703 if (!fundecl || !DECL_IN_SYSTEM_HEADER (fundecl))
6704 pedwarn (location, OPT_Wpedantic,
6705 "ISO C prohibits argument conversion to union type");
6706
6707 rhs = fold_convert_loc (location, TREE_TYPE (memb), rhs);
6708 return build_constructor_single (type, memb, rhs);
6709 }
6710 }
6711
6712 /* Conversions among pointers */
6713 else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
6714 && (coder == codel))
6715 {
6716 tree ttl = TREE_TYPE (type);
6717 tree ttr = TREE_TYPE (rhstype);
6718 tree mvl = ttl;
6719 tree mvr = ttr;
6720 bool is_opaque_pointer;
6721 int target_cmp = 0; /* Cache comp_target_types () result. */
6722 addr_space_t asl;
6723 addr_space_t asr;
6724
6725 if (TREE_CODE (mvl) != ARRAY_TYPE)
6726 mvl = (TYPE_ATOMIC (mvl)
6727 ? c_build_qualified_type (TYPE_MAIN_VARIANT (mvl),
6728 TYPE_QUAL_ATOMIC)
6729 : TYPE_MAIN_VARIANT (mvl));
6730 if (TREE_CODE (mvr) != ARRAY_TYPE)
6731 mvr = (TYPE_ATOMIC (mvr)
6732 ? c_build_qualified_type (TYPE_MAIN_VARIANT (mvr),
6733 TYPE_QUAL_ATOMIC)
6734 : TYPE_MAIN_VARIANT (mvr));
6735 /* Opaque pointers are treated like void pointers. */
6736 is_opaque_pointer = vector_targets_convertible_p (ttl, ttr);
6737
6738 /* The Plan 9 compiler permits a pointer to a struct to be
6739 automatically converted into a pointer to an anonymous field
6740 within the struct. */
6741 if (flag_plan9_extensions
6742 && RECORD_OR_UNION_TYPE_P (mvl)
6743 && RECORD_OR_UNION_TYPE_P (mvr)
6744 && mvl != mvr)
6745 {
6746 tree new_rhs = convert_to_anonymous_field (location, type, rhs);
6747 if (new_rhs != NULL_TREE)
6748 {
6749 rhs = new_rhs;
6750 rhstype = TREE_TYPE (rhs);
6751 coder = TREE_CODE (rhstype);
6752 ttr = TREE_TYPE (rhstype);
6753 mvr = TYPE_MAIN_VARIANT (ttr);
6754 }
6755 }
6756
6757 /* C++ does not allow the implicit conversion void* -> T*. However,
6758 for the purpose of reducing the number of false positives, we
6759 tolerate the special case of
6760
6761 int *p = NULL;
6762
6763 where NULL is typically defined in C to be '(void *) 0'. */
6764 if (VOID_TYPE_P (ttr) && rhs != null_pointer_node && !VOID_TYPE_P (ttl))
6765 warning_at (errtype == ic_argpass ? expr_loc : location,
6766 OPT_Wc___compat,
6767 "request for implicit conversion "
6768 "from %qT to %qT not permitted in C++", rhstype, type);
6769
6770 /* See if the pointers point to incompatible address spaces. */
6771 asl = TYPE_ADDR_SPACE (ttl);
6772 asr = TYPE_ADDR_SPACE (ttr);
6773 if (!null_pointer_constant_p (rhs)
6774 && asr != asl && !targetm.addr_space.subset_p (asr, asl))
6775 {
6776 switch (errtype)
6777 {
6778 case ic_argpass:
6779 error_at (expr_loc, "passing argument %d of %qE from pointer to "
6780 "non-enclosed address space", parmnum, rname);
6781 break;
6782 case ic_assign:
6783 error_at (location, "assignment from pointer to "
6784 "non-enclosed address space");
6785 break;
6786 case ic_init:
6787 error_at (location, "initialization from pointer to "
6788 "non-enclosed address space");
6789 break;
6790 case ic_return:
6791 error_at (location, "return from pointer to "
6792 "non-enclosed address space");
6793 break;
6794 default:
6795 gcc_unreachable ();
6796 }
6797 return error_mark_node;
6798 }
6799
6800 /* Check if the right-hand side has a format attribute but the
6801 left-hand side doesn't. */
6802 if (warn_suggest_attribute_format
6803 && check_missing_format_attribute (type, rhstype))
6804 {
6805 switch (errtype)
6806 {
6807 case ic_argpass:
6808 warning_at (expr_loc, OPT_Wsuggest_attribute_format,
6809 "argument %d of %qE might be "
6810 "a candidate for a format attribute",
6811 parmnum, rname);
6812 break;
6813 case ic_assign:
6814 warning_at (location, OPT_Wsuggest_attribute_format,
6815 "assignment left-hand side might be "
6816 "a candidate for a format attribute");
6817 break;
6818 case ic_init:
6819 warning_at (location, OPT_Wsuggest_attribute_format,
6820 "initialization left-hand side might be "
6821 "a candidate for a format attribute");
6822 break;
6823 case ic_return:
6824 warning_at (location, OPT_Wsuggest_attribute_format,
6825 "return type might be "
6826 "a candidate for a format attribute");
6827 break;
6828 default:
6829 gcc_unreachable ();
6830 }
6831 }
6832
6833 /* Any non-function converts to a [const][volatile] void *
6834 and vice versa; otherwise, targets must be the same.
6835 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
6836 if ((VOID_TYPE_P (ttl) && !TYPE_ATOMIC (ttl))
6837 || (VOID_TYPE_P (ttr) && !TYPE_ATOMIC (ttr))
6838 || (target_cmp = comp_target_types (location, type, rhstype))
6839 || is_opaque_pointer
6840 || ((c_common_unsigned_type (mvl)
6841 == c_common_unsigned_type (mvr))
6842 && (c_common_signed_type (mvl)
6843 == c_common_signed_type (mvr))
6844 && TYPE_ATOMIC (mvl) == TYPE_ATOMIC (mvr)))
6845 {
6846 /* Warn about loss of qualifers from pointers to arrays with
6847 qualifiers on the element type. */
6848 if (TREE_CODE (ttr) == ARRAY_TYPE)
6849 {
6850 ttr = strip_array_types (ttr);
6851 ttl = strip_array_types (ttl);
6852
6853 if (TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC (ttr)
6854 & ~TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC (ttl))
6855 WARNING_FOR_QUALIFIERS (location, expr_loc,
6856 OPT_Wdiscarded_array_qualifiers,
6857 G_("passing argument %d of %qE discards "
6858 "%qv qualifier from pointer target type"),
6859 G_("assignment discards %qv qualifier "
6860 "from pointer target type"),
6861 G_("initialization discards %qv qualifier "
6862 "from pointer target type"),
6863 G_("return discards %qv qualifier from "
6864 "pointer target type"),
6865 TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl));
6866 }
6867 else if (pedantic
6868 && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
6869 ||
6870 (VOID_TYPE_P (ttr)
6871 && !null_pointer_constant
6872 && TREE_CODE (ttl) == FUNCTION_TYPE)))
6873 PEDWARN_FOR_ASSIGNMENT (location, expr_loc, OPT_Wpedantic,
6874 G_("ISO C forbids passing argument %d of "
6875 "%qE between function pointer "
6876 "and %<void *%>"),
6877 G_("ISO C forbids assignment between "
6878 "function pointer and %<void *%>"),
6879 G_("ISO C forbids initialization between "
6880 "function pointer and %<void *%>"),
6881 G_("ISO C forbids return between function "
6882 "pointer and %<void *%>"));
6883 /* Const and volatile mean something different for function types,
6884 so the usual warnings are not appropriate. */
6885 else if (TREE_CODE (ttr) != FUNCTION_TYPE
6886 && TREE_CODE (ttl) != FUNCTION_TYPE)
6887 {
6888 /* Don't warn about loss of qualifier for conversions from
6889 qualified void* to pointers to arrays with corresponding
6890 qualifier on the element type. */
6891 if (!pedantic)
6892 ttl = strip_array_types (ttl);
6893
6894 /* Assignments between atomic and non-atomic objects are OK. */
6895 if (TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC (ttr)
6896 & ~TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC (ttl))
6897 {
6898 PEDWARN_FOR_QUALIFIERS (location, expr_loc,
6899 OPT_Wdiscarded_qualifiers,
6900 G_("passing argument %d of %qE discards "
6901 "%qv qualifier from pointer target type"),
6902 G_("assignment discards %qv qualifier "
6903 "from pointer target type"),
6904 G_("initialization discards %qv qualifier "
6905 "from pointer target type"),
6906 G_("return discards %qv qualifier from "
6907 "pointer target type"),
6908 TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl));
6909 }
6910 /* If this is not a case of ignoring a mismatch in signedness,
6911 no warning. */
6912 else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
6913 || target_cmp)
6914 ;
6915 /* If there is a mismatch, do warn. */
6916 else if (warn_pointer_sign)
6917 switch (errtype)
6918 {
6919 case ic_argpass:
6920 if (pedwarn (expr_loc, OPT_Wpointer_sign,
6921 "pointer targets in passing argument %d of "
6922 "%qE differ in signedness", parmnum, rname))
6923 inform ((fundecl && !DECL_IS_BUILTIN (fundecl))
6924 ? DECL_SOURCE_LOCATION (fundecl) : expr_loc,
6925 "expected %qT but argument is of type %qT",
6926 type, rhstype);
6927 break;
6928 case ic_assign:
6929 pedwarn (location, OPT_Wpointer_sign,
6930 "pointer targets in assignment from %qT to %qT "
6931 "differ in signedness", rhstype, type);
6932 break;
6933 case ic_init:
6934 pedwarn_init (location, OPT_Wpointer_sign,
6935 "pointer targets in initialization of %qT "
6936 "from %qT differ in signedness", type,
6937 rhstype);
6938 break;
6939 case ic_return:
6940 pedwarn (location, OPT_Wpointer_sign, "pointer targets in "
6941 "returning %qT from a function with return type "
6942 "%qT differ in signedness", rhstype, type);
6943 break;
6944 default:
6945 gcc_unreachable ();
6946 }
6947 }
6948 else if (TREE_CODE (ttl) == FUNCTION_TYPE
6949 && TREE_CODE (ttr) == FUNCTION_TYPE)
6950 {
6951 /* Because const and volatile on functions are restrictions
6952 that say the function will not do certain things,
6953 it is okay to use a const or volatile function
6954 where an ordinary one is wanted, but not vice-versa. */
6955 if (TYPE_QUALS_NO_ADDR_SPACE (ttl)
6956 & ~TYPE_QUALS_NO_ADDR_SPACE (ttr))
6957 PEDWARN_FOR_QUALIFIERS (location, expr_loc,
6958 OPT_Wdiscarded_qualifiers,
6959 G_("passing argument %d of %qE makes "
6960 "%q#v qualified function pointer "
6961 "from unqualified"),
6962 G_("assignment makes %q#v qualified function "
6963 "pointer from unqualified"),
6964 G_("initialization makes %q#v qualified "
6965 "function pointer from unqualified"),
6966 G_("return makes %q#v qualified function "
6967 "pointer from unqualified"),
6968 TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr));
6969 }
6970 }
6971 /* Avoid warning about the volatile ObjC EH puts on decls. */
6972 else if (!objc_ok)
6973 {
6974 switch (errtype)
6975 {
6976 case ic_argpass:
6977 if (pedwarn (expr_loc, OPT_Wincompatible_pointer_types,
6978 "passing argument %d of %qE from incompatible "
6979 "pointer type", parmnum, rname))
6980 inform_for_arg (fundecl, expr_loc, parmnum, type, rhstype);
6981 break;
6982 case ic_assign:
6983 pedwarn (location, OPT_Wincompatible_pointer_types,
6984 "assignment to %qT from incompatible pointer type %qT",
6985 type, rhstype);
6986 break;
6987 case ic_init:
6988 pedwarn_init (location, OPT_Wincompatible_pointer_types,
6989 "initialization of %qT from incompatible pointer "
6990 "type %qT", type, rhstype);
6991 break;
6992 case ic_return:
6993 pedwarn (location, OPT_Wincompatible_pointer_types,
6994 "returning %qT from a function with incompatible "
6995 "return type %qT", rhstype, type);
6996 break;
6997 default:
6998 gcc_unreachable ();
6999 }
7000 }
7001
7002 return convert (type, rhs);
7003 }
7004 else if (codel == POINTER_TYPE && coder == ARRAY_TYPE)
7005 {
7006 /* ??? This should not be an error when inlining calls to
7007 unprototyped functions. */
7008 error_at (location, "invalid use of non-lvalue array");
7009 return error_mark_node;
7010 }
7011 else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
7012 {
7013 /* An explicit constant 0 can convert to a pointer,
7014 or one that results from arithmetic, even including
7015 a cast to integer type. */
7016 if (!null_pointer_constant)
7017 switch (errtype)
7018 {
7019 case ic_argpass:
7020 if (pedwarn (expr_loc, OPT_Wint_conversion,
7021 "passing argument %d of %qE makes pointer from "
7022 "integer without a cast", parmnum, rname))
7023 inform_for_arg (fundecl, expr_loc, parmnum, type, rhstype);
7024 break;
7025 case ic_assign:
7026 pedwarn (location, OPT_Wint_conversion,
7027 "assignment to %qT from %qT makes pointer from integer "
7028 "without a cast", type, rhstype);
7029 break;
7030 case ic_init:
7031 pedwarn_init (location, OPT_Wint_conversion,
7032 "initialization of %qT from %qT makes pointer from "
7033 "integer without a cast", type, rhstype);
7034 break;
7035 case ic_return:
7036 pedwarn (location, OPT_Wint_conversion, "returning %qT from a "
7037 "function with return type %qT makes pointer from "
7038 "integer without a cast", rhstype, type);
7039 break;
7040 default:
7041 gcc_unreachable ();
7042 }
7043
7044 return convert (type, rhs);
7045 }
7046 else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
7047 {
7048 switch (errtype)
7049 {
7050 case ic_argpass:
7051 if (pedwarn (expr_loc, OPT_Wint_conversion,
7052 "passing argument %d of %qE makes integer from "
7053 "pointer without a cast", parmnum, rname))
7054 inform_for_arg (fundecl, expr_loc, parmnum, type, rhstype);
7055 break;
7056 case ic_assign:
7057 pedwarn (location, OPT_Wint_conversion,
7058 "assignment to %qT from %qT makes integer from pointer "
7059 "without a cast", type, rhstype);
7060 break;
7061 case ic_init:
7062 pedwarn_init (location, OPT_Wint_conversion,
7063 "initialization of %qT from %qT makes integer from "
7064 "pointer without a cast", type, rhstype);
7065 break;
7066 case ic_return:
7067 pedwarn (location, OPT_Wint_conversion, "returning %qT from a "
7068 "function with return type %qT makes integer from "
7069 "pointer without a cast", rhstype, type);
7070 break;
7071 default:
7072 gcc_unreachable ();
7073 }
7074
7075 return convert (type, rhs);
7076 }
7077 else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
7078 {
7079 tree ret;
7080 bool save = in_late_binary_op;
7081 in_late_binary_op = true;
7082 ret = convert (type, rhs);
7083 in_late_binary_op = save;
7084 return ret;
7085 }
7086
7087 switch (errtype)
7088 {
7089 case ic_argpass:
7090 error_at (expr_loc, "incompatible type for argument %d of %qE", parmnum,
7091 rname);
7092 inform_for_arg (fundecl, expr_loc, parmnum, type, rhstype);
7093 break;
7094 case ic_assign:
7095 error_at (location, "incompatible types when assigning to type %qT from "
7096 "type %qT", type, rhstype);
7097 break;
7098 case ic_init:
7099 error_at (location,
7100 "incompatible types when initializing type %qT using type %qT",
7101 type, rhstype);
7102 break;
7103 case ic_return:
7104 error_at (location,
7105 "incompatible types when returning type %qT but %qT was "
7106 "expected", rhstype, type);
7107 break;
7108 default:
7109 gcc_unreachable ();
7110 }
7111
7112 return error_mark_node;
7113 }
7114
7115 /* If VALUE is a compound expr all of whose expressions are constant, then
7116 return its value. Otherwise, return error_mark_node.
7117
7118 This is for handling COMPOUND_EXPRs as initializer elements
7119 which is allowed with a warning when -pedantic is specified. */
7120
7121 static tree
valid_compound_expr_initializer(tree value,tree endtype)7122 valid_compound_expr_initializer (tree value, tree endtype)
7123 {
7124 if (TREE_CODE (value) == COMPOUND_EXPR)
7125 {
7126 if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
7127 == error_mark_node)
7128 return error_mark_node;
7129 return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
7130 endtype);
7131 }
7132 else if (!initializer_constant_valid_p (value, endtype))
7133 return error_mark_node;
7134 else
7135 return value;
7136 }
7137
7138 /* Perform appropriate conversions on the initial value of a variable,
7139 store it in the declaration DECL,
7140 and print any error messages that are appropriate.
7141 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
7142 If the init is invalid, store an ERROR_MARK.
7143
7144 INIT_LOC is the location of the initial value. */
7145
7146 void
store_init_value(location_t init_loc,tree decl,tree init,tree origtype)7147 store_init_value (location_t init_loc, tree decl, tree init, tree origtype)
7148 {
7149 tree value, type;
7150 bool npc = false;
7151
7152 /* If variable's type was invalidly declared, just ignore it. */
7153
7154 type = TREE_TYPE (decl);
7155 if (TREE_CODE (type) == ERROR_MARK)
7156 return;
7157
7158 /* Digest the specified initializer into an expression. */
7159
7160 if (init)
7161 npc = null_pointer_constant_p (init);
7162 value = digest_init (init_loc, type, init, origtype, npc,
7163 true, TREE_STATIC (decl));
7164
7165 /* Store the expression if valid; else report error. */
7166
7167 if (!in_system_header_at (input_location)
7168 && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && !TREE_STATIC (decl))
7169 warning (OPT_Wtraditional, "traditional C rejects automatic "
7170 "aggregate initialization");
7171
7172 if (value != error_mark_node || TREE_CODE (decl) != FUNCTION_DECL)
7173 DECL_INITIAL (decl) = value;
7174
7175 /* ANSI wants warnings about out-of-range constant initializers. */
7176 STRIP_TYPE_NOPS (value);
7177 if (TREE_STATIC (decl))
7178 constant_expression_warning (value);
7179
7180 /* Check if we need to set array size from compound literal size. */
7181 if (TREE_CODE (type) == ARRAY_TYPE
7182 && TYPE_DOMAIN (type) == NULL_TREE
7183 && value != error_mark_node)
7184 {
7185 tree inside_init = init;
7186
7187 STRIP_TYPE_NOPS (inside_init);
7188 inside_init = fold (inside_init);
7189
7190 if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
7191 {
7192 tree cldecl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
7193
7194 if (TYPE_DOMAIN (TREE_TYPE (cldecl)))
7195 {
7196 /* For int foo[] = (int [3]){1}; we need to set array size
7197 now since later on array initializer will be just the
7198 brace enclosed list of the compound literal. */
7199 tree etype = strip_array_types (TREE_TYPE (decl));
7200 type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
7201 TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (cldecl));
7202 layout_type (type);
7203 layout_decl (cldecl, 0);
7204 TREE_TYPE (decl)
7205 = c_build_qualified_type (type, TYPE_QUALS (etype));
7206 }
7207 }
7208 }
7209 }
7210
7211 /* Methods for storing and printing names for error messages. */
7212
7213 /* Implement a spelling stack that allows components of a name to be pushed
7214 and popped. Each element on the stack is this structure. */
7215
7216 struct spelling
7217 {
7218 int kind;
7219 union
7220 {
7221 unsigned HOST_WIDE_INT i;
7222 const char *s;
7223 } u;
7224 };
7225
7226 #define SPELLING_STRING 1
7227 #define SPELLING_MEMBER 2
7228 #define SPELLING_BOUNDS 3
7229
7230 static struct spelling *spelling; /* Next stack element (unused). */
7231 static struct spelling *spelling_base; /* Spelling stack base. */
7232 static int spelling_size; /* Size of the spelling stack. */
7233
7234 /* Macros to save and restore the spelling stack around push_... functions.
7235 Alternative to SAVE_SPELLING_STACK. */
7236
7237 #define SPELLING_DEPTH() (spelling - spelling_base)
7238 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
7239
7240 /* Push an element on the spelling stack with type KIND and assign VALUE
7241 to MEMBER. */
7242
7243 #define PUSH_SPELLING(KIND, VALUE, MEMBER) \
7244 { \
7245 int depth = SPELLING_DEPTH (); \
7246 \
7247 if (depth >= spelling_size) \
7248 { \
7249 spelling_size += 10; \
7250 spelling_base = XRESIZEVEC (struct spelling, spelling_base, \
7251 spelling_size); \
7252 RESTORE_SPELLING_DEPTH (depth); \
7253 } \
7254 \
7255 spelling->kind = (KIND); \
7256 spelling->MEMBER = (VALUE); \
7257 spelling++; \
7258 }
7259
7260 /* Push STRING on the stack. Printed literally. */
7261
7262 static void
push_string(const char * string)7263 push_string (const char *string)
7264 {
7265 PUSH_SPELLING (SPELLING_STRING, string, u.s);
7266 }
7267
7268 /* Push a member name on the stack. Printed as '.' STRING. */
7269
7270 static void
push_member_name(tree decl)7271 push_member_name (tree decl)
7272 {
7273 const char *const string
7274 = (DECL_NAME (decl)
7275 ? identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl)))
7276 : _("<anonymous>"));
7277 PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
7278 }
7279
7280 /* Push an array bounds on the stack. Printed as [BOUNDS]. */
7281
7282 static void
push_array_bounds(unsigned HOST_WIDE_INT bounds)7283 push_array_bounds (unsigned HOST_WIDE_INT bounds)
7284 {
7285 PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
7286 }
7287
7288 /* Compute the maximum size in bytes of the printed spelling. */
7289
7290 static int
spelling_length(void)7291 spelling_length (void)
7292 {
7293 int size = 0;
7294 struct spelling *p;
7295
7296 for (p = spelling_base; p < spelling; p++)
7297 {
7298 if (p->kind == SPELLING_BOUNDS)
7299 size += 25;
7300 else
7301 size += strlen (p->u.s) + 1;
7302 }
7303
7304 return size;
7305 }
7306
7307 /* Print the spelling to BUFFER and return it. */
7308
7309 static char *
print_spelling(char * buffer)7310 print_spelling (char *buffer)
7311 {
7312 char *d = buffer;
7313 struct spelling *p;
7314
7315 for (p = spelling_base; p < spelling; p++)
7316 if (p->kind == SPELLING_BOUNDS)
7317 {
7318 sprintf (d, "[" HOST_WIDE_INT_PRINT_UNSIGNED "]", p->u.i);
7319 d += strlen (d);
7320 }
7321 else
7322 {
7323 const char *s;
7324 if (p->kind == SPELLING_MEMBER)
7325 *d++ = '.';
7326 for (s = p->u.s; (*d = *s++); d++)
7327 ;
7328 }
7329 *d++ = '\0';
7330 return buffer;
7331 }
7332
7333 /* Digest the parser output INIT as an initializer for type TYPE.
7334 Return a C expression of type TYPE to represent the initial value.
7335
7336 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
7337
7338 NULL_POINTER_CONSTANT is true if INIT is a null pointer constant.
7339
7340 If INIT is a string constant, STRICT_STRING is true if it is
7341 unparenthesized or we should not warn here for it being parenthesized.
7342 For other types of INIT, STRICT_STRING is not used.
7343
7344 INIT_LOC is the location of the INIT.
7345
7346 REQUIRE_CONSTANT requests an error if non-constant initializers or
7347 elements are seen. */
7348
7349 static tree
digest_init(location_t init_loc,tree type,tree init,tree origtype,bool null_pointer_constant,bool strict_string,int require_constant)7350 digest_init (location_t init_loc, tree type, tree init, tree origtype,
7351 bool null_pointer_constant, bool strict_string,
7352 int require_constant)
7353 {
7354 enum tree_code code = TREE_CODE (type);
7355 tree inside_init = init;
7356 tree semantic_type = NULL_TREE;
7357 bool maybe_const = true;
7358
7359 if (type == error_mark_node
7360 || !init
7361 || error_operand_p (init))
7362 return error_mark_node;
7363
7364 STRIP_TYPE_NOPS (inside_init);
7365
7366 if (TREE_CODE (inside_init) == EXCESS_PRECISION_EXPR)
7367 {
7368 semantic_type = TREE_TYPE (inside_init);
7369 inside_init = TREE_OPERAND (inside_init, 0);
7370 }
7371 inside_init = c_fully_fold (inside_init, require_constant, &maybe_const);
7372
7373 /* Initialization of an array of chars from a string constant
7374 optionally enclosed in braces. */
7375
7376 if (code == ARRAY_TYPE && inside_init
7377 && TREE_CODE (inside_init) == STRING_CST)
7378 {
7379 tree typ1
7380 = (TYPE_ATOMIC (TREE_TYPE (type))
7381 ? c_build_qualified_type (TYPE_MAIN_VARIANT (TREE_TYPE (type)),
7382 TYPE_QUAL_ATOMIC)
7383 : TYPE_MAIN_VARIANT (TREE_TYPE (type)));
7384 /* Note that an array could be both an array of character type
7385 and an array of wchar_t if wchar_t is signed char or unsigned
7386 char. */
7387 bool char_array = (typ1 == char_type_node
7388 || typ1 == signed_char_type_node
7389 || typ1 == unsigned_char_type_node);
7390 bool wchar_array = !!comptypes (typ1, wchar_type_node);
7391 bool char16_array = !!comptypes (typ1, char16_type_node);
7392 bool char32_array = !!comptypes (typ1, char32_type_node);
7393
7394 if (char_array || wchar_array || char16_array || char32_array)
7395 {
7396 struct c_expr expr;
7397 tree typ2 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)));
7398 expr.value = inside_init;
7399 expr.original_code = (strict_string ? STRING_CST : ERROR_MARK);
7400 expr.original_type = NULL;
7401 maybe_warn_string_init (init_loc, type, expr);
7402
7403 if (TYPE_DOMAIN (type) && !TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
7404 pedwarn_init (init_loc, OPT_Wpedantic,
7405 "initialization of a flexible array member");
7406
7407 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
7408 TYPE_MAIN_VARIANT (type)))
7409 return inside_init;
7410
7411 if (char_array)
7412 {
7413 if (typ2 != char_type_node)
7414 {
7415 error_init (init_loc, "char-array initialized from wide "
7416 "string");
7417 return error_mark_node;
7418 }
7419 }
7420 else
7421 {
7422 if (typ2 == char_type_node)
7423 {
7424 error_init (init_loc, "wide character array initialized "
7425 "from non-wide string");
7426 return error_mark_node;
7427 }
7428 else if (!comptypes(typ1, typ2))
7429 {
7430 error_init (init_loc, "wide character array initialized "
7431 "from incompatible wide string");
7432 return error_mark_node;
7433 }
7434 }
7435
7436 TREE_TYPE (inside_init) = type;
7437 if (TYPE_DOMAIN (type) != NULL_TREE
7438 && TYPE_SIZE (type) != NULL_TREE
7439 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
7440 {
7441 unsigned HOST_WIDE_INT len = TREE_STRING_LENGTH (inside_init);
7442
7443 /* Subtract the size of a single (possibly wide) character
7444 because it's ok to ignore the terminating null char
7445 that is counted in the length of the constant. */
7446 if (compare_tree_int (TYPE_SIZE_UNIT (type),
7447 (len - (TYPE_PRECISION (typ1)
7448 / BITS_PER_UNIT))) < 0)
7449 pedwarn_init (init_loc, 0,
7450 ("initializer-string for array of chars "
7451 "is too long"));
7452 else if (warn_cxx_compat
7453 && compare_tree_int (TYPE_SIZE_UNIT (type), len) < 0)
7454 warning_at (init_loc, OPT_Wc___compat,
7455 ("initializer-string for array chars "
7456 "is too long for C++"));
7457 }
7458
7459 return inside_init;
7460 }
7461 else if (INTEGRAL_TYPE_P (typ1))
7462 {
7463 error_init (init_loc, "array of inappropriate type initialized "
7464 "from string constant");
7465 return error_mark_node;
7466 }
7467 }
7468
7469 /* Build a VECTOR_CST from a *constant* vector constructor. If the
7470 vector constructor is not constant (e.g. {1,2,3,foo()}) then punt
7471 below and handle as a constructor. */
7472 if (code == VECTOR_TYPE
7473 && VECTOR_TYPE_P (TREE_TYPE (inside_init))
7474 && vector_types_convertible_p (TREE_TYPE (inside_init), type, true)
7475 && TREE_CONSTANT (inside_init))
7476 {
7477 if (TREE_CODE (inside_init) == VECTOR_CST
7478 && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
7479 TYPE_MAIN_VARIANT (type)))
7480 return inside_init;
7481
7482 if (TREE_CODE (inside_init) == CONSTRUCTOR)
7483 {
7484 unsigned HOST_WIDE_INT ix;
7485 tree value;
7486 bool constant_p = true;
7487
7488 /* Iterate through elements and check if all constructor
7489 elements are *_CSTs. */
7490 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (inside_init), ix, value)
7491 if (!CONSTANT_CLASS_P (value))
7492 {
7493 constant_p = false;
7494 break;
7495 }
7496
7497 if (constant_p)
7498 return build_vector_from_ctor (type,
7499 CONSTRUCTOR_ELTS (inside_init));
7500 }
7501 }
7502
7503 if (warn_sequence_point)
7504 verify_sequence_points (inside_init);
7505
7506 /* Any type can be initialized
7507 from an expression of the same type, optionally with braces. */
7508
7509 if (inside_init && TREE_TYPE (inside_init) != NULL_TREE
7510 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
7511 TYPE_MAIN_VARIANT (type))
7512 || (code == ARRAY_TYPE
7513 && comptypes (TREE_TYPE (inside_init), type))
7514 || (code == VECTOR_TYPE
7515 && comptypes (TREE_TYPE (inside_init), type))
7516 || (code == POINTER_TYPE
7517 && TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
7518 && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
7519 TREE_TYPE (type)))))
7520 {
7521 if (code == POINTER_TYPE)
7522 {
7523 if (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE)
7524 {
7525 if (TREE_CODE (inside_init) == STRING_CST
7526 || TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
7527 inside_init = array_to_pointer_conversion
7528 (init_loc, inside_init);
7529 else
7530 {
7531 error_init (init_loc, "invalid use of non-lvalue array");
7532 return error_mark_node;
7533 }
7534 }
7535 }
7536
7537 if (code == VECTOR_TYPE)
7538 /* Although the types are compatible, we may require a
7539 conversion. */
7540 inside_init = convert (type, inside_init);
7541
7542 if (require_constant
7543 && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
7544 {
7545 /* As an extension, allow initializing objects with static storage
7546 duration with compound literals (which are then treated just as
7547 the brace enclosed list they contain). Also allow this for
7548 vectors, as we can only assign them with compound literals. */
7549 if (flag_isoc99 && code != VECTOR_TYPE)
7550 pedwarn_init (init_loc, OPT_Wpedantic, "initializer element "
7551 "is not constant");
7552 tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
7553 inside_init = DECL_INITIAL (decl);
7554 }
7555
7556 if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
7557 && TREE_CODE (inside_init) != CONSTRUCTOR)
7558 {
7559 error_init (init_loc, "array initialized from non-constant array "
7560 "expression");
7561 return error_mark_node;
7562 }
7563
7564 /* Compound expressions can only occur here if -Wpedantic or
7565 -pedantic-errors is specified. In the later case, we always want
7566 an error. In the former case, we simply want a warning. */
7567 if (require_constant && pedantic
7568 && TREE_CODE (inside_init) == COMPOUND_EXPR)
7569 {
7570 inside_init
7571 = valid_compound_expr_initializer (inside_init,
7572 TREE_TYPE (inside_init));
7573 if (inside_init == error_mark_node)
7574 error_init (init_loc, "initializer element is not constant");
7575 else
7576 pedwarn_init (init_loc, OPT_Wpedantic,
7577 "initializer element is not constant");
7578 if (flag_pedantic_errors)
7579 inside_init = error_mark_node;
7580 }
7581 else if (require_constant
7582 && !initializer_constant_valid_p (inside_init,
7583 TREE_TYPE (inside_init)))
7584 {
7585 error_init (init_loc, "initializer element is not constant");
7586 inside_init = error_mark_node;
7587 }
7588 else if (require_constant && !maybe_const)
7589 pedwarn_init (init_loc, OPT_Wpedantic,
7590 "initializer element is not a constant expression");
7591
7592 /* Added to enable additional -Wsuggest-attribute=format warnings. */
7593 if (TREE_CODE (TREE_TYPE (inside_init)) == POINTER_TYPE)
7594 inside_init = convert_for_assignment (init_loc, UNKNOWN_LOCATION,
7595 type, inside_init, origtype,
7596 ic_init, null_pointer_constant,
7597 NULL_TREE, NULL_TREE, 0);
7598 return inside_init;
7599 }
7600
7601 /* Handle scalar types, including conversions. */
7602
7603 if (code == INTEGER_TYPE || code == REAL_TYPE || code == FIXED_POINT_TYPE
7604 || code == POINTER_TYPE || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE
7605 || code == COMPLEX_TYPE || code == VECTOR_TYPE)
7606 {
7607 if (TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE
7608 && (TREE_CODE (init) == STRING_CST
7609 || TREE_CODE (init) == COMPOUND_LITERAL_EXPR))
7610 inside_init = init = array_to_pointer_conversion (init_loc, init);
7611 if (semantic_type)
7612 inside_init = build1 (EXCESS_PRECISION_EXPR, semantic_type,
7613 inside_init);
7614 inside_init
7615 = convert_for_assignment (init_loc, UNKNOWN_LOCATION, type,
7616 inside_init, origtype, ic_init,
7617 null_pointer_constant, NULL_TREE, NULL_TREE,
7618 0);
7619
7620 /* Check to see if we have already given an error message. */
7621 if (inside_init == error_mark_node)
7622 ;
7623 else if (require_constant && !TREE_CONSTANT (inside_init))
7624 {
7625 error_init (init_loc, "initializer element is not constant");
7626 inside_init = error_mark_node;
7627 }
7628 else if (require_constant
7629 && !initializer_constant_valid_p (inside_init,
7630 TREE_TYPE (inside_init)))
7631 {
7632 error_init (init_loc, "initializer element is not computable at "
7633 "load time");
7634 inside_init = error_mark_node;
7635 }
7636 else if (require_constant && !maybe_const)
7637 pedwarn_init (init_loc, OPT_Wpedantic,
7638 "initializer element is not a constant expression");
7639
7640 return inside_init;
7641 }
7642
7643 /* Come here only for records and arrays. */
7644
7645 if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
7646 {
7647 error_init (init_loc, "variable-sized object may not be initialized");
7648 return error_mark_node;
7649 }
7650
7651 error_init (init_loc, "invalid initializer");
7652 return error_mark_node;
7653 }
7654
7655 /* Handle initializers that use braces. */
7656
7657 /* Type of object we are accumulating a constructor for.
7658 This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */
7659 static tree constructor_type;
7660
7661 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
7662 left to fill. */
7663 static tree constructor_fields;
7664
7665 /* For an ARRAY_TYPE, this is the specified index
7666 at which to store the next element we get. */
7667 static tree constructor_index;
7668
7669 /* For an ARRAY_TYPE, this is the maximum index. */
7670 static tree constructor_max_index;
7671
7672 /* For a RECORD_TYPE, this is the first field not yet written out. */
7673 static tree constructor_unfilled_fields;
7674
7675 /* For an ARRAY_TYPE, this is the index of the first element
7676 not yet written out. */
7677 static tree constructor_unfilled_index;
7678
7679 /* In a RECORD_TYPE, the byte index of the next consecutive field.
7680 This is so we can generate gaps between fields, when appropriate. */
7681 static tree constructor_bit_index;
7682
7683 /* If we are saving up the elements rather than allocating them,
7684 this is the list of elements so far (in reverse order,
7685 most recent first). */
7686 static vec<constructor_elt, va_gc> *constructor_elements;
7687
7688 /* 1 if constructor should be incrementally stored into a constructor chain,
7689 0 if all the elements should be kept in AVL tree. */
7690 static int constructor_incremental;
7691
7692 /* 1 if so far this constructor's elements are all compile-time constants. */
7693 static int constructor_constant;
7694
7695 /* 1 if so far this constructor's elements are all valid address constants. */
7696 static int constructor_simple;
7697
7698 /* 1 if this constructor has an element that cannot be part of a
7699 constant expression. */
7700 static int constructor_nonconst;
7701
7702 /* 1 if this constructor is erroneous so far. */
7703 static int constructor_erroneous;
7704
7705 /* 1 if this constructor is the universal zero initializer { 0 }. */
7706 static int constructor_zeroinit;
7707
7708 /* Structure for managing pending initializer elements, organized as an
7709 AVL tree. */
7710
7711 struct init_node
7712 {
7713 struct init_node *left, *right;
7714 struct init_node *parent;
7715 int balance;
7716 tree purpose;
7717 tree value;
7718 tree origtype;
7719 };
7720
7721 /* Tree of pending elements at this constructor level.
7722 These are elements encountered out of order
7723 which belong at places we haven't reached yet in actually
7724 writing the output.
7725 Will never hold tree nodes across GC runs. */
7726 static struct init_node *constructor_pending_elts;
7727
7728 /* The SPELLING_DEPTH of this constructor. */
7729 static int constructor_depth;
7730
7731 /* DECL node for which an initializer is being read.
7732 0 means we are reading a constructor expression
7733 such as (struct foo) {...}. */
7734 static tree constructor_decl;
7735
7736 /* Nonzero if this is an initializer for a top-level decl. */
7737 static int constructor_top_level;
7738
7739 /* Nonzero if there were any member designators in this initializer. */
7740 static int constructor_designated;
7741
7742 /* Nesting depth of designator list. */
7743 static int designator_depth;
7744
7745 /* Nonzero if there were diagnosed errors in this designator list. */
7746 static int designator_erroneous;
7747
7748
7749 /* This stack has a level for each implicit or explicit level of
7750 structuring in the initializer, including the outermost one. It
7751 saves the values of most of the variables above. */
7752
7753 struct constructor_range_stack;
7754
7755 struct constructor_stack
7756 {
7757 struct constructor_stack *next;
7758 tree type;
7759 tree fields;
7760 tree index;
7761 tree max_index;
7762 tree unfilled_index;
7763 tree unfilled_fields;
7764 tree bit_index;
7765 vec<constructor_elt, va_gc> *elements;
7766 struct init_node *pending_elts;
7767 int offset;
7768 int depth;
7769 /* If value nonzero, this value should replace the entire
7770 constructor at this level. */
7771 struct c_expr replacement_value;
7772 struct constructor_range_stack *range_stack;
7773 char constant;
7774 char simple;
7775 char nonconst;
7776 char implicit;
7777 char erroneous;
7778 char outer;
7779 char incremental;
7780 char designated;
7781 int designator_depth;
7782 };
7783
7784 static struct constructor_stack *constructor_stack;
7785
7786 /* This stack represents designators from some range designator up to
7787 the last designator in the list. */
7788
7789 struct constructor_range_stack
7790 {
7791 struct constructor_range_stack *next, *prev;
7792 struct constructor_stack *stack;
7793 tree range_start;
7794 tree index;
7795 tree range_end;
7796 tree fields;
7797 };
7798
7799 static struct constructor_range_stack *constructor_range_stack;
7800
7801 /* This stack records separate initializers that are nested.
7802 Nested initializers can't happen in ANSI C, but GNU C allows them
7803 in cases like { ... (struct foo) { ... } ... }. */
7804
7805 struct initializer_stack
7806 {
7807 struct initializer_stack *next;
7808 tree decl;
7809 struct constructor_stack *constructor_stack;
7810 struct constructor_range_stack *constructor_range_stack;
7811 vec<constructor_elt, va_gc> *elements;
7812 struct spelling *spelling;
7813 struct spelling *spelling_base;
7814 int spelling_size;
7815 char top_level;
7816 char require_constant_value;
7817 char require_constant_elements;
7818 rich_location *missing_brace_richloc;
7819 };
7820
7821 static struct initializer_stack *initializer_stack;
7822
7823 /* Prepare to parse and output the initializer for variable DECL. */
7824
7825 void
start_init(tree decl,tree asmspec_tree ATTRIBUTE_UNUSED,int top_level,rich_location * richloc)7826 start_init (tree decl, tree asmspec_tree ATTRIBUTE_UNUSED, int top_level,
7827 rich_location *richloc)
7828 {
7829 const char *locus;
7830 struct initializer_stack *p = XNEW (struct initializer_stack);
7831
7832 p->decl = constructor_decl;
7833 p->require_constant_value = require_constant_value;
7834 p->require_constant_elements = require_constant_elements;
7835 p->constructor_stack = constructor_stack;
7836 p->constructor_range_stack = constructor_range_stack;
7837 p->elements = constructor_elements;
7838 p->spelling = spelling;
7839 p->spelling_base = spelling_base;
7840 p->spelling_size = spelling_size;
7841 p->top_level = constructor_top_level;
7842 p->next = initializer_stack;
7843 p->missing_brace_richloc = richloc;
7844 initializer_stack = p;
7845
7846 constructor_decl = decl;
7847 constructor_designated = 0;
7848 constructor_top_level = top_level;
7849
7850 if (decl != NULL_TREE && decl != error_mark_node)
7851 {
7852 require_constant_value = TREE_STATIC (decl);
7853 require_constant_elements
7854 = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
7855 /* For a scalar, you can always use any value to initialize,
7856 even within braces. */
7857 && AGGREGATE_TYPE_P (TREE_TYPE (decl)));
7858 locus = identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl)));
7859 }
7860 else
7861 {
7862 require_constant_value = 0;
7863 require_constant_elements = 0;
7864 locus = _("(anonymous)");
7865 }
7866
7867 constructor_stack = 0;
7868 constructor_range_stack = 0;
7869
7870 found_missing_braces = 0;
7871
7872 spelling_base = 0;
7873 spelling_size = 0;
7874 RESTORE_SPELLING_DEPTH (0);
7875
7876 if (locus)
7877 push_string (locus);
7878 }
7879
7880 void
finish_init(void)7881 finish_init (void)
7882 {
7883 struct initializer_stack *p = initializer_stack;
7884
7885 /* Free the whole constructor stack of this initializer. */
7886 while (constructor_stack)
7887 {
7888 struct constructor_stack *q = constructor_stack;
7889 constructor_stack = q->next;
7890 free (q);
7891 }
7892
7893 gcc_assert (!constructor_range_stack);
7894
7895 /* Pop back to the data of the outer initializer (if any). */
7896 free (spelling_base);
7897
7898 constructor_decl = p->decl;
7899 require_constant_value = p->require_constant_value;
7900 require_constant_elements = p->require_constant_elements;
7901 constructor_stack = p->constructor_stack;
7902 constructor_range_stack = p->constructor_range_stack;
7903 constructor_elements = p->elements;
7904 spelling = p->spelling;
7905 spelling_base = p->spelling_base;
7906 spelling_size = p->spelling_size;
7907 constructor_top_level = p->top_level;
7908 initializer_stack = p->next;
7909 free (p);
7910 }
7911
7912 /* Call here when we see the initializer is surrounded by braces.
7913 This is instead of a call to push_init_level;
7914 it is matched by a call to pop_init_level.
7915
7916 TYPE is the type to initialize, for a constructor expression.
7917 For an initializer for a decl, TYPE is zero. */
7918
7919 void
really_start_incremental_init(tree type)7920 really_start_incremental_init (tree type)
7921 {
7922 struct constructor_stack *p = XNEW (struct constructor_stack);
7923
7924 if (type == NULL_TREE)
7925 type = TREE_TYPE (constructor_decl);
7926
7927 if (VECTOR_TYPE_P (type)
7928 && TYPE_VECTOR_OPAQUE (type))
7929 error ("opaque vector types cannot be initialized");
7930
7931 p->type = constructor_type;
7932 p->fields = constructor_fields;
7933 p->index = constructor_index;
7934 p->max_index = constructor_max_index;
7935 p->unfilled_index = constructor_unfilled_index;
7936 p->unfilled_fields = constructor_unfilled_fields;
7937 p->bit_index = constructor_bit_index;
7938 p->elements = constructor_elements;
7939 p->constant = constructor_constant;
7940 p->simple = constructor_simple;
7941 p->nonconst = constructor_nonconst;
7942 p->erroneous = constructor_erroneous;
7943 p->pending_elts = constructor_pending_elts;
7944 p->depth = constructor_depth;
7945 p->replacement_value.value = 0;
7946 p->replacement_value.original_code = ERROR_MARK;
7947 p->replacement_value.original_type = NULL;
7948 p->implicit = 0;
7949 p->range_stack = 0;
7950 p->outer = 0;
7951 p->incremental = constructor_incremental;
7952 p->designated = constructor_designated;
7953 p->designator_depth = designator_depth;
7954 p->next = 0;
7955 constructor_stack = p;
7956
7957 constructor_constant = 1;
7958 constructor_simple = 1;
7959 constructor_nonconst = 0;
7960 constructor_depth = SPELLING_DEPTH ();
7961 constructor_elements = NULL;
7962 constructor_pending_elts = 0;
7963 constructor_type = type;
7964 constructor_incremental = 1;
7965 constructor_designated = 0;
7966 constructor_zeroinit = 1;
7967 designator_depth = 0;
7968 designator_erroneous = 0;
7969
7970 if (RECORD_OR_UNION_TYPE_P (constructor_type))
7971 {
7972 constructor_fields = TYPE_FIELDS (constructor_type);
7973 /* Skip any nameless bit fields at the beginning. */
7974 while (constructor_fields != NULL_TREE
7975 && DECL_UNNAMED_BIT_FIELD (constructor_fields))
7976 constructor_fields = DECL_CHAIN (constructor_fields);
7977
7978 constructor_unfilled_fields = constructor_fields;
7979 constructor_bit_index = bitsize_zero_node;
7980 }
7981 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
7982 {
7983 if (TYPE_DOMAIN (constructor_type))
7984 {
7985 constructor_max_index
7986 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
7987
7988 /* Detect non-empty initializations of zero-length arrays. */
7989 if (constructor_max_index == NULL_TREE
7990 && TYPE_SIZE (constructor_type))
7991 constructor_max_index = integer_minus_one_node;
7992
7993 /* constructor_max_index needs to be an INTEGER_CST. Attempts
7994 to initialize VLAs will cause a proper error; avoid tree
7995 checking errors as well by setting a safe value. */
7996 if (constructor_max_index
7997 && TREE_CODE (constructor_max_index) != INTEGER_CST)
7998 constructor_max_index = integer_minus_one_node;
7999
8000 constructor_index
8001 = convert (bitsizetype,
8002 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
8003 }
8004 else
8005 {
8006 constructor_index = bitsize_zero_node;
8007 constructor_max_index = NULL_TREE;
8008 }
8009
8010 constructor_unfilled_index = constructor_index;
8011 }
8012 else if (VECTOR_TYPE_P (constructor_type))
8013 {
8014 /* Vectors are like simple fixed-size arrays. */
8015 constructor_max_index =
8016 bitsize_int (TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
8017 constructor_index = bitsize_zero_node;
8018 constructor_unfilled_index = constructor_index;
8019 }
8020 else
8021 {
8022 /* Handle the case of int x = {5}; */
8023 constructor_fields = constructor_type;
8024 constructor_unfilled_fields = constructor_type;
8025 }
8026 }
8027
8028 extern location_t last_init_list_comma;
8029
8030 /* Called when we see an open brace for a nested initializer. Finish
8031 off any pending levels with implicit braces. */
8032 void
finish_implicit_inits(location_t loc,struct obstack * braced_init_obstack)8033 finish_implicit_inits (location_t loc, struct obstack *braced_init_obstack)
8034 {
8035 while (constructor_stack->implicit)
8036 {
8037 if (RECORD_OR_UNION_TYPE_P (constructor_type)
8038 && constructor_fields == NULL_TREE)
8039 process_init_element (input_location,
8040 pop_init_level (loc, 1, braced_init_obstack,
8041 last_init_list_comma),
8042 true, braced_init_obstack);
8043 else if (TREE_CODE (constructor_type) == ARRAY_TYPE
8044 && constructor_max_index
8045 && tree_int_cst_lt (constructor_max_index,
8046 constructor_index))
8047 process_init_element (input_location,
8048 pop_init_level (loc, 1, braced_init_obstack,
8049 last_init_list_comma),
8050 true, braced_init_obstack);
8051 else
8052 break;
8053 }
8054 }
8055
8056 /* Push down into a subobject, for initialization.
8057 If this is for an explicit set of braces, IMPLICIT is 0.
8058 If it is because the next element belongs at a lower level,
8059 IMPLICIT is 1 (or 2 if the push is because of designator list). */
8060
8061 void
push_init_level(location_t loc,int implicit,struct obstack * braced_init_obstack)8062 push_init_level (location_t loc, int implicit,
8063 struct obstack *braced_init_obstack)
8064 {
8065 struct constructor_stack *p;
8066 tree value = NULL_TREE;
8067
8068 /* Unless this is an explicit brace, we need to preserve previous
8069 content if any. */
8070 if (implicit)
8071 {
8072 if (RECORD_OR_UNION_TYPE_P (constructor_type) && constructor_fields)
8073 value = find_init_member (constructor_fields, braced_init_obstack);
8074 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
8075 value = find_init_member (constructor_index, braced_init_obstack);
8076 }
8077
8078 p = XNEW (struct constructor_stack);
8079 p->type = constructor_type;
8080 p->fields = constructor_fields;
8081 p->index = constructor_index;
8082 p->max_index = constructor_max_index;
8083 p->unfilled_index = constructor_unfilled_index;
8084 p->unfilled_fields = constructor_unfilled_fields;
8085 p->bit_index = constructor_bit_index;
8086 p->elements = constructor_elements;
8087 p->constant = constructor_constant;
8088 p->simple = constructor_simple;
8089 p->nonconst = constructor_nonconst;
8090 p->erroneous = constructor_erroneous;
8091 p->pending_elts = constructor_pending_elts;
8092 p->depth = constructor_depth;
8093 p->replacement_value.value = NULL_TREE;
8094 p->replacement_value.original_code = ERROR_MARK;
8095 p->replacement_value.original_type = NULL;
8096 p->implicit = implicit;
8097 p->outer = 0;
8098 p->incremental = constructor_incremental;
8099 p->designated = constructor_designated;
8100 p->designator_depth = designator_depth;
8101 p->next = constructor_stack;
8102 p->range_stack = 0;
8103 constructor_stack = p;
8104
8105 constructor_constant = 1;
8106 constructor_simple = 1;
8107 constructor_nonconst = 0;
8108 constructor_depth = SPELLING_DEPTH ();
8109 constructor_elements = NULL;
8110 constructor_incremental = 1;
8111 constructor_designated = 0;
8112 constructor_pending_elts = 0;
8113 if (!implicit)
8114 {
8115 p->range_stack = constructor_range_stack;
8116 constructor_range_stack = 0;
8117 designator_depth = 0;
8118 designator_erroneous = 0;
8119 }
8120
8121 /* Don't die if an entire brace-pair level is superfluous
8122 in the containing level. */
8123 if (constructor_type == NULL_TREE)
8124 ;
8125 else if (RECORD_OR_UNION_TYPE_P (constructor_type))
8126 {
8127 /* Don't die if there are extra init elts at the end. */
8128 if (constructor_fields == NULL_TREE)
8129 constructor_type = NULL_TREE;
8130 else
8131 {
8132 constructor_type = TREE_TYPE (constructor_fields);
8133 push_member_name (constructor_fields);
8134 constructor_depth++;
8135 }
8136 /* If upper initializer is designated, then mark this as
8137 designated too to prevent bogus warnings. */
8138 constructor_designated = p->designated;
8139 }
8140 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
8141 {
8142 constructor_type = TREE_TYPE (constructor_type);
8143 push_array_bounds (tree_to_uhwi (constructor_index));
8144 constructor_depth++;
8145 }
8146
8147 if (constructor_type == NULL_TREE)
8148 {
8149 error_init (loc, "extra brace group at end of initializer");
8150 constructor_fields = NULL_TREE;
8151 constructor_unfilled_fields = NULL_TREE;
8152 return;
8153 }
8154
8155 if (value && TREE_CODE (value) == CONSTRUCTOR)
8156 {
8157 constructor_constant = TREE_CONSTANT (value);
8158 constructor_simple = TREE_STATIC (value);
8159 constructor_nonconst = CONSTRUCTOR_NON_CONST (value);
8160 constructor_elements = CONSTRUCTOR_ELTS (value);
8161 if (!vec_safe_is_empty (constructor_elements)
8162 && (TREE_CODE (constructor_type) == RECORD_TYPE
8163 || TREE_CODE (constructor_type) == ARRAY_TYPE))
8164 set_nonincremental_init (braced_init_obstack);
8165 }
8166
8167 if (implicit == 1)
8168 {
8169 found_missing_braces = 1;
8170 if (initializer_stack->missing_brace_richloc)
8171 initializer_stack->missing_brace_richloc->add_fixit_insert_before
8172 (loc, "{");
8173 }
8174
8175 if (RECORD_OR_UNION_TYPE_P (constructor_type))
8176 {
8177 constructor_fields = TYPE_FIELDS (constructor_type);
8178 /* Skip any nameless bit fields at the beginning. */
8179 while (constructor_fields != NULL_TREE
8180 && DECL_UNNAMED_BIT_FIELD (constructor_fields))
8181 constructor_fields = DECL_CHAIN (constructor_fields);
8182
8183 constructor_unfilled_fields = constructor_fields;
8184 constructor_bit_index = bitsize_zero_node;
8185 }
8186 else if (VECTOR_TYPE_P (constructor_type))
8187 {
8188 /* Vectors are like simple fixed-size arrays. */
8189 constructor_max_index =
8190 bitsize_int (TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
8191 constructor_index = bitsize_int (0);
8192 constructor_unfilled_index = constructor_index;
8193 }
8194 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
8195 {
8196 if (TYPE_DOMAIN (constructor_type))
8197 {
8198 constructor_max_index
8199 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
8200
8201 /* Detect non-empty initializations of zero-length arrays. */
8202 if (constructor_max_index == NULL_TREE
8203 && TYPE_SIZE (constructor_type))
8204 constructor_max_index = integer_minus_one_node;
8205
8206 /* constructor_max_index needs to be an INTEGER_CST. Attempts
8207 to initialize VLAs will cause a proper error; avoid tree
8208 checking errors as well by setting a safe value. */
8209 if (constructor_max_index
8210 && TREE_CODE (constructor_max_index) != INTEGER_CST)
8211 constructor_max_index = integer_minus_one_node;
8212
8213 constructor_index
8214 = convert (bitsizetype,
8215 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
8216 }
8217 else
8218 constructor_index = bitsize_zero_node;
8219
8220 constructor_unfilled_index = constructor_index;
8221 if (value && TREE_CODE (value) == STRING_CST)
8222 {
8223 /* We need to split the char/wchar array into individual
8224 characters, so that we don't have to special case it
8225 everywhere. */
8226 set_nonincremental_init_from_string (value, braced_init_obstack);
8227 }
8228 }
8229 else
8230 {
8231 if (constructor_type != error_mark_node)
8232 warning_init (input_location, 0, "braces around scalar initializer");
8233 constructor_fields = constructor_type;
8234 constructor_unfilled_fields = constructor_type;
8235 }
8236 }
8237
8238 /* At the end of an implicit or explicit brace level,
8239 finish up that level of constructor. If a single expression
8240 with redundant braces initialized that level, return the
8241 c_expr structure for that expression. Otherwise, the original_code
8242 element is set to ERROR_MARK.
8243 If we were outputting the elements as they are read, return 0 as the value
8244 from inner levels (process_init_element ignores that),
8245 but return error_mark_node as the value from the outermost level
8246 (that's what we want to put in DECL_INITIAL).
8247 Otherwise, return a CONSTRUCTOR expression as the value. */
8248
8249 struct c_expr
pop_init_level(location_t loc,int implicit,struct obstack * braced_init_obstack,location_t insert_before)8250 pop_init_level (location_t loc, int implicit,
8251 struct obstack *braced_init_obstack,
8252 location_t insert_before)
8253 {
8254 struct constructor_stack *p;
8255 struct c_expr ret;
8256 ret.value = NULL_TREE;
8257 ret.original_code = ERROR_MARK;
8258 ret.original_type = NULL;
8259
8260 if (implicit == 0)
8261 {
8262 /* When we come to an explicit close brace,
8263 pop any inner levels that didn't have explicit braces. */
8264 while (constructor_stack->implicit)
8265 process_init_element (input_location,
8266 pop_init_level (loc, 1, braced_init_obstack,
8267 insert_before),
8268 true, braced_init_obstack);
8269 gcc_assert (!constructor_range_stack);
8270 }
8271 else
8272 if (initializer_stack->missing_brace_richloc)
8273 initializer_stack->missing_brace_richloc->add_fixit_insert_before
8274 (insert_before, "}");
8275
8276 /* Now output all pending elements. */
8277 constructor_incremental = 1;
8278 output_pending_init_elements (1, braced_init_obstack);
8279
8280 p = constructor_stack;
8281
8282 /* Error for initializing a flexible array member, or a zero-length
8283 array member in an inappropriate context. */
8284 if (constructor_type && constructor_fields
8285 && TREE_CODE (constructor_type) == ARRAY_TYPE
8286 && TYPE_DOMAIN (constructor_type)
8287 && !TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
8288 {
8289 /* Silently discard empty initializations. The parser will
8290 already have pedwarned for empty brackets. */
8291 if (integer_zerop (constructor_unfilled_index))
8292 constructor_type = NULL_TREE;
8293 else
8294 {
8295 gcc_assert (!TYPE_SIZE (constructor_type));
8296
8297 if (constructor_depth > 2)
8298 error_init (loc, "initialization of flexible array member in a nested context");
8299 else
8300 pedwarn_init (loc, OPT_Wpedantic,
8301 "initialization of a flexible array member");
8302
8303 /* We have already issued an error message for the existence
8304 of a flexible array member not at the end of the structure.
8305 Discard the initializer so that we do not die later. */
8306 if (DECL_CHAIN (constructor_fields) != NULL_TREE)
8307 constructor_type = NULL_TREE;
8308 }
8309 }
8310
8311 switch (vec_safe_length (constructor_elements))
8312 {
8313 case 0:
8314 /* Initialization with { } counts as zeroinit. */
8315 constructor_zeroinit = 1;
8316 break;
8317 case 1:
8318 /* This might be zeroinit as well. */
8319 if (integer_zerop ((*constructor_elements)[0].value))
8320 constructor_zeroinit = 1;
8321 break;
8322 default:
8323 /* If the constructor has more than one element, it can't be { 0 }. */
8324 constructor_zeroinit = 0;
8325 break;
8326 }
8327
8328 /* Warn when some structs are initialized with direct aggregation. */
8329 if (!implicit && found_missing_braces && warn_missing_braces
8330 && !constructor_zeroinit)
8331 {
8332 gcc_assert (initializer_stack->missing_brace_richloc);
8333 warning_at (initializer_stack->missing_brace_richloc,
8334 OPT_Wmissing_braces,
8335 "missing braces around initializer");
8336 }
8337
8338 /* Warn when some struct elements are implicitly initialized to zero. */
8339 if (warn_missing_field_initializers
8340 && constructor_type
8341 && TREE_CODE (constructor_type) == RECORD_TYPE
8342 && constructor_unfilled_fields)
8343 {
8344 /* Do not warn for flexible array members or zero-length arrays. */
8345 while (constructor_unfilled_fields
8346 && (!DECL_SIZE (constructor_unfilled_fields)
8347 || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
8348 constructor_unfilled_fields = DECL_CHAIN (constructor_unfilled_fields);
8349
8350 if (constructor_unfilled_fields
8351 /* Do not warn if this level of the initializer uses member
8352 designators; it is likely to be deliberate. */
8353 && !constructor_designated
8354 /* Do not warn about initializing with { 0 } or with { }. */
8355 && !constructor_zeroinit)
8356 {
8357 if (warning_at (input_location, OPT_Wmissing_field_initializers,
8358 "missing initializer for field %qD of %qT",
8359 constructor_unfilled_fields,
8360 constructor_type))
8361 inform (DECL_SOURCE_LOCATION (constructor_unfilled_fields),
8362 "%qD declared here", constructor_unfilled_fields);
8363 }
8364 }
8365
8366 /* Pad out the end of the structure. */
8367 if (p->replacement_value.value)
8368 /* If this closes a superfluous brace pair,
8369 just pass out the element between them. */
8370 ret = p->replacement_value;
8371 else if (constructor_type == NULL_TREE)
8372 ;
8373 else if (!RECORD_OR_UNION_TYPE_P (constructor_type)
8374 && TREE_CODE (constructor_type) != ARRAY_TYPE
8375 && !VECTOR_TYPE_P (constructor_type))
8376 {
8377 /* A nonincremental scalar initializer--just return
8378 the element, after verifying there is just one. */
8379 if (vec_safe_is_empty (constructor_elements))
8380 {
8381 if (!constructor_erroneous)
8382 error_init (loc, "empty scalar initializer");
8383 ret.value = error_mark_node;
8384 }
8385 else if (vec_safe_length (constructor_elements) != 1)
8386 {
8387 error_init (loc, "extra elements in scalar initializer");
8388 ret.value = (*constructor_elements)[0].value;
8389 }
8390 else
8391 ret.value = (*constructor_elements)[0].value;
8392 }
8393 else
8394 {
8395 if (constructor_erroneous)
8396 ret.value = error_mark_node;
8397 else
8398 {
8399 ret.value = build_constructor (constructor_type,
8400 constructor_elements);
8401 if (constructor_constant)
8402 TREE_CONSTANT (ret.value) = 1;
8403 if (constructor_constant && constructor_simple)
8404 TREE_STATIC (ret.value) = 1;
8405 if (constructor_nonconst)
8406 CONSTRUCTOR_NON_CONST (ret.value) = 1;
8407 }
8408 }
8409
8410 if (ret.value && TREE_CODE (ret.value) != CONSTRUCTOR)
8411 {
8412 if (constructor_nonconst)
8413 ret.original_code = C_MAYBE_CONST_EXPR;
8414 else if (ret.original_code == C_MAYBE_CONST_EXPR)
8415 ret.original_code = ERROR_MARK;
8416 }
8417
8418 constructor_type = p->type;
8419 constructor_fields = p->fields;
8420 constructor_index = p->index;
8421 constructor_max_index = p->max_index;
8422 constructor_unfilled_index = p->unfilled_index;
8423 constructor_unfilled_fields = p->unfilled_fields;
8424 constructor_bit_index = p->bit_index;
8425 constructor_elements = p->elements;
8426 constructor_constant = p->constant;
8427 constructor_simple = p->simple;
8428 constructor_nonconst = p->nonconst;
8429 constructor_erroneous = p->erroneous;
8430 constructor_incremental = p->incremental;
8431 constructor_designated = p->designated;
8432 designator_depth = p->designator_depth;
8433 constructor_pending_elts = p->pending_elts;
8434 constructor_depth = p->depth;
8435 if (!p->implicit)
8436 constructor_range_stack = p->range_stack;
8437 RESTORE_SPELLING_DEPTH (constructor_depth);
8438
8439 constructor_stack = p->next;
8440 free (p);
8441
8442 if (ret.value == NULL_TREE && constructor_stack == 0)
8443 ret.value = error_mark_node;
8444 return ret;
8445 }
8446
8447 /* Common handling for both array range and field name designators.
8448 ARRAY argument is nonzero for array ranges. Returns false for success. */
8449
8450 static bool
set_designator(location_t loc,bool array,struct obstack * braced_init_obstack)8451 set_designator (location_t loc, bool array,
8452 struct obstack *braced_init_obstack)
8453 {
8454 tree subtype;
8455 enum tree_code subcode;
8456
8457 /* Don't die if an entire brace-pair level is superfluous
8458 in the containing level. */
8459 if (constructor_type == NULL_TREE)
8460 return true;
8461
8462 /* If there were errors in this designator list already, bail out
8463 silently. */
8464 if (designator_erroneous)
8465 return true;
8466
8467 if (!designator_depth)
8468 {
8469 gcc_assert (!constructor_range_stack);
8470
8471 /* Designator list starts at the level of closest explicit
8472 braces. */
8473 while (constructor_stack->implicit)
8474 process_init_element (input_location,
8475 pop_init_level (loc, 1, braced_init_obstack,
8476 last_init_list_comma),
8477 true, braced_init_obstack);
8478 constructor_designated = 1;
8479 return false;
8480 }
8481
8482 switch (TREE_CODE (constructor_type))
8483 {
8484 case RECORD_TYPE:
8485 case UNION_TYPE:
8486 subtype = TREE_TYPE (constructor_fields);
8487 if (subtype != error_mark_node)
8488 subtype = TYPE_MAIN_VARIANT (subtype);
8489 break;
8490 case ARRAY_TYPE:
8491 subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
8492 break;
8493 default:
8494 gcc_unreachable ();
8495 }
8496
8497 subcode = TREE_CODE (subtype);
8498 if (array && subcode != ARRAY_TYPE)
8499 {
8500 error_init (loc, "array index in non-array initializer");
8501 return true;
8502 }
8503 else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
8504 {
8505 error_init (loc, "field name not in record or union initializer");
8506 return true;
8507 }
8508
8509 constructor_designated = 1;
8510 finish_implicit_inits (loc, braced_init_obstack);
8511 push_init_level (loc, 2, braced_init_obstack);
8512 return false;
8513 }
8514
8515 /* If there are range designators in designator list, push a new designator
8516 to constructor_range_stack. RANGE_END is end of such stack range or
8517 NULL_TREE if there is no range designator at this level. */
8518
8519 static void
push_range_stack(tree range_end,struct obstack * braced_init_obstack)8520 push_range_stack (tree range_end, struct obstack * braced_init_obstack)
8521 {
8522 struct constructor_range_stack *p;
8523
8524 p = (struct constructor_range_stack *)
8525 obstack_alloc (braced_init_obstack,
8526 sizeof (struct constructor_range_stack));
8527 p->prev = constructor_range_stack;
8528 p->next = 0;
8529 p->fields = constructor_fields;
8530 p->range_start = constructor_index;
8531 p->index = constructor_index;
8532 p->stack = constructor_stack;
8533 p->range_end = range_end;
8534 if (constructor_range_stack)
8535 constructor_range_stack->next = p;
8536 constructor_range_stack = p;
8537 }
8538
8539 /* Within an array initializer, specify the next index to be initialized.
8540 FIRST is that index. If LAST is nonzero, then initialize a range
8541 of indices, running from FIRST through LAST. */
8542
8543 void
set_init_index(location_t loc,tree first,tree last,struct obstack * braced_init_obstack)8544 set_init_index (location_t loc, tree first, tree last,
8545 struct obstack *braced_init_obstack)
8546 {
8547 if (set_designator (loc, true, braced_init_obstack))
8548 return;
8549
8550 designator_erroneous = 1;
8551
8552 if (!INTEGRAL_TYPE_P (TREE_TYPE (first))
8553 || (last && !INTEGRAL_TYPE_P (TREE_TYPE (last))))
8554 {
8555 error_init (loc, "array index in initializer not of integer type");
8556 return;
8557 }
8558
8559 if (TREE_CODE (first) != INTEGER_CST)
8560 {
8561 first = c_fully_fold (first, false, NULL);
8562 if (TREE_CODE (first) == INTEGER_CST)
8563 pedwarn_init (loc, OPT_Wpedantic,
8564 "array index in initializer is not "
8565 "an integer constant expression");
8566 }
8567
8568 if (last && TREE_CODE (last) != INTEGER_CST)
8569 {
8570 last = c_fully_fold (last, false, NULL);
8571 if (TREE_CODE (last) == INTEGER_CST)
8572 pedwarn_init (loc, OPT_Wpedantic,
8573 "array index in initializer is not "
8574 "an integer constant expression");
8575 }
8576
8577 if (TREE_CODE (first) != INTEGER_CST)
8578 error_init (loc, "nonconstant array index in initializer");
8579 else if (last != NULL_TREE && TREE_CODE (last) != INTEGER_CST)
8580 error_init (loc, "nonconstant array index in initializer");
8581 else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
8582 error_init (loc, "array index in non-array initializer");
8583 else if (tree_int_cst_sgn (first) == -1)
8584 error_init (loc, "array index in initializer exceeds array bounds");
8585 else if (constructor_max_index
8586 && tree_int_cst_lt (constructor_max_index, first))
8587 error_init (loc, "array index in initializer exceeds array bounds");
8588 else
8589 {
8590 constant_expression_warning (first);
8591 if (last)
8592 constant_expression_warning (last);
8593 constructor_index = convert (bitsizetype, first);
8594 if (tree_int_cst_lt (constructor_index, first))
8595 {
8596 constructor_index = copy_node (constructor_index);
8597 TREE_OVERFLOW (constructor_index) = 1;
8598 }
8599
8600 if (last)
8601 {
8602 if (tree_int_cst_equal (first, last))
8603 last = NULL_TREE;
8604 else if (tree_int_cst_lt (last, first))
8605 {
8606 error_init (loc, "empty index range in initializer");
8607 last = NULL_TREE;
8608 }
8609 else
8610 {
8611 last = convert (bitsizetype, last);
8612 if (constructor_max_index != NULL_TREE
8613 && tree_int_cst_lt (constructor_max_index, last))
8614 {
8615 error_init (loc, "array index range in initializer exceeds "
8616 "array bounds");
8617 last = NULL_TREE;
8618 }
8619 }
8620 }
8621
8622 designator_depth++;
8623 designator_erroneous = 0;
8624 if (constructor_range_stack || last)
8625 push_range_stack (last, braced_init_obstack);
8626 }
8627 }
8628
8629 /* Within a struct initializer, specify the next field to be initialized. */
8630
8631 void
set_init_label(location_t loc,tree fieldname,location_t fieldname_loc,struct obstack * braced_init_obstack)8632 set_init_label (location_t loc, tree fieldname, location_t fieldname_loc,
8633 struct obstack *braced_init_obstack)
8634 {
8635 tree field;
8636
8637 if (set_designator (loc, false, braced_init_obstack))
8638 return;
8639
8640 designator_erroneous = 1;
8641
8642 if (!RECORD_OR_UNION_TYPE_P (constructor_type))
8643 {
8644 error_init (loc, "field name not in record or union initializer");
8645 return;
8646 }
8647
8648 field = lookup_field (constructor_type, fieldname);
8649
8650 if (field == NULL_TREE)
8651 {
8652 tree guessed_id = lookup_field_fuzzy (constructor_type, fieldname);
8653 if (guessed_id)
8654 {
8655 gcc_rich_location rich_loc (fieldname_loc);
8656 rich_loc.add_fixit_misspelled_id (fieldname_loc, guessed_id);
8657 error_at (&rich_loc,
8658 "%qT has no member named %qE; did you mean %qE?",
8659 constructor_type, fieldname, guessed_id);
8660 }
8661 else
8662 error_at (fieldname_loc, "%qT has no member named %qE",
8663 constructor_type, fieldname);
8664 }
8665 else
8666 do
8667 {
8668 constructor_fields = TREE_VALUE (field);
8669 designator_depth++;
8670 designator_erroneous = 0;
8671 if (constructor_range_stack)
8672 push_range_stack (NULL_TREE, braced_init_obstack);
8673 field = TREE_CHAIN (field);
8674 if (field)
8675 {
8676 if (set_designator (loc, false, braced_init_obstack))
8677 return;
8678 }
8679 }
8680 while (field != NULL_TREE);
8681 }
8682
8683 /* Add a new initializer to the tree of pending initializers. PURPOSE
8684 identifies the initializer, either array index or field in a structure.
8685 VALUE is the value of that index or field. If ORIGTYPE is not
8686 NULL_TREE, it is the original type of VALUE.
8687
8688 IMPLICIT is true if value comes from pop_init_level (1),
8689 the new initializer has been merged with the existing one
8690 and thus no warnings should be emitted about overriding an
8691 existing initializer. */
8692
8693 static void
add_pending_init(location_t loc,tree purpose,tree value,tree origtype,bool implicit,struct obstack * braced_init_obstack)8694 add_pending_init (location_t loc, tree purpose, tree value, tree origtype,
8695 bool implicit, struct obstack *braced_init_obstack)
8696 {
8697 struct init_node *p, **q, *r;
8698
8699 q = &constructor_pending_elts;
8700 p = 0;
8701
8702 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
8703 {
8704 while (*q != 0)
8705 {
8706 p = *q;
8707 if (tree_int_cst_lt (purpose, p->purpose))
8708 q = &p->left;
8709 else if (tree_int_cst_lt (p->purpose, purpose))
8710 q = &p->right;
8711 else
8712 {
8713 if (!implicit)
8714 {
8715 if (TREE_SIDE_EFFECTS (p->value))
8716 warning_init (loc, OPT_Woverride_init_side_effects,
8717 "initialized field with side-effects "
8718 "overwritten");
8719 else if (warn_override_init)
8720 warning_init (loc, OPT_Woverride_init,
8721 "initialized field overwritten");
8722 }
8723 p->value = value;
8724 p->origtype = origtype;
8725 return;
8726 }
8727 }
8728 }
8729 else
8730 {
8731 tree bitpos;
8732
8733 bitpos = bit_position (purpose);
8734 while (*q != NULL)
8735 {
8736 p = *q;
8737 if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
8738 q = &p->left;
8739 else if (p->purpose != purpose)
8740 q = &p->right;
8741 else
8742 {
8743 if (!implicit)
8744 {
8745 if (TREE_SIDE_EFFECTS (p->value))
8746 warning_init (loc, OPT_Woverride_init_side_effects,
8747 "initialized field with side-effects "
8748 "overwritten");
8749 else if (warn_override_init)
8750 warning_init (loc, OPT_Woverride_init,
8751 "initialized field overwritten");
8752 }
8753 p->value = value;
8754 p->origtype = origtype;
8755 return;
8756 }
8757 }
8758 }
8759
8760 r = (struct init_node *) obstack_alloc (braced_init_obstack,
8761 sizeof (struct init_node));
8762 r->purpose = purpose;
8763 r->value = value;
8764 r->origtype = origtype;
8765
8766 *q = r;
8767 r->parent = p;
8768 r->left = 0;
8769 r->right = 0;
8770 r->balance = 0;
8771
8772 while (p)
8773 {
8774 struct init_node *s;
8775
8776 if (r == p->left)
8777 {
8778 if (p->balance == 0)
8779 p->balance = -1;
8780 else if (p->balance < 0)
8781 {
8782 if (r->balance < 0)
8783 {
8784 /* L rotation. */
8785 p->left = r->right;
8786 if (p->left)
8787 p->left->parent = p;
8788 r->right = p;
8789
8790 p->balance = 0;
8791 r->balance = 0;
8792
8793 s = p->parent;
8794 p->parent = r;
8795 r->parent = s;
8796 if (s)
8797 {
8798 if (s->left == p)
8799 s->left = r;
8800 else
8801 s->right = r;
8802 }
8803 else
8804 constructor_pending_elts = r;
8805 }
8806 else
8807 {
8808 /* LR rotation. */
8809 struct init_node *t = r->right;
8810
8811 r->right = t->left;
8812 if (r->right)
8813 r->right->parent = r;
8814 t->left = r;
8815
8816 p->left = t->right;
8817 if (p->left)
8818 p->left->parent = p;
8819 t->right = p;
8820
8821 p->balance = t->balance < 0;
8822 r->balance = -(t->balance > 0);
8823 t->balance = 0;
8824
8825 s = p->parent;
8826 p->parent = t;
8827 r->parent = t;
8828 t->parent = s;
8829 if (s)
8830 {
8831 if (s->left == p)
8832 s->left = t;
8833 else
8834 s->right = t;
8835 }
8836 else
8837 constructor_pending_elts = t;
8838 }
8839 break;
8840 }
8841 else
8842 {
8843 /* p->balance == +1; growth of left side balances the node. */
8844 p->balance = 0;
8845 break;
8846 }
8847 }
8848 else /* r == p->right */
8849 {
8850 if (p->balance == 0)
8851 /* Growth propagation from right side. */
8852 p->balance++;
8853 else if (p->balance > 0)
8854 {
8855 if (r->balance > 0)
8856 {
8857 /* R rotation. */
8858 p->right = r->left;
8859 if (p->right)
8860 p->right->parent = p;
8861 r->left = p;
8862
8863 p->balance = 0;
8864 r->balance = 0;
8865
8866 s = p->parent;
8867 p->parent = r;
8868 r->parent = s;
8869 if (s)
8870 {
8871 if (s->left == p)
8872 s->left = r;
8873 else
8874 s->right = r;
8875 }
8876 else
8877 constructor_pending_elts = r;
8878 }
8879 else /* r->balance == -1 */
8880 {
8881 /* RL rotation */
8882 struct init_node *t = r->left;
8883
8884 r->left = t->right;
8885 if (r->left)
8886 r->left->parent = r;
8887 t->right = r;
8888
8889 p->right = t->left;
8890 if (p->right)
8891 p->right->parent = p;
8892 t->left = p;
8893
8894 r->balance = (t->balance < 0);
8895 p->balance = -(t->balance > 0);
8896 t->balance = 0;
8897
8898 s = p->parent;
8899 p->parent = t;
8900 r->parent = t;
8901 t->parent = s;
8902 if (s)
8903 {
8904 if (s->left == p)
8905 s->left = t;
8906 else
8907 s->right = t;
8908 }
8909 else
8910 constructor_pending_elts = t;
8911 }
8912 break;
8913 }
8914 else
8915 {
8916 /* p->balance == -1; growth of right side balances the node. */
8917 p->balance = 0;
8918 break;
8919 }
8920 }
8921
8922 r = p;
8923 p = p->parent;
8924 }
8925 }
8926
8927 /* Build AVL tree from a sorted chain. */
8928
8929 static void
set_nonincremental_init(struct obstack * braced_init_obstack)8930 set_nonincremental_init (struct obstack * braced_init_obstack)
8931 {
8932 unsigned HOST_WIDE_INT ix;
8933 tree index, value;
8934
8935 if (TREE_CODE (constructor_type) != RECORD_TYPE
8936 && TREE_CODE (constructor_type) != ARRAY_TYPE)
8937 return;
8938
8939 FOR_EACH_CONSTRUCTOR_ELT (constructor_elements, ix, index, value)
8940 add_pending_init (input_location, index, value, NULL_TREE, true,
8941 braced_init_obstack);
8942 constructor_elements = NULL;
8943 if (TREE_CODE (constructor_type) == RECORD_TYPE)
8944 {
8945 constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
8946 /* Skip any nameless bit fields at the beginning. */
8947 while (constructor_unfilled_fields != NULL_TREE
8948 && DECL_UNNAMED_BIT_FIELD (constructor_unfilled_fields))
8949 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
8950
8951 }
8952 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
8953 {
8954 if (TYPE_DOMAIN (constructor_type))
8955 constructor_unfilled_index
8956 = convert (bitsizetype,
8957 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
8958 else
8959 constructor_unfilled_index = bitsize_zero_node;
8960 }
8961 constructor_incremental = 0;
8962 }
8963
8964 /* Build AVL tree from a string constant. */
8965
8966 static void
set_nonincremental_init_from_string(tree str,struct obstack * braced_init_obstack)8967 set_nonincremental_init_from_string (tree str,
8968 struct obstack * braced_init_obstack)
8969 {
8970 tree value, purpose, type;
8971 HOST_WIDE_INT val[2];
8972 const char *p, *end;
8973 int byte, wchar_bytes, charwidth, bitpos;
8974
8975 gcc_assert (TREE_CODE (constructor_type) == ARRAY_TYPE);
8976
8977 wchar_bytes = TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str))) / BITS_PER_UNIT;
8978 charwidth = TYPE_PRECISION (char_type_node);
8979 gcc_assert ((size_t) wchar_bytes * charwidth
8980 <= ARRAY_SIZE (val) * HOST_BITS_PER_WIDE_INT);
8981 type = TREE_TYPE (constructor_type);
8982 p = TREE_STRING_POINTER (str);
8983 end = p + TREE_STRING_LENGTH (str);
8984
8985 for (purpose = bitsize_zero_node;
8986 p < end
8987 && !(constructor_max_index
8988 && tree_int_cst_lt (constructor_max_index, purpose));
8989 purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
8990 {
8991 if (wchar_bytes == 1)
8992 {
8993 val[0] = (unsigned char) *p++;
8994 val[1] = 0;
8995 }
8996 else
8997 {
8998 val[1] = 0;
8999 val[0] = 0;
9000 for (byte = 0; byte < wchar_bytes; byte++)
9001 {
9002 if (BYTES_BIG_ENDIAN)
9003 bitpos = (wchar_bytes - byte - 1) * charwidth;
9004 else
9005 bitpos = byte * charwidth;
9006 val[bitpos / HOST_BITS_PER_WIDE_INT]
9007 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
9008 << (bitpos % HOST_BITS_PER_WIDE_INT);
9009 }
9010 }
9011
9012 if (!TYPE_UNSIGNED (type))
9013 {
9014 bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
9015 if (bitpos < HOST_BITS_PER_WIDE_INT)
9016 {
9017 if (val[0] & (HOST_WIDE_INT_1 << (bitpos - 1)))
9018 {
9019 val[0] |= HOST_WIDE_INT_M1U << bitpos;
9020 val[1] = -1;
9021 }
9022 }
9023 else if (bitpos == HOST_BITS_PER_WIDE_INT)
9024 {
9025 if (val[0] < 0)
9026 val[1] = -1;
9027 }
9028 else if (val[1] & (HOST_WIDE_INT_1
9029 << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
9030 val[1] |= HOST_WIDE_INT_M1U << (bitpos - HOST_BITS_PER_WIDE_INT);
9031 }
9032
9033 value = wide_int_to_tree (type,
9034 wide_int::from_array (val, 2,
9035 HOST_BITS_PER_WIDE_INT * 2));
9036 add_pending_init (input_location, purpose, value, NULL_TREE, true,
9037 braced_init_obstack);
9038 }
9039
9040 constructor_incremental = 0;
9041 }
9042
9043 /* Return value of FIELD in pending initializer or NULL_TREE if the field was
9044 not initialized yet. */
9045
9046 static tree
find_init_member(tree field,struct obstack * braced_init_obstack)9047 find_init_member (tree field, struct obstack * braced_init_obstack)
9048 {
9049 struct init_node *p;
9050
9051 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
9052 {
9053 if (constructor_incremental
9054 && tree_int_cst_lt (field, constructor_unfilled_index))
9055 set_nonincremental_init (braced_init_obstack);
9056
9057 p = constructor_pending_elts;
9058 while (p)
9059 {
9060 if (tree_int_cst_lt (field, p->purpose))
9061 p = p->left;
9062 else if (tree_int_cst_lt (p->purpose, field))
9063 p = p->right;
9064 else
9065 return p->value;
9066 }
9067 }
9068 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
9069 {
9070 tree bitpos = bit_position (field);
9071
9072 if (constructor_incremental
9073 && (!constructor_unfilled_fields
9074 || tree_int_cst_lt (bitpos,
9075 bit_position (constructor_unfilled_fields))))
9076 set_nonincremental_init (braced_init_obstack);
9077
9078 p = constructor_pending_elts;
9079 while (p)
9080 {
9081 if (field == p->purpose)
9082 return p->value;
9083 else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
9084 p = p->left;
9085 else
9086 p = p->right;
9087 }
9088 }
9089 else if (TREE_CODE (constructor_type) == UNION_TYPE)
9090 {
9091 if (!vec_safe_is_empty (constructor_elements)
9092 && (constructor_elements->last ().index == field))
9093 return constructor_elements->last ().value;
9094 }
9095 return NULL_TREE;
9096 }
9097
9098 /* "Output" the next constructor element.
9099 At top level, really output it to assembler code now.
9100 Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
9101 If ORIGTYPE is not NULL_TREE, it is the original type of VALUE.
9102 TYPE is the data type that the containing data type wants here.
9103 FIELD is the field (a FIELD_DECL) or the index that this element fills.
9104 If VALUE is a string constant, STRICT_STRING is true if it is
9105 unparenthesized or we should not warn here for it being parenthesized.
9106 For other types of VALUE, STRICT_STRING is not used.
9107
9108 PENDING if true means output pending elements that belong
9109 right after this element. (PENDING is normally true;
9110 it is false while outputting pending elements, to avoid recursion.)
9111
9112 IMPLICIT is true if value comes from pop_init_level (1),
9113 the new initializer has been merged with the existing one
9114 and thus no warnings should be emitted about overriding an
9115 existing initializer. */
9116
9117 static void
output_init_element(location_t loc,tree value,tree origtype,bool strict_string,tree type,tree field,bool pending,bool implicit,struct obstack * braced_init_obstack)9118 output_init_element (location_t loc, tree value, tree origtype,
9119 bool strict_string, tree type, tree field, bool pending,
9120 bool implicit, struct obstack * braced_init_obstack)
9121 {
9122 tree semantic_type = NULL_TREE;
9123 bool maybe_const = true;
9124 bool npc;
9125
9126 if (type == error_mark_node || value == error_mark_node)
9127 {
9128 constructor_erroneous = 1;
9129 return;
9130 }
9131 if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
9132 && (TREE_CODE (value) == STRING_CST
9133 || TREE_CODE (value) == COMPOUND_LITERAL_EXPR)
9134 && !(TREE_CODE (value) == STRING_CST
9135 && TREE_CODE (type) == ARRAY_TYPE
9136 && INTEGRAL_TYPE_P (TREE_TYPE (type)))
9137 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
9138 TYPE_MAIN_VARIANT (type)))
9139 value = array_to_pointer_conversion (input_location, value);
9140
9141 if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR
9142 && require_constant_value && pending)
9143 {
9144 /* As an extension, allow initializing objects with static storage
9145 duration with compound literals (which are then treated just as
9146 the brace enclosed list they contain). */
9147 if (flag_isoc99)
9148 pedwarn_init (loc, OPT_Wpedantic, "initializer element is not "
9149 "constant");
9150 tree decl = COMPOUND_LITERAL_EXPR_DECL (value);
9151 value = DECL_INITIAL (decl);
9152 }
9153
9154 npc = null_pointer_constant_p (value);
9155 if (TREE_CODE (value) == EXCESS_PRECISION_EXPR)
9156 {
9157 semantic_type = TREE_TYPE (value);
9158 value = TREE_OPERAND (value, 0);
9159 }
9160 value = c_fully_fold (value, require_constant_value, &maybe_const);
9161
9162 if (value == error_mark_node)
9163 constructor_erroneous = 1;
9164 else if (!TREE_CONSTANT (value))
9165 constructor_constant = 0;
9166 else if (!initializer_constant_valid_p (value,
9167 TREE_TYPE (value),
9168 AGGREGATE_TYPE_P (constructor_type)
9169 && TYPE_REVERSE_STORAGE_ORDER
9170 (constructor_type))
9171 || (RECORD_OR_UNION_TYPE_P (constructor_type)
9172 && DECL_C_BIT_FIELD (field)
9173 && TREE_CODE (value) != INTEGER_CST))
9174 constructor_simple = 0;
9175 if (!maybe_const)
9176 constructor_nonconst = 1;
9177
9178 /* Digest the initializer and issue any errors about incompatible
9179 types before issuing errors about non-constant initializers. */
9180 tree new_value = value;
9181 if (semantic_type)
9182 new_value = build1 (EXCESS_PRECISION_EXPR, semantic_type, value);
9183 new_value = digest_init (loc, type, new_value, origtype, npc, strict_string,
9184 require_constant_value);
9185 if (new_value == error_mark_node)
9186 {
9187 constructor_erroneous = 1;
9188 return;
9189 }
9190 if (require_constant_value || require_constant_elements)
9191 constant_expression_warning (new_value);
9192
9193 /* Proceed to check the constness of the original initializer. */
9194 if (!initializer_constant_valid_p (value, TREE_TYPE (value)))
9195 {
9196 if (require_constant_value)
9197 {
9198 error_init (loc, "initializer element is not constant");
9199 value = error_mark_node;
9200 }
9201 else if (require_constant_elements)
9202 pedwarn (loc, OPT_Wpedantic,
9203 "initializer element is not computable at load time");
9204 }
9205 else if (!maybe_const
9206 && (require_constant_value || require_constant_elements))
9207 pedwarn_init (loc, OPT_Wpedantic,
9208 "initializer element is not a constant expression");
9209
9210 /* Issue -Wc++-compat warnings about initializing a bitfield with
9211 enum type. */
9212 if (warn_cxx_compat
9213 && field != NULL_TREE
9214 && TREE_CODE (field) == FIELD_DECL
9215 && DECL_BIT_FIELD_TYPE (field) != NULL_TREE
9216 && (TYPE_MAIN_VARIANT (DECL_BIT_FIELD_TYPE (field))
9217 != TYPE_MAIN_VARIANT (type))
9218 && TREE_CODE (DECL_BIT_FIELD_TYPE (field)) == ENUMERAL_TYPE)
9219 {
9220 tree checktype = origtype != NULL_TREE ? origtype : TREE_TYPE (value);
9221 if (checktype != error_mark_node
9222 && (TYPE_MAIN_VARIANT (checktype)
9223 != TYPE_MAIN_VARIANT (DECL_BIT_FIELD_TYPE (field))))
9224 warning_init (loc, OPT_Wc___compat,
9225 "enum conversion in initialization is invalid in C++");
9226 }
9227
9228 /* If this field is empty and does not have side effects (and is not at
9229 the end of structure), don't do anything other than checking the
9230 initializer. */
9231 if (field
9232 && (TREE_TYPE (field) == error_mark_node
9233 || (COMPLETE_TYPE_P (TREE_TYPE (field))
9234 && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
9235 && !TREE_SIDE_EFFECTS (new_value)
9236 && (TREE_CODE (constructor_type) == ARRAY_TYPE
9237 || DECL_CHAIN (field)))))
9238 return;
9239
9240 /* Finally, set VALUE to the initializer value digested above. */
9241 value = new_value;
9242
9243 /* If this element doesn't come next in sequence,
9244 put it on constructor_pending_elts. */
9245 if (TREE_CODE (constructor_type) == ARRAY_TYPE
9246 && (!constructor_incremental
9247 || !tree_int_cst_equal (field, constructor_unfilled_index)))
9248 {
9249 if (constructor_incremental
9250 && tree_int_cst_lt (field, constructor_unfilled_index))
9251 set_nonincremental_init (braced_init_obstack);
9252
9253 add_pending_init (loc, field, value, origtype, implicit,
9254 braced_init_obstack);
9255 return;
9256 }
9257 else if (TREE_CODE (constructor_type) == RECORD_TYPE
9258 && (!constructor_incremental
9259 || field != constructor_unfilled_fields))
9260 {
9261 /* We do this for records but not for unions. In a union,
9262 no matter which field is specified, it can be initialized
9263 right away since it starts at the beginning of the union. */
9264 if (constructor_incremental)
9265 {
9266 if (!constructor_unfilled_fields)
9267 set_nonincremental_init (braced_init_obstack);
9268 else
9269 {
9270 tree bitpos, unfillpos;
9271
9272 bitpos = bit_position (field);
9273 unfillpos = bit_position (constructor_unfilled_fields);
9274
9275 if (tree_int_cst_lt (bitpos, unfillpos))
9276 set_nonincremental_init (braced_init_obstack);
9277 }
9278 }
9279
9280 add_pending_init (loc, field, value, origtype, implicit,
9281 braced_init_obstack);
9282 return;
9283 }
9284 else if (TREE_CODE (constructor_type) == UNION_TYPE
9285 && !vec_safe_is_empty (constructor_elements))
9286 {
9287 if (!implicit)
9288 {
9289 if (TREE_SIDE_EFFECTS (constructor_elements->last ().value))
9290 warning_init (loc, OPT_Woverride_init_side_effects,
9291 "initialized field with side-effects overwritten");
9292 else if (warn_override_init)
9293 warning_init (loc, OPT_Woverride_init,
9294 "initialized field overwritten");
9295 }
9296
9297 /* We can have just one union field set. */
9298 constructor_elements = NULL;
9299 }
9300
9301 /* Otherwise, output this element either to
9302 constructor_elements or to the assembler file. */
9303
9304 constructor_elt celt = {field, value};
9305 vec_safe_push (constructor_elements, celt);
9306
9307 /* Advance the variable that indicates sequential elements output. */
9308 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
9309 constructor_unfilled_index
9310 = size_binop_loc (input_location, PLUS_EXPR, constructor_unfilled_index,
9311 bitsize_one_node);
9312 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
9313 {
9314 constructor_unfilled_fields
9315 = DECL_CHAIN (constructor_unfilled_fields);
9316
9317 /* Skip any nameless bit fields. */
9318 while (constructor_unfilled_fields != NULL_TREE
9319 && DECL_UNNAMED_BIT_FIELD (constructor_unfilled_fields))
9320 constructor_unfilled_fields =
9321 DECL_CHAIN (constructor_unfilled_fields);
9322 }
9323 else if (TREE_CODE (constructor_type) == UNION_TYPE)
9324 constructor_unfilled_fields = NULL_TREE;
9325
9326 /* Now output any pending elements which have become next. */
9327 if (pending)
9328 output_pending_init_elements (0, braced_init_obstack);
9329 }
9330
9331 /* For two FIELD_DECLs in the same chain, return -1 if field1
9332 comes before field2, 1 if field1 comes after field2 and
9333 0 if field1 == field2. */
9334
9335 static int
init_field_decl_cmp(tree field1,tree field2)9336 init_field_decl_cmp (tree field1, tree field2)
9337 {
9338 if (field1 == field2)
9339 return 0;
9340
9341 tree bitpos1 = bit_position (field1);
9342 tree bitpos2 = bit_position (field2);
9343 if (tree_int_cst_equal (bitpos1, bitpos2))
9344 {
9345 /* If one of the fields has non-zero bitsize, then that
9346 field must be the last one in a sequence of zero
9347 sized fields, fields after it will have bigger
9348 bit_position. */
9349 if (TREE_TYPE (field1) != error_mark_node
9350 && COMPLETE_TYPE_P (TREE_TYPE (field1))
9351 && integer_nonzerop (TREE_TYPE (field1)))
9352 return 1;
9353 if (TREE_TYPE (field2) != error_mark_node
9354 && COMPLETE_TYPE_P (TREE_TYPE (field2))
9355 && integer_nonzerop (TREE_TYPE (field2)))
9356 return -1;
9357 /* Otherwise, fallback to DECL_CHAIN walk to find out
9358 which field comes earlier. Walk chains of both
9359 fields, so that if field1 and field2 are close to each
9360 other in either order, it is found soon even for large
9361 sequences of zero sized fields. */
9362 tree f1 = field1, f2 = field2;
9363 while (1)
9364 {
9365 f1 = DECL_CHAIN (f1);
9366 f2 = DECL_CHAIN (f2);
9367 if (f1 == NULL_TREE)
9368 {
9369 gcc_assert (f2);
9370 return 1;
9371 }
9372 if (f2 == NULL_TREE)
9373 return -1;
9374 if (f1 == field2)
9375 return -1;
9376 if (f2 == field1)
9377 return 1;
9378 if (!tree_int_cst_equal (bit_position (f1), bitpos1))
9379 return 1;
9380 if (!tree_int_cst_equal (bit_position (f2), bitpos1))
9381 return -1;
9382 }
9383 }
9384 else if (tree_int_cst_lt (bitpos1, bitpos2))
9385 return -1;
9386 else
9387 return 1;
9388 }
9389
9390 /* Output any pending elements which have become next.
9391 As we output elements, constructor_unfilled_{fields,index}
9392 advances, which may cause other elements to become next;
9393 if so, they too are output.
9394
9395 If ALL is 0, we return when there are
9396 no more pending elements to output now.
9397
9398 If ALL is 1, we output space as necessary so that
9399 we can output all the pending elements. */
9400 static void
output_pending_init_elements(int all,struct obstack * braced_init_obstack)9401 output_pending_init_elements (int all, struct obstack * braced_init_obstack)
9402 {
9403 struct init_node *elt = constructor_pending_elts;
9404 tree next;
9405
9406 retry:
9407
9408 /* Look through the whole pending tree.
9409 If we find an element that should be output now,
9410 output it. Otherwise, set NEXT to the element
9411 that comes first among those still pending. */
9412
9413 next = NULL_TREE;
9414 while (elt)
9415 {
9416 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
9417 {
9418 if (tree_int_cst_equal (elt->purpose,
9419 constructor_unfilled_index))
9420 output_init_element (input_location, elt->value, elt->origtype,
9421 true, TREE_TYPE (constructor_type),
9422 constructor_unfilled_index, false, false,
9423 braced_init_obstack);
9424 else if (tree_int_cst_lt (constructor_unfilled_index,
9425 elt->purpose))
9426 {
9427 /* Advance to the next smaller node. */
9428 if (elt->left)
9429 elt = elt->left;
9430 else
9431 {
9432 /* We have reached the smallest node bigger than the
9433 current unfilled index. Fill the space first. */
9434 next = elt->purpose;
9435 break;
9436 }
9437 }
9438 else
9439 {
9440 /* Advance to the next bigger node. */
9441 if (elt->right)
9442 elt = elt->right;
9443 else
9444 {
9445 /* We have reached the biggest node in a subtree. Find
9446 the parent of it, which is the next bigger node. */
9447 while (elt->parent && elt->parent->right == elt)
9448 elt = elt->parent;
9449 elt = elt->parent;
9450 if (elt && tree_int_cst_lt (constructor_unfilled_index,
9451 elt->purpose))
9452 {
9453 next = elt->purpose;
9454 break;
9455 }
9456 }
9457 }
9458 }
9459 else if (RECORD_OR_UNION_TYPE_P (constructor_type))
9460 {
9461 /* If the current record is complete we are done. */
9462 if (constructor_unfilled_fields == NULL_TREE)
9463 break;
9464
9465 int cmp = init_field_decl_cmp (constructor_unfilled_fields,
9466 elt->purpose);
9467 if (cmp == 0)
9468 output_init_element (input_location, elt->value, elt->origtype,
9469 true, TREE_TYPE (elt->purpose),
9470 elt->purpose, false, false,
9471 braced_init_obstack);
9472 else if (cmp < 0)
9473 {
9474 /* Advance to the next smaller node. */
9475 if (elt->left)
9476 elt = elt->left;
9477 else
9478 {
9479 /* We have reached the smallest node bigger than the
9480 current unfilled field. Fill the space first. */
9481 next = elt->purpose;
9482 break;
9483 }
9484 }
9485 else
9486 {
9487 /* Advance to the next bigger node. */
9488 if (elt->right)
9489 elt = elt->right;
9490 else
9491 {
9492 /* We have reached the biggest node in a subtree. Find
9493 the parent of it, which is the next bigger node. */
9494 while (elt->parent && elt->parent->right == elt)
9495 elt = elt->parent;
9496 elt = elt->parent;
9497 if (elt
9498 && init_field_decl_cmp (constructor_unfilled_fields,
9499 elt->purpose) < 0)
9500 {
9501 next = elt->purpose;
9502 break;
9503 }
9504 }
9505 }
9506 }
9507 }
9508
9509 /* Ordinarily return, but not if we want to output all
9510 and there are elements left. */
9511 if (!(all && next != NULL_TREE))
9512 return;
9513
9514 /* If it's not incremental, just skip over the gap, so that after
9515 jumping to retry we will output the next successive element. */
9516 if (RECORD_OR_UNION_TYPE_P (constructor_type))
9517 constructor_unfilled_fields = next;
9518 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
9519 constructor_unfilled_index = next;
9520
9521 /* ELT now points to the node in the pending tree with the next
9522 initializer to output. */
9523 goto retry;
9524 }
9525
9526 /* Add one non-braced element to the current constructor level.
9527 This adjusts the current position within the constructor's type.
9528 This may also start or terminate implicit levels
9529 to handle a partly-braced initializer.
9530
9531 Once this has found the correct level for the new element,
9532 it calls output_init_element.
9533
9534 IMPLICIT is true if value comes from pop_init_level (1),
9535 the new initializer has been merged with the existing one
9536 and thus no warnings should be emitted about overriding an
9537 existing initializer. */
9538
9539 void
process_init_element(location_t loc,struct c_expr value,bool implicit,struct obstack * braced_init_obstack)9540 process_init_element (location_t loc, struct c_expr value, bool implicit,
9541 struct obstack * braced_init_obstack)
9542 {
9543 tree orig_value = value.value;
9544 int string_flag
9545 = (orig_value != NULL_TREE && TREE_CODE (orig_value) == STRING_CST);
9546 bool strict_string = value.original_code == STRING_CST;
9547 bool was_designated = designator_depth != 0;
9548
9549 designator_depth = 0;
9550 designator_erroneous = 0;
9551
9552 if (!implicit && value.value && !integer_zerop (value.value))
9553 constructor_zeroinit = 0;
9554
9555 /* Handle superfluous braces around string cst as in
9556 char x[] = {"foo"}; */
9557 if (string_flag
9558 && constructor_type
9559 && !was_designated
9560 && TREE_CODE (constructor_type) == ARRAY_TYPE
9561 && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type))
9562 && integer_zerop (constructor_unfilled_index))
9563 {
9564 if (constructor_stack->replacement_value.value)
9565 error_init (loc, "excess elements in char array initializer");
9566 constructor_stack->replacement_value = value;
9567 return;
9568 }
9569
9570 if (constructor_stack->replacement_value.value != NULL_TREE)
9571 {
9572 error_init (loc, "excess elements in struct initializer");
9573 return;
9574 }
9575
9576 /* Ignore elements of a brace group if it is entirely superfluous
9577 and has already been diagnosed. */
9578 if (constructor_type == NULL_TREE)
9579 return;
9580
9581 if (!implicit && warn_designated_init && !was_designated
9582 && TREE_CODE (constructor_type) == RECORD_TYPE
9583 && lookup_attribute ("designated_init",
9584 TYPE_ATTRIBUTES (constructor_type)))
9585 warning_init (loc,
9586 OPT_Wdesignated_init,
9587 "positional initialization of field "
9588 "in %<struct%> declared with %<designated_init%> attribute");
9589
9590 /* If we've exhausted any levels that didn't have braces,
9591 pop them now. */
9592 while (constructor_stack->implicit)
9593 {
9594 if (RECORD_OR_UNION_TYPE_P (constructor_type)
9595 && constructor_fields == NULL_TREE)
9596 process_init_element (loc,
9597 pop_init_level (loc, 1, braced_init_obstack,
9598 last_init_list_comma),
9599 true, braced_init_obstack);
9600 else if ((TREE_CODE (constructor_type) == ARRAY_TYPE
9601 || VECTOR_TYPE_P (constructor_type))
9602 && constructor_max_index
9603 && tree_int_cst_lt (constructor_max_index,
9604 constructor_index))
9605 process_init_element (loc,
9606 pop_init_level (loc, 1, braced_init_obstack,
9607 last_init_list_comma),
9608 true, braced_init_obstack);
9609 else
9610 break;
9611 }
9612
9613 /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */
9614 if (constructor_range_stack)
9615 {
9616 /* If value is a compound literal and we'll be just using its
9617 content, don't put it into a SAVE_EXPR. */
9618 if (TREE_CODE (value.value) != COMPOUND_LITERAL_EXPR
9619 || !require_constant_value)
9620 {
9621 tree semantic_type = NULL_TREE;
9622 if (TREE_CODE (value.value) == EXCESS_PRECISION_EXPR)
9623 {
9624 semantic_type = TREE_TYPE (value.value);
9625 value.value = TREE_OPERAND (value.value, 0);
9626 }
9627 value.value = save_expr (value.value);
9628 if (semantic_type)
9629 value.value = build1 (EXCESS_PRECISION_EXPR, semantic_type,
9630 value.value);
9631 }
9632 }
9633
9634 while (1)
9635 {
9636 if (TREE_CODE (constructor_type) == RECORD_TYPE)
9637 {
9638 tree fieldtype;
9639 enum tree_code fieldcode;
9640
9641 if (constructor_fields == NULL_TREE)
9642 {
9643 pedwarn_init (loc, 0, "excess elements in struct initializer");
9644 break;
9645 }
9646
9647 fieldtype = TREE_TYPE (constructor_fields);
9648 if (fieldtype != error_mark_node)
9649 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
9650 fieldcode = TREE_CODE (fieldtype);
9651
9652 /* Error for non-static initialization of a flexible array member. */
9653 if (fieldcode == ARRAY_TYPE
9654 && !require_constant_value
9655 && TYPE_SIZE (fieldtype) == NULL_TREE
9656 && DECL_CHAIN (constructor_fields) == NULL_TREE)
9657 {
9658 error_init (loc, "non-static initialization of a flexible "
9659 "array member");
9660 break;
9661 }
9662
9663 /* Error for initialization of a flexible array member with
9664 a string constant if the structure is in an array. E.g.:
9665 struct S { int x; char y[]; };
9666 struct S s[] = { { 1, "foo" } };
9667 is invalid. */
9668 if (string_flag
9669 && fieldcode == ARRAY_TYPE
9670 && constructor_depth > 1
9671 && TYPE_SIZE (fieldtype) == NULL_TREE
9672 && DECL_CHAIN (constructor_fields) == NULL_TREE)
9673 {
9674 bool in_array_p = false;
9675 for (struct constructor_stack *p = constructor_stack;
9676 p && p->type; p = p->next)
9677 if (TREE_CODE (p->type) == ARRAY_TYPE)
9678 {
9679 in_array_p = true;
9680 break;
9681 }
9682 if (in_array_p)
9683 {
9684 error_init (loc, "initialization of flexible array "
9685 "member in a nested context");
9686 break;
9687 }
9688 }
9689
9690 /* Accept a string constant to initialize a subarray. */
9691 if (value.value != NULL_TREE
9692 && fieldcode == ARRAY_TYPE
9693 && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
9694 && string_flag)
9695 value.value = orig_value;
9696 /* Otherwise, if we have come to a subaggregate,
9697 and we don't have an element of its type, push into it. */
9698 else if (value.value != NULL_TREE
9699 && value.value != error_mark_node
9700 && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
9701 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
9702 || fieldcode == UNION_TYPE || fieldcode == VECTOR_TYPE))
9703 {
9704 push_init_level (loc, 1, braced_init_obstack);
9705 continue;
9706 }
9707
9708 if (value.value)
9709 {
9710 push_member_name (constructor_fields);
9711 output_init_element (loc, value.value, value.original_type,
9712 strict_string, fieldtype,
9713 constructor_fields, true, implicit,
9714 braced_init_obstack);
9715 RESTORE_SPELLING_DEPTH (constructor_depth);
9716 }
9717 else
9718 /* Do the bookkeeping for an element that was
9719 directly output as a constructor. */
9720 {
9721 /* For a record, keep track of end position of last field. */
9722 if (DECL_SIZE (constructor_fields))
9723 constructor_bit_index
9724 = size_binop_loc (input_location, PLUS_EXPR,
9725 bit_position (constructor_fields),
9726 DECL_SIZE (constructor_fields));
9727
9728 /* If the current field was the first one not yet written out,
9729 it isn't now, so update. */
9730 if (constructor_unfilled_fields == constructor_fields)
9731 {
9732 constructor_unfilled_fields = DECL_CHAIN (constructor_fields);
9733 /* Skip any nameless bit fields. */
9734 while (constructor_unfilled_fields != 0
9735 && (DECL_UNNAMED_BIT_FIELD
9736 (constructor_unfilled_fields)))
9737 constructor_unfilled_fields =
9738 DECL_CHAIN (constructor_unfilled_fields);
9739 }
9740 }
9741
9742 constructor_fields = DECL_CHAIN (constructor_fields);
9743 /* Skip any nameless bit fields at the beginning. */
9744 while (constructor_fields != NULL_TREE
9745 && DECL_UNNAMED_BIT_FIELD (constructor_fields))
9746 constructor_fields = DECL_CHAIN (constructor_fields);
9747 }
9748 else if (TREE_CODE (constructor_type) == UNION_TYPE)
9749 {
9750 tree fieldtype;
9751 enum tree_code fieldcode;
9752
9753 if (constructor_fields == NULL_TREE)
9754 {
9755 pedwarn_init (loc, 0,
9756 "excess elements in union initializer");
9757 break;
9758 }
9759
9760 fieldtype = TREE_TYPE (constructor_fields);
9761 if (fieldtype != error_mark_node)
9762 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
9763 fieldcode = TREE_CODE (fieldtype);
9764
9765 /* Warn that traditional C rejects initialization of unions.
9766 We skip the warning if the value is zero. This is done
9767 under the assumption that the zero initializer in user
9768 code appears conditioned on e.g. __STDC__ to avoid
9769 "missing initializer" warnings and relies on default
9770 initialization to zero in the traditional C case.
9771 We also skip the warning if the initializer is designated,
9772 again on the assumption that this must be conditional on
9773 __STDC__ anyway (and we've already complained about the
9774 member-designator already). */
9775 if (!in_system_header_at (input_location) && !constructor_designated
9776 && !(value.value && (integer_zerop (value.value)
9777 || real_zerop (value.value))))
9778 warning (OPT_Wtraditional, "traditional C rejects initialization "
9779 "of unions");
9780
9781 /* Accept a string constant to initialize a subarray. */
9782 if (value.value != NULL_TREE
9783 && fieldcode == ARRAY_TYPE
9784 && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
9785 && string_flag)
9786 value.value = orig_value;
9787 /* Otherwise, if we have come to a subaggregate,
9788 and we don't have an element of its type, push into it. */
9789 else if (value.value != NULL_TREE
9790 && value.value != error_mark_node
9791 && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
9792 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
9793 || fieldcode == UNION_TYPE || fieldcode == VECTOR_TYPE))
9794 {
9795 push_init_level (loc, 1, braced_init_obstack);
9796 continue;
9797 }
9798
9799 if (value.value)
9800 {
9801 push_member_name (constructor_fields);
9802 output_init_element (loc, value.value, value.original_type,
9803 strict_string, fieldtype,
9804 constructor_fields, true, implicit,
9805 braced_init_obstack);
9806 RESTORE_SPELLING_DEPTH (constructor_depth);
9807 }
9808 else
9809 /* Do the bookkeeping for an element that was
9810 directly output as a constructor. */
9811 {
9812 constructor_bit_index = DECL_SIZE (constructor_fields);
9813 constructor_unfilled_fields = DECL_CHAIN (constructor_fields);
9814 }
9815
9816 constructor_fields = NULL_TREE;
9817 }
9818 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
9819 {
9820 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
9821 enum tree_code eltcode = TREE_CODE (elttype);
9822
9823 /* Accept a string constant to initialize a subarray. */
9824 if (value.value != NULL_TREE
9825 && eltcode == ARRAY_TYPE
9826 && INTEGRAL_TYPE_P (TREE_TYPE (elttype))
9827 && string_flag)
9828 value.value = orig_value;
9829 /* Otherwise, if we have come to a subaggregate,
9830 and we don't have an element of its type, push into it. */
9831 else if (value.value != NULL_TREE
9832 && value.value != error_mark_node
9833 && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != elttype
9834 && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
9835 || eltcode == UNION_TYPE || eltcode == VECTOR_TYPE))
9836 {
9837 push_init_level (loc, 1, braced_init_obstack);
9838 continue;
9839 }
9840
9841 if (constructor_max_index != NULL_TREE
9842 && (tree_int_cst_lt (constructor_max_index, constructor_index)
9843 || integer_all_onesp (constructor_max_index)))
9844 {
9845 pedwarn_init (loc, 0,
9846 "excess elements in array initializer");
9847 break;
9848 }
9849
9850 /* Now output the actual element. */
9851 if (value.value)
9852 {
9853 push_array_bounds (tree_to_uhwi (constructor_index));
9854 output_init_element (loc, value.value, value.original_type,
9855 strict_string, elttype,
9856 constructor_index, true, implicit,
9857 braced_init_obstack);
9858 RESTORE_SPELLING_DEPTH (constructor_depth);
9859 }
9860
9861 constructor_index
9862 = size_binop_loc (input_location, PLUS_EXPR,
9863 constructor_index, bitsize_one_node);
9864
9865 if (!value.value)
9866 /* If we are doing the bookkeeping for an element that was
9867 directly output as a constructor, we must update
9868 constructor_unfilled_index. */
9869 constructor_unfilled_index = constructor_index;
9870 }
9871 else if (VECTOR_TYPE_P (constructor_type))
9872 {
9873 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
9874
9875 /* Do a basic check of initializer size. Note that vectors
9876 always have a fixed size derived from their type. */
9877 if (tree_int_cst_lt (constructor_max_index, constructor_index))
9878 {
9879 pedwarn_init (loc, 0,
9880 "excess elements in vector initializer");
9881 break;
9882 }
9883
9884 /* Now output the actual element. */
9885 if (value.value)
9886 {
9887 if (TREE_CODE (value.value) == VECTOR_CST)
9888 elttype = TYPE_MAIN_VARIANT (constructor_type);
9889 output_init_element (loc, value.value, value.original_type,
9890 strict_string, elttype,
9891 constructor_index, true, implicit,
9892 braced_init_obstack);
9893 }
9894
9895 constructor_index
9896 = size_binop_loc (input_location,
9897 PLUS_EXPR, constructor_index, bitsize_one_node);
9898
9899 if (!value.value)
9900 /* If we are doing the bookkeeping for an element that was
9901 directly output as a constructor, we must update
9902 constructor_unfilled_index. */
9903 constructor_unfilled_index = constructor_index;
9904 }
9905
9906 /* Handle the sole element allowed in a braced initializer
9907 for a scalar variable. */
9908 else if (constructor_type != error_mark_node
9909 && constructor_fields == NULL_TREE)
9910 {
9911 pedwarn_init (loc, 0,
9912 "excess elements in scalar initializer");
9913 break;
9914 }
9915 else
9916 {
9917 if (value.value)
9918 output_init_element (loc, value.value, value.original_type,
9919 strict_string, constructor_type,
9920 NULL_TREE, true, implicit,
9921 braced_init_obstack);
9922 constructor_fields = NULL_TREE;
9923 }
9924
9925 /* Handle range initializers either at this level or anywhere higher
9926 in the designator stack. */
9927 if (constructor_range_stack)
9928 {
9929 struct constructor_range_stack *p, *range_stack;
9930 int finish = 0;
9931
9932 range_stack = constructor_range_stack;
9933 constructor_range_stack = 0;
9934 while (constructor_stack != range_stack->stack)
9935 {
9936 gcc_assert (constructor_stack->implicit);
9937 process_init_element (loc,
9938 pop_init_level (loc, 1,
9939 braced_init_obstack,
9940 last_init_list_comma),
9941 true, braced_init_obstack);
9942 }
9943 for (p = range_stack;
9944 !p->range_end || tree_int_cst_equal (p->index, p->range_end);
9945 p = p->prev)
9946 {
9947 gcc_assert (constructor_stack->implicit);
9948 process_init_element (loc,
9949 pop_init_level (loc, 1,
9950 braced_init_obstack,
9951 last_init_list_comma),
9952 true, braced_init_obstack);
9953 }
9954
9955 p->index = size_binop_loc (input_location,
9956 PLUS_EXPR, p->index, bitsize_one_node);
9957 if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
9958 finish = 1;
9959
9960 while (1)
9961 {
9962 constructor_index = p->index;
9963 constructor_fields = p->fields;
9964 if (finish && p->range_end && p->index == p->range_start)
9965 {
9966 finish = 0;
9967 p->prev = 0;
9968 }
9969 p = p->next;
9970 if (!p)
9971 break;
9972 finish_implicit_inits (loc, braced_init_obstack);
9973 push_init_level (loc, 2, braced_init_obstack);
9974 p->stack = constructor_stack;
9975 if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
9976 p->index = p->range_start;
9977 }
9978
9979 if (!finish)
9980 constructor_range_stack = range_stack;
9981 continue;
9982 }
9983
9984 break;
9985 }
9986
9987 constructor_range_stack = 0;
9988 }
9989
9990 /* Build a complete asm-statement, whose components are a CV_QUALIFIER
9991 (guaranteed to be 'volatile' or null) and ARGS (represented using
9992 an ASM_EXPR node). */
9993 tree
build_asm_stmt(bool is_volatile,tree args)9994 build_asm_stmt (bool is_volatile, tree args)
9995 {
9996 if (is_volatile)
9997 ASM_VOLATILE_P (args) = 1;
9998 return add_stmt (args);
9999 }
10000
10001 /* Build an asm-expr, whose components are a STRING, some OUTPUTS,
10002 some INPUTS, and some CLOBBERS. The latter three may be NULL.
10003 SIMPLE indicates whether there was anything at all after the
10004 string in the asm expression -- asm("blah") and asm("blah" : )
10005 are subtly different. We use a ASM_EXPR node to represent this.
10006 LOC is the location of the asm, and IS_INLINE says whether this
10007 is asm inline. */
10008 tree
build_asm_expr(location_t loc,tree string,tree outputs,tree inputs,tree clobbers,tree labels,bool simple,bool is_inline)10009 build_asm_expr (location_t loc, tree string, tree outputs, tree inputs,
10010 tree clobbers, tree labels, bool simple, bool is_inline)
10011 {
10012 tree tail;
10013 tree args;
10014 int i;
10015 const char *constraint;
10016 const char **oconstraints;
10017 bool allows_mem, allows_reg, is_inout;
10018 int ninputs, noutputs;
10019
10020 ninputs = list_length (inputs);
10021 noutputs = list_length (outputs);
10022 oconstraints = (const char **) alloca (noutputs * sizeof (const char *));
10023
10024 string = resolve_asm_operand_names (string, outputs, inputs, labels);
10025
10026 /* Remove output conversions that change the type but not the mode. */
10027 for (i = 0, tail = outputs; tail; ++i, tail = TREE_CHAIN (tail))
10028 {
10029 tree output = TREE_VALUE (tail);
10030
10031 output = c_fully_fold (output, false, NULL, true);
10032
10033 /* ??? Really, this should not be here. Users should be using a
10034 proper lvalue, dammit. But there's a long history of using casts
10035 in the output operands. In cases like longlong.h, this becomes a
10036 primitive form of typechecking -- if the cast can be removed, then
10037 the output operand had a type of the proper width; otherwise we'll
10038 get an error. Gross, but ... */
10039 STRIP_NOPS (output);
10040
10041 if (!lvalue_or_else (loc, output, lv_asm))
10042 output = error_mark_node;
10043
10044 if (output != error_mark_node
10045 && (TREE_READONLY (output)
10046 || TYPE_READONLY (TREE_TYPE (output))
10047 || (RECORD_OR_UNION_TYPE_P (TREE_TYPE (output))
10048 && C_TYPE_FIELDS_READONLY (TREE_TYPE (output)))))
10049 readonly_error (loc, output, lv_asm);
10050
10051 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
10052 oconstraints[i] = constraint;
10053
10054 if (parse_output_constraint (&constraint, i, ninputs, noutputs,
10055 &allows_mem, &allows_reg, &is_inout))
10056 {
10057 /* If the operand is going to end up in memory,
10058 mark it addressable. */
10059 if (!allows_reg && !c_mark_addressable (output))
10060 output = error_mark_node;
10061 if (!(!allows_reg && allows_mem)
10062 && output != error_mark_node
10063 && VOID_TYPE_P (TREE_TYPE (output)))
10064 {
10065 error_at (loc, "invalid use of void expression");
10066 output = error_mark_node;
10067 }
10068 }
10069 else
10070 output = error_mark_node;
10071
10072 TREE_VALUE (tail) = output;
10073 }
10074
10075 for (i = 0, tail = inputs; tail; ++i, tail = TREE_CHAIN (tail))
10076 {
10077 tree input;
10078
10079 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
10080 input = TREE_VALUE (tail);
10081
10082 if (parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
10083 oconstraints, &allows_mem, &allows_reg))
10084 {
10085 /* If the operand is going to end up in memory,
10086 mark it addressable. */
10087 if (!allows_reg && allows_mem)
10088 {
10089 input = c_fully_fold (input, false, NULL, true);
10090
10091 /* Strip the nops as we allow this case. FIXME, this really
10092 should be rejected or made deprecated. */
10093 STRIP_NOPS (input);
10094 if (!c_mark_addressable (input))
10095 input = error_mark_node;
10096 }
10097 else
10098 {
10099 struct c_expr expr;
10100 memset (&expr, 0, sizeof (expr));
10101 expr.value = input;
10102 expr = convert_lvalue_to_rvalue (loc, expr, true, false);
10103 input = c_fully_fold (expr.value, false, NULL);
10104
10105 if (input != error_mark_node && VOID_TYPE_P (TREE_TYPE (input)))
10106 {
10107 error_at (loc, "invalid use of void expression");
10108 input = error_mark_node;
10109 }
10110 }
10111 }
10112 else
10113 input = error_mark_node;
10114
10115 TREE_VALUE (tail) = input;
10116 }
10117
10118 /* ASMs with labels cannot have outputs. This should have been
10119 enforced by the parser. */
10120 gcc_assert (outputs == NULL || labels == NULL);
10121
10122 args = build_stmt (loc, ASM_EXPR, string, outputs, inputs, clobbers, labels);
10123
10124 /* asm statements without outputs, including simple ones, are treated
10125 as volatile. */
10126 ASM_INPUT_P (args) = simple;
10127 ASM_VOLATILE_P (args) = (noutputs == 0);
10128 ASM_INLINE_P (args) = is_inline;
10129
10130 return args;
10131 }
10132
10133 /* Generate a goto statement to LABEL. LOC is the location of the
10134 GOTO. */
10135
10136 tree
c_finish_goto_label(location_t loc,tree label)10137 c_finish_goto_label (location_t loc, tree label)
10138 {
10139 tree decl = lookup_label_for_goto (loc, label);
10140 if (!decl)
10141 return NULL_TREE;
10142 TREE_USED (decl) = 1;
10143 {
10144 add_stmt (build_predict_expr (PRED_GOTO, NOT_TAKEN));
10145 tree t = build1 (GOTO_EXPR, void_type_node, decl);
10146 SET_EXPR_LOCATION (t, loc);
10147 return add_stmt (t);
10148 }
10149 }
10150
10151 /* Generate a computed goto statement to EXPR. LOC is the location of
10152 the GOTO. */
10153
10154 tree
c_finish_goto_ptr(location_t loc,tree expr)10155 c_finish_goto_ptr (location_t loc, tree expr)
10156 {
10157 tree t;
10158 pedwarn (loc, OPT_Wpedantic, "ISO C forbids %<goto *expr;%>");
10159 expr = c_fully_fold (expr, false, NULL);
10160 expr = convert (ptr_type_node, expr);
10161 t = build1 (GOTO_EXPR, void_type_node, expr);
10162 SET_EXPR_LOCATION (t, loc);
10163 return add_stmt (t);
10164 }
10165
10166 /* Generate a C `return' statement. RETVAL is the expression for what
10167 to return, or a null pointer for `return;' with no value. LOC is
10168 the location of the return statement, or the location of the expression,
10169 if the statement has any. If ORIGTYPE is not NULL_TREE, it
10170 is the original type of RETVAL. */
10171
10172 tree
c_finish_return(location_t loc,tree retval,tree origtype)10173 c_finish_return (location_t loc, tree retval, tree origtype)
10174 {
10175 tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl)), ret_stmt;
10176 bool no_warning = false;
10177 bool npc = false;
10178
10179 /* Use the expansion point to handle cases such as returning NULL
10180 in a function returning void. */
10181 source_location xloc = expansion_point_location_if_in_system_header (loc);
10182
10183 if (TREE_THIS_VOLATILE (current_function_decl))
10184 warning_at (xloc, 0,
10185 "function declared %<noreturn%> has a %<return%> statement");
10186
10187 if (retval)
10188 {
10189 tree semantic_type = NULL_TREE;
10190 npc = null_pointer_constant_p (retval);
10191 if (TREE_CODE (retval) == EXCESS_PRECISION_EXPR)
10192 {
10193 semantic_type = TREE_TYPE (retval);
10194 retval = TREE_OPERAND (retval, 0);
10195 }
10196 retval = c_fully_fold (retval, false, NULL);
10197 if (semantic_type)
10198 retval = build1 (EXCESS_PRECISION_EXPR, semantic_type, retval);
10199 }
10200
10201 if (!retval)
10202 {
10203 current_function_returns_null = 1;
10204 if ((warn_return_type || flag_isoc99)
10205 && valtype != NULL_TREE && TREE_CODE (valtype) != VOID_TYPE)
10206 {
10207 bool warned_here;
10208 if (flag_isoc99)
10209 warned_here = pedwarn
10210 (loc, 0,
10211 "%<return%> with no value, in function returning non-void");
10212 else
10213 warned_here = warning_at
10214 (loc, OPT_Wreturn_type,
10215 "%<return%> with no value, in function returning non-void");
10216 no_warning = true;
10217 if (warned_here)
10218 inform (DECL_SOURCE_LOCATION (current_function_decl),
10219 "declared here");
10220 }
10221 }
10222 else if (valtype == NULL_TREE || TREE_CODE (valtype) == VOID_TYPE)
10223 {
10224 current_function_returns_null = 1;
10225 bool warned_here;
10226 if (TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
10227 warned_here = pedwarn
10228 (xloc, 0,
10229 "%<return%> with a value, in function returning void");
10230 else
10231 warned_here = pedwarn
10232 (xloc, OPT_Wpedantic, "ISO C forbids "
10233 "%<return%> with expression, in function returning void");
10234 if (warned_here)
10235 inform (DECL_SOURCE_LOCATION (current_function_decl),
10236 "declared here");
10237 }
10238 else
10239 {
10240 tree t = convert_for_assignment (loc, UNKNOWN_LOCATION, valtype,
10241 retval, origtype, ic_return,
10242 npc, NULL_TREE, NULL_TREE, 0);
10243 tree res = DECL_RESULT (current_function_decl);
10244 tree inner;
10245 bool save;
10246
10247 current_function_returns_value = 1;
10248 if (t == error_mark_node)
10249 return NULL_TREE;
10250
10251 save = in_late_binary_op;
10252 if (TREE_CODE (TREE_TYPE (res)) == BOOLEAN_TYPE
10253 || TREE_CODE (TREE_TYPE (res)) == COMPLEX_TYPE
10254 || (TREE_CODE (TREE_TYPE (t)) == REAL_TYPE
10255 && (TREE_CODE (TREE_TYPE (res)) == INTEGER_TYPE
10256 || TREE_CODE (TREE_TYPE (res)) == ENUMERAL_TYPE)
10257 && sanitize_flags_p (SANITIZE_FLOAT_CAST)))
10258 in_late_binary_op = true;
10259 inner = t = convert (TREE_TYPE (res), t);
10260 in_late_binary_op = save;
10261
10262 /* Strip any conversions, additions, and subtractions, and see if
10263 we are returning the address of a local variable. Warn if so. */
10264 while (1)
10265 {
10266 switch (TREE_CODE (inner))
10267 {
10268 CASE_CONVERT:
10269 case NON_LVALUE_EXPR:
10270 case PLUS_EXPR:
10271 case POINTER_PLUS_EXPR:
10272 inner = TREE_OPERAND (inner, 0);
10273 continue;
10274
10275 case MINUS_EXPR:
10276 /* If the second operand of the MINUS_EXPR has a pointer
10277 type (or is converted from it), this may be valid, so
10278 don't give a warning. */
10279 {
10280 tree op1 = TREE_OPERAND (inner, 1);
10281
10282 while (!POINTER_TYPE_P (TREE_TYPE (op1))
10283 && (CONVERT_EXPR_P (op1)
10284 || TREE_CODE (op1) == NON_LVALUE_EXPR))
10285 op1 = TREE_OPERAND (op1, 0);
10286
10287 if (POINTER_TYPE_P (TREE_TYPE (op1)))
10288 break;
10289
10290 inner = TREE_OPERAND (inner, 0);
10291 continue;
10292 }
10293
10294 case ADDR_EXPR:
10295 inner = TREE_OPERAND (inner, 0);
10296
10297 while (REFERENCE_CLASS_P (inner)
10298 && !INDIRECT_REF_P (inner))
10299 inner = TREE_OPERAND (inner, 0);
10300
10301 if (DECL_P (inner)
10302 && !DECL_EXTERNAL (inner)
10303 && !TREE_STATIC (inner)
10304 && DECL_CONTEXT (inner) == current_function_decl)
10305 {
10306 if (TREE_CODE (inner) == LABEL_DECL)
10307 warning_at (loc, OPT_Wreturn_local_addr,
10308 "function returns address of label");
10309 else
10310 {
10311 warning_at (loc, OPT_Wreturn_local_addr,
10312 "function returns address of local variable");
10313 tree zero = build_zero_cst (TREE_TYPE (res));
10314 t = build2 (COMPOUND_EXPR, TREE_TYPE (res), t, zero);
10315 }
10316 }
10317 break;
10318
10319 default:
10320 break;
10321 }
10322
10323 break;
10324 }
10325
10326 retval = build2 (MODIFY_EXPR, TREE_TYPE (res), res, t);
10327 SET_EXPR_LOCATION (retval, loc);
10328
10329 if (warn_sequence_point)
10330 verify_sequence_points (retval);
10331 }
10332
10333 ret_stmt = build_stmt (loc, RETURN_EXPR, retval);
10334 TREE_NO_WARNING (ret_stmt) |= no_warning;
10335 return add_stmt (ret_stmt);
10336 }
10337
10338 struct c_switch {
10339 /* The SWITCH_EXPR being built. */
10340 tree switch_expr;
10341
10342 /* The original type of the testing expression, i.e. before the
10343 default conversion is applied. */
10344 tree orig_type;
10345
10346 /* A splay-tree mapping the low element of a case range to the high
10347 element, or NULL_TREE if there is no high element. Used to
10348 determine whether or not a new case label duplicates an old case
10349 label. We need a tree, rather than simply a hash table, because
10350 of the GNU case range extension. */
10351 splay_tree cases;
10352
10353 /* The bindings at the point of the switch. This is used for
10354 warnings crossing decls when branching to a case label. */
10355 struct c_spot_bindings *bindings;
10356
10357 /* The next node on the stack. */
10358 struct c_switch *next;
10359
10360 /* Remember whether the controlling expression had boolean type
10361 before integer promotions for the sake of -Wswitch-bool. */
10362 bool bool_cond_p;
10363
10364 /* Remember whether there was a case value that is outside the
10365 range of the ORIG_TYPE. */
10366 bool outside_range_p;
10367 };
10368
10369 /* A stack of the currently active switch statements. The innermost
10370 switch statement is on the top of the stack. There is no need to
10371 mark the stack for garbage collection because it is only active
10372 during the processing of the body of a function, and we never
10373 collect at that point. */
10374
10375 struct c_switch *c_switch_stack;
10376
10377 /* Start a C switch statement, testing expression EXP. Return the new
10378 SWITCH_EXPR. SWITCH_LOC is the location of the `switch'.
10379 SWITCH_COND_LOC is the location of the switch's condition.
10380 EXPLICIT_CAST_P is true if the expression EXP has an explicit cast. */
10381
10382 tree
c_start_case(location_t switch_loc,location_t switch_cond_loc,tree exp,bool explicit_cast_p)10383 c_start_case (location_t switch_loc,
10384 location_t switch_cond_loc,
10385 tree exp, bool explicit_cast_p)
10386 {
10387 tree orig_type = error_mark_node;
10388 bool bool_cond_p = false;
10389 struct c_switch *cs;
10390
10391 if (exp != error_mark_node)
10392 {
10393 orig_type = TREE_TYPE (exp);
10394
10395 if (!INTEGRAL_TYPE_P (orig_type))
10396 {
10397 if (orig_type != error_mark_node)
10398 {
10399 error_at (switch_cond_loc, "switch quantity not an integer");
10400 orig_type = error_mark_node;
10401 }
10402 exp = integer_zero_node;
10403 }
10404 else
10405 {
10406 tree type = TYPE_MAIN_VARIANT (orig_type);
10407 tree e = exp;
10408
10409 /* Warn if the condition has boolean value. */
10410 while (TREE_CODE (e) == COMPOUND_EXPR)
10411 e = TREE_OPERAND (e, 1);
10412
10413 if ((TREE_CODE (type) == BOOLEAN_TYPE
10414 || truth_value_p (TREE_CODE (e)))
10415 /* Explicit cast to int suppresses this warning. */
10416 && !(TREE_CODE (type) == INTEGER_TYPE
10417 && explicit_cast_p))
10418 bool_cond_p = true;
10419
10420 if (!in_system_header_at (input_location)
10421 && (type == long_integer_type_node
10422 || type == long_unsigned_type_node))
10423 warning_at (switch_cond_loc,
10424 OPT_Wtraditional, "%<long%> switch expression not "
10425 "converted to %<int%> in ISO C");
10426
10427 exp = c_fully_fold (exp, false, NULL);
10428 exp = default_conversion (exp);
10429
10430 if (warn_sequence_point)
10431 verify_sequence_points (exp);
10432 }
10433 }
10434
10435 /* Add this new SWITCH_EXPR to the stack. */
10436 cs = XNEW (struct c_switch);
10437 cs->switch_expr = build2 (SWITCH_EXPR, orig_type, exp, NULL_TREE);
10438 SET_EXPR_LOCATION (cs->switch_expr, switch_loc);
10439 cs->orig_type = orig_type;
10440 cs->cases = splay_tree_new (case_compare, NULL, NULL);
10441 cs->bindings = c_get_switch_bindings ();
10442 cs->bool_cond_p = bool_cond_p;
10443 cs->outside_range_p = false;
10444 cs->next = c_switch_stack;
10445 c_switch_stack = cs;
10446
10447 return add_stmt (cs->switch_expr);
10448 }
10449
10450 /* Process a case label at location LOC. */
10451
10452 tree
do_case(location_t loc,tree low_value,tree high_value)10453 do_case (location_t loc, tree low_value, tree high_value)
10454 {
10455 tree label = NULL_TREE;
10456
10457 if (low_value && TREE_CODE (low_value) != INTEGER_CST)
10458 {
10459 low_value = c_fully_fold (low_value, false, NULL);
10460 if (TREE_CODE (low_value) == INTEGER_CST)
10461 pedwarn (loc, OPT_Wpedantic,
10462 "case label is not an integer constant expression");
10463 }
10464
10465 if (high_value && TREE_CODE (high_value) != INTEGER_CST)
10466 {
10467 high_value = c_fully_fold (high_value, false, NULL);
10468 if (TREE_CODE (high_value) == INTEGER_CST)
10469 pedwarn (input_location, OPT_Wpedantic,
10470 "case label is not an integer constant expression");
10471 }
10472
10473 if (c_switch_stack == NULL)
10474 {
10475 if (low_value)
10476 error_at (loc, "case label not within a switch statement");
10477 else
10478 error_at (loc, "%<default%> label not within a switch statement");
10479 return NULL_TREE;
10480 }
10481
10482 if (c_check_switch_jump_warnings (c_switch_stack->bindings,
10483 EXPR_LOCATION (c_switch_stack->switch_expr),
10484 loc))
10485 return NULL_TREE;
10486
10487 label = c_add_case_label (loc, c_switch_stack->cases,
10488 SWITCH_COND (c_switch_stack->switch_expr),
10489 c_switch_stack->orig_type,
10490 low_value, high_value,
10491 &c_switch_stack->outside_range_p);
10492 if (label == error_mark_node)
10493 label = NULL_TREE;
10494 return label;
10495 }
10496
10497 /* Finish the switch statement. TYPE is the original type of the
10498 controlling expression of the switch, or NULL_TREE. */
10499
10500 void
c_finish_case(tree body,tree type)10501 c_finish_case (tree body, tree type)
10502 {
10503 struct c_switch *cs = c_switch_stack;
10504 location_t switch_location;
10505
10506 SWITCH_BODY (cs->switch_expr) = body;
10507
10508 /* Emit warnings as needed. */
10509 switch_location = EXPR_LOCATION (cs->switch_expr);
10510 c_do_switch_warnings (cs->cases, switch_location,
10511 type ? type : TREE_TYPE (cs->switch_expr),
10512 SWITCH_COND (cs->switch_expr),
10513 cs->bool_cond_p, cs->outside_range_p);
10514 if (c_switch_covers_all_cases_p (cs->cases, TREE_TYPE (cs->switch_expr)))
10515 SWITCH_ALL_CASES_P (cs->switch_expr) = 1;
10516
10517 /* Pop the stack. */
10518 c_switch_stack = cs->next;
10519 splay_tree_delete (cs->cases);
10520 c_release_switch_bindings (cs->bindings);
10521 XDELETE (cs);
10522 }
10523
10524 /* Emit an if statement. IF_LOCUS is the location of the 'if'. COND,
10525 THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK
10526 may be null. */
10527
10528 void
c_finish_if_stmt(location_t if_locus,tree cond,tree then_block,tree else_block)10529 c_finish_if_stmt (location_t if_locus, tree cond, tree then_block,
10530 tree else_block)
10531 {
10532 tree stmt;
10533
10534 stmt = build3 (COND_EXPR, void_type_node, cond, then_block, else_block);
10535 SET_EXPR_LOCATION (stmt, if_locus);
10536 add_stmt (stmt);
10537 }
10538
10539 /* Emit a general-purpose loop construct. START_LOCUS is the location of
10540 the beginning of the loop. COND is the loop condition. COND_IS_FIRST
10541 is false for DO loops. INCR is the FOR increment expression. BODY is
10542 the statement controlled by the loop. BLAB is the break label. CLAB is
10543 the continue label. Everything is allowed to be NULL.
10544 COND_LOCUS is the location of the loop condition, INCR_LOCUS is the
10545 location of the FOR increment expression. */
10546
10547 void
c_finish_loop(location_t start_locus,location_t cond_locus,tree cond,location_t incr_locus,tree incr,tree body,tree blab,tree clab,bool cond_is_first)10548 c_finish_loop (location_t start_locus, location_t cond_locus, tree cond,
10549 location_t incr_locus, tree incr, tree body, tree blab,
10550 tree clab, bool cond_is_first)
10551 {
10552 tree entry = NULL, exit = NULL, t;
10553
10554 /* If the condition is zero don't generate a loop construct. */
10555 if (cond && integer_zerop (cond))
10556 {
10557 if (cond_is_first)
10558 {
10559 t = build_and_jump (&blab);
10560 SET_EXPR_LOCATION (t, start_locus);
10561 add_stmt (t);
10562 }
10563 }
10564 else
10565 {
10566 tree top = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
10567
10568 /* If we have an exit condition, then we build an IF with gotos either
10569 out of the loop, or to the top of it. If there's no exit condition,
10570 then we just build a jump back to the top. */
10571 exit = build_and_jump (&LABEL_EXPR_LABEL (top));
10572
10573 if (cond && !integer_nonzerop (cond))
10574 {
10575 /* Canonicalize the loop condition to the end. This means
10576 generating a branch to the loop condition. Reuse the
10577 continue label, if possible. */
10578 if (cond_is_first)
10579 {
10580 if (incr || !clab)
10581 {
10582 entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
10583 t = build_and_jump (&LABEL_EXPR_LABEL (entry));
10584 }
10585 else
10586 t = build1 (GOTO_EXPR, void_type_node, clab);
10587 SET_EXPR_LOCATION (t, start_locus);
10588 add_stmt (t);
10589 }
10590
10591 t = build_and_jump (&blab);
10592 exit = fold_build3_loc (cond_is_first ? start_locus : input_location,
10593 COND_EXPR, void_type_node, cond, exit, t);
10594 }
10595 else
10596 {
10597 /* For the backward-goto's location of an unconditional loop
10598 use the beginning of the body, or, if there is none, the
10599 top of the loop. */
10600 location_t loc = EXPR_LOCATION (expr_first (body));
10601 if (loc == UNKNOWN_LOCATION)
10602 loc = start_locus;
10603 SET_EXPR_LOCATION (exit, loc);
10604 }
10605
10606 add_stmt (top);
10607 }
10608
10609 if (body)
10610 add_stmt (body);
10611 if (clab)
10612 add_stmt (build1 (LABEL_EXPR, void_type_node, clab));
10613 if (incr)
10614 {
10615 if (MAY_HAVE_DEBUG_MARKER_STMTS && incr_locus != UNKNOWN_LOCATION)
10616 {
10617 t = build0 (DEBUG_BEGIN_STMT, void_type_node);
10618 SET_EXPR_LOCATION (t, incr_locus);
10619 add_stmt (t);
10620 }
10621 add_stmt (incr);
10622 }
10623 if (entry)
10624 add_stmt (entry);
10625 if (MAY_HAVE_DEBUG_MARKER_STMTS && cond_locus != UNKNOWN_LOCATION)
10626 {
10627 t = build0 (DEBUG_BEGIN_STMT, void_type_node);
10628 SET_EXPR_LOCATION (t, cond_locus);
10629 add_stmt (t);
10630 }
10631 if (exit)
10632 add_stmt (exit);
10633 if (blab)
10634 add_stmt (build1 (LABEL_EXPR, void_type_node, blab));
10635 }
10636
10637 tree
c_finish_bc_stmt(location_t loc,tree * label_p,bool is_break)10638 c_finish_bc_stmt (location_t loc, tree *label_p, bool is_break)
10639 {
10640 bool skip;
10641 tree label = *label_p;
10642
10643 /* In switch statements break is sometimes stylistically used after
10644 a return statement. This can lead to spurious warnings about
10645 control reaching the end of a non-void function when it is
10646 inlined. Note that we are calling block_may_fallthru with
10647 language specific tree nodes; this works because
10648 block_may_fallthru returns true when given something it does not
10649 understand. */
10650 skip = !block_may_fallthru (cur_stmt_list);
10651
10652 if (!label)
10653 {
10654 if (!skip)
10655 *label_p = label = create_artificial_label (loc);
10656 }
10657 else if (TREE_CODE (label) == LABEL_DECL)
10658 ;
10659 else switch (TREE_INT_CST_LOW (label))
10660 {
10661 case 0:
10662 if (is_break)
10663 error_at (loc, "break statement not within loop or switch");
10664 else
10665 error_at (loc, "continue statement not within a loop");
10666 return NULL_TREE;
10667
10668 case 1:
10669 gcc_assert (is_break);
10670 error_at (loc, "break statement used with OpenMP for loop");
10671 return NULL_TREE;
10672
10673 case 2:
10674 if (is_break)
10675 error ("break statement within %<#pragma simd%> loop body");
10676 else
10677 error ("continue statement within %<#pragma simd%> loop body");
10678 return NULL_TREE;
10679
10680 default:
10681 gcc_unreachable ();
10682 }
10683
10684 if (skip)
10685 return NULL_TREE;
10686
10687 if (!is_break)
10688 add_stmt (build_predict_expr (PRED_CONTINUE, NOT_TAKEN));
10689
10690 return add_stmt (build1 (GOTO_EXPR, void_type_node, label));
10691 }
10692
10693 /* A helper routine for c_process_expr_stmt and c_finish_stmt_expr. */
10694
10695 static void
emit_side_effect_warnings(location_t loc,tree expr)10696 emit_side_effect_warnings (location_t loc, tree expr)
10697 {
10698 if (expr == error_mark_node)
10699 ;
10700 else if (!TREE_SIDE_EFFECTS (expr))
10701 {
10702 if (!VOID_TYPE_P (TREE_TYPE (expr)) && !TREE_NO_WARNING (expr))
10703 warning_at (loc, OPT_Wunused_value, "statement with no effect");
10704 }
10705 else if (TREE_CODE (expr) == COMPOUND_EXPR)
10706 {
10707 tree r = expr;
10708 location_t cloc = loc;
10709 while (TREE_CODE (r) == COMPOUND_EXPR)
10710 {
10711 if (EXPR_HAS_LOCATION (r))
10712 cloc = EXPR_LOCATION (r);
10713 r = TREE_OPERAND (r, 1);
10714 }
10715 if (!TREE_SIDE_EFFECTS (r)
10716 && !VOID_TYPE_P (TREE_TYPE (r))
10717 && !CONVERT_EXPR_P (r)
10718 && !TREE_NO_WARNING (r)
10719 && !TREE_NO_WARNING (expr))
10720 warning_at (cloc, OPT_Wunused_value,
10721 "right-hand operand of comma expression has no effect");
10722 }
10723 else
10724 warn_if_unused_value (expr, loc);
10725 }
10726
10727 /* Process an expression as if it were a complete statement. Emit
10728 diagnostics, but do not call ADD_STMT. LOC is the location of the
10729 statement. */
10730
10731 tree
c_process_expr_stmt(location_t loc,tree expr)10732 c_process_expr_stmt (location_t loc, tree expr)
10733 {
10734 tree exprv;
10735
10736 if (!expr)
10737 return NULL_TREE;
10738
10739 expr = c_fully_fold (expr, false, NULL);
10740
10741 if (warn_sequence_point)
10742 verify_sequence_points (expr);
10743
10744 if (TREE_TYPE (expr) != error_mark_node
10745 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
10746 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
10747 error_at (loc, "expression statement has incomplete type");
10748
10749 /* If we're not processing a statement expression, warn about unused values.
10750 Warnings for statement expressions will be emitted later, once we figure
10751 out which is the result. */
10752 if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
10753 && warn_unused_value)
10754 emit_side_effect_warnings (EXPR_LOC_OR_LOC (expr, loc), expr);
10755
10756 exprv = expr;
10757 while (TREE_CODE (exprv) == COMPOUND_EXPR)
10758 exprv = TREE_OPERAND (exprv, 1);
10759 while (CONVERT_EXPR_P (exprv))
10760 exprv = TREE_OPERAND (exprv, 0);
10761 if (DECL_P (exprv)
10762 || handled_component_p (exprv)
10763 || TREE_CODE (exprv) == ADDR_EXPR)
10764 mark_exp_read (exprv);
10765
10766 /* If the expression is not of a type to which we cannot assign a line
10767 number, wrap the thing in a no-op NOP_EXPR. */
10768 if (DECL_P (expr) || CONSTANT_CLASS_P (expr))
10769 {
10770 expr = build1 (NOP_EXPR, TREE_TYPE (expr), expr);
10771 SET_EXPR_LOCATION (expr, loc);
10772 }
10773
10774 return expr;
10775 }
10776
10777 /* Emit an expression as a statement. LOC is the location of the
10778 expression. */
10779
10780 tree
c_finish_expr_stmt(location_t loc,tree expr)10781 c_finish_expr_stmt (location_t loc, tree expr)
10782 {
10783 if (expr)
10784 return add_stmt (c_process_expr_stmt (loc, expr));
10785 else
10786 return NULL;
10787 }
10788
10789 /* Do the opposite and emit a statement as an expression. To begin,
10790 create a new binding level and return it. */
10791
10792 tree
c_begin_stmt_expr(void)10793 c_begin_stmt_expr (void)
10794 {
10795 tree ret;
10796
10797 /* We must force a BLOCK for this level so that, if it is not expanded
10798 later, there is a way to turn off the entire subtree of blocks that
10799 are contained in it. */
10800 keep_next_level ();
10801 ret = c_begin_compound_stmt (true);
10802
10803 c_bindings_start_stmt_expr (c_switch_stack == NULL
10804 ? NULL
10805 : c_switch_stack->bindings);
10806
10807 /* Mark the current statement list as belonging to a statement list. */
10808 STATEMENT_LIST_STMT_EXPR (ret) = 1;
10809
10810 return ret;
10811 }
10812
10813 /* LOC is the location of the compound statement to which this body
10814 belongs. */
10815
10816 tree
c_finish_stmt_expr(location_t loc,tree body)10817 c_finish_stmt_expr (location_t loc, tree body)
10818 {
10819 tree last, type, tmp, val;
10820 tree *last_p;
10821
10822 body = c_end_compound_stmt (loc, body, true);
10823
10824 c_bindings_end_stmt_expr (c_switch_stack == NULL
10825 ? NULL
10826 : c_switch_stack->bindings);
10827
10828 /* Locate the last statement in BODY. See c_end_compound_stmt
10829 about always returning a BIND_EXPR. */
10830 last_p = &BIND_EXPR_BODY (body);
10831 last = BIND_EXPR_BODY (body);
10832
10833 continue_searching:
10834 if (TREE_CODE (last) == STATEMENT_LIST)
10835 {
10836 tree_stmt_iterator l = tsi_last (last);
10837
10838 while (!tsi_end_p (l) && TREE_CODE (tsi_stmt (l)) == DEBUG_BEGIN_STMT)
10839 tsi_prev (&l);
10840
10841 /* This can happen with degenerate cases like ({ }). No value. */
10842 if (tsi_end_p (l))
10843 return body;
10844
10845 /* If we're supposed to generate side effects warnings, process
10846 all of the statements except the last. */
10847 if (warn_unused_value)
10848 {
10849 for (tree_stmt_iterator i = tsi_start (last);
10850 tsi_stmt (i) != tsi_stmt (l); tsi_next (&i))
10851 {
10852 location_t tloc;
10853 tree t = tsi_stmt (i);
10854
10855 tloc = EXPR_HAS_LOCATION (t) ? EXPR_LOCATION (t) : loc;
10856 emit_side_effect_warnings (tloc, t);
10857 }
10858 }
10859 last_p = tsi_stmt_ptr (l);
10860 last = *last_p;
10861 }
10862
10863 /* If the end of the list is exception related, then the list was split
10864 by a call to push_cleanup. Continue searching. */
10865 if (TREE_CODE (last) == TRY_FINALLY_EXPR
10866 || TREE_CODE (last) == TRY_CATCH_EXPR)
10867 {
10868 last_p = &TREE_OPERAND (last, 0);
10869 last = *last_p;
10870 goto continue_searching;
10871 }
10872
10873 if (last == error_mark_node)
10874 return last;
10875
10876 /* In the case that the BIND_EXPR is not necessary, return the
10877 expression out from inside it. */
10878 if ((last == BIND_EXPR_BODY (body)
10879 /* Skip nested debug stmts. */
10880 || last == expr_first (BIND_EXPR_BODY (body)))
10881 && BIND_EXPR_VARS (body) == NULL)
10882 {
10883 /* Even if this looks constant, do not allow it in a constant
10884 expression. */
10885 last = c_wrap_maybe_const (last, true);
10886 /* Do not warn if the return value of a statement expression is
10887 unused. */
10888 TREE_NO_WARNING (last) = 1;
10889 return last;
10890 }
10891
10892 /* Extract the type of said expression. */
10893 type = TREE_TYPE (last);
10894
10895 /* If we're not returning a value at all, then the BIND_EXPR that
10896 we already have is a fine expression to return. */
10897 if (!type || VOID_TYPE_P (type))
10898 return body;
10899
10900 /* Now that we've located the expression containing the value, it seems
10901 silly to make voidify_wrapper_expr repeat the process. Create a
10902 temporary of the appropriate type and stick it in a TARGET_EXPR. */
10903 tmp = create_tmp_var_raw (type);
10904
10905 /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt. This avoids
10906 tree_expr_nonnegative_p giving up immediately. */
10907 val = last;
10908 if (TREE_CODE (val) == NOP_EXPR
10909 && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0)))
10910 val = TREE_OPERAND (val, 0);
10911
10912 *last_p = build2 (MODIFY_EXPR, void_type_node, tmp, val);
10913 SET_EXPR_LOCATION (*last_p, EXPR_LOCATION (last));
10914
10915 {
10916 tree t = build4 (TARGET_EXPR, type, tmp, body, NULL_TREE, NULL_TREE);
10917 SET_EXPR_LOCATION (t, loc);
10918 return t;
10919 }
10920 }
10921
10922 /* Begin and end compound statements. This is as simple as pushing
10923 and popping new statement lists from the tree. */
10924
10925 tree
c_begin_compound_stmt(bool do_scope)10926 c_begin_compound_stmt (bool do_scope)
10927 {
10928 tree stmt = push_stmt_list ();
10929 if (do_scope)
10930 push_scope ();
10931 return stmt;
10932 }
10933
10934 /* End a compound statement. STMT is the statement. LOC is the
10935 location of the compound statement-- this is usually the location
10936 of the opening brace. */
10937
10938 tree
c_end_compound_stmt(location_t loc,tree stmt,bool do_scope)10939 c_end_compound_stmt (location_t loc, tree stmt, bool do_scope)
10940 {
10941 tree block = NULL;
10942
10943 if (do_scope)
10944 {
10945 if (c_dialect_objc ())
10946 objc_clear_super_receiver ();
10947 block = pop_scope ();
10948 }
10949
10950 stmt = pop_stmt_list (stmt);
10951 stmt = c_build_bind_expr (loc, block, stmt);
10952
10953 /* If this compound statement is nested immediately inside a statement
10954 expression, then force a BIND_EXPR to be created. Otherwise we'll
10955 do the wrong thing for ({ { 1; } }) or ({ 1; { } }). In particular,
10956 STATEMENT_LISTs merge, and thus we can lose track of what statement
10957 was really last. */
10958 if (building_stmt_list_p ()
10959 && STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
10960 && TREE_CODE (stmt) != BIND_EXPR)
10961 {
10962 stmt = build3 (BIND_EXPR, void_type_node, NULL, stmt, NULL);
10963 TREE_SIDE_EFFECTS (stmt) = 1;
10964 SET_EXPR_LOCATION (stmt, loc);
10965 }
10966
10967 return stmt;
10968 }
10969
10970 /* Queue a cleanup. CLEANUP is an expression/statement to be executed
10971 when the current scope is exited. EH_ONLY is true when this is not
10972 meant to apply to normal control flow transfer. */
10973
10974 void
push_cleanup(tree decl,tree cleanup,bool eh_only)10975 push_cleanup (tree decl, tree cleanup, bool eh_only)
10976 {
10977 enum tree_code code;
10978 tree stmt, list;
10979 bool stmt_expr;
10980
10981 code = eh_only ? TRY_CATCH_EXPR : TRY_FINALLY_EXPR;
10982 stmt = build_stmt (DECL_SOURCE_LOCATION (decl), code, NULL, cleanup);
10983 add_stmt (stmt);
10984 stmt_expr = STATEMENT_LIST_STMT_EXPR (cur_stmt_list);
10985 list = push_stmt_list ();
10986 TREE_OPERAND (stmt, 0) = list;
10987 STATEMENT_LIST_STMT_EXPR (list) = stmt_expr;
10988 }
10989
10990 /* Build a vector comparison of ARG0 and ARG1 using CODE opcode
10991 into a value of TYPE type. Comparison is done via VEC_COND_EXPR. */
10992
10993 static tree
build_vec_cmp(tree_code code,tree type,tree arg0,tree arg1)10994 build_vec_cmp (tree_code code, tree type,
10995 tree arg0, tree arg1)
10996 {
10997 tree zero_vec = build_zero_cst (type);
10998 tree minus_one_vec = build_minus_one_cst (type);
10999 tree cmp_type = build_same_sized_truth_vector_type (type);
11000 tree cmp = build2 (code, cmp_type, arg0, arg1);
11001 return build3 (VEC_COND_EXPR, type, cmp, minus_one_vec, zero_vec);
11002 }
11003
11004 /* Build a binary-operation expression without default conversions.
11005 CODE is the kind of expression to build.
11006 LOCATION is the operator's location.
11007 This function differs from `build' in several ways:
11008 the data type of the result is computed and recorded in it,
11009 warnings are generated if arg data types are invalid,
11010 special handling for addition and subtraction of pointers is known,
11011 and some optimization is done (operations on narrow ints
11012 are done in the narrower type when that gives the same result).
11013 Constant folding is also done before the result is returned.
11014
11015 Note that the operands will never have enumeral types, or function
11016 or array types, because either they will have the default conversions
11017 performed or they have both just been converted to some other type in which
11018 the arithmetic is to be done. */
11019
11020 tree
build_binary_op(location_t location,enum tree_code code,tree orig_op0,tree orig_op1,bool convert_p)11021 build_binary_op (location_t location, enum tree_code code,
11022 tree orig_op0, tree orig_op1, bool convert_p)
11023 {
11024 tree type0, type1, orig_type0, orig_type1;
11025 tree eptype;
11026 enum tree_code code0, code1;
11027 tree op0, op1;
11028 tree ret = error_mark_node;
11029 const char *invalid_op_diag;
11030 bool op0_int_operands, op1_int_operands;
11031 bool int_const, int_const_or_overflow, int_operands;
11032
11033 /* Expression code to give to the expression when it is built.
11034 Normally this is CODE, which is what the caller asked for,
11035 but in some special cases we change it. */
11036 enum tree_code resultcode = code;
11037
11038 /* Data type in which the computation is to be performed.
11039 In the simplest cases this is the common type of the arguments. */
11040 tree result_type = NULL;
11041
11042 /* When the computation is in excess precision, the type of the
11043 final EXCESS_PRECISION_EXPR. */
11044 tree semantic_result_type = NULL;
11045
11046 /* Nonzero means operands have already been type-converted
11047 in whatever way is necessary.
11048 Zero means they need to be converted to RESULT_TYPE. */
11049 int converted = 0;
11050
11051 /* Nonzero means create the expression with this type, rather than
11052 RESULT_TYPE. */
11053 tree build_type = NULL_TREE;
11054
11055 /* Nonzero means after finally constructing the expression
11056 convert it to this type. */
11057 tree final_type = NULL_TREE;
11058
11059 /* Nonzero if this is an operation like MIN or MAX which can
11060 safely be computed in short if both args are promoted shorts.
11061 Also implies COMMON.
11062 -1 indicates a bitwise operation; this makes a difference
11063 in the exact conditions for when it is safe to do the operation
11064 in a narrower mode. */
11065 int shorten = 0;
11066
11067 /* Nonzero if this is a comparison operation;
11068 if both args are promoted shorts, compare the original shorts.
11069 Also implies COMMON. */
11070 int short_compare = 0;
11071
11072 /* Nonzero if this is a right-shift operation, which can be computed on the
11073 original short and then promoted if the operand is a promoted short. */
11074 int short_shift = 0;
11075
11076 /* Nonzero means set RESULT_TYPE to the common type of the args. */
11077 int common = 0;
11078
11079 /* True means types are compatible as far as ObjC is concerned. */
11080 bool objc_ok;
11081
11082 /* True means this is an arithmetic operation that may need excess
11083 precision. */
11084 bool may_need_excess_precision;
11085
11086 /* True means this is a boolean operation that converts both its
11087 operands to truth-values. */
11088 bool boolean_op = false;
11089
11090 /* Remember whether we're doing / or %. */
11091 bool doing_div_or_mod = false;
11092
11093 /* Remember whether we're doing << or >>. */
11094 bool doing_shift = false;
11095
11096 /* Tree holding instrumentation expression. */
11097 tree instrument_expr = NULL;
11098
11099 if (location == UNKNOWN_LOCATION)
11100 location = input_location;
11101
11102 op0 = orig_op0;
11103 op1 = orig_op1;
11104
11105 op0_int_operands = EXPR_INT_CONST_OPERANDS (orig_op0);
11106 if (op0_int_operands)
11107 op0 = remove_c_maybe_const_expr (op0);
11108 op1_int_operands = EXPR_INT_CONST_OPERANDS (orig_op1);
11109 if (op1_int_operands)
11110 op1 = remove_c_maybe_const_expr (op1);
11111 int_operands = (op0_int_operands && op1_int_operands);
11112 if (int_operands)
11113 {
11114 int_const_or_overflow = (TREE_CODE (orig_op0) == INTEGER_CST
11115 && TREE_CODE (orig_op1) == INTEGER_CST);
11116 int_const = (int_const_or_overflow
11117 && !TREE_OVERFLOW (orig_op0)
11118 && !TREE_OVERFLOW (orig_op1));
11119 }
11120 else
11121 int_const = int_const_or_overflow = false;
11122
11123 /* Do not apply default conversion in mixed vector/scalar expression. */
11124 if (convert_p
11125 && VECTOR_TYPE_P (TREE_TYPE (op0)) == VECTOR_TYPE_P (TREE_TYPE (op1)))
11126 {
11127 op0 = default_conversion (op0);
11128 op1 = default_conversion (op1);
11129 }
11130
11131 orig_type0 = type0 = TREE_TYPE (op0);
11132
11133 orig_type1 = type1 = TREE_TYPE (op1);
11134
11135 /* The expression codes of the data types of the arguments tell us
11136 whether the arguments are integers, floating, pointers, etc. */
11137 code0 = TREE_CODE (type0);
11138 code1 = TREE_CODE (type1);
11139
11140 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
11141 STRIP_TYPE_NOPS (op0);
11142 STRIP_TYPE_NOPS (op1);
11143
11144 /* If an error was already reported for one of the arguments,
11145 avoid reporting another error. */
11146
11147 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
11148 return error_mark_node;
11149
11150 if (code0 == POINTER_TYPE
11151 && reject_gcc_builtin (op0, EXPR_LOCATION (orig_op0)))
11152 return error_mark_node;
11153
11154 if (code1 == POINTER_TYPE
11155 && reject_gcc_builtin (op1, EXPR_LOCATION (orig_op1)))
11156 return error_mark_node;
11157
11158 if ((invalid_op_diag
11159 = targetm.invalid_binary_op (code, type0, type1)))
11160 {
11161 error_at (location, invalid_op_diag);
11162 return error_mark_node;
11163 }
11164
11165 switch (code)
11166 {
11167 case PLUS_EXPR:
11168 case MINUS_EXPR:
11169 case MULT_EXPR:
11170 case TRUNC_DIV_EXPR:
11171 case CEIL_DIV_EXPR:
11172 case FLOOR_DIV_EXPR:
11173 case ROUND_DIV_EXPR:
11174 case EXACT_DIV_EXPR:
11175 may_need_excess_precision = true;
11176 break;
11177 default:
11178 may_need_excess_precision = false;
11179 break;
11180 }
11181 if (TREE_CODE (op0) == EXCESS_PRECISION_EXPR)
11182 {
11183 op0 = TREE_OPERAND (op0, 0);
11184 type0 = TREE_TYPE (op0);
11185 }
11186 else if (may_need_excess_precision
11187 && (eptype = excess_precision_type (type0)) != NULL_TREE)
11188 {
11189 type0 = eptype;
11190 op0 = convert (eptype, op0);
11191 }
11192 if (TREE_CODE (op1) == EXCESS_PRECISION_EXPR)
11193 {
11194 op1 = TREE_OPERAND (op1, 0);
11195 type1 = TREE_TYPE (op1);
11196 }
11197 else if (may_need_excess_precision
11198 && (eptype = excess_precision_type (type1)) != NULL_TREE)
11199 {
11200 type1 = eptype;
11201 op1 = convert (eptype, op1);
11202 }
11203
11204 objc_ok = objc_compare_types (type0, type1, -3, NULL_TREE);
11205
11206 /* In case when one of the operands of the binary operation is
11207 a vector and another is a scalar -- convert scalar to vector. */
11208 if ((code0 == VECTOR_TYPE) != (code1 == VECTOR_TYPE))
11209 {
11210 enum stv_conv convert_flag = scalar_to_vector (location, code, op0, op1,
11211 true);
11212
11213 switch (convert_flag)
11214 {
11215 case stv_error:
11216 return error_mark_node;
11217 case stv_firstarg:
11218 {
11219 bool maybe_const = true;
11220 tree sc;
11221 sc = c_fully_fold (op0, false, &maybe_const);
11222 sc = save_expr (sc);
11223 sc = convert (TREE_TYPE (type1), sc);
11224 op0 = build_vector_from_val (type1, sc);
11225 if (!maybe_const)
11226 op0 = c_wrap_maybe_const (op0, true);
11227 orig_type0 = type0 = TREE_TYPE (op0);
11228 code0 = TREE_CODE (type0);
11229 converted = 1;
11230 break;
11231 }
11232 case stv_secondarg:
11233 {
11234 bool maybe_const = true;
11235 tree sc;
11236 sc = c_fully_fold (op1, false, &maybe_const);
11237 sc = save_expr (sc);
11238 sc = convert (TREE_TYPE (type0), sc);
11239 op1 = build_vector_from_val (type0, sc);
11240 if (!maybe_const)
11241 op1 = c_wrap_maybe_const (op1, true);
11242 orig_type1 = type1 = TREE_TYPE (op1);
11243 code1 = TREE_CODE (type1);
11244 converted = 1;
11245 break;
11246 }
11247 default:
11248 break;
11249 }
11250 }
11251
11252 switch (code)
11253 {
11254 case PLUS_EXPR:
11255 /* Handle the pointer + int case. */
11256 if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
11257 {
11258 ret = pointer_int_sum (location, PLUS_EXPR, op0, op1);
11259 goto return_build_binary_op;
11260 }
11261 else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
11262 {
11263 ret = pointer_int_sum (location, PLUS_EXPR, op1, op0);
11264 goto return_build_binary_op;
11265 }
11266 else
11267 common = 1;
11268 break;
11269
11270 case MINUS_EXPR:
11271 /* Subtraction of two similar pointers.
11272 We must subtract them as integers, then divide by object size. */
11273 if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
11274 && comp_target_types (location, type0, type1))
11275 {
11276 ret = pointer_diff (location, op0, op1, &instrument_expr);
11277 goto return_build_binary_op;
11278 }
11279 /* Handle pointer minus int. Just like pointer plus int. */
11280 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
11281 {
11282 ret = pointer_int_sum (location, MINUS_EXPR, op0, op1);
11283 goto return_build_binary_op;
11284 }
11285 else
11286 common = 1;
11287 break;
11288
11289 case MULT_EXPR:
11290 common = 1;
11291 break;
11292
11293 case TRUNC_DIV_EXPR:
11294 case CEIL_DIV_EXPR:
11295 case FLOOR_DIV_EXPR:
11296 case ROUND_DIV_EXPR:
11297 case EXACT_DIV_EXPR:
11298 doing_div_or_mod = true;
11299 warn_for_div_by_zero (location, op1);
11300
11301 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
11302 || code0 == FIXED_POINT_TYPE
11303 || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
11304 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
11305 || code1 == FIXED_POINT_TYPE
11306 || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
11307 {
11308 enum tree_code tcode0 = code0, tcode1 = code1;
11309
11310 if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
11311 tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
11312 if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)
11313 tcode1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
11314
11315 if (!((tcode0 == INTEGER_TYPE && tcode1 == INTEGER_TYPE)
11316 || (tcode0 == FIXED_POINT_TYPE && tcode1 == FIXED_POINT_TYPE)))
11317 resultcode = RDIV_EXPR;
11318 else
11319 /* Although it would be tempting to shorten always here, that
11320 loses on some targets, since the modulo instruction is
11321 undefined if the quotient can't be represented in the
11322 computation mode. We shorten only if unsigned or if
11323 dividing by something we know != -1. */
11324 shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
11325 || (TREE_CODE (op1) == INTEGER_CST
11326 && !integer_all_onesp (op1)));
11327 common = 1;
11328 }
11329 break;
11330
11331 case BIT_AND_EXPR:
11332 case BIT_IOR_EXPR:
11333 case BIT_XOR_EXPR:
11334 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
11335 shorten = -1;
11336 /* Allow vector types which are not floating point types. */
11337 else if (code0 == VECTOR_TYPE
11338 && code1 == VECTOR_TYPE
11339 && !VECTOR_FLOAT_TYPE_P (type0)
11340 && !VECTOR_FLOAT_TYPE_P (type1))
11341 common = 1;
11342 break;
11343
11344 case TRUNC_MOD_EXPR:
11345 case FLOOR_MOD_EXPR:
11346 doing_div_or_mod = true;
11347 warn_for_div_by_zero (location, op1);
11348
11349 if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
11350 && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE
11351 && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE)
11352 common = 1;
11353 else if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
11354 {
11355 /* Although it would be tempting to shorten always here, that loses
11356 on some targets, since the modulo instruction is undefined if the
11357 quotient can't be represented in the computation mode. We shorten
11358 only if unsigned or if dividing by something we know != -1. */
11359 shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
11360 || (TREE_CODE (op1) == INTEGER_CST
11361 && !integer_all_onesp (op1)));
11362 common = 1;
11363 }
11364 break;
11365
11366 case TRUTH_ANDIF_EXPR:
11367 case TRUTH_ORIF_EXPR:
11368 case TRUTH_AND_EXPR:
11369 case TRUTH_OR_EXPR:
11370 case TRUTH_XOR_EXPR:
11371 if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
11372 || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
11373 || code0 == FIXED_POINT_TYPE)
11374 && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
11375 || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
11376 || code1 == FIXED_POINT_TYPE))
11377 {
11378 /* Result of these operations is always an int,
11379 but that does not mean the operands should be
11380 converted to ints! */
11381 result_type = integer_type_node;
11382 if (op0_int_operands)
11383 {
11384 op0 = c_objc_common_truthvalue_conversion (location, orig_op0);
11385 op0 = remove_c_maybe_const_expr (op0);
11386 }
11387 else
11388 op0 = c_objc_common_truthvalue_conversion (location, op0);
11389 if (op1_int_operands)
11390 {
11391 op1 = c_objc_common_truthvalue_conversion (location, orig_op1);
11392 op1 = remove_c_maybe_const_expr (op1);
11393 }
11394 else
11395 op1 = c_objc_common_truthvalue_conversion (location, op1);
11396 converted = 1;
11397 boolean_op = true;
11398 }
11399 if (code == TRUTH_ANDIF_EXPR)
11400 {
11401 int_const_or_overflow = (int_operands
11402 && TREE_CODE (orig_op0) == INTEGER_CST
11403 && (op0 == truthvalue_false_node
11404 || TREE_CODE (orig_op1) == INTEGER_CST));
11405 int_const = (int_const_or_overflow
11406 && !TREE_OVERFLOW (orig_op0)
11407 && (op0 == truthvalue_false_node
11408 || !TREE_OVERFLOW (orig_op1)));
11409 }
11410 else if (code == TRUTH_ORIF_EXPR)
11411 {
11412 int_const_or_overflow = (int_operands
11413 && TREE_CODE (orig_op0) == INTEGER_CST
11414 && (op0 == truthvalue_true_node
11415 || TREE_CODE (orig_op1) == INTEGER_CST));
11416 int_const = (int_const_or_overflow
11417 && !TREE_OVERFLOW (orig_op0)
11418 && (op0 == truthvalue_true_node
11419 || !TREE_OVERFLOW (orig_op1)));
11420 }
11421 break;
11422
11423 /* Shift operations: result has same type as first operand;
11424 always convert second operand to int.
11425 Also set SHORT_SHIFT if shifting rightward. */
11426
11427 case RSHIFT_EXPR:
11428 if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
11429 && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE
11430 && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE
11431 && known_eq (TYPE_VECTOR_SUBPARTS (type0),
11432 TYPE_VECTOR_SUBPARTS (type1)))
11433 {
11434 result_type = type0;
11435 converted = 1;
11436 }
11437 else if ((code0 == INTEGER_TYPE || code0 == FIXED_POINT_TYPE
11438 || (code0 == VECTOR_TYPE
11439 && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE))
11440 && code1 == INTEGER_TYPE)
11441 {
11442 doing_shift = true;
11443 if (TREE_CODE (op1) == INTEGER_CST)
11444 {
11445 if (tree_int_cst_sgn (op1) < 0)
11446 {
11447 int_const = false;
11448 if (c_inhibit_evaluation_warnings == 0)
11449 warning_at (location, OPT_Wshift_count_negative,
11450 "right shift count is negative");
11451 }
11452 else if (code0 == VECTOR_TYPE)
11453 {
11454 if (compare_tree_int (op1,
11455 TYPE_PRECISION (TREE_TYPE (type0)))
11456 >= 0)
11457 {
11458 int_const = false;
11459 if (c_inhibit_evaluation_warnings == 0)
11460 warning_at (location, OPT_Wshift_count_overflow,
11461 "right shift count >= width of vector element");
11462 }
11463 }
11464 else
11465 {
11466 if (!integer_zerop (op1))
11467 short_shift = 1;
11468
11469 if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
11470 {
11471 int_const = false;
11472 if (c_inhibit_evaluation_warnings == 0)
11473 warning_at (location, OPT_Wshift_count_overflow,
11474 "right shift count >= width of type");
11475 }
11476 }
11477 }
11478
11479 /* Use the type of the value to be shifted. */
11480 result_type = type0;
11481 /* Avoid converting op1 to result_type later. */
11482 converted = 1;
11483 }
11484 break;
11485
11486 case LSHIFT_EXPR:
11487 if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
11488 && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE
11489 && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE
11490 && known_eq (TYPE_VECTOR_SUBPARTS (type0),
11491 TYPE_VECTOR_SUBPARTS (type1)))
11492 {
11493 result_type = type0;
11494 converted = 1;
11495 }
11496 else if ((code0 == INTEGER_TYPE || code0 == FIXED_POINT_TYPE
11497 || (code0 == VECTOR_TYPE
11498 && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE))
11499 && code1 == INTEGER_TYPE)
11500 {
11501 doing_shift = true;
11502 if (TREE_CODE (op0) == INTEGER_CST
11503 && tree_int_cst_sgn (op0) < 0)
11504 {
11505 /* Don't reject a left shift of a negative value in a context
11506 where a constant expression is needed in C90. */
11507 if (flag_isoc99)
11508 int_const = false;
11509 if (c_inhibit_evaluation_warnings == 0)
11510 warning_at (location, OPT_Wshift_negative_value,
11511 "left shift of negative value");
11512 }
11513 if (TREE_CODE (op1) == INTEGER_CST)
11514 {
11515 if (tree_int_cst_sgn (op1) < 0)
11516 {
11517 int_const = false;
11518 if (c_inhibit_evaluation_warnings == 0)
11519 warning_at (location, OPT_Wshift_count_negative,
11520 "left shift count is negative");
11521 }
11522 else if (code0 == VECTOR_TYPE)
11523 {
11524 if (compare_tree_int (op1,
11525 TYPE_PRECISION (TREE_TYPE (type0)))
11526 >= 0)
11527 {
11528 int_const = false;
11529 if (c_inhibit_evaluation_warnings == 0)
11530 warning_at (location, OPT_Wshift_count_overflow,
11531 "left shift count >= width of vector element");
11532 }
11533 }
11534 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
11535 {
11536 int_const = false;
11537 if (c_inhibit_evaluation_warnings == 0)
11538 warning_at (location, OPT_Wshift_count_overflow,
11539 "left shift count >= width of type");
11540 }
11541 else if (TREE_CODE (op0) == INTEGER_CST
11542 && maybe_warn_shift_overflow (location, op0, op1)
11543 && flag_isoc99)
11544 int_const = false;
11545 }
11546
11547 /* Use the type of the value to be shifted. */
11548 result_type = type0;
11549 /* Avoid converting op1 to result_type later. */
11550 converted = 1;
11551 }
11552 break;
11553
11554 case EQ_EXPR:
11555 case NE_EXPR:
11556 if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
11557 {
11558 tree intt;
11559 if (!vector_types_compatible_elements_p (type0, type1))
11560 {
11561 error_at (location, "comparing vectors with different "
11562 "element types");
11563 return error_mark_node;
11564 }
11565
11566 if (maybe_ne (TYPE_VECTOR_SUBPARTS (type0),
11567 TYPE_VECTOR_SUBPARTS (type1)))
11568 {
11569 error_at (location, "comparing vectors with different "
11570 "number of elements");
11571 return error_mark_node;
11572 }
11573
11574 /* It's not precisely specified how the usual arithmetic
11575 conversions apply to the vector types. Here, we use
11576 the unsigned type if one of the operands is signed and
11577 the other one is unsigned. */
11578 if (TYPE_UNSIGNED (type0) != TYPE_UNSIGNED (type1))
11579 {
11580 if (!TYPE_UNSIGNED (type0))
11581 op0 = build1 (VIEW_CONVERT_EXPR, type1, op0);
11582 else
11583 op1 = build1 (VIEW_CONVERT_EXPR, type0, op1);
11584 warning_at (location, OPT_Wsign_compare, "comparison between "
11585 "types %qT and %qT", type0, type1);
11586 }
11587
11588 /* Always construct signed integer vector type. */
11589 intt = c_common_type_for_size (GET_MODE_BITSIZE
11590 (SCALAR_TYPE_MODE
11591 (TREE_TYPE (type0))), 0);
11592 if (!intt)
11593 {
11594 error_at (location, "could not find an integer type "
11595 "of the same size as %qT",
11596 TREE_TYPE (type0));
11597 return error_mark_node;
11598 }
11599 result_type = build_opaque_vector_type (intt,
11600 TYPE_VECTOR_SUBPARTS (type0));
11601 converted = 1;
11602 ret = build_vec_cmp (resultcode, result_type, op0, op1);
11603 goto return_build_binary_op;
11604 }
11605 if (FLOAT_TYPE_P (type0) || FLOAT_TYPE_P (type1))
11606 warning_at (location,
11607 OPT_Wfloat_equal,
11608 "comparing floating point with == or != is unsafe");
11609 /* Result of comparison is always int,
11610 but don't convert the args to int! */
11611 build_type = integer_type_node;
11612 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
11613 || code0 == FIXED_POINT_TYPE || code0 == COMPLEX_TYPE)
11614 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
11615 || code1 == FIXED_POINT_TYPE || code1 == COMPLEX_TYPE))
11616 short_compare = 1;
11617 else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1))
11618 {
11619 if (TREE_CODE (op0) == ADDR_EXPR
11620 && decl_with_nonnull_addr_p (TREE_OPERAND (op0, 0))
11621 && !from_macro_expansion_at (location))
11622 {
11623 if (code == EQ_EXPR)
11624 warning_at (location,
11625 OPT_Waddress,
11626 "the comparison will always evaluate as %<false%> "
11627 "for the address of %qD will never be NULL",
11628 TREE_OPERAND (op0, 0));
11629 else
11630 warning_at (location,
11631 OPT_Waddress,
11632 "the comparison will always evaluate as %<true%> "
11633 "for the address of %qD will never be NULL",
11634 TREE_OPERAND (op0, 0));
11635 }
11636 result_type = type0;
11637 }
11638 else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0))
11639 {
11640 if (TREE_CODE (op1) == ADDR_EXPR
11641 && decl_with_nonnull_addr_p (TREE_OPERAND (op1, 0))
11642 && !from_macro_expansion_at (location))
11643 {
11644 if (code == EQ_EXPR)
11645 warning_at (location,
11646 OPT_Waddress,
11647 "the comparison will always evaluate as %<false%> "
11648 "for the address of %qD will never be NULL",
11649 TREE_OPERAND (op1, 0));
11650 else
11651 warning_at (location,
11652 OPT_Waddress,
11653 "the comparison will always evaluate as %<true%> "
11654 "for the address of %qD will never be NULL",
11655 TREE_OPERAND (op1, 0));
11656 }
11657 result_type = type1;
11658 }
11659 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
11660 {
11661 tree tt0 = TREE_TYPE (type0);
11662 tree tt1 = TREE_TYPE (type1);
11663 addr_space_t as0 = TYPE_ADDR_SPACE (tt0);
11664 addr_space_t as1 = TYPE_ADDR_SPACE (tt1);
11665 addr_space_t as_common = ADDR_SPACE_GENERIC;
11666
11667 /* Anything compares with void *. void * compares with anything.
11668 Otherwise, the targets must be compatible
11669 and both must be object or both incomplete. */
11670 if (comp_target_types (location, type0, type1))
11671 result_type = common_pointer_type (type0, type1);
11672 else if (!addr_space_superset (as0, as1, &as_common))
11673 {
11674 error_at (location, "comparison of pointers to "
11675 "disjoint address spaces");
11676 return error_mark_node;
11677 }
11678 else if (VOID_TYPE_P (tt0) && !TYPE_ATOMIC (tt0))
11679 {
11680 if (pedantic && TREE_CODE (tt1) == FUNCTION_TYPE)
11681 pedwarn (location, OPT_Wpedantic, "ISO C forbids "
11682 "comparison of %<void *%> with function pointer");
11683 }
11684 else if (VOID_TYPE_P (tt1) && !TYPE_ATOMIC (tt1))
11685 {
11686 if (pedantic && TREE_CODE (tt0) == FUNCTION_TYPE)
11687 pedwarn (location, OPT_Wpedantic, "ISO C forbids "
11688 "comparison of %<void *%> with function pointer");
11689 }
11690 else
11691 /* Avoid warning about the volatile ObjC EH puts on decls. */
11692 if (!objc_ok)
11693 pedwarn (location, 0,
11694 "comparison of distinct pointer types lacks a cast");
11695
11696 if (result_type == NULL_TREE)
11697 {
11698 int qual = ENCODE_QUAL_ADDR_SPACE (as_common);
11699 result_type = build_pointer_type
11700 (build_qualified_type (void_type_node, qual));
11701 }
11702 }
11703 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
11704 {
11705 result_type = type0;
11706 pedwarn (location, 0, "comparison between pointer and integer");
11707 }
11708 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
11709 {
11710 result_type = type1;
11711 pedwarn (location, 0, "comparison between pointer and integer");
11712 }
11713 if ((TREE_CODE (TREE_TYPE (orig_op0)) == BOOLEAN_TYPE
11714 || truth_value_p (TREE_CODE (orig_op0)))
11715 ^ (TREE_CODE (TREE_TYPE (orig_op1)) == BOOLEAN_TYPE
11716 || truth_value_p (TREE_CODE (orig_op1))))
11717 maybe_warn_bool_compare (location, code, orig_op0, orig_op1);
11718 break;
11719
11720 case LE_EXPR:
11721 case GE_EXPR:
11722 case LT_EXPR:
11723 case GT_EXPR:
11724 if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
11725 {
11726 tree intt;
11727 if (!vector_types_compatible_elements_p (type0, type1))
11728 {
11729 error_at (location, "comparing vectors with different "
11730 "element types");
11731 return error_mark_node;
11732 }
11733
11734 if (maybe_ne (TYPE_VECTOR_SUBPARTS (type0),
11735 TYPE_VECTOR_SUBPARTS (type1)))
11736 {
11737 error_at (location, "comparing vectors with different "
11738 "number of elements");
11739 return error_mark_node;
11740 }
11741
11742 /* It's not precisely specified how the usual arithmetic
11743 conversions apply to the vector types. Here, we use
11744 the unsigned type if one of the operands is signed and
11745 the other one is unsigned. */
11746 if (TYPE_UNSIGNED (type0) != TYPE_UNSIGNED (type1))
11747 {
11748 if (!TYPE_UNSIGNED (type0))
11749 op0 = build1 (VIEW_CONVERT_EXPR, type1, op0);
11750 else
11751 op1 = build1 (VIEW_CONVERT_EXPR, type0, op1);
11752 warning_at (location, OPT_Wsign_compare, "comparison between "
11753 "types %qT and %qT", type0, type1);
11754 }
11755
11756 /* Always construct signed integer vector type. */
11757 intt = c_common_type_for_size (GET_MODE_BITSIZE
11758 (SCALAR_TYPE_MODE
11759 (TREE_TYPE (type0))), 0);
11760 if (!intt)
11761 {
11762 error_at (location, "could not find an integer type "
11763 "of the same size as %qT",
11764 TREE_TYPE (type0));
11765 return error_mark_node;
11766 }
11767 result_type = build_opaque_vector_type (intt,
11768 TYPE_VECTOR_SUBPARTS (type0));
11769 converted = 1;
11770 ret = build_vec_cmp (resultcode, result_type, op0, op1);
11771 goto return_build_binary_op;
11772 }
11773 build_type = integer_type_node;
11774 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
11775 || code0 == FIXED_POINT_TYPE)
11776 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
11777 || code1 == FIXED_POINT_TYPE))
11778 short_compare = 1;
11779 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
11780 {
11781 addr_space_t as0 = TYPE_ADDR_SPACE (TREE_TYPE (type0));
11782 addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (type1));
11783 addr_space_t as_common;
11784
11785 if (comp_target_types (location, type0, type1))
11786 {
11787 result_type = common_pointer_type (type0, type1);
11788 if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
11789 != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
11790 pedwarn (location, 0,
11791 "comparison of complete and incomplete pointers");
11792 else if (TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
11793 pedwarn (location, OPT_Wpedantic, "ISO C forbids "
11794 "ordered comparisons of pointers to functions");
11795 else if (null_pointer_constant_p (orig_op0)
11796 || null_pointer_constant_p (orig_op1))
11797 warning_at (location, OPT_Wextra,
11798 "ordered comparison of pointer with null pointer");
11799
11800 }
11801 else if (!addr_space_superset (as0, as1, &as_common))
11802 {
11803 error_at (location, "comparison of pointers to "
11804 "disjoint address spaces");
11805 return error_mark_node;
11806 }
11807 else
11808 {
11809 int qual = ENCODE_QUAL_ADDR_SPACE (as_common);
11810 result_type = build_pointer_type
11811 (build_qualified_type (void_type_node, qual));
11812 pedwarn (location, 0,
11813 "comparison of distinct pointer types lacks a cast");
11814 }
11815 }
11816 else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1))
11817 {
11818 result_type = type0;
11819 if (pedantic)
11820 pedwarn (location, OPT_Wpedantic,
11821 "ordered comparison of pointer with integer zero");
11822 else if (extra_warnings)
11823 warning_at (location, OPT_Wextra,
11824 "ordered comparison of pointer with integer zero");
11825 }
11826 else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0))
11827 {
11828 result_type = type1;
11829 if (pedantic)
11830 pedwarn (location, OPT_Wpedantic,
11831 "ordered comparison of pointer with integer zero");
11832 else if (extra_warnings)
11833 warning_at (location, OPT_Wextra,
11834 "ordered comparison of pointer with integer zero");
11835 }
11836 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
11837 {
11838 result_type = type0;
11839 pedwarn (location, 0, "comparison between pointer and integer");
11840 }
11841 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
11842 {
11843 result_type = type1;
11844 pedwarn (location, 0, "comparison between pointer and integer");
11845 }
11846
11847 if ((code0 == POINTER_TYPE || code1 == POINTER_TYPE)
11848 && sanitize_flags_p (SANITIZE_POINTER_COMPARE))
11849 {
11850 op0 = save_expr (op0);
11851 op1 = save_expr (op1);
11852
11853 tree tt = builtin_decl_explicit (BUILT_IN_ASAN_POINTER_COMPARE);
11854 instrument_expr = build_call_expr_loc (location, tt, 2, op0, op1);
11855 }
11856
11857 if ((TREE_CODE (TREE_TYPE (orig_op0)) == BOOLEAN_TYPE
11858 || truth_value_p (TREE_CODE (orig_op0)))
11859 ^ (TREE_CODE (TREE_TYPE (orig_op1)) == BOOLEAN_TYPE
11860 || truth_value_p (TREE_CODE (orig_op1))))
11861 maybe_warn_bool_compare (location, code, orig_op0, orig_op1);
11862 break;
11863
11864 default:
11865 gcc_unreachable ();
11866 }
11867
11868 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
11869 return error_mark_node;
11870
11871 if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
11872 && (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1))
11873 || !vector_types_compatible_elements_p (type0, type1)))
11874 {
11875 gcc_rich_location richloc (location);
11876 richloc.maybe_add_expr (orig_op0);
11877 richloc.maybe_add_expr (orig_op1);
11878 binary_op_error (&richloc, code, type0, type1);
11879 return error_mark_node;
11880 }
11881
11882 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
11883 || code0 == FIXED_POINT_TYPE || code0 == VECTOR_TYPE)
11884 &&
11885 (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
11886 || code1 == FIXED_POINT_TYPE || code1 == VECTOR_TYPE))
11887 {
11888 bool first_complex = (code0 == COMPLEX_TYPE);
11889 bool second_complex = (code1 == COMPLEX_TYPE);
11890 int none_complex = (!first_complex && !second_complex);
11891
11892 if (shorten || common || short_compare)
11893 {
11894 result_type = c_common_type (type0, type1);
11895 do_warn_double_promotion (result_type, type0, type1,
11896 "implicit conversion from %qT to %qT "
11897 "to match other operand of binary "
11898 "expression",
11899 location);
11900 if (result_type == error_mark_node)
11901 return error_mark_node;
11902 }
11903
11904 if (first_complex != second_complex
11905 && (code == PLUS_EXPR
11906 || code == MINUS_EXPR
11907 || code == MULT_EXPR
11908 || (code == TRUNC_DIV_EXPR && first_complex))
11909 && TREE_CODE (TREE_TYPE (result_type)) == REAL_TYPE
11910 && flag_signed_zeros)
11911 {
11912 /* An operation on mixed real/complex operands must be
11913 handled specially, but the language-independent code can
11914 more easily optimize the plain complex arithmetic if
11915 -fno-signed-zeros. */
11916 tree real_type = TREE_TYPE (result_type);
11917 tree real, imag;
11918 if (type0 != orig_type0 || type1 != orig_type1)
11919 {
11920 gcc_assert (may_need_excess_precision && common);
11921 semantic_result_type = c_common_type (orig_type0, orig_type1);
11922 }
11923 if (first_complex)
11924 {
11925 if (TREE_TYPE (op0) != result_type)
11926 op0 = convert_and_check (location, result_type, op0);
11927 if (TREE_TYPE (op1) != real_type)
11928 op1 = convert_and_check (location, real_type, op1);
11929 }
11930 else
11931 {
11932 if (TREE_TYPE (op0) != real_type)
11933 op0 = convert_and_check (location, real_type, op0);
11934 if (TREE_TYPE (op1) != result_type)
11935 op1 = convert_and_check (location, result_type, op1);
11936 }
11937 if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK)
11938 return error_mark_node;
11939 if (first_complex)
11940 {
11941 op0 = save_expr (op0);
11942 real = build_unary_op (EXPR_LOCATION (orig_op0), REALPART_EXPR,
11943 op0, true);
11944 imag = build_unary_op (EXPR_LOCATION (orig_op0), IMAGPART_EXPR,
11945 op0, true);
11946 switch (code)
11947 {
11948 case MULT_EXPR:
11949 case TRUNC_DIV_EXPR:
11950 op1 = save_expr (op1);
11951 imag = build2 (resultcode, real_type, imag, op1);
11952 /* Fall through. */
11953 case PLUS_EXPR:
11954 case MINUS_EXPR:
11955 real = build2 (resultcode, real_type, real, op1);
11956 break;
11957 default:
11958 gcc_unreachable();
11959 }
11960 }
11961 else
11962 {
11963 op1 = save_expr (op1);
11964 real = build_unary_op (EXPR_LOCATION (orig_op1), REALPART_EXPR,
11965 op1, true);
11966 imag = build_unary_op (EXPR_LOCATION (orig_op1), IMAGPART_EXPR,
11967 op1, true);
11968 switch (code)
11969 {
11970 case MULT_EXPR:
11971 op0 = save_expr (op0);
11972 imag = build2 (resultcode, real_type, op0, imag);
11973 /* Fall through. */
11974 case PLUS_EXPR:
11975 real = build2 (resultcode, real_type, op0, real);
11976 break;
11977 case MINUS_EXPR:
11978 real = build2 (resultcode, real_type, op0, real);
11979 imag = build1 (NEGATE_EXPR, real_type, imag);
11980 break;
11981 default:
11982 gcc_unreachable();
11983 }
11984 }
11985 ret = build2 (COMPLEX_EXPR, result_type, real, imag);
11986 goto return_build_binary_op;
11987 }
11988
11989 /* For certain operations (which identify themselves by shorten != 0)
11990 if both args were extended from the same smaller type,
11991 do the arithmetic in that type and then extend.
11992
11993 shorten !=0 and !=1 indicates a bitwise operation.
11994 For them, this optimization is safe only if
11995 both args are zero-extended or both are sign-extended.
11996 Otherwise, we might change the result.
11997 Eg, (short)-1 | (unsigned short)-1 is (int)-1
11998 but calculated in (unsigned short) it would be (unsigned short)-1. */
11999
12000 if (shorten && none_complex)
12001 {
12002 final_type = result_type;
12003 result_type = shorten_binary_op (result_type, op0, op1,
12004 shorten == -1);
12005 }
12006
12007 /* Shifts can be shortened if shifting right. */
12008
12009 if (short_shift)
12010 {
12011 int unsigned_arg;
12012 tree arg0 = get_narrower (op0, &unsigned_arg);
12013
12014 final_type = result_type;
12015
12016 if (arg0 == op0 && final_type == TREE_TYPE (op0))
12017 unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0));
12018
12019 if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
12020 && tree_int_cst_sgn (op1) > 0
12021 /* We can shorten only if the shift count is less than the
12022 number of bits in the smaller type size. */
12023 && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
12024 /* We cannot drop an unsigned shift after sign-extension. */
12025 && (!TYPE_UNSIGNED (final_type) || unsigned_arg))
12026 {
12027 /* Do an unsigned shift if the operand was zero-extended. */
12028 result_type
12029 = c_common_signed_or_unsigned_type (unsigned_arg,
12030 TREE_TYPE (arg0));
12031 /* Convert value-to-be-shifted to that type. */
12032 if (TREE_TYPE (op0) != result_type)
12033 op0 = convert (result_type, op0);
12034 converted = 1;
12035 }
12036 }
12037
12038 /* Comparison operations are shortened too but differently.
12039 They identify themselves by setting short_compare = 1. */
12040
12041 if (short_compare)
12042 {
12043 /* Don't write &op0, etc., because that would prevent op0
12044 from being kept in a register.
12045 Instead, make copies of the our local variables and
12046 pass the copies by reference, then copy them back afterward. */
12047 tree xop0 = op0, xop1 = op1, xresult_type = result_type;
12048 enum tree_code xresultcode = resultcode;
12049 tree val
12050 = shorten_compare (location, &xop0, &xop1, &xresult_type,
12051 &xresultcode);
12052
12053 if (val != NULL_TREE)
12054 {
12055 ret = val;
12056 goto return_build_binary_op;
12057 }
12058
12059 op0 = xop0, op1 = xop1;
12060 converted = 1;
12061 resultcode = xresultcode;
12062
12063 if (c_inhibit_evaluation_warnings == 0)
12064 {
12065 bool op0_maybe_const = true;
12066 bool op1_maybe_const = true;
12067 tree orig_op0_folded, orig_op1_folded;
12068
12069 if (in_late_binary_op)
12070 {
12071 orig_op0_folded = orig_op0;
12072 orig_op1_folded = orig_op1;
12073 }
12074 else
12075 {
12076 /* Fold for the sake of possible warnings, as in
12077 build_conditional_expr. This requires the
12078 "original" values to be folded, not just op0 and
12079 op1. */
12080 c_inhibit_evaluation_warnings++;
12081 op0 = c_fully_fold (op0, require_constant_value,
12082 &op0_maybe_const);
12083 op1 = c_fully_fold (op1, require_constant_value,
12084 &op1_maybe_const);
12085 c_inhibit_evaluation_warnings--;
12086 orig_op0_folded = c_fully_fold (orig_op0,
12087 require_constant_value,
12088 NULL);
12089 orig_op1_folded = c_fully_fold (orig_op1,
12090 require_constant_value,
12091 NULL);
12092 }
12093
12094 if (warn_sign_compare)
12095 warn_for_sign_compare (location, orig_op0_folded,
12096 orig_op1_folded, op0, op1,
12097 result_type, resultcode);
12098 if (!in_late_binary_op && !int_operands)
12099 {
12100 if (!op0_maybe_const || TREE_CODE (op0) != INTEGER_CST)
12101 op0 = c_wrap_maybe_const (op0, !op0_maybe_const);
12102 if (!op1_maybe_const || TREE_CODE (op1) != INTEGER_CST)
12103 op1 = c_wrap_maybe_const (op1, !op1_maybe_const);
12104 }
12105 }
12106 }
12107 }
12108
12109 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
12110 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
12111 Then the expression will be built.
12112 It will be given type FINAL_TYPE if that is nonzero;
12113 otherwise, it will be given type RESULT_TYPE. */
12114
12115 if (!result_type)
12116 {
12117 gcc_rich_location richloc (location);
12118 richloc.maybe_add_expr (orig_op0);
12119 richloc.maybe_add_expr (orig_op1);
12120 binary_op_error (&richloc, code, TREE_TYPE (op0), TREE_TYPE (op1));
12121 return error_mark_node;
12122 }
12123
12124 if (build_type == NULL_TREE)
12125 {
12126 build_type = result_type;
12127 if ((type0 != orig_type0 || type1 != orig_type1)
12128 && !boolean_op)
12129 {
12130 gcc_assert (may_need_excess_precision && common);
12131 semantic_result_type = c_common_type (orig_type0, orig_type1);
12132 }
12133 }
12134
12135 if (!converted)
12136 {
12137 op0 = ep_convert_and_check (location, result_type, op0,
12138 semantic_result_type);
12139 op1 = ep_convert_and_check (location, result_type, op1,
12140 semantic_result_type);
12141
12142 /* This can happen if one operand has a vector type, and the other
12143 has a different type. */
12144 if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK)
12145 return error_mark_node;
12146 }
12147
12148 if (sanitize_flags_p ((SANITIZE_SHIFT
12149 | SANITIZE_DIVIDE | SANITIZE_FLOAT_DIVIDE))
12150 && current_function_decl != NULL_TREE
12151 && (doing_div_or_mod || doing_shift)
12152 && !require_constant_value)
12153 {
12154 /* OP0 and/or OP1 might have side-effects. */
12155 op0 = save_expr (op0);
12156 op1 = save_expr (op1);
12157 op0 = c_fully_fold (op0, false, NULL);
12158 op1 = c_fully_fold (op1, false, NULL);
12159 if (doing_div_or_mod && (sanitize_flags_p ((SANITIZE_DIVIDE
12160 | SANITIZE_FLOAT_DIVIDE))))
12161 instrument_expr = ubsan_instrument_division (location, op0, op1);
12162 else if (doing_shift && sanitize_flags_p (SANITIZE_SHIFT))
12163 instrument_expr = ubsan_instrument_shift (location, code, op0, op1);
12164 }
12165
12166 /* Treat expressions in initializers specially as they can't trap. */
12167 if (int_const_or_overflow)
12168 ret = (require_constant_value
12169 ? fold_build2_initializer_loc (location, resultcode, build_type,
12170 op0, op1)
12171 : fold_build2_loc (location, resultcode, build_type, op0, op1));
12172 else
12173 ret = build2 (resultcode, build_type, op0, op1);
12174 if (final_type != NULL_TREE)
12175 ret = convert (final_type, ret);
12176
12177 return_build_binary_op:
12178 gcc_assert (ret != error_mark_node);
12179 if (TREE_CODE (ret) == INTEGER_CST && !TREE_OVERFLOW (ret) && !int_const)
12180 ret = (int_operands
12181 ? note_integer_operands (ret)
12182 : build1 (NOP_EXPR, TREE_TYPE (ret), ret));
12183 else if (TREE_CODE (ret) != INTEGER_CST && int_operands
12184 && !in_late_binary_op)
12185 ret = note_integer_operands (ret);
12186 protected_set_expr_location (ret, location);
12187
12188 if (instrument_expr != NULL)
12189 ret = fold_build2 (COMPOUND_EXPR, TREE_TYPE (ret),
12190 instrument_expr, ret);
12191
12192 if (semantic_result_type)
12193 ret = build1_loc (location, EXCESS_PRECISION_EXPR,
12194 semantic_result_type, ret);
12195
12196 return ret;
12197 }
12198
12199
12200 /* Convert EXPR to be a truth-value, validating its type for this
12201 purpose. LOCATION is the source location for the expression. */
12202
12203 tree
c_objc_common_truthvalue_conversion(location_t location,tree expr)12204 c_objc_common_truthvalue_conversion (location_t location, tree expr)
12205 {
12206 bool int_const, int_operands;
12207
12208 switch (TREE_CODE (TREE_TYPE (expr)))
12209 {
12210 case ARRAY_TYPE:
12211 error_at (location, "used array that cannot be converted to pointer where scalar is required");
12212 return error_mark_node;
12213
12214 case RECORD_TYPE:
12215 error_at (location, "used struct type value where scalar is required");
12216 return error_mark_node;
12217
12218 case UNION_TYPE:
12219 error_at (location, "used union type value where scalar is required");
12220 return error_mark_node;
12221
12222 case VOID_TYPE:
12223 error_at (location, "void value not ignored as it ought to be");
12224 return error_mark_node;
12225
12226 case POINTER_TYPE:
12227 if (reject_gcc_builtin (expr))
12228 return error_mark_node;
12229 break;
12230
12231 case FUNCTION_TYPE:
12232 gcc_unreachable ();
12233
12234 case VECTOR_TYPE:
12235 error_at (location, "used vector type where scalar is required");
12236 return error_mark_node;
12237
12238 default:
12239 break;
12240 }
12241
12242 int_const = (TREE_CODE (expr) == INTEGER_CST && !TREE_OVERFLOW (expr));
12243 int_operands = EXPR_INT_CONST_OPERANDS (expr);
12244 if (int_operands && TREE_CODE (expr) != INTEGER_CST)
12245 {
12246 expr = remove_c_maybe_const_expr (expr);
12247 expr = build2 (NE_EXPR, integer_type_node, expr,
12248 convert (TREE_TYPE (expr), integer_zero_node));
12249 expr = note_integer_operands (expr);
12250 }
12251 else
12252 /* ??? Should we also give an error for vectors rather than leaving
12253 those to give errors later? */
12254 expr = c_common_truthvalue_conversion (location, expr);
12255
12256 if (TREE_CODE (expr) == INTEGER_CST && int_operands && !int_const)
12257 {
12258 if (TREE_OVERFLOW (expr))
12259 return expr;
12260 else
12261 return note_integer_operands (expr);
12262 }
12263 if (TREE_CODE (expr) == INTEGER_CST && !int_const)
12264 return build1 (NOP_EXPR, TREE_TYPE (expr), expr);
12265 return expr;
12266 }
12267
12268
12269 /* Convert EXPR to a contained DECL, updating *TC, *TI and *SE as
12270 required. */
12271
12272 tree
c_expr_to_decl(tree expr,bool * tc ATTRIBUTE_UNUSED,bool * se)12273 c_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, bool *se)
12274 {
12275 if (TREE_CODE (expr) == COMPOUND_LITERAL_EXPR)
12276 {
12277 tree decl = COMPOUND_LITERAL_EXPR_DECL (expr);
12278 /* Executing a compound literal inside a function reinitializes
12279 it. */
12280 if (!TREE_STATIC (decl))
12281 *se = true;
12282 return decl;
12283 }
12284 else
12285 return expr;
12286 }
12287
12288 /* Generate OMP construct CODE, with BODY and CLAUSES as its compound
12289 statement. LOC is the location of the construct. */
12290
12291 tree
c_finish_omp_construct(location_t loc,enum tree_code code,tree body,tree clauses)12292 c_finish_omp_construct (location_t loc, enum tree_code code, tree body,
12293 tree clauses)
12294 {
12295 body = c_end_compound_stmt (loc, body, true);
12296
12297 tree stmt = make_node (code);
12298 TREE_TYPE (stmt) = void_type_node;
12299 OMP_BODY (stmt) = body;
12300 OMP_CLAUSES (stmt) = clauses;
12301 SET_EXPR_LOCATION (stmt, loc);
12302
12303 return add_stmt (stmt);
12304 }
12305
12306 /* Generate OACC_DATA, with CLAUSES and BLOCK as its compound
12307 statement. LOC is the location of the OACC_DATA. */
12308
12309 tree
c_finish_oacc_data(location_t loc,tree clauses,tree block)12310 c_finish_oacc_data (location_t loc, tree clauses, tree block)
12311 {
12312 tree stmt;
12313
12314 block = c_end_compound_stmt (loc, block, true);
12315
12316 stmt = make_node (OACC_DATA);
12317 TREE_TYPE (stmt) = void_type_node;
12318 OACC_DATA_CLAUSES (stmt) = clauses;
12319 OACC_DATA_BODY (stmt) = block;
12320 SET_EXPR_LOCATION (stmt, loc);
12321
12322 return add_stmt (stmt);
12323 }
12324
12325 /* Generate OACC_HOST_DATA, with CLAUSES and BLOCK as its compound
12326 statement. LOC is the location of the OACC_HOST_DATA. */
12327
12328 tree
c_finish_oacc_host_data(location_t loc,tree clauses,tree block)12329 c_finish_oacc_host_data (location_t loc, tree clauses, tree block)
12330 {
12331 tree stmt;
12332
12333 block = c_end_compound_stmt (loc, block, true);
12334
12335 stmt = make_node (OACC_HOST_DATA);
12336 TREE_TYPE (stmt) = void_type_node;
12337 OACC_HOST_DATA_CLAUSES (stmt) = clauses;
12338 OACC_HOST_DATA_BODY (stmt) = block;
12339 SET_EXPR_LOCATION (stmt, loc);
12340
12341 return add_stmt (stmt);
12342 }
12343
12344 /* Like c_begin_compound_stmt, except force the retention of the BLOCK. */
12345
12346 tree
c_begin_omp_parallel(void)12347 c_begin_omp_parallel (void)
12348 {
12349 tree block;
12350
12351 keep_next_level ();
12352 block = c_begin_compound_stmt (true);
12353
12354 return block;
12355 }
12356
12357 /* Generate OMP_PARALLEL, with CLAUSES and BLOCK as its compound
12358 statement. LOC is the location of the OMP_PARALLEL. */
12359
12360 tree
c_finish_omp_parallel(location_t loc,tree clauses,tree block)12361 c_finish_omp_parallel (location_t loc, tree clauses, tree block)
12362 {
12363 tree stmt;
12364
12365 block = c_end_compound_stmt (loc, block, true);
12366
12367 stmt = make_node (OMP_PARALLEL);
12368 TREE_TYPE (stmt) = void_type_node;
12369 OMP_PARALLEL_CLAUSES (stmt) = clauses;
12370 OMP_PARALLEL_BODY (stmt) = block;
12371 SET_EXPR_LOCATION (stmt, loc);
12372
12373 return add_stmt (stmt);
12374 }
12375
12376 /* Like c_begin_compound_stmt, except force the retention of the BLOCK. */
12377
12378 tree
c_begin_omp_task(void)12379 c_begin_omp_task (void)
12380 {
12381 tree block;
12382
12383 keep_next_level ();
12384 block = c_begin_compound_stmt (true);
12385
12386 return block;
12387 }
12388
12389 /* Generate OMP_TASK, with CLAUSES and BLOCK as its compound
12390 statement. LOC is the location of the #pragma. */
12391
12392 tree
c_finish_omp_task(location_t loc,tree clauses,tree block)12393 c_finish_omp_task (location_t loc, tree clauses, tree block)
12394 {
12395 tree stmt;
12396
12397 block = c_end_compound_stmt (loc, block, true);
12398
12399 stmt = make_node (OMP_TASK);
12400 TREE_TYPE (stmt) = void_type_node;
12401 OMP_TASK_CLAUSES (stmt) = clauses;
12402 OMP_TASK_BODY (stmt) = block;
12403 SET_EXPR_LOCATION (stmt, loc);
12404
12405 return add_stmt (stmt);
12406 }
12407
12408 /* Generate GOMP_cancel call for #pragma omp cancel. */
12409
12410 void
c_finish_omp_cancel(location_t loc,tree clauses)12411 c_finish_omp_cancel (location_t loc, tree clauses)
12412 {
12413 tree fn = builtin_decl_explicit (BUILT_IN_GOMP_CANCEL);
12414 int mask = 0;
12415 if (omp_find_clause (clauses, OMP_CLAUSE_PARALLEL))
12416 mask = 1;
12417 else if (omp_find_clause (clauses, OMP_CLAUSE_FOR))
12418 mask = 2;
12419 else if (omp_find_clause (clauses, OMP_CLAUSE_SECTIONS))
12420 mask = 4;
12421 else if (omp_find_clause (clauses, OMP_CLAUSE_TASKGROUP))
12422 mask = 8;
12423 else
12424 {
12425 error_at (loc, "%<#pragma omp cancel%> must specify one of "
12426 "%<parallel%>, %<for%>, %<sections%> or %<taskgroup%> "
12427 "clauses");
12428 return;
12429 }
12430 tree ifc = omp_find_clause (clauses, OMP_CLAUSE_IF);
12431 if (ifc != NULL_TREE)
12432 {
12433 tree type = TREE_TYPE (OMP_CLAUSE_IF_EXPR (ifc));
12434 ifc = fold_build2_loc (OMP_CLAUSE_LOCATION (ifc), NE_EXPR,
12435 boolean_type_node, OMP_CLAUSE_IF_EXPR (ifc),
12436 build_zero_cst (type));
12437 }
12438 else
12439 ifc = boolean_true_node;
12440 tree stmt = build_call_expr_loc (loc, fn, 2,
12441 build_int_cst (integer_type_node, mask),
12442 ifc);
12443 add_stmt (stmt);
12444 }
12445
12446 /* Generate GOMP_cancellation_point call for
12447 #pragma omp cancellation point. */
12448
12449 void
c_finish_omp_cancellation_point(location_t loc,tree clauses)12450 c_finish_omp_cancellation_point (location_t loc, tree clauses)
12451 {
12452 tree fn = builtin_decl_explicit (BUILT_IN_GOMP_CANCELLATION_POINT);
12453 int mask = 0;
12454 if (omp_find_clause (clauses, OMP_CLAUSE_PARALLEL))
12455 mask = 1;
12456 else if (omp_find_clause (clauses, OMP_CLAUSE_FOR))
12457 mask = 2;
12458 else if (omp_find_clause (clauses, OMP_CLAUSE_SECTIONS))
12459 mask = 4;
12460 else if (omp_find_clause (clauses, OMP_CLAUSE_TASKGROUP))
12461 mask = 8;
12462 else
12463 {
12464 error_at (loc, "%<#pragma omp cancellation point%> must specify one of "
12465 "%<parallel%>, %<for%>, %<sections%> or %<taskgroup%> "
12466 "clauses");
12467 return;
12468 }
12469 tree stmt = build_call_expr_loc (loc, fn, 1,
12470 build_int_cst (integer_type_node, mask));
12471 add_stmt (stmt);
12472 }
12473
12474 /* Helper function for handle_omp_array_sections. Called recursively
12475 to handle multiple array-section-subscripts. C is the clause,
12476 T current expression (initially OMP_CLAUSE_DECL), which is either
12477 a TREE_LIST for array-section-subscript (TREE_PURPOSE is low-bound
12478 expression if specified, TREE_VALUE length expression if specified,
12479 TREE_CHAIN is what it has been specified after, or some decl.
12480 TYPES vector is populated with array section types, MAYBE_ZERO_LEN
12481 set to true if any of the array-section-subscript could have length
12482 of zero (explicit or implicit), FIRST_NON_ONE is the index of the
12483 first array-section-subscript which is known not to have length
12484 of one. Given say:
12485 map(a[:b][2:1][:c][:2][:d][e:f][2:5])
12486 FIRST_NON_ONE will be 3, array-section-subscript [:b], [2:1] and [:c]
12487 all are or may have length of 1, array-section-subscript [:2] is the
12488 first one known not to have length 1. For array-section-subscript
12489 <= FIRST_NON_ONE we diagnose non-contiguous arrays if low bound isn't
12490 0 or length isn't the array domain max + 1, for > FIRST_NON_ONE we
12491 can if MAYBE_ZERO_LEN is false. MAYBE_ZERO_LEN will be true in the above
12492 case though, as some lengths could be zero. */
12493
12494 static tree
handle_omp_array_sections_1(tree c,tree t,vec<tree> & types,bool & maybe_zero_len,unsigned int & first_non_one,enum c_omp_region_type ort)12495 handle_omp_array_sections_1 (tree c, tree t, vec<tree> &types,
12496 bool &maybe_zero_len, unsigned int &first_non_one,
12497 enum c_omp_region_type ort)
12498 {
12499 tree ret, low_bound, length, type;
12500 if (TREE_CODE (t) != TREE_LIST)
12501 {
12502 if (error_operand_p (t))
12503 return error_mark_node;
12504 ret = t;
12505 if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND
12506 && TYPE_ATOMIC (strip_array_types (TREE_TYPE (t))))
12507 {
12508 error_at (OMP_CLAUSE_LOCATION (c), "%<_Atomic%> %qE in %qs clause",
12509 t, omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12510 return error_mark_node;
12511 }
12512 if (TREE_CODE (t) == COMPONENT_REF
12513 && ort == C_ORT_OMP
12514 && (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
12515 || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_TO
12516 || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FROM))
12517 {
12518 if (DECL_BIT_FIELD (TREE_OPERAND (t, 1)))
12519 {
12520 error_at (OMP_CLAUSE_LOCATION (c),
12521 "bit-field %qE in %qs clause",
12522 t, omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12523 return error_mark_node;
12524 }
12525 while (TREE_CODE (t) == COMPONENT_REF)
12526 {
12527 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == UNION_TYPE)
12528 {
12529 error_at (OMP_CLAUSE_LOCATION (c),
12530 "%qE is a member of a union", t);
12531 return error_mark_node;
12532 }
12533 t = TREE_OPERAND (t, 0);
12534 }
12535 }
12536 if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
12537 {
12538 if (DECL_P (t))
12539 error_at (OMP_CLAUSE_LOCATION (c),
12540 "%qD is not a variable in %qs clause", t,
12541 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12542 else
12543 error_at (OMP_CLAUSE_LOCATION (c),
12544 "%qE is not a variable in %qs clause", t,
12545 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12546 return error_mark_node;
12547 }
12548 else if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND
12549 && TYPE_ATOMIC (TREE_TYPE (t)))
12550 {
12551 error_at (OMP_CLAUSE_LOCATION (c), "%<_Atomic%> %qD in %qs clause",
12552 t, omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12553 return error_mark_node;
12554 }
12555 else if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND
12556 && VAR_P (t)
12557 && DECL_THREAD_LOCAL_P (t))
12558 {
12559 error_at (OMP_CLAUSE_LOCATION (c),
12560 "%qD is threadprivate variable in %qs clause", t,
12561 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12562 return error_mark_node;
12563 }
12564 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND
12565 && TYPE_ATOMIC (TREE_TYPE (t))
12566 && POINTER_TYPE_P (TREE_TYPE (t)))
12567 {
12568 /* If the array section is pointer based and the pointer
12569 itself is _Atomic qualified, we need to atomically load
12570 the pointer. */
12571 c_expr expr;
12572 memset (&expr, 0, sizeof (expr));
12573 expr.value = ret;
12574 expr = convert_lvalue_to_rvalue (OMP_CLAUSE_LOCATION (c),
12575 expr, false, false);
12576 ret = expr.value;
12577 }
12578 return ret;
12579 }
12580
12581 ret = handle_omp_array_sections_1 (c, TREE_CHAIN (t), types,
12582 maybe_zero_len, first_non_one, ort);
12583 if (ret == error_mark_node || ret == NULL_TREE)
12584 return ret;
12585
12586 type = TREE_TYPE (ret);
12587 low_bound = TREE_PURPOSE (t);
12588 length = TREE_VALUE (t);
12589
12590 if (low_bound == error_mark_node || length == error_mark_node)
12591 return error_mark_node;
12592
12593 if (low_bound && !INTEGRAL_TYPE_P (TREE_TYPE (low_bound)))
12594 {
12595 error_at (OMP_CLAUSE_LOCATION (c),
12596 "low bound %qE of array section does not have integral type",
12597 low_bound);
12598 return error_mark_node;
12599 }
12600 if (length && !INTEGRAL_TYPE_P (TREE_TYPE (length)))
12601 {
12602 error_at (OMP_CLAUSE_LOCATION (c),
12603 "length %qE of array section does not have integral type",
12604 length);
12605 return error_mark_node;
12606 }
12607 if (low_bound
12608 && TREE_CODE (low_bound) == INTEGER_CST
12609 && TYPE_PRECISION (TREE_TYPE (low_bound))
12610 > TYPE_PRECISION (sizetype))
12611 low_bound = fold_convert (sizetype, low_bound);
12612 if (length
12613 && TREE_CODE (length) == INTEGER_CST
12614 && TYPE_PRECISION (TREE_TYPE (length))
12615 > TYPE_PRECISION (sizetype))
12616 length = fold_convert (sizetype, length);
12617 if (low_bound == NULL_TREE)
12618 low_bound = integer_zero_node;
12619
12620 if (length != NULL_TREE)
12621 {
12622 if (!integer_nonzerop (length))
12623 {
12624 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND
12625 || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION)
12626 {
12627 if (integer_zerop (length))
12628 {
12629 error_at (OMP_CLAUSE_LOCATION (c),
12630 "zero length array section in %qs clause",
12631 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12632 return error_mark_node;
12633 }
12634 }
12635 else
12636 maybe_zero_len = true;
12637 }
12638 if (first_non_one == types.length ()
12639 && (TREE_CODE (length) != INTEGER_CST || integer_onep (length)))
12640 first_non_one++;
12641 }
12642 if (TREE_CODE (type) == ARRAY_TYPE)
12643 {
12644 if (length == NULL_TREE
12645 && (TYPE_DOMAIN (type) == NULL_TREE
12646 || TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL_TREE))
12647 {
12648 error_at (OMP_CLAUSE_LOCATION (c),
12649 "for unknown bound array type length expression must "
12650 "be specified");
12651 return error_mark_node;
12652 }
12653 if (TREE_CODE (low_bound) == INTEGER_CST
12654 && tree_int_cst_sgn (low_bound) == -1)
12655 {
12656 error_at (OMP_CLAUSE_LOCATION (c),
12657 "negative low bound in array section in %qs clause",
12658 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12659 return error_mark_node;
12660 }
12661 if (length != NULL_TREE
12662 && TREE_CODE (length) == INTEGER_CST
12663 && tree_int_cst_sgn (length) == -1)
12664 {
12665 error_at (OMP_CLAUSE_LOCATION (c),
12666 "negative length in array section in %qs clause",
12667 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12668 return error_mark_node;
12669 }
12670 if (TYPE_DOMAIN (type)
12671 && TYPE_MAX_VALUE (TYPE_DOMAIN (type))
12672 && TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
12673 == INTEGER_CST)
12674 {
12675 tree size
12676 = fold_convert (sizetype, TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
12677 size = size_binop (PLUS_EXPR, size, size_one_node);
12678 if (TREE_CODE (low_bound) == INTEGER_CST)
12679 {
12680 if (tree_int_cst_lt (size, low_bound))
12681 {
12682 error_at (OMP_CLAUSE_LOCATION (c),
12683 "low bound %qE above array section size "
12684 "in %qs clause", low_bound,
12685 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12686 return error_mark_node;
12687 }
12688 if (tree_int_cst_equal (size, low_bound))
12689 {
12690 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND
12691 || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION)
12692 {
12693 error_at (OMP_CLAUSE_LOCATION (c),
12694 "zero length array section in %qs clause",
12695 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12696 return error_mark_node;
12697 }
12698 maybe_zero_len = true;
12699 }
12700 else if (length == NULL_TREE
12701 && first_non_one == types.length ()
12702 && tree_int_cst_equal
12703 (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
12704 low_bound))
12705 first_non_one++;
12706 }
12707 else if (length == NULL_TREE)
12708 {
12709 if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND
12710 && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_REDUCTION)
12711 maybe_zero_len = true;
12712 if (first_non_one == types.length ())
12713 first_non_one++;
12714 }
12715 if (length && TREE_CODE (length) == INTEGER_CST)
12716 {
12717 if (tree_int_cst_lt (size, length))
12718 {
12719 error_at (OMP_CLAUSE_LOCATION (c),
12720 "length %qE above array section size "
12721 "in %qs clause", length,
12722 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12723 return error_mark_node;
12724 }
12725 if (TREE_CODE (low_bound) == INTEGER_CST)
12726 {
12727 tree lbpluslen
12728 = size_binop (PLUS_EXPR,
12729 fold_convert (sizetype, low_bound),
12730 fold_convert (sizetype, length));
12731 if (TREE_CODE (lbpluslen) == INTEGER_CST
12732 && tree_int_cst_lt (size, lbpluslen))
12733 {
12734 error_at (OMP_CLAUSE_LOCATION (c),
12735 "high bound %qE above array section size "
12736 "in %qs clause", lbpluslen,
12737 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12738 return error_mark_node;
12739 }
12740 }
12741 }
12742 }
12743 else if (length == NULL_TREE)
12744 {
12745 if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND
12746 && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_REDUCTION)
12747 maybe_zero_len = true;
12748 if (first_non_one == types.length ())
12749 first_non_one++;
12750 }
12751
12752 /* For [lb:] we will need to evaluate lb more than once. */
12753 if (length == NULL_TREE && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND)
12754 {
12755 tree lb = save_expr (low_bound);
12756 if (lb != low_bound)
12757 {
12758 TREE_PURPOSE (t) = lb;
12759 low_bound = lb;
12760 }
12761 }
12762 }
12763 else if (TREE_CODE (type) == POINTER_TYPE)
12764 {
12765 if (length == NULL_TREE)
12766 {
12767 error_at (OMP_CLAUSE_LOCATION (c),
12768 "for pointer type length expression must be specified");
12769 return error_mark_node;
12770 }
12771 if (length != NULL_TREE
12772 && TREE_CODE (length) == INTEGER_CST
12773 && tree_int_cst_sgn (length) == -1)
12774 {
12775 error_at (OMP_CLAUSE_LOCATION (c),
12776 "negative length in array section in %qs clause",
12777 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12778 return error_mark_node;
12779 }
12780 /* If there is a pointer type anywhere but in the very first
12781 array-section-subscript, the array section can't be contiguous. */
12782 if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND
12783 && TREE_CODE (TREE_CHAIN (t)) == TREE_LIST)
12784 {
12785 error_at (OMP_CLAUSE_LOCATION (c),
12786 "array section is not contiguous in %qs clause",
12787 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12788 return error_mark_node;
12789 }
12790 }
12791 else
12792 {
12793 error_at (OMP_CLAUSE_LOCATION (c),
12794 "%qE does not have pointer or array type", ret);
12795 return error_mark_node;
12796 }
12797 if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_DEPEND)
12798 types.safe_push (TREE_TYPE (ret));
12799 /* We will need to evaluate lb more than once. */
12800 tree lb = save_expr (low_bound);
12801 if (lb != low_bound)
12802 {
12803 TREE_PURPOSE (t) = lb;
12804 low_bound = lb;
12805 }
12806 ret = build_array_ref (OMP_CLAUSE_LOCATION (c), ret, low_bound);
12807 return ret;
12808 }
12809
12810 /* Handle array sections for clause C. */
12811
12812 static bool
handle_omp_array_sections(tree c,enum c_omp_region_type ort)12813 handle_omp_array_sections (tree c, enum c_omp_region_type ort)
12814 {
12815 bool maybe_zero_len = false;
12816 unsigned int first_non_one = 0;
12817 auto_vec<tree, 10> types;
12818 tree first = handle_omp_array_sections_1 (c, OMP_CLAUSE_DECL (c), types,
12819 maybe_zero_len, first_non_one,
12820 ort);
12821 if (first == error_mark_node)
12822 return true;
12823 if (first == NULL_TREE)
12824 return false;
12825 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_DEPEND)
12826 {
12827 tree t = OMP_CLAUSE_DECL (c);
12828 tree tem = NULL_TREE;
12829 /* Need to evaluate side effects in the length expressions
12830 if any. */
12831 while (TREE_CODE (t) == TREE_LIST)
12832 {
12833 if (TREE_VALUE (t) && TREE_SIDE_EFFECTS (TREE_VALUE (t)))
12834 {
12835 if (tem == NULL_TREE)
12836 tem = TREE_VALUE (t);
12837 else
12838 tem = build2 (COMPOUND_EXPR, TREE_TYPE (tem),
12839 TREE_VALUE (t), tem);
12840 }
12841 t = TREE_CHAIN (t);
12842 }
12843 if (tem)
12844 first = build2 (COMPOUND_EXPR, TREE_TYPE (first), tem, first);
12845 first = c_fully_fold (first, false, NULL, true);
12846 OMP_CLAUSE_DECL (c) = first;
12847 }
12848 else
12849 {
12850 unsigned int num = types.length (), i;
12851 tree t, side_effects = NULL_TREE, size = NULL_TREE;
12852 tree condition = NULL_TREE;
12853
12854 if (int_size_in_bytes (TREE_TYPE (first)) <= 0)
12855 maybe_zero_len = true;
12856
12857 for (i = num, t = OMP_CLAUSE_DECL (c); i > 0;
12858 t = TREE_CHAIN (t))
12859 {
12860 tree low_bound = TREE_PURPOSE (t);
12861 tree length = TREE_VALUE (t);
12862
12863 i--;
12864 if (low_bound
12865 && TREE_CODE (low_bound) == INTEGER_CST
12866 && TYPE_PRECISION (TREE_TYPE (low_bound))
12867 > TYPE_PRECISION (sizetype))
12868 low_bound = fold_convert (sizetype, low_bound);
12869 if (length
12870 && TREE_CODE (length) == INTEGER_CST
12871 && TYPE_PRECISION (TREE_TYPE (length))
12872 > TYPE_PRECISION (sizetype))
12873 length = fold_convert (sizetype, length);
12874 if (low_bound == NULL_TREE)
12875 low_bound = integer_zero_node;
12876 if (!maybe_zero_len && i > first_non_one)
12877 {
12878 if (integer_nonzerop (low_bound))
12879 goto do_warn_noncontiguous;
12880 if (length != NULL_TREE
12881 && TREE_CODE (length) == INTEGER_CST
12882 && TYPE_DOMAIN (types[i])
12883 && TYPE_MAX_VALUE (TYPE_DOMAIN (types[i]))
12884 && TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (types[i])))
12885 == INTEGER_CST)
12886 {
12887 tree size;
12888 size = size_binop (PLUS_EXPR,
12889 TYPE_MAX_VALUE (TYPE_DOMAIN (types[i])),
12890 size_one_node);
12891 if (!tree_int_cst_equal (length, size))
12892 {
12893 do_warn_noncontiguous:
12894 error_at (OMP_CLAUSE_LOCATION (c),
12895 "array section is not contiguous in %qs "
12896 "clause",
12897 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12898 return true;
12899 }
12900 }
12901 if (length != NULL_TREE
12902 && TREE_SIDE_EFFECTS (length))
12903 {
12904 if (side_effects == NULL_TREE)
12905 side_effects = length;
12906 else
12907 side_effects = build2 (COMPOUND_EXPR,
12908 TREE_TYPE (side_effects),
12909 length, side_effects);
12910 }
12911 }
12912 else
12913 {
12914 tree l;
12915
12916 if (i > first_non_one
12917 && ((length && integer_nonzerop (length))
12918 || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION))
12919 continue;
12920 if (length)
12921 l = fold_convert (sizetype, length);
12922 else
12923 {
12924 l = size_binop (PLUS_EXPR,
12925 TYPE_MAX_VALUE (TYPE_DOMAIN (types[i])),
12926 size_one_node);
12927 l = size_binop (MINUS_EXPR, l,
12928 fold_convert (sizetype, low_bound));
12929 }
12930 if (i > first_non_one)
12931 {
12932 l = fold_build2 (NE_EXPR, boolean_type_node, l,
12933 size_zero_node);
12934 if (condition == NULL_TREE)
12935 condition = l;
12936 else
12937 condition = fold_build2 (BIT_AND_EXPR, boolean_type_node,
12938 l, condition);
12939 }
12940 else if (size == NULL_TREE)
12941 {
12942 size = size_in_bytes (TREE_TYPE (types[i]));
12943 tree eltype = TREE_TYPE (types[num - 1]);
12944 while (TREE_CODE (eltype) == ARRAY_TYPE)
12945 eltype = TREE_TYPE (eltype);
12946 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION)
12947 {
12948 if (integer_zerop (size)
12949 || integer_zerop (size_in_bytes (eltype)))
12950 {
12951 error_at (OMP_CLAUSE_LOCATION (c),
12952 "zero length array section in %qs clause",
12953 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
12954 return error_mark_node;
12955 }
12956 size = size_binop (EXACT_DIV_EXPR, size,
12957 size_in_bytes (eltype));
12958 }
12959 size = size_binop (MULT_EXPR, size, l);
12960 if (condition)
12961 size = fold_build3 (COND_EXPR, sizetype, condition,
12962 size, size_zero_node);
12963 }
12964 else
12965 size = size_binop (MULT_EXPR, size, l);
12966 }
12967 }
12968 if (side_effects)
12969 size = build2 (COMPOUND_EXPR, sizetype, side_effects, size);
12970 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION)
12971 {
12972 size = size_binop (MINUS_EXPR, size, size_one_node);
12973 size = c_fully_fold (size, false, NULL);
12974 tree index_type = build_index_type (size);
12975 tree eltype = TREE_TYPE (first);
12976 while (TREE_CODE (eltype) == ARRAY_TYPE)
12977 eltype = TREE_TYPE (eltype);
12978 tree type = build_array_type (eltype, index_type);
12979 tree ptype = build_pointer_type (eltype);
12980 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
12981 t = build_fold_addr_expr (t);
12982 tree t2 = build_fold_addr_expr (first);
12983 t2 = fold_convert_loc (OMP_CLAUSE_LOCATION (c),
12984 ptrdiff_type_node, t2);
12985 t2 = fold_build2_loc (OMP_CLAUSE_LOCATION (c), MINUS_EXPR,
12986 ptrdiff_type_node, t2,
12987 fold_convert_loc (OMP_CLAUSE_LOCATION (c),
12988 ptrdiff_type_node, t));
12989 t2 = c_fully_fold (t2, false, NULL);
12990 if (tree_fits_shwi_p (t2))
12991 t = build2 (MEM_REF, type, t,
12992 build_int_cst (ptype, tree_to_shwi (t2)));
12993 else
12994 {
12995 t2 = fold_convert_loc (OMP_CLAUSE_LOCATION (c), sizetype, t2);
12996 t = build2_loc (OMP_CLAUSE_LOCATION (c), POINTER_PLUS_EXPR,
12997 TREE_TYPE (t), t, t2);
12998 t = build2 (MEM_REF, type, t, build_int_cst (ptype, 0));
12999 }
13000 OMP_CLAUSE_DECL (c) = t;
13001 return false;
13002 }
13003 first = c_fully_fold (first, false, NULL);
13004 OMP_CLAUSE_DECL (c) = first;
13005 if (size)
13006 size = c_fully_fold (size, false, NULL);
13007 OMP_CLAUSE_SIZE (c) = size;
13008 if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_MAP
13009 || (TREE_CODE (t) == COMPONENT_REF
13010 && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE))
13011 return false;
13012 gcc_assert (OMP_CLAUSE_MAP_KIND (c) != GOMP_MAP_FORCE_DEVICEPTR);
13013 if (ort == C_ORT_OMP || ort == C_ORT_ACC)
13014 switch (OMP_CLAUSE_MAP_KIND (c))
13015 {
13016 case GOMP_MAP_ALLOC:
13017 case GOMP_MAP_TO:
13018 case GOMP_MAP_FROM:
13019 case GOMP_MAP_TOFROM:
13020 case GOMP_MAP_ALWAYS_TO:
13021 case GOMP_MAP_ALWAYS_FROM:
13022 case GOMP_MAP_ALWAYS_TOFROM:
13023 case GOMP_MAP_RELEASE:
13024 case GOMP_MAP_DELETE:
13025 case GOMP_MAP_FORCE_TO:
13026 case GOMP_MAP_FORCE_FROM:
13027 case GOMP_MAP_FORCE_TOFROM:
13028 case GOMP_MAP_FORCE_PRESENT:
13029 OMP_CLAUSE_MAP_MAYBE_ZERO_LENGTH_ARRAY_SECTION (c) = 1;
13030 break;
13031 default:
13032 break;
13033 }
13034 tree c2 = build_omp_clause (OMP_CLAUSE_LOCATION (c), OMP_CLAUSE_MAP);
13035 if (ort != C_ORT_OMP && ort != C_ORT_ACC)
13036 OMP_CLAUSE_SET_MAP_KIND (c2, GOMP_MAP_POINTER);
13037 else if (TREE_CODE (t) == COMPONENT_REF)
13038 OMP_CLAUSE_SET_MAP_KIND (c2, GOMP_MAP_ALWAYS_POINTER);
13039 else
13040 OMP_CLAUSE_SET_MAP_KIND (c2, GOMP_MAP_FIRSTPRIVATE_POINTER);
13041 if (OMP_CLAUSE_MAP_KIND (c2) != GOMP_MAP_FIRSTPRIVATE_POINTER
13042 && !c_mark_addressable (t))
13043 return false;
13044 OMP_CLAUSE_DECL (c2) = t;
13045 t = build_fold_addr_expr (first);
13046 t = fold_convert_loc (OMP_CLAUSE_LOCATION (c), ptrdiff_type_node, t);
13047 tree ptr = OMP_CLAUSE_DECL (c2);
13048 if (!POINTER_TYPE_P (TREE_TYPE (ptr)))
13049 ptr = build_fold_addr_expr (ptr);
13050 t = fold_build2_loc (OMP_CLAUSE_LOCATION (c), MINUS_EXPR,
13051 ptrdiff_type_node, t,
13052 fold_convert_loc (OMP_CLAUSE_LOCATION (c),
13053 ptrdiff_type_node, ptr));
13054 t = c_fully_fold (t, false, NULL);
13055 OMP_CLAUSE_SIZE (c2) = t;
13056 OMP_CLAUSE_CHAIN (c2) = OMP_CLAUSE_CHAIN (c);
13057 OMP_CLAUSE_CHAIN (c) = c2;
13058 }
13059 return false;
13060 }
13061
13062 /* Helper function of finish_omp_clauses. Clone STMT as if we were making
13063 an inline call. But, remap
13064 the OMP_DECL1 VAR_DECL (omp_out resp. omp_orig) to PLACEHOLDER
13065 and OMP_DECL2 VAR_DECL (omp_in resp. omp_priv) to DECL. */
13066
13067 static tree
c_clone_omp_udr(tree stmt,tree omp_decl1,tree omp_decl2,tree decl,tree placeholder)13068 c_clone_omp_udr (tree stmt, tree omp_decl1, tree omp_decl2,
13069 tree decl, tree placeholder)
13070 {
13071 copy_body_data id;
13072 hash_map<tree, tree> decl_map;
13073
13074 decl_map.put (omp_decl1, placeholder);
13075 decl_map.put (omp_decl2, decl);
13076 memset (&id, 0, sizeof (id));
13077 id.src_fn = DECL_CONTEXT (omp_decl1);
13078 id.dst_fn = current_function_decl;
13079 id.src_cfun = DECL_STRUCT_FUNCTION (id.src_fn);
13080 id.decl_map = &decl_map;
13081
13082 id.copy_decl = copy_decl_no_change;
13083 id.transform_call_graph_edges = CB_CGE_DUPLICATE;
13084 id.transform_new_cfg = true;
13085 id.transform_return_to_modify = false;
13086 id.transform_lang_insert_block = NULL;
13087 id.eh_lp_nr = 0;
13088 walk_tree (&stmt, copy_tree_body_r, &id, NULL);
13089 return stmt;
13090 }
13091
13092 /* Helper function of c_finish_omp_clauses, called via walk_tree.
13093 Find OMP_CLAUSE_PLACEHOLDER (passed in DATA) in *TP. */
13094
13095 static tree
c_find_omp_placeholder_r(tree * tp,int *,void * data)13096 c_find_omp_placeholder_r (tree *tp, int *, void *data)
13097 {
13098 if (*tp == (tree) data)
13099 return *tp;
13100 return NULL_TREE;
13101 }
13102
13103 /* For all elements of CLAUSES, validate them against their constraints.
13104 Remove any elements from the list that are invalid. */
13105
13106 tree
c_finish_omp_clauses(tree clauses,enum c_omp_region_type ort)13107 c_finish_omp_clauses (tree clauses, enum c_omp_region_type ort)
13108 {
13109 bitmap_head generic_head, firstprivate_head, lastprivate_head;
13110 bitmap_head aligned_head, map_head, map_field_head, oacc_reduction_head;
13111 tree c, t, type, *pc;
13112 tree simdlen = NULL_TREE, safelen = NULL_TREE;
13113 bool branch_seen = false;
13114 bool copyprivate_seen = false;
13115 bool linear_variable_step_check = false;
13116 tree *nowait_clause = NULL;
13117 bool ordered_seen = false;
13118 tree schedule_clause = NULL_TREE;
13119 bool oacc_async = false;
13120
13121 bitmap_obstack_initialize (NULL);
13122 bitmap_initialize (&generic_head, &bitmap_default_obstack);
13123 bitmap_initialize (&firstprivate_head, &bitmap_default_obstack);
13124 bitmap_initialize (&lastprivate_head, &bitmap_default_obstack);
13125 bitmap_initialize (&aligned_head, &bitmap_default_obstack);
13126 bitmap_initialize (&map_head, &bitmap_default_obstack);
13127 bitmap_initialize (&map_field_head, &bitmap_default_obstack);
13128 bitmap_initialize (&oacc_reduction_head, &bitmap_default_obstack);
13129
13130 if (ort & C_ORT_ACC)
13131 for (c = clauses; c; c = OMP_CLAUSE_CHAIN (c))
13132 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_ASYNC)
13133 {
13134 oacc_async = true;
13135 break;
13136 }
13137
13138 for (pc = &clauses, c = clauses; c ; c = *pc)
13139 {
13140 bool remove = false;
13141 bool need_complete = false;
13142 bool need_implicitly_determined = false;
13143
13144 switch (OMP_CLAUSE_CODE (c))
13145 {
13146 case OMP_CLAUSE_SHARED:
13147 need_implicitly_determined = true;
13148 goto check_dup_generic;
13149
13150 case OMP_CLAUSE_PRIVATE:
13151 need_complete = true;
13152 need_implicitly_determined = true;
13153 goto check_dup_generic;
13154
13155 case OMP_CLAUSE_REDUCTION:
13156 need_implicitly_determined = true;
13157 t = OMP_CLAUSE_DECL (c);
13158 if (TREE_CODE (t) == TREE_LIST)
13159 {
13160 if (handle_omp_array_sections (c, ort))
13161 {
13162 remove = true;
13163 break;
13164 }
13165
13166 t = OMP_CLAUSE_DECL (c);
13167 }
13168 t = require_complete_type (OMP_CLAUSE_LOCATION (c), t);
13169 if (t == error_mark_node)
13170 {
13171 remove = true;
13172 break;
13173 }
13174 if (oacc_async)
13175 c_mark_addressable (t);
13176 type = TREE_TYPE (t);
13177 if (TREE_CODE (t) == MEM_REF)
13178 type = TREE_TYPE (type);
13179 if (TREE_CODE (type) == ARRAY_TYPE)
13180 {
13181 tree oatype = type;
13182 gcc_assert (TREE_CODE (t) != MEM_REF);
13183 while (TREE_CODE (type) == ARRAY_TYPE)
13184 type = TREE_TYPE (type);
13185 if (integer_zerop (TYPE_SIZE_UNIT (type)))
13186 {
13187 error_at (OMP_CLAUSE_LOCATION (c),
13188 "%qD in %<reduction%> clause is a zero size array",
13189 t);
13190 remove = true;
13191 break;
13192 }
13193 tree size = size_binop (EXACT_DIV_EXPR, TYPE_SIZE_UNIT (oatype),
13194 TYPE_SIZE_UNIT (type));
13195 if (integer_zerop (size))
13196 {
13197 error_at (OMP_CLAUSE_LOCATION (c),
13198 "%qD in %<reduction%> clause is a zero size array",
13199 t);
13200 remove = true;
13201 break;
13202 }
13203 size = size_binop (MINUS_EXPR, size, size_one_node);
13204 tree index_type = build_index_type (size);
13205 tree atype = build_array_type (type, index_type);
13206 tree ptype = build_pointer_type (type);
13207 if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
13208 t = build_fold_addr_expr (t);
13209 t = build2 (MEM_REF, atype, t, build_int_cst (ptype, 0));
13210 OMP_CLAUSE_DECL (c) = t;
13211 }
13212 if (TYPE_ATOMIC (type))
13213 {
13214 error_at (OMP_CLAUSE_LOCATION (c),
13215 "%<_Atomic%> %qE in %<reduction%> clause", t);
13216 remove = true;
13217 break;
13218 }
13219 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c) == NULL_TREE
13220 && (FLOAT_TYPE_P (type)
13221 || TREE_CODE (type) == COMPLEX_TYPE))
13222 {
13223 enum tree_code r_code = OMP_CLAUSE_REDUCTION_CODE (c);
13224 const char *r_name = NULL;
13225
13226 switch (r_code)
13227 {
13228 case PLUS_EXPR:
13229 case MULT_EXPR:
13230 case MINUS_EXPR:
13231 break;
13232 case MIN_EXPR:
13233 if (TREE_CODE (type) == COMPLEX_TYPE)
13234 r_name = "min";
13235 break;
13236 case MAX_EXPR:
13237 if (TREE_CODE (type) == COMPLEX_TYPE)
13238 r_name = "max";
13239 break;
13240 case BIT_AND_EXPR:
13241 r_name = "&";
13242 break;
13243 case BIT_XOR_EXPR:
13244 r_name = "^";
13245 break;
13246 case BIT_IOR_EXPR:
13247 r_name = "|";
13248 break;
13249 case TRUTH_ANDIF_EXPR:
13250 if (FLOAT_TYPE_P (type))
13251 r_name = "&&";
13252 break;
13253 case TRUTH_ORIF_EXPR:
13254 if (FLOAT_TYPE_P (type))
13255 r_name = "||";
13256 break;
13257 default:
13258 gcc_unreachable ();
13259 }
13260 if (r_name)
13261 {
13262 error_at (OMP_CLAUSE_LOCATION (c),
13263 "%qE has invalid type for %<reduction(%s)%>",
13264 t, r_name);
13265 remove = true;
13266 break;
13267 }
13268 }
13269 else if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c) == error_mark_node)
13270 {
13271 error_at (OMP_CLAUSE_LOCATION (c),
13272 "user defined reduction not found for %qE", t);
13273 remove = true;
13274 break;
13275 }
13276 else if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c))
13277 {
13278 tree list = OMP_CLAUSE_REDUCTION_PLACEHOLDER (c);
13279 type = TYPE_MAIN_VARIANT (type);
13280 tree placeholder = build_decl (OMP_CLAUSE_LOCATION (c),
13281 VAR_DECL, NULL_TREE, type);
13282 tree decl_placeholder = NULL_TREE;
13283 OMP_CLAUSE_REDUCTION_PLACEHOLDER (c) = placeholder;
13284 DECL_ARTIFICIAL (placeholder) = 1;
13285 DECL_IGNORED_P (placeholder) = 1;
13286 if (TREE_CODE (t) == MEM_REF)
13287 {
13288 decl_placeholder = build_decl (OMP_CLAUSE_LOCATION (c),
13289 VAR_DECL, NULL_TREE, type);
13290 OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c) = decl_placeholder;
13291 DECL_ARTIFICIAL (decl_placeholder) = 1;
13292 DECL_IGNORED_P (decl_placeholder) = 1;
13293 }
13294 if (TREE_ADDRESSABLE (TREE_VEC_ELT (list, 0)))
13295 c_mark_addressable (placeholder);
13296 if (TREE_ADDRESSABLE (TREE_VEC_ELT (list, 1)))
13297 c_mark_addressable (decl_placeholder ? decl_placeholder
13298 : OMP_CLAUSE_DECL (c));
13299 OMP_CLAUSE_REDUCTION_MERGE (c)
13300 = c_clone_omp_udr (TREE_VEC_ELT (list, 2),
13301 TREE_VEC_ELT (list, 0),
13302 TREE_VEC_ELT (list, 1),
13303 decl_placeholder ? decl_placeholder
13304 : OMP_CLAUSE_DECL (c), placeholder);
13305 OMP_CLAUSE_REDUCTION_MERGE (c)
13306 = build3_loc (OMP_CLAUSE_LOCATION (c), BIND_EXPR,
13307 void_type_node, NULL_TREE,
13308 OMP_CLAUSE_REDUCTION_MERGE (c), NULL_TREE);
13309 TREE_SIDE_EFFECTS (OMP_CLAUSE_REDUCTION_MERGE (c)) = 1;
13310 if (TREE_VEC_LENGTH (list) == 6)
13311 {
13312 if (TREE_ADDRESSABLE (TREE_VEC_ELT (list, 3)))
13313 c_mark_addressable (decl_placeholder ? decl_placeholder
13314 : OMP_CLAUSE_DECL (c));
13315 if (TREE_ADDRESSABLE (TREE_VEC_ELT (list, 4)))
13316 c_mark_addressable (placeholder);
13317 tree init = TREE_VEC_ELT (list, 5);
13318 if (init == error_mark_node)
13319 init = DECL_INITIAL (TREE_VEC_ELT (list, 3));
13320 OMP_CLAUSE_REDUCTION_INIT (c)
13321 = c_clone_omp_udr (init, TREE_VEC_ELT (list, 4),
13322 TREE_VEC_ELT (list, 3),
13323 decl_placeholder ? decl_placeholder
13324 : OMP_CLAUSE_DECL (c), placeholder);
13325 if (TREE_VEC_ELT (list, 5) == error_mark_node)
13326 {
13327 tree v = decl_placeholder ? decl_placeholder : t;
13328 OMP_CLAUSE_REDUCTION_INIT (c)
13329 = build2 (INIT_EXPR, TREE_TYPE (v), v,
13330 OMP_CLAUSE_REDUCTION_INIT (c));
13331 }
13332 if (walk_tree (&OMP_CLAUSE_REDUCTION_INIT (c),
13333 c_find_omp_placeholder_r,
13334 placeholder, NULL))
13335 OMP_CLAUSE_REDUCTION_OMP_ORIG_REF (c) = 1;
13336 }
13337 else
13338 {
13339 tree init;
13340 tree v = decl_placeholder ? decl_placeholder : t;
13341 if (AGGREGATE_TYPE_P (TREE_TYPE (v)))
13342 init = build_constructor (TREE_TYPE (v), NULL);
13343 else
13344 init = fold_convert (TREE_TYPE (v), integer_zero_node);
13345 OMP_CLAUSE_REDUCTION_INIT (c)
13346 = build2 (INIT_EXPR, TREE_TYPE (v), v, init);
13347 }
13348 OMP_CLAUSE_REDUCTION_INIT (c)
13349 = build3_loc (OMP_CLAUSE_LOCATION (c), BIND_EXPR,
13350 void_type_node, NULL_TREE,
13351 OMP_CLAUSE_REDUCTION_INIT (c), NULL_TREE);
13352 TREE_SIDE_EFFECTS (OMP_CLAUSE_REDUCTION_INIT (c)) = 1;
13353 }
13354 if (TREE_CODE (t) == MEM_REF)
13355 {
13356 if (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (t))) == NULL_TREE
13357 || TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (t))))
13358 != INTEGER_CST)
13359 {
13360 sorry ("variable length element type in array "
13361 "%<reduction%> clause");
13362 remove = true;
13363 break;
13364 }
13365 t = TREE_OPERAND (t, 0);
13366 if (TREE_CODE (t) == POINTER_PLUS_EXPR)
13367 t = TREE_OPERAND (t, 0);
13368 if (TREE_CODE (t) == ADDR_EXPR)
13369 t = TREE_OPERAND (t, 0);
13370 }
13371 goto check_dup_generic_t;
13372
13373 case OMP_CLAUSE_COPYPRIVATE:
13374 copyprivate_seen = true;
13375 if (nowait_clause)
13376 {
13377 error_at (OMP_CLAUSE_LOCATION (*nowait_clause),
13378 "%<nowait%> clause must not be used together "
13379 "with %<copyprivate%>");
13380 *nowait_clause = OMP_CLAUSE_CHAIN (*nowait_clause);
13381 nowait_clause = NULL;
13382 }
13383 goto check_dup_generic;
13384
13385 case OMP_CLAUSE_COPYIN:
13386 t = OMP_CLAUSE_DECL (c);
13387 if (!VAR_P (t) || !DECL_THREAD_LOCAL_P (t))
13388 {
13389 error_at (OMP_CLAUSE_LOCATION (c),
13390 "%qE must be %<threadprivate%> for %<copyin%>", t);
13391 remove = true;
13392 break;
13393 }
13394 goto check_dup_generic;
13395
13396 case OMP_CLAUSE_LINEAR:
13397 if (ort != C_ORT_OMP_DECLARE_SIMD)
13398 need_implicitly_determined = true;
13399 t = OMP_CLAUSE_DECL (c);
13400 if (ort != C_ORT_OMP_DECLARE_SIMD
13401 && OMP_CLAUSE_LINEAR_KIND (c) != OMP_CLAUSE_LINEAR_DEFAULT)
13402 {
13403 error_at (OMP_CLAUSE_LOCATION (c),
13404 "modifier should not be specified in %<linear%> "
13405 "clause on %<simd%> or %<for%> constructs");
13406 OMP_CLAUSE_LINEAR_KIND (c) = OMP_CLAUSE_LINEAR_DEFAULT;
13407 }
13408 if (!INTEGRAL_TYPE_P (TREE_TYPE (t))
13409 && TREE_CODE (TREE_TYPE (t)) != POINTER_TYPE)
13410 {
13411 error_at (OMP_CLAUSE_LOCATION (c),
13412 "linear clause applied to non-integral non-pointer "
13413 "variable with type %qT", TREE_TYPE (t));
13414 remove = true;
13415 break;
13416 }
13417 if (TYPE_ATOMIC (TREE_TYPE (t)))
13418 {
13419 error_at (OMP_CLAUSE_LOCATION (c),
13420 "%<_Atomic%> %qD in %<linear%> clause", t);
13421 remove = true;
13422 break;
13423 }
13424 if (ort == C_ORT_OMP_DECLARE_SIMD)
13425 {
13426 tree s = OMP_CLAUSE_LINEAR_STEP (c);
13427 if (TREE_CODE (s) == PARM_DECL)
13428 {
13429 OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (c) = 1;
13430 /* map_head bitmap is used as uniform_head if
13431 declare_simd. */
13432 if (!bitmap_bit_p (&map_head, DECL_UID (s)))
13433 linear_variable_step_check = true;
13434 goto check_dup_generic;
13435 }
13436 if (TREE_CODE (s) != INTEGER_CST)
13437 {
13438 error_at (OMP_CLAUSE_LOCATION (c),
13439 "%<linear%> clause step %qE is neither constant "
13440 "nor a parameter", s);
13441 remove = true;
13442 break;
13443 }
13444 }
13445 if (TREE_CODE (TREE_TYPE (OMP_CLAUSE_DECL (c))) == POINTER_TYPE)
13446 {
13447 tree s = OMP_CLAUSE_LINEAR_STEP (c);
13448 s = pointer_int_sum (OMP_CLAUSE_LOCATION (c), PLUS_EXPR,
13449 OMP_CLAUSE_DECL (c), s);
13450 s = fold_build2_loc (OMP_CLAUSE_LOCATION (c), MINUS_EXPR,
13451 sizetype, fold_convert (sizetype, s),
13452 fold_convert
13453 (sizetype, OMP_CLAUSE_DECL (c)));
13454 if (s == error_mark_node)
13455 s = size_one_node;
13456 OMP_CLAUSE_LINEAR_STEP (c) = s;
13457 }
13458 else
13459 OMP_CLAUSE_LINEAR_STEP (c)
13460 = fold_convert (TREE_TYPE (t), OMP_CLAUSE_LINEAR_STEP (c));
13461 goto check_dup_generic;
13462
13463 check_dup_generic:
13464 t = OMP_CLAUSE_DECL (c);
13465 check_dup_generic_t:
13466 if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
13467 {
13468 error_at (OMP_CLAUSE_LOCATION (c),
13469 "%qE is not a variable in clause %qs", t,
13470 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13471 remove = true;
13472 }
13473 else if (ort == C_ORT_ACC
13474 && OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION)
13475 {
13476 if (bitmap_bit_p (&oacc_reduction_head, DECL_UID (t)))
13477 {
13478 error ("%qD appears more than once in reduction clauses", t);
13479 remove = true;
13480 }
13481 else
13482 bitmap_set_bit (&oacc_reduction_head, DECL_UID (t));
13483 }
13484 else if (bitmap_bit_p (&generic_head, DECL_UID (t))
13485 || bitmap_bit_p (&firstprivate_head, DECL_UID (t))
13486 || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
13487 {
13488 error_at (OMP_CLAUSE_LOCATION (c),
13489 "%qE appears more than once in data clauses", t);
13490 remove = true;
13491 }
13492 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_PRIVATE
13493 && bitmap_bit_p (&map_head, DECL_UID (t)))
13494 {
13495 if (ort == C_ORT_ACC)
13496 error ("%qD appears more than once in data clauses", t);
13497 else
13498 error ("%qD appears both in data and map clauses", t);
13499 remove = true;
13500 }
13501 else
13502 bitmap_set_bit (&generic_head, DECL_UID (t));
13503 break;
13504
13505 case OMP_CLAUSE_FIRSTPRIVATE:
13506 t = OMP_CLAUSE_DECL (c);
13507 need_complete = true;
13508 need_implicitly_determined = true;
13509 if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
13510 {
13511 error_at (OMP_CLAUSE_LOCATION (c),
13512 "%qE is not a variable in clause %<firstprivate%>", t);
13513 remove = true;
13514 }
13515 else if (bitmap_bit_p (&generic_head, DECL_UID (t))
13516 || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
13517 {
13518 error_at (OMP_CLAUSE_LOCATION (c),
13519 "%qE appears more than once in data clauses", t);
13520 remove = true;
13521 }
13522 else if (bitmap_bit_p (&map_head, DECL_UID (t)))
13523 {
13524 if (ort == C_ORT_ACC)
13525 error ("%qD appears more than once in data clauses", t);
13526 else
13527 error ("%qD appears both in data and map clauses", t);
13528 remove = true;
13529 }
13530 else
13531 bitmap_set_bit (&firstprivate_head, DECL_UID (t));
13532 break;
13533
13534 case OMP_CLAUSE_LASTPRIVATE:
13535 t = OMP_CLAUSE_DECL (c);
13536 need_complete = true;
13537 need_implicitly_determined = true;
13538 if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
13539 {
13540 error_at (OMP_CLAUSE_LOCATION (c),
13541 "%qE is not a variable in clause %<lastprivate%>", t);
13542 remove = true;
13543 }
13544 else if (bitmap_bit_p (&generic_head, DECL_UID (t))
13545 || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
13546 {
13547 error_at (OMP_CLAUSE_LOCATION (c),
13548 "%qE appears more than once in data clauses", t);
13549 remove = true;
13550 }
13551 else
13552 bitmap_set_bit (&lastprivate_head, DECL_UID (t));
13553 break;
13554
13555 case OMP_CLAUSE_ALIGNED:
13556 t = OMP_CLAUSE_DECL (c);
13557 if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
13558 {
13559 error_at (OMP_CLAUSE_LOCATION (c),
13560 "%qE is not a variable in %<aligned%> clause", t);
13561 remove = true;
13562 }
13563 else if (!POINTER_TYPE_P (TREE_TYPE (t))
13564 && TREE_CODE (TREE_TYPE (t)) != ARRAY_TYPE)
13565 {
13566 error_at (OMP_CLAUSE_LOCATION (c),
13567 "%qE in %<aligned%> clause is neither a pointer nor "
13568 "an array", t);
13569 remove = true;
13570 }
13571 else if (TYPE_ATOMIC (TREE_TYPE (t)))
13572 {
13573 error_at (OMP_CLAUSE_LOCATION (c),
13574 "%<_Atomic%> %qD in %<aligned%> clause", t);
13575 remove = true;
13576 break;
13577 }
13578 else if (bitmap_bit_p (&aligned_head, DECL_UID (t)))
13579 {
13580 error_at (OMP_CLAUSE_LOCATION (c),
13581 "%qE appears more than once in %<aligned%> clauses",
13582 t);
13583 remove = true;
13584 }
13585 else
13586 bitmap_set_bit (&aligned_head, DECL_UID (t));
13587 break;
13588
13589 case OMP_CLAUSE_DEPEND:
13590 t = OMP_CLAUSE_DECL (c);
13591 if (t == NULL_TREE)
13592 {
13593 gcc_assert (OMP_CLAUSE_DEPEND_KIND (c)
13594 == OMP_CLAUSE_DEPEND_SOURCE);
13595 break;
13596 }
13597 if (OMP_CLAUSE_DEPEND_KIND (c) == OMP_CLAUSE_DEPEND_SINK)
13598 {
13599 gcc_assert (TREE_CODE (t) == TREE_LIST);
13600 for (; t; t = TREE_CHAIN (t))
13601 {
13602 tree decl = TREE_VALUE (t);
13603 if (TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE)
13604 {
13605 tree offset = TREE_PURPOSE (t);
13606 bool neg = wi::neg_p (wi::to_wide (offset));
13607 offset = fold_unary (ABS_EXPR, TREE_TYPE (offset), offset);
13608 tree t2 = pointer_int_sum (OMP_CLAUSE_LOCATION (c),
13609 neg ? MINUS_EXPR : PLUS_EXPR,
13610 decl, offset);
13611 t2 = fold_build2_loc (OMP_CLAUSE_LOCATION (c), MINUS_EXPR,
13612 sizetype,
13613 fold_convert (sizetype, t2),
13614 fold_convert (sizetype, decl));
13615 if (t2 == error_mark_node)
13616 {
13617 remove = true;
13618 break;
13619 }
13620 TREE_PURPOSE (t) = t2;
13621 }
13622 }
13623 break;
13624 }
13625 if (TREE_CODE (t) == TREE_LIST)
13626 {
13627 if (handle_omp_array_sections (c, ort))
13628 remove = true;
13629 break;
13630 }
13631 if (t == error_mark_node)
13632 remove = true;
13633 else if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
13634 {
13635 error_at (OMP_CLAUSE_LOCATION (c),
13636 "%qE is not a variable in %<depend%> clause", t);
13637 remove = true;
13638 }
13639 else if (!c_mark_addressable (t))
13640 remove = true;
13641 break;
13642
13643 case OMP_CLAUSE_MAP:
13644 case OMP_CLAUSE_TO:
13645 case OMP_CLAUSE_FROM:
13646 case OMP_CLAUSE__CACHE_:
13647 t = OMP_CLAUSE_DECL (c);
13648 if (TREE_CODE (t) == TREE_LIST)
13649 {
13650 if (handle_omp_array_sections (c, ort))
13651 remove = true;
13652 else
13653 {
13654 t = OMP_CLAUSE_DECL (c);
13655 if (!lang_hooks.types.omp_mappable_type (TREE_TYPE (t)))
13656 {
13657 error_at (OMP_CLAUSE_LOCATION (c),
13658 "array section does not have mappable type "
13659 "in %qs clause",
13660 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13661 remove = true;
13662 }
13663 else if (TYPE_ATOMIC (TREE_TYPE (t)))
13664 {
13665 error_at (OMP_CLAUSE_LOCATION (c),
13666 "%<_Atomic%> %qE in %qs clause", t,
13667 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13668 remove = true;
13669 }
13670 while (TREE_CODE (t) == ARRAY_REF)
13671 t = TREE_OPERAND (t, 0);
13672 if (TREE_CODE (t) == COMPONENT_REF
13673 && TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE)
13674 {
13675 while (TREE_CODE (t) == COMPONENT_REF)
13676 t = TREE_OPERAND (t, 0);
13677 if (bitmap_bit_p (&map_field_head, DECL_UID (t)))
13678 break;
13679 if (bitmap_bit_p (&map_head, DECL_UID (t)))
13680 {
13681 if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_MAP)
13682 error ("%qD appears more than once in motion"
13683 " clauses", t);
13684 else if (ort == C_ORT_ACC)
13685 error ("%qD appears more than once in data"
13686 " clauses", t);
13687 else
13688 error ("%qD appears more than once in map"
13689 " clauses", t);
13690 remove = true;
13691 }
13692 else
13693 {
13694 bitmap_set_bit (&map_head, DECL_UID (t));
13695 bitmap_set_bit (&map_field_head, DECL_UID (t));
13696 }
13697 }
13698 }
13699 break;
13700 }
13701 if (t == error_mark_node)
13702 {
13703 remove = true;
13704 break;
13705 }
13706 if (TREE_CODE (t) == COMPONENT_REF
13707 && (ort & C_ORT_OMP)
13708 && OMP_CLAUSE_CODE (c) != OMP_CLAUSE__CACHE_)
13709 {
13710 if (DECL_BIT_FIELD (TREE_OPERAND (t, 1)))
13711 {
13712 error_at (OMP_CLAUSE_LOCATION (c),
13713 "bit-field %qE in %qs clause",
13714 t, omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13715 remove = true;
13716 }
13717 else if (!lang_hooks.types.omp_mappable_type (TREE_TYPE (t)))
13718 {
13719 error_at (OMP_CLAUSE_LOCATION (c),
13720 "%qE does not have a mappable type in %qs clause",
13721 t, omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13722 remove = true;
13723 }
13724 else if (TYPE_ATOMIC (TREE_TYPE (t)))
13725 {
13726 error_at (OMP_CLAUSE_LOCATION (c),
13727 "%<_Atomic%> %qE in %qs clause", t,
13728 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13729 remove = true;
13730 }
13731 while (TREE_CODE (t) == COMPONENT_REF)
13732 {
13733 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0)))
13734 == UNION_TYPE)
13735 {
13736 error_at (OMP_CLAUSE_LOCATION (c),
13737 "%qE is a member of a union", t);
13738 remove = true;
13739 break;
13740 }
13741 t = TREE_OPERAND (t, 0);
13742 }
13743 if (remove)
13744 break;
13745 if (VAR_P (t) || TREE_CODE (t) == PARM_DECL)
13746 {
13747 if (bitmap_bit_p (&map_field_head, DECL_UID (t)))
13748 break;
13749 }
13750 }
13751 if (!VAR_P (t) && TREE_CODE (t) != PARM_DECL)
13752 {
13753 error_at (OMP_CLAUSE_LOCATION (c),
13754 "%qE is not a variable in %qs clause", t,
13755 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13756 remove = true;
13757 }
13758 else if (VAR_P (t) && DECL_THREAD_LOCAL_P (t))
13759 {
13760 error_at (OMP_CLAUSE_LOCATION (c),
13761 "%qD is threadprivate variable in %qs clause", t,
13762 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13763 remove = true;
13764 }
13765 else if ((OMP_CLAUSE_CODE (c) != OMP_CLAUSE_MAP
13766 || (OMP_CLAUSE_MAP_KIND (c)
13767 != GOMP_MAP_FIRSTPRIVATE_POINTER))
13768 && !c_mark_addressable (t))
13769 remove = true;
13770 else if (!(OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
13771 && (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_POINTER
13772 || (OMP_CLAUSE_MAP_KIND (c)
13773 == GOMP_MAP_FIRSTPRIVATE_POINTER)
13774 || (OMP_CLAUSE_MAP_KIND (c)
13775 == GOMP_MAP_FORCE_DEVICEPTR)))
13776 && t == OMP_CLAUSE_DECL (c)
13777 && !lang_hooks.types.omp_mappable_type (TREE_TYPE (t)))
13778 {
13779 error_at (OMP_CLAUSE_LOCATION (c),
13780 "%qD does not have a mappable type in %qs clause", t,
13781 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13782 remove = true;
13783 }
13784 else if (TREE_TYPE (t) == error_mark_node)
13785 remove = true;
13786 else if (TYPE_ATOMIC (strip_array_types (TREE_TYPE (t))))
13787 {
13788 error_at (OMP_CLAUSE_LOCATION (c),
13789 "%<_Atomic%> %qE in %qs clause", t,
13790 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13791 remove = true;
13792 }
13793 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
13794 && OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_FIRSTPRIVATE_POINTER)
13795 {
13796 if (bitmap_bit_p (&generic_head, DECL_UID (t))
13797 || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
13798 {
13799 error ("%qD appears more than once in data clauses", t);
13800 remove = true;
13801 }
13802 else if (bitmap_bit_p (&map_head, DECL_UID (t)))
13803 {
13804 if (ort == C_ORT_ACC)
13805 error ("%qD appears more than once in data clauses", t);
13806 else
13807 error ("%qD appears both in data and map clauses", t);
13808 remove = true;
13809 }
13810 else
13811 bitmap_set_bit (&generic_head, DECL_UID (t));
13812 }
13813 else if (bitmap_bit_p (&map_head, DECL_UID (t)))
13814 {
13815 if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_MAP)
13816 error ("%qD appears more than once in motion clauses", t);
13817 else if (ort == C_ORT_ACC)
13818 error ("%qD appears more than once in data clauses", t);
13819 else
13820 error ("%qD appears more than once in map clauses", t);
13821 remove = true;
13822 }
13823 else if (bitmap_bit_p (&generic_head, DECL_UID (t))
13824 || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
13825 {
13826 if (ort == C_ORT_ACC)
13827 error ("%qD appears more than once in data clauses", t);
13828 else
13829 error ("%qD appears both in data and map clauses", t);
13830 remove = true;
13831 }
13832 else
13833 {
13834 bitmap_set_bit (&map_head, DECL_UID (t));
13835 if (t != OMP_CLAUSE_DECL (c)
13836 && TREE_CODE (OMP_CLAUSE_DECL (c)) == COMPONENT_REF)
13837 bitmap_set_bit (&map_field_head, DECL_UID (t));
13838 }
13839 break;
13840
13841 case OMP_CLAUSE_TO_DECLARE:
13842 case OMP_CLAUSE_LINK:
13843 t = OMP_CLAUSE_DECL (c);
13844 if (TREE_CODE (t) == FUNCTION_DECL
13845 && OMP_CLAUSE_CODE (c) == OMP_CLAUSE_TO_DECLARE)
13846 ;
13847 else if (!VAR_P (t))
13848 {
13849 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_TO_DECLARE)
13850 error_at (OMP_CLAUSE_LOCATION (c),
13851 "%qE is neither a variable nor a function name in "
13852 "clause %qs", t,
13853 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13854 else
13855 error_at (OMP_CLAUSE_LOCATION (c),
13856 "%qE is not a variable in clause %qs", t,
13857 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13858 remove = true;
13859 }
13860 else if (DECL_THREAD_LOCAL_P (t))
13861 {
13862 error_at (OMP_CLAUSE_LOCATION (c),
13863 "%qD is threadprivate variable in %qs clause", t,
13864 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13865 remove = true;
13866 }
13867 else if (!lang_hooks.types.omp_mappable_type (TREE_TYPE (t)))
13868 {
13869 error_at (OMP_CLAUSE_LOCATION (c),
13870 "%qD does not have a mappable type in %qs clause", t,
13871 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13872 remove = true;
13873 }
13874 if (remove)
13875 break;
13876 if (bitmap_bit_p (&generic_head, DECL_UID (t)))
13877 {
13878 error_at (OMP_CLAUSE_LOCATION (c),
13879 "%qE appears more than once on the same "
13880 "%<declare target%> directive", t);
13881 remove = true;
13882 }
13883 else
13884 bitmap_set_bit (&generic_head, DECL_UID (t));
13885 break;
13886
13887 case OMP_CLAUSE_UNIFORM:
13888 t = OMP_CLAUSE_DECL (c);
13889 if (TREE_CODE (t) != PARM_DECL)
13890 {
13891 if (DECL_P (t))
13892 error_at (OMP_CLAUSE_LOCATION (c),
13893 "%qD is not an argument in %<uniform%> clause", t);
13894 else
13895 error_at (OMP_CLAUSE_LOCATION (c),
13896 "%qE is not an argument in %<uniform%> clause", t);
13897 remove = true;
13898 break;
13899 }
13900 /* map_head bitmap is used as uniform_head if declare_simd. */
13901 bitmap_set_bit (&map_head, DECL_UID (t));
13902 goto check_dup_generic;
13903
13904 case OMP_CLAUSE_IS_DEVICE_PTR:
13905 case OMP_CLAUSE_USE_DEVICE_PTR:
13906 t = OMP_CLAUSE_DECL (c);
13907 if (TREE_CODE (TREE_TYPE (t)) != POINTER_TYPE
13908 && TREE_CODE (TREE_TYPE (t)) != ARRAY_TYPE)
13909 {
13910 error_at (OMP_CLAUSE_LOCATION (c),
13911 "%qs variable is neither a pointer nor an array",
13912 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
13913 remove = true;
13914 }
13915 goto check_dup_generic;
13916
13917 case OMP_CLAUSE_NOWAIT:
13918 if (copyprivate_seen)
13919 {
13920 error_at (OMP_CLAUSE_LOCATION (c),
13921 "%<nowait%> clause must not be used together "
13922 "with %<copyprivate%>");
13923 remove = true;
13924 break;
13925 }
13926 nowait_clause = pc;
13927 pc = &OMP_CLAUSE_CHAIN (c);
13928 continue;
13929
13930 case OMP_CLAUSE_IF:
13931 case OMP_CLAUSE_NUM_THREADS:
13932 case OMP_CLAUSE_NUM_TEAMS:
13933 case OMP_CLAUSE_THREAD_LIMIT:
13934 case OMP_CLAUSE_DEFAULT:
13935 case OMP_CLAUSE_UNTIED:
13936 case OMP_CLAUSE_COLLAPSE:
13937 case OMP_CLAUSE_FINAL:
13938 case OMP_CLAUSE_MERGEABLE:
13939 case OMP_CLAUSE_DEVICE:
13940 case OMP_CLAUSE_DIST_SCHEDULE:
13941 case OMP_CLAUSE_PARALLEL:
13942 case OMP_CLAUSE_FOR:
13943 case OMP_CLAUSE_SECTIONS:
13944 case OMP_CLAUSE_TASKGROUP:
13945 case OMP_CLAUSE_PROC_BIND:
13946 case OMP_CLAUSE_PRIORITY:
13947 case OMP_CLAUSE_GRAINSIZE:
13948 case OMP_CLAUSE_NUM_TASKS:
13949 case OMP_CLAUSE_NOGROUP:
13950 case OMP_CLAUSE_THREADS:
13951 case OMP_CLAUSE_SIMD:
13952 case OMP_CLAUSE_HINT:
13953 case OMP_CLAUSE_DEFAULTMAP:
13954 case OMP_CLAUSE_NUM_GANGS:
13955 case OMP_CLAUSE_NUM_WORKERS:
13956 case OMP_CLAUSE_VECTOR_LENGTH:
13957 case OMP_CLAUSE_ASYNC:
13958 case OMP_CLAUSE_WAIT:
13959 case OMP_CLAUSE_AUTO:
13960 case OMP_CLAUSE_INDEPENDENT:
13961 case OMP_CLAUSE_SEQ:
13962 case OMP_CLAUSE_GANG:
13963 case OMP_CLAUSE_WORKER:
13964 case OMP_CLAUSE_VECTOR:
13965 case OMP_CLAUSE_TILE:
13966 pc = &OMP_CLAUSE_CHAIN (c);
13967 continue;
13968
13969 case OMP_CLAUSE_SCHEDULE:
13970 if (OMP_CLAUSE_SCHEDULE_KIND (c) & OMP_CLAUSE_SCHEDULE_NONMONOTONIC)
13971 {
13972 const char *p = NULL;
13973 switch (OMP_CLAUSE_SCHEDULE_KIND (c) & OMP_CLAUSE_SCHEDULE_MASK)
13974 {
13975 case OMP_CLAUSE_SCHEDULE_STATIC: p = "static"; break;
13976 case OMP_CLAUSE_SCHEDULE_DYNAMIC: break;
13977 case OMP_CLAUSE_SCHEDULE_GUIDED: break;
13978 case OMP_CLAUSE_SCHEDULE_AUTO: p = "auto"; break;
13979 case OMP_CLAUSE_SCHEDULE_RUNTIME: p = "runtime"; break;
13980 default: gcc_unreachable ();
13981 }
13982 if (p)
13983 {
13984 error_at (OMP_CLAUSE_LOCATION (c),
13985 "%<nonmonotonic%> modifier specified for %qs "
13986 "schedule kind", p);
13987 OMP_CLAUSE_SCHEDULE_KIND (c)
13988 = (enum omp_clause_schedule_kind)
13989 (OMP_CLAUSE_SCHEDULE_KIND (c)
13990 & ~OMP_CLAUSE_SCHEDULE_NONMONOTONIC);
13991 }
13992 }
13993 schedule_clause = c;
13994 pc = &OMP_CLAUSE_CHAIN (c);
13995 continue;
13996
13997 case OMP_CLAUSE_ORDERED:
13998 ordered_seen = true;
13999 pc = &OMP_CLAUSE_CHAIN (c);
14000 continue;
14001
14002 case OMP_CLAUSE_SAFELEN:
14003 safelen = c;
14004 pc = &OMP_CLAUSE_CHAIN (c);
14005 continue;
14006 case OMP_CLAUSE_SIMDLEN:
14007 simdlen = c;
14008 pc = &OMP_CLAUSE_CHAIN (c);
14009 continue;
14010
14011 case OMP_CLAUSE_INBRANCH:
14012 case OMP_CLAUSE_NOTINBRANCH:
14013 if (branch_seen)
14014 {
14015 error_at (OMP_CLAUSE_LOCATION (c),
14016 "%<inbranch%> clause is incompatible with "
14017 "%<notinbranch%>");
14018 remove = true;
14019 break;
14020 }
14021 branch_seen = true;
14022 pc = &OMP_CLAUSE_CHAIN (c);
14023 continue;
14024
14025 default:
14026 gcc_unreachable ();
14027 }
14028
14029 if (!remove)
14030 {
14031 t = OMP_CLAUSE_DECL (c);
14032
14033 if (need_complete)
14034 {
14035 t = require_complete_type (OMP_CLAUSE_LOCATION (c), t);
14036 if (t == error_mark_node)
14037 remove = true;
14038 }
14039
14040 if (need_implicitly_determined)
14041 {
14042 const char *share_name = NULL;
14043
14044 if (VAR_P (t) && DECL_THREAD_LOCAL_P (t))
14045 share_name = "threadprivate";
14046 else switch (c_omp_predetermined_sharing (t))
14047 {
14048 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
14049 break;
14050 case OMP_CLAUSE_DEFAULT_SHARED:
14051 /* const vars may be specified in firstprivate clause. */
14052 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
14053 && TREE_READONLY (t))
14054 break;
14055 share_name = "shared";
14056 break;
14057 case OMP_CLAUSE_DEFAULT_PRIVATE:
14058 share_name = "private";
14059 break;
14060 default:
14061 gcc_unreachable ();
14062 }
14063 if (share_name)
14064 {
14065 error_at (OMP_CLAUSE_LOCATION (c),
14066 "%qE is predetermined %qs for %qs",
14067 t, share_name,
14068 omp_clause_code_name[OMP_CLAUSE_CODE (c)]);
14069 remove = true;
14070 }
14071 }
14072 }
14073
14074 if (remove)
14075 *pc = OMP_CLAUSE_CHAIN (c);
14076 else
14077 pc = &OMP_CLAUSE_CHAIN (c);
14078 }
14079
14080 if (simdlen
14081 && safelen
14082 && tree_int_cst_lt (OMP_CLAUSE_SAFELEN_EXPR (safelen),
14083 OMP_CLAUSE_SIMDLEN_EXPR (simdlen)))
14084 {
14085 error_at (OMP_CLAUSE_LOCATION (simdlen),
14086 "%<simdlen%> clause value is bigger than "
14087 "%<safelen%> clause value");
14088 OMP_CLAUSE_SIMDLEN_EXPR (simdlen)
14089 = OMP_CLAUSE_SAFELEN_EXPR (safelen);
14090 }
14091
14092 if (ordered_seen
14093 && schedule_clause
14094 && (OMP_CLAUSE_SCHEDULE_KIND (schedule_clause)
14095 & OMP_CLAUSE_SCHEDULE_NONMONOTONIC))
14096 {
14097 error_at (OMP_CLAUSE_LOCATION (schedule_clause),
14098 "%<nonmonotonic%> schedule modifier specified together "
14099 "with %<ordered%> clause");
14100 OMP_CLAUSE_SCHEDULE_KIND (schedule_clause)
14101 = (enum omp_clause_schedule_kind)
14102 (OMP_CLAUSE_SCHEDULE_KIND (schedule_clause)
14103 & ~OMP_CLAUSE_SCHEDULE_NONMONOTONIC);
14104 }
14105
14106 if (linear_variable_step_check)
14107 for (pc = &clauses, c = clauses; c ; c = *pc)
14108 {
14109 bool remove = false;
14110 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LINEAR
14111 && OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (c)
14112 && !bitmap_bit_p (&map_head,
14113 DECL_UID (OMP_CLAUSE_LINEAR_STEP (c))))
14114 {
14115 error_at (OMP_CLAUSE_LOCATION (c),
14116 "%<linear%> clause step is a parameter %qD not "
14117 "specified in %<uniform%> clause",
14118 OMP_CLAUSE_LINEAR_STEP (c));
14119 remove = true;
14120 }
14121
14122 if (remove)
14123 *pc = OMP_CLAUSE_CHAIN (c);
14124 else
14125 pc = &OMP_CLAUSE_CHAIN (c);
14126 }
14127
14128 bitmap_obstack_release (NULL);
14129 return clauses;
14130 }
14131
14132 /* Return code to initialize DST with a copy constructor from SRC.
14133 C doesn't have copy constructors nor assignment operators, only for
14134 _Atomic vars we need to perform __atomic_load from src into a temporary
14135 followed by __atomic_store of the temporary to dst. */
14136
14137 tree
c_omp_clause_copy_ctor(tree clause,tree dst,tree src)14138 c_omp_clause_copy_ctor (tree clause, tree dst, tree src)
14139 {
14140 if (!really_atomic_lvalue (dst) && !really_atomic_lvalue (src))
14141 return build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
14142
14143 location_t loc = OMP_CLAUSE_LOCATION (clause);
14144 tree type = TREE_TYPE (dst);
14145 tree nonatomic_type = build_qualified_type (type, TYPE_UNQUALIFIED);
14146 tree tmp = create_tmp_var (nonatomic_type);
14147 tree tmp_addr = build_fold_addr_expr (tmp);
14148 TREE_ADDRESSABLE (tmp) = 1;
14149 TREE_NO_WARNING (tmp) = 1;
14150 tree src_addr = build_fold_addr_expr (src);
14151 tree dst_addr = build_fold_addr_expr (dst);
14152 tree seq_cst = build_int_cst (integer_type_node, MEMMODEL_SEQ_CST);
14153 vec<tree, va_gc> *params;
14154 /* Expansion of a generic atomic load may require an addition
14155 element, so allocate enough to prevent a resize. */
14156 vec_alloc (params, 4);
14157
14158 /* Build __atomic_load (&src, &tmp, SEQ_CST); */
14159 tree fndecl = builtin_decl_explicit (BUILT_IN_ATOMIC_LOAD);
14160 params->quick_push (src_addr);
14161 params->quick_push (tmp_addr);
14162 params->quick_push (seq_cst);
14163 tree load = c_build_function_call_vec (loc, vNULL, fndecl, params, NULL);
14164
14165 vec_alloc (params, 4);
14166
14167 /* Build __atomic_store (&dst, &tmp, SEQ_CST); */
14168 fndecl = builtin_decl_explicit (BUILT_IN_ATOMIC_STORE);
14169 params->quick_push (dst_addr);
14170 params->quick_push (tmp_addr);
14171 params->quick_push (seq_cst);
14172 tree store = c_build_function_call_vec (loc, vNULL, fndecl, params, NULL);
14173 return build2 (COMPOUND_EXPR, void_type_node, load, store);
14174 }
14175
14176 /* Create a transaction node. */
14177
14178 tree
c_finish_transaction(location_t loc,tree block,int flags)14179 c_finish_transaction (location_t loc, tree block, int flags)
14180 {
14181 tree stmt = build_stmt (loc, TRANSACTION_EXPR, block);
14182 if (flags & TM_STMT_ATTR_OUTER)
14183 TRANSACTION_EXPR_OUTER (stmt) = 1;
14184 if (flags & TM_STMT_ATTR_RELAXED)
14185 TRANSACTION_EXPR_RELAXED (stmt) = 1;
14186 return add_stmt (stmt);
14187 }
14188
14189 /* Make a variant type in the proper way for C/C++, propagating qualifiers
14190 down to the element type of an array. If ORIG_QUAL_TYPE is not
14191 NULL, then it should be used as the qualified type
14192 ORIG_QUAL_INDIRECT levels down in array type derivation (to
14193 preserve information about the typedef name from which an array
14194 type was derived). */
14195
14196 tree
c_build_qualified_type(tree type,int type_quals,tree orig_qual_type,size_t orig_qual_indirect)14197 c_build_qualified_type (tree type, int type_quals, tree orig_qual_type,
14198 size_t orig_qual_indirect)
14199 {
14200 if (type == error_mark_node)
14201 return type;
14202
14203 if (TREE_CODE (type) == ARRAY_TYPE)
14204 {
14205 tree t;
14206 tree element_type = c_build_qualified_type (TREE_TYPE (type),
14207 type_quals, orig_qual_type,
14208 orig_qual_indirect - 1);
14209
14210 /* See if we already have an identically qualified type. */
14211 if (orig_qual_type && orig_qual_indirect == 0)
14212 t = orig_qual_type;
14213 else
14214 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
14215 {
14216 if (TYPE_QUALS (strip_array_types (t)) == type_quals
14217 && TYPE_NAME (t) == TYPE_NAME (type)
14218 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
14219 && attribute_list_equal (TYPE_ATTRIBUTES (t),
14220 TYPE_ATTRIBUTES (type)))
14221 break;
14222 }
14223 if (!t)
14224 {
14225 tree domain = TYPE_DOMAIN (type);
14226
14227 t = build_variant_type_copy (type);
14228 TREE_TYPE (t) = element_type;
14229
14230 if (TYPE_STRUCTURAL_EQUALITY_P (element_type)
14231 || (domain && TYPE_STRUCTURAL_EQUALITY_P (domain)))
14232 SET_TYPE_STRUCTURAL_EQUALITY (t);
14233 else if (TYPE_CANONICAL (element_type) != element_type
14234 || (domain && TYPE_CANONICAL (domain) != domain))
14235 {
14236 tree unqualified_canon
14237 = build_array_type (TYPE_CANONICAL (element_type),
14238 domain? TYPE_CANONICAL (domain)
14239 : NULL_TREE);
14240 if (TYPE_REVERSE_STORAGE_ORDER (type))
14241 {
14242 unqualified_canon
14243 = build_distinct_type_copy (unqualified_canon);
14244 TYPE_REVERSE_STORAGE_ORDER (unqualified_canon) = 1;
14245 }
14246 TYPE_CANONICAL (t)
14247 = c_build_qualified_type (unqualified_canon, type_quals);
14248 }
14249 else
14250 TYPE_CANONICAL (t) = t;
14251 }
14252 return t;
14253 }
14254
14255 /* A restrict-qualified pointer type must be a pointer to object or
14256 incomplete type. Note that the use of POINTER_TYPE_P also allows
14257 REFERENCE_TYPEs, which is appropriate for C++. */
14258 if ((type_quals & TYPE_QUAL_RESTRICT)
14259 && (!POINTER_TYPE_P (type)
14260 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
14261 {
14262 error ("invalid use of %<restrict%>");
14263 type_quals &= ~TYPE_QUAL_RESTRICT;
14264 }
14265
14266 tree var_type = (orig_qual_type && orig_qual_indirect == 0
14267 ? orig_qual_type
14268 : build_qualified_type (type, type_quals));
14269 /* A variant type does not inherit the list of incomplete vars from the
14270 type main variant. */
14271 if (RECORD_OR_UNION_TYPE_P (var_type)
14272 && TYPE_MAIN_VARIANT (var_type) != var_type)
14273 C_TYPE_INCOMPLETE_VARS (var_type) = 0;
14274 return var_type;
14275 }
14276
14277 /* Build a VA_ARG_EXPR for the C parser. */
14278
14279 tree
c_build_va_arg(location_t loc1,tree expr,location_t loc2,tree type)14280 c_build_va_arg (location_t loc1, tree expr, location_t loc2, tree type)
14281 {
14282 if (error_operand_p (type))
14283 return error_mark_node;
14284 /* VA_ARG_EXPR cannot be used for a scalar va_list with reverse storage
14285 order because it takes the address of the expression. */
14286 else if (handled_component_p (expr)
14287 && reverse_storage_order_for_component_p (expr))
14288 {
14289 error_at (loc1, "cannot use %<va_arg%> with reverse storage order");
14290 return error_mark_node;
14291 }
14292 else if (!COMPLETE_TYPE_P (type))
14293 {
14294 error_at (loc2, "second argument to %<va_arg%> is of incomplete "
14295 "type %qT", type);
14296 return error_mark_node;
14297 }
14298 else if (warn_cxx_compat && TREE_CODE (type) == ENUMERAL_TYPE)
14299 warning_at (loc2, OPT_Wc___compat,
14300 "C++ requires promoted type, not enum type, in %<va_arg%>");
14301 return build_va_arg (loc2, expr, type);
14302 }
14303
14304 /* Return truthvalue of whether T1 is the same tree structure as T2.
14305 Return 1 if they are the same. Return false if they are different. */
14306
14307 bool
c_tree_equal(tree t1,tree t2)14308 c_tree_equal (tree t1, tree t2)
14309 {
14310 enum tree_code code1, code2;
14311
14312 if (t1 == t2)
14313 return true;
14314 if (!t1 || !t2)
14315 return false;
14316
14317 for (code1 = TREE_CODE (t1);
14318 CONVERT_EXPR_CODE_P (code1)
14319 || code1 == NON_LVALUE_EXPR;
14320 code1 = TREE_CODE (t1))
14321 t1 = TREE_OPERAND (t1, 0);
14322 for (code2 = TREE_CODE (t2);
14323 CONVERT_EXPR_CODE_P (code2)
14324 || code2 == NON_LVALUE_EXPR;
14325 code2 = TREE_CODE (t2))
14326 t2 = TREE_OPERAND (t2, 0);
14327
14328 /* They might have become equal now. */
14329 if (t1 == t2)
14330 return true;
14331
14332 if (code1 != code2)
14333 return false;
14334
14335 switch (code1)
14336 {
14337 case INTEGER_CST:
14338 return wi::to_wide (t1) == wi::to_wide (t2);
14339
14340 case REAL_CST:
14341 return real_equal (&TREE_REAL_CST (t1), &TREE_REAL_CST (t2));
14342
14343 case STRING_CST:
14344 return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
14345 && !memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
14346 TREE_STRING_LENGTH (t1));
14347
14348 case FIXED_CST:
14349 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1),
14350 TREE_FIXED_CST (t2));
14351
14352 case COMPLEX_CST:
14353 return c_tree_equal (TREE_REALPART (t1), TREE_REALPART (t2))
14354 && c_tree_equal (TREE_IMAGPART (t1), TREE_IMAGPART (t2));
14355
14356 case VECTOR_CST:
14357 return operand_equal_p (t1, t2, OEP_ONLY_CONST);
14358
14359 case CONSTRUCTOR:
14360 /* We need to do this when determining whether or not two
14361 non-type pointer to member function template arguments
14362 are the same. */
14363 if (!comptypes (TREE_TYPE (t1), TREE_TYPE (t2))
14364 || CONSTRUCTOR_NELTS (t1) != CONSTRUCTOR_NELTS (t2))
14365 return false;
14366 {
14367 tree field, value;
14368 unsigned int i;
14369 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1), i, field, value)
14370 {
14371 constructor_elt *elt2 = CONSTRUCTOR_ELT (t2, i);
14372 if (!c_tree_equal (field, elt2->index)
14373 || !c_tree_equal (value, elt2->value))
14374 return false;
14375 }
14376 }
14377 return true;
14378
14379 case TREE_LIST:
14380 if (!c_tree_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)))
14381 return false;
14382 if (!c_tree_equal (TREE_VALUE (t1), TREE_VALUE (t2)))
14383 return false;
14384 return c_tree_equal (TREE_CHAIN (t1), TREE_CHAIN (t2));
14385
14386 case SAVE_EXPR:
14387 return c_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
14388
14389 case CALL_EXPR:
14390 {
14391 tree arg1, arg2;
14392 call_expr_arg_iterator iter1, iter2;
14393 if (!c_tree_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2)))
14394 return false;
14395 for (arg1 = first_call_expr_arg (t1, &iter1),
14396 arg2 = first_call_expr_arg (t2, &iter2);
14397 arg1 && arg2;
14398 arg1 = next_call_expr_arg (&iter1),
14399 arg2 = next_call_expr_arg (&iter2))
14400 if (!c_tree_equal (arg1, arg2))
14401 return false;
14402 if (arg1 || arg2)
14403 return false;
14404 return true;
14405 }
14406
14407 case TARGET_EXPR:
14408 {
14409 tree o1 = TREE_OPERAND (t1, 0);
14410 tree o2 = TREE_OPERAND (t2, 0);
14411
14412 /* Special case: if either target is an unallocated VAR_DECL,
14413 it means that it's going to be unified with whatever the
14414 TARGET_EXPR is really supposed to initialize, so treat it
14415 as being equivalent to anything. */
14416 if (VAR_P (o1) && DECL_NAME (o1) == NULL_TREE
14417 && !DECL_RTL_SET_P (o1))
14418 /*Nop*/;
14419 else if (VAR_P (o2) && DECL_NAME (o2) == NULL_TREE
14420 && !DECL_RTL_SET_P (o2))
14421 /*Nop*/;
14422 else if (!c_tree_equal (o1, o2))
14423 return false;
14424
14425 return c_tree_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
14426 }
14427
14428 case COMPONENT_REF:
14429 if (TREE_OPERAND (t1, 1) != TREE_OPERAND (t2, 1))
14430 return false;
14431 return c_tree_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
14432
14433 case PARM_DECL:
14434 case VAR_DECL:
14435 case CONST_DECL:
14436 case FIELD_DECL:
14437 case FUNCTION_DECL:
14438 case IDENTIFIER_NODE:
14439 case SSA_NAME:
14440 return false;
14441
14442 case TREE_VEC:
14443 {
14444 unsigned ix;
14445 if (TREE_VEC_LENGTH (t1) != TREE_VEC_LENGTH (t2))
14446 return false;
14447 for (ix = TREE_VEC_LENGTH (t1); ix--;)
14448 if (!c_tree_equal (TREE_VEC_ELT (t1, ix),
14449 TREE_VEC_ELT (t2, ix)))
14450 return false;
14451 return true;
14452 }
14453
14454 default:
14455 break;
14456 }
14457
14458 switch (TREE_CODE_CLASS (code1))
14459 {
14460 case tcc_unary:
14461 case tcc_binary:
14462 case tcc_comparison:
14463 case tcc_expression:
14464 case tcc_vl_exp:
14465 case tcc_reference:
14466 case tcc_statement:
14467 {
14468 int i, n = TREE_OPERAND_LENGTH (t1);
14469
14470 switch (code1)
14471 {
14472 case PREINCREMENT_EXPR:
14473 case PREDECREMENT_EXPR:
14474 case POSTINCREMENT_EXPR:
14475 case POSTDECREMENT_EXPR:
14476 n = 1;
14477 break;
14478 case ARRAY_REF:
14479 n = 2;
14480 break;
14481 default:
14482 break;
14483 }
14484
14485 if (TREE_CODE_CLASS (code1) == tcc_vl_exp
14486 && n != TREE_OPERAND_LENGTH (t2))
14487 return false;
14488
14489 for (i = 0; i < n; ++i)
14490 if (!c_tree_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)))
14491 return false;
14492
14493 return true;
14494 }
14495
14496 case tcc_type:
14497 return comptypes (t1, t2);
14498 default:
14499 gcc_unreachable ();
14500 }
14501 /* We can get here with --disable-checking. */
14502 return false;
14503 }
14504
14505 /* Returns true when the function declaration FNDECL is implicit,
14506 introduced as a result of a call to an otherwise undeclared
14507 function, and false otherwise. */
14508
14509 bool
c_decl_implicit(const_tree fndecl)14510 c_decl_implicit (const_tree fndecl)
14511 {
14512 return C_DECL_IMPLICIT (fndecl);
14513 }
14514