1 /* Build expressions with type checking for C compiler.
2 Copyright (C) 1987-2018 Free Software Foundation, Inc.
4 This file is part of GCC.
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
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
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/>. */
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. */
28 #include "coretypes.h"
34 #include "gimple-expr.h"
36 #include "stor-layout.h"
37 #include "trans-mem.h"
40 #include "langhooks.h"
43 #include "tree-iterator.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"
56 /* Possible cases of implicit bad conversions. Used to select
57 diagnostic messages in convert_for_assignment. */
65 /* The level of nesting inside "__alignof__". */
68 /* The level of nesting inside "sizeof". */
71 /* The level of nesting inside "typeof". */
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
;
79 /* Nonzero if we might need to print a "missing braces around
80 initializer" message within this initializer. */
81 static int found_missing_braces
;
83 static int require_constant_value
;
84 static int require_constant_elements
;
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 *,
90 static int comp_target_types (location_t
, tree
, tree
);
91 static int function_types_compatible_p (const_tree
, const_tree
, 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
,
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,
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 *);
123 /* Return true if EXP is a null pointer constant, false otherwise. */
126 null_pointer_constant_p (const_tree expr
)
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
)));
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. */
146 note_integer_operands (tree expr
)
149 if (TREE_CODE (expr
) == INTEGER_CST
&& in_late_binary_op
)
151 ret
= copy_node (expr
);
152 TREE_OVERFLOW (ret
) = 1;
156 ret
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (expr
), NULL_TREE
, expr
);
157 C_MAYBE_CONST_EXPR_INT_OPERANDS (ret
) = 1;
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
168 remove_c_maybe_const_expr (tree expr
)
170 if (TREE_CODE (expr
) == C_MAYBE_CONST_EXPR
)
171 return C_MAYBE_CONST_EXPR_EXPR (expr
);
176 \f/* This is a cache to hold if two types are compatible or not. */
178 struct tagged_tu_seen_cache
{
179 const struct tagged_tu_seen_cache
* next
;
182 /* The return value of tagged_types_tu_compatible_p if we had seen
183 these two types already. */
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
*);
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. */
195 require_complete_type (location_t loc
, tree value
)
197 tree type
= TREE_TYPE (value
);
199 if (error_operand_p (value
))
200 return error_mark_node
;
202 /* First, detect a valid value with a complete type. */
203 if (COMPLETE_TYPE_P (type
))
206 c_incomplete_type_error (loc
, value
, type
);
207 return error_mark_node
;
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
216 c_incomplete_type_error (location_t loc
, const_tree value
, const_tree type
)
218 /* Avoid duplicate error message. */
219 if (TREE_CODE (type
) == ERROR_MARK
)
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
);
227 /* We must print an error message. Be clever about what it says. */
229 switch (TREE_CODE (type
))
237 error_at (loc
, "invalid use of void expression");
241 if (TYPE_DOMAIN (type
))
243 if (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) == NULL
)
245 error_at (loc
, "invalid use of flexible array member");
248 type
= TREE_TYPE (type
);
251 error_at (loc
, "invalid use of array with unspecified bounds");
258 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
259 error_at (loc
, "invalid use of undefined type %qT", type
);
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
);
266 /* Given a type, apply default promotions wrt unnamed function
267 arguments and return the new type. */
270 c_type_promotes_to (tree type
)
272 tree ret
= NULL_TREE
;
274 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
275 ret
= double_type_node
;
276 else if (c_promoting_integer_type_p (type
))
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
;
283 ret
= integer_type_node
;
286 if (ret
!= NULL_TREE
)
287 return (TYPE_ATOMIC (type
)
288 ? c_build_qualified_type (ret
, TYPE_QUAL_ATOMIC
)
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. */
299 addr_space_superset (addr_space_t as1
, addr_space_t as2
, addr_space_t
*common
)
306 else if (targetm
.addr_space
.subset_p (as1
, as2
))
311 else if (targetm
.addr_space
.subset_p (as2
, as1
))
320 /* Return a variant of TYPE which has all the type qualifiers of LIKE
321 as well as those of TYPE. */
324 qualify_type (tree type
, tree like
)
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
;
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
))
335 error ("%qT and %qT are in disjoint named address spaces",
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
));
345 /* Return true iff the given tree T is a variable length array. */
348 c_vla_type_p (const_tree t
)
350 if (TREE_CODE (t
) == ARRAY_TYPE
351 && C_TYPE_VARIABLE_SIZE (t
))
356 /* Return the composite type of two compatible types.
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. */
363 composite_type (tree t1
, tree t2
)
365 enum tree_code code1
;
366 enum tree_code code2
;
369 /* Save time if the two types are the same. */
371 if (t1
== t2
) return t1
;
373 /* If one type is nonsense, use the other. */
374 if (t1
== error_mark_node
)
376 if (t2
== error_mark_node
)
379 code1
= TREE_CODE (t1
);
380 code2
= TREE_CODE (t2
);
382 /* Merge the attributes. */
383 attributes
= targetm
.merge_type_attributes (t1
, t2
);
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. */
390 if (code1
== ENUMERAL_TYPE
&& code2
== INTEGER_TYPE
)
392 if (code2
== ENUMERAL_TYPE
&& code1
== INTEGER_TYPE
)
395 gcc_assert (code1
== code2
);
400 /* For two pointers, do this recursively on the target type. */
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
);
412 tree elt
= composite_type (TREE_TYPE (t1
), TREE_TYPE (t2
));
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
;
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
));
425 t1_complete
= COMPLETE_TYPE_P (t1
);
426 t2_complete
= COMPLETE_TYPE_P (t2
);
428 d1_zero
= d1
== NULL_TREE
|| !TYPE_MAX_VALUE (d1
);
429 d2_zero
= d2
== NULL_TREE
|| !TYPE_MAX_VALUE (d2
);
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
));
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
);
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
);
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
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
)
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
))
473 TYPE_SIZE (t1
) = bitsize_zero_node
;
474 TYPE_SIZE_UNIT (t1
) = size_zero_node
;
476 t1
= c_build_qualified_type (t1
, quals
);
477 return build_type_attribute_variant (t1
, attributes
);
483 if (attributes
!= NULL
)
485 /* Try harder not to create a new aggregate type. */
486 if (attribute_list_equal (TYPE_ATTRIBUTES (t1
), attributes
))
488 if (attribute_list_equal (TYPE_ATTRIBUTES (t2
), attributes
))
491 return build_type_attribute_variant (t1
, attributes
);
494 /* Function types: prefer the one that specified arg types.
495 If both do, merge the arg types. Also merge the return types. */
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
);
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
);
510 /* Simple way if one arg fails to specify argument types. */
511 if (TYPE_ARG_TYPES (t1
) == NULL_TREE
)
513 t1
= build_function_type (valtype
, TYPE_ARG_TYPES (t2
));
514 t1
= build_type_attribute_variant (t1
, attributes
);
515 return qualify_type (t1
, t2
);
517 if (TYPE_ARG_TYPES (t2
) == NULL_TREE
)
519 t1
= build_function_type (valtype
, TYPE_ARG_TYPES (t1
));
520 t1
= build_type_attribute_variant (t1
, attributes
);
521 return qualify_type (t1
, t2
);
524 /* If both args specify argument types, we must merge the two
525 lists, argument by argument. */
527 for (len
= 0, newargs
= p1
;
528 newargs
&& newargs
!= void_list_node
;
529 len
++, newargs
= TREE_CHAIN (newargs
))
532 for (i
= 0; i
< len
; i
++)
533 newargs
= tree_cons (NULL_TREE
, NULL_TREE
, newargs
);
537 for (; p1
&& p1
!= void_list_node
;
538 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
), n
= TREE_CHAIN (n
))
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
)
544 TREE_VALUE (n
) = TREE_VALUE (p2
);
547 if (TREE_VALUE (p2
) == NULL_TREE
)
549 TREE_VALUE (n
) = TREE_VALUE (p1
);
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
))
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
))
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
))
573 TREE_VALUE (n
) = composite_type (TREE_TYPE (memb
),
575 pedwarn (input_location
, OPT_Wpedantic
,
576 "function types not truly compatible in ISO C");
581 if (TREE_CODE (TREE_VALUE (p2
)) == UNION_TYPE
582 && TREE_VALUE (p2
) != TREE_VALUE (p1
))
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
))
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
))
598 TREE_VALUE (n
) = composite_type (TREE_TYPE (memb
),
600 pedwarn (input_location
, OPT_Wpedantic
,
601 "function types not truly compatible in ISO C");
606 TREE_VALUE (n
) = composite_type (TREE_VALUE (p1
), TREE_VALUE (p2
));
610 t1
= build_function_type (valtype
, newargs
);
611 t1
= qualify_type (t1
, t2
);
616 return build_type_attribute_variant (t1
, attributes
);
621 /* Return the type of a conditional expression between pointers to
622 possibly differently qualified versions of compatible types.
624 We assume that comp_target_types has already been done and returned
625 nonzero; if that isn't so, this may crash. */
628 common_pointer_type (tree t1
, tree t2
)
631 tree pointed_to_1
, mv1
;
632 tree pointed_to_2
, mv2
;
634 unsigned target_quals
;
635 addr_space_t as1
, as2
, as_common
;
638 /* Save time if the two types are the same. */
640 if (t1
== t2
) return t1
;
642 /* If one type is nonsense, use the other. */
643 if (t1
== error_mark_node
)
645 if (t2
== error_mark_node
)
648 gcc_assert (TREE_CODE (t1
) == POINTER_TYPE
649 && TREE_CODE (t2
) == POINTER_TYPE
);
651 /* Merge the attributes. */
652 attributes
= targetm
.merge_type_attributes (t1
, t2
);
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
);
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
));
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
);
675 target_quals
= (quals1
| quals2
);
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
))
685 target_quals
|= ENCODE_QUAL_ADDR_SPACE (as_common
);
687 t1
= build_pointer_type (c_build_qualified_type (target
, target_quals
));
688 return build_type_attribute_variant (t1
, attributes
);
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.
696 This is the type for the result of most arithmetic operations
697 if the operands have the given two types. */
700 c_common_type (tree t1
, tree t2
)
702 enum tree_code code1
;
703 enum tree_code code2
;
705 /* If one type is nonsense, use the other. */
706 if (t1
== error_mark_node
)
708 if (t2
== error_mark_node
)
711 if (TYPE_QUALS (t1
) != TYPE_UNQUALIFIED
)
712 t1
= TYPE_MAIN_VARIANT (t1
);
714 if (TYPE_QUALS (t2
) != TYPE_UNQUALIFIED
)
715 t2
= TYPE_MAIN_VARIANT (t2
);
717 if (TYPE_ATTRIBUTES (t1
) != NULL_TREE
)
718 t1
= build_type_attribute_variant (t1
, NULL_TREE
);
720 if (TYPE_ATTRIBUTES (t2
) != NULL_TREE
)
721 t2
= build_type_attribute_variant (t2
, NULL_TREE
);
723 /* Save time if the two types are the same. */
725 if (t1
== t2
) return t1
;
727 code1
= TREE_CODE (t1
);
728 code2
= TREE_CODE (t2
);
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
);
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
740 if ((DECIMAL_FLOAT_TYPE_P (t1
) || DECIMAL_FLOAT_TYPE_P (t2
))
741 && !(DECIMAL_FLOAT_TYPE_P (t1
) && DECIMAL_FLOAT_TYPE_P (t2
)))
743 if (code1
== VECTOR_TYPE
|| code2
== VECTOR_TYPE
)
745 error ("can%'t mix operands of decimal float and vector types");
746 return error_mark_node
;
748 if (code1
== COMPLEX_TYPE
|| code2
== COMPLEX_TYPE
)
750 error ("can%'t mix operands of decimal float and complex types");
751 return error_mark_node
;
753 if (code1
== REAL_TYPE
&& code2
== REAL_TYPE
)
755 error ("can%'t mix operands of decimal float and other float types");
756 return error_mark_node
;
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
)
766 if (code2
== VECTOR_TYPE
)
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
772 if (code1
== COMPLEX_TYPE
|| code2
== COMPLEX_TYPE
)
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
);
778 if (code1
== COMPLEX_TYPE
&& TREE_TYPE (t1
) == subtype
)
780 else if (code2
== COMPLEX_TYPE
&& TREE_TYPE (t2
) == subtype
)
783 return build_complex_type (subtype
);
786 /* If only one is real, use it as the result. */
788 if (code1
== REAL_TYPE
&& code2
!= REAL_TYPE
)
791 if (code2
== REAL_TYPE
&& code1
!= REAL_TYPE
)
794 /* If both are real and either are decimal floating point types, use
795 the decimal floating point type with the greater precision. */
797 if (code1
== REAL_TYPE
&& code2
== REAL_TYPE
)
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
;
810 /* Deal with fixed-point types. */
811 if (code1
== FIXED_POINT_TYPE
|| code2
== FIXED_POINT_TYPE
)
813 unsigned int unsignedp
= 0, satp
= 0;
815 unsigned int fbit1
, ibit1
, fbit2
, ibit2
, max_fbit
, max_ibit
;
817 m1
= SCALAR_TYPE_MODE (t1
);
818 m2
= SCALAR_TYPE_MODE (t2
);
820 /* If one input type is saturating, the result type is saturating. */
821 if (TYPE_SATURATING (t1
) || TYPE_SATURATING (t2
))
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
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
)))
836 /* The result type is signed. */
839 /* If the input type is unsigned, we need to convert to the
841 if (code1
== FIXED_POINT_TYPE
&& TYPE_UNSIGNED (t1
))
843 enum mode_class mclass
= (enum mode_class
) 0;
844 if (GET_MODE_CLASS (m1
) == MODE_UFRACT
)
846 else if (GET_MODE_CLASS (m1
) == MODE_UACCUM
)
850 m1
= as_a
<scalar_mode
>
851 (mode_for_size (GET_MODE_PRECISION (m1
), mclass
, 0));
853 if (code2
== FIXED_POINT_TYPE
&& TYPE_UNSIGNED (t2
))
855 enum mode_class mclass
= (enum mode_class
) 0;
856 if (GET_MODE_CLASS (m2
) == MODE_UFRACT
)
858 else if (GET_MODE_CLASS (m2
) == MODE_UACCUM
)
862 m2
= as_a
<scalar_mode
>
863 (mode_for_size (GET_MODE_PRECISION (m2
), mclass
, 0));
867 if (code1
== FIXED_POINT_TYPE
)
869 fbit1
= GET_MODE_FBIT (m1
);
870 ibit1
= GET_MODE_IBIT (m1
);
875 /* Signed integers need to subtract one sign bit. */
876 ibit1
= TYPE_PRECISION (t1
) - (!TYPE_UNSIGNED (t1
));
879 if (code2
== FIXED_POINT_TYPE
)
881 fbit2
= GET_MODE_FBIT (m2
);
882 ibit2
= GET_MODE_IBIT (m2
);
887 /* Signed integers need to subtract one sign bit. */
888 ibit2
= TYPE_PRECISION (t2
) - (!TYPE_UNSIGNED (t2
));
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
,
897 /* Both real or both integers; use the one with greater precision. */
899 if (TYPE_PRECISION (t1
) > TYPE_PRECISION (t2
))
901 else if (TYPE_PRECISION (t2
) > TYPE_PRECISION (t1
))
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). */
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
;
912 if (TYPE_MAIN_VARIANT (t1
) == long_long_integer_type_node
913 || TYPE_MAIN_VARIANT (t2
) == long_long_integer_type_node
)
915 if (TYPE_UNSIGNED (t1
) || TYPE_UNSIGNED (t2
))
916 return long_long_unsigned_type_node
;
918 return long_long_integer_type_node
;
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
;
925 if (TYPE_MAIN_VARIANT (t1
) == long_integer_type_node
926 || TYPE_MAIN_VARIANT (t2
) == long_integer_type_node
)
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
;
933 return long_integer_type_node
;
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
947 tree mv1
= TYPE_MAIN_VARIANT (t1
);
948 tree mv2
= TYPE_MAIN_VARIANT (t2
);
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
);
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
;
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
;
964 if (mv1
== float_type_node
|| mv2
== float_type_node
)
965 return float_type_node
;
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
);
971 /* Otherwise prefer the unsigned one. */
973 if (TYPE_UNSIGNED (t1
))
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. */
985 common_type (tree t1
, tree t2
)
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);
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
;
997 /* If either type is BOOLEAN_TYPE, then return the other. */
998 if (TREE_CODE (t1
) == BOOLEAN_TYPE
)
1000 if (TREE_CODE (t2
) == BOOLEAN_TYPE
)
1003 return c_common_type (t1
, t2
);
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. */
1011 comptypes (tree type1
, tree type2
)
1013 const struct tagged_tu_seen_cache
* tagged_tu_seen_base1
= tagged_tu_seen_base
;
1016 val
= comptypes_internal (type1
, type2
, NULL
, NULL
);
1017 free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1
);
1022 /* Like comptypes, but if it returns non-zero because enum and int are
1023 compatible, it sets *ENUM_AND_INT_P to true. */
1026 comptypes_check_enum_int (tree type1
, tree type2
, bool *enum_and_int_p
)
1028 const struct tagged_tu_seen_cache
* tagged_tu_seen_base1
= tagged_tu_seen_base
;
1031 val
= comptypes_internal (type1
, type2
, enum_and_int_p
, NULL
);
1032 free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1
);
1037 /* Like comptypes, but if it returns nonzero for different types, it
1038 sets *DIFFERENT_TYPES_P to true. */
1041 comptypes_check_different_types (tree type1
, tree type2
,
1042 bool *different_types_p
)
1044 const struct tagged_tu_seen_cache
* tagged_tu_seen_base1
= tagged_tu_seen_base
;
1047 val
= comptypes_internal (type1
, type2
, NULL
, different_types_p
);
1048 free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1
);
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
1067 comptypes_internal (const_tree type1
, const_tree type2
, bool *enum_and_int_p
,
1068 bool *different_types_p
)
1070 const_tree t1
= type1
;
1071 const_tree t2
= type2
;
1074 /* Suppress errors caused by previously reported errors. */
1076 if (t1
== t2
|| !t1
|| !t2
1077 || TREE_CODE (t1
) == ERROR_MARK
|| TREE_CODE (t2
) == ERROR_MARK
)
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. */
1084 if (TREE_CODE (t1
) == ENUMERAL_TYPE
&& TREE_CODE (t2
) != ENUMERAL_TYPE
)
1086 t1
= c_common_type_for_size (TYPE_PRECISION (t1
), TYPE_UNSIGNED (t1
));
1087 if (TREE_CODE (t2
) != VOID_TYPE
)
1089 if (enum_and_int_p
!= NULL
)
1090 *enum_and_int_p
= true;
1091 if (different_types_p
!= NULL
)
1092 *different_types_p
= true;
1095 else if (TREE_CODE (t2
) == ENUMERAL_TYPE
&& TREE_CODE (t1
) != ENUMERAL_TYPE
)
1097 t2
= c_common_type_for_size (TYPE_PRECISION (t2
), TYPE_UNSIGNED (t2
));
1098 if (TREE_CODE (t1
) != VOID_TYPE
)
1100 if (enum_and_int_p
!= NULL
)
1101 *enum_and_int_p
= true;
1102 if (different_types_p
!= NULL
)
1103 *different_types_p
= true;
1110 /* Different classes of types can't be compatible. */
1112 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1115 /* Qualifiers must match. C99 6.7.3p9 */
1117 if (TYPE_QUALS (t1
) != TYPE_QUALS (t2
))
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). */
1124 if (TREE_CODE (t1
) != ARRAY_TYPE
1125 && TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
1128 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1129 if (!(attrval
= comp_type_attributes (t1
, t2
)))
1132 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1135 switch (TREE_CODE (t1
))
1138 case FIXED_POINT_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
1149 typedef int INT __attribute((may_alias));
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
);
1157 /* Do not remove mode information. */
1158 if (TYPE_MODE (t1
) != TYPE_MODE (t2
))
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
));
1166 val
= function_types_compatible_p (t1
, t2
, enum_and_int_p
,
1172 tree d1
= TYPE_DOMAIN (t1
);
1173 tree d2
= TYPE_DOMAIN (t2
);
1174 bool d1_variable
, d2_variable
;
1175 bool d1_zero
, d2_zero
;
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
),
1182 different_types_p
)) == 0)
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
)
1192 d1_zero
= !TYPE_MAX_VALUE (d1
);
1193 d2_zero
= !TYPE_MAX_VALUE (d2
);
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
));
1204 if (different_types_p
!= NULL
1205 && d1_variable
!= d2_variable
)
1206 *different_types_p
= true;
1207 if (d1_variable
|| d2_variable
)
1209 if (d1_zero
&& d2_zero
)
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
)))
1222 if (val
!= 1 && !same_translation_unit_p (t1
, t2
))
1224 tree a1
= TYPE_ATTRIBUTES (t1
);
1225 tree a2
= TYPE_ATTRIBUTES (t2
);
1227 if (! attribute_list_contained (a1
, a2
)
1228 && ! attribute_list_contained (a2
, a1
))
1232 return tagged_types_tu_compatible_p (t1
, t2
, enum_and_int_p
,
1234 val
= tagged_types_tu_compatible_p (t1
, t2
, enum_and_int_p
,
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
));
1248 return attrval
== 2 && val
== 1 ? 2 : val
;
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. */
1257 comp_target_types (location_t location
, tree ttl
, tree ttr
)
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
;
1268 /* Fail if pointers point to incompatible address spaces. */
1269 if (!addr_space_superset (asl
, asr
, &as_common
))
1272 /* For pedantic record result of comptypes on arrays before losing
1273 qualifiers on the element type below. */
1276 if (TREE_CODE (mvl
) == ARRAY_TYPE
1277 && TREE_CODE (mvr
) == ARRAY_TYPE
)
1278 val_ped
= comptypes (mvl
, mvr
);
1280 /* Qualifiers on element types of array types that are
1281 pointer targets are lost by taking their TYPE_MAIN_VARIANT. */
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
));
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
));
1291 enum_and_int_p
= false;
1292 val
= comptypes_check_enum_int (mvl
, mvr
, &enum_and_int_p
);
1294 if (val
== 1 && val_ped
!= 1)
1295 pedwarn (location
, OPT_Wpedantic
, "pointers to arrays with different qualifiers "
1296 "are incompatible in ISO C");
1299 pedwarn (location
, OPT_Wpedantic
, "types are not quite compatible");
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++");
1308 /* Subroutines of `comptypes'. */
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. */
1316 same_translation_unit_p (const_tree t1
, const_tree t2
)
1318 while (t1
&& TREE_CODE (t1
) != TRANSLATION_UNIT_DECL
)
1319 switch (TREE_CODE_CLASS (TREE_CODE (t1
)))
1321 case tcc_declaration
:
1322 t1
= DECL_CONTEXT (t1
); break;
1324 t1
= TYPE_CONTEXT (t1
); break;
1325 case tcc_exceptional
:
1326 t1
= BLOCK_SUPERCONTEXT (t1
); break; /* assume block */
1327 default: gcc_unreachable ();
1330 while (t2
&& TREE_CODE (t2
) != TRANSLATION_UNIT_DECL
)
1331 switch (TREE_CODE_CLASS (TREE_CODE (t2
)))
1333 case tcc_declaration
:
1334 t2
= DECL_CONTEXT (t2
); break;
1336 t2
= TYPE_CONTEXT (t2
); break;
1337 case tcc_exceptional
:
1338 t2
= BLOCK_SUPERCONTEXT (t2
); break; /* assume block */
1339 default: gcc_unreachable ();
1345 /* Allocate the seen two types, assuming that they are compatible. */
1347 static struct tagged_tu_seen_cache
*
1348 alloc_tagged_tu_seen_cache (const_tree t1
, const_tree t2
)
1350 struct tagged_tu_seen_cache
*tu
= XNEW (struct tagged_tu_seen_cache
);
1351 tu
->next
= tagged_tu_seen_base
;
1355 tagged_tu_seen_base
= tu
;
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:
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
1373 /* Free the seen types until we get to TU_TIL. */
1376 free_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache
*tu_til
)
1378 const struct tagged_tu_seen_cache
*tu
= tagged_tu_seen_base
;
1379 while (tu
!= tu_til
)
1381 const struct tagged_tu_seen_cache
*const tu1
1382 = (const struct tagged_tu_seen_cache
*) tu
;
1384 free (CONST_CAST (struct tagged_tu_seen_cache
*, tu1
));
1386 tagged_tu_seen_base
= tu_til
;
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. */
1397 tagged_types_tu_compatible_p (const_tree t1
, const_tree t2
,
1398 bool *enum_and_int_p
, bool *different_types_p
)
1401 bool needs_warning
= false;
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
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
));
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
));
1419 /* C90 didn't have the requirement that the two tags be the same. */
1420 if (flag_isoc99
&& TYPE_NAME (t1
) != TYPE_NAME (t2
))
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
1426 if (TYPE_SIZE (t1
) == NULL
1427 || TYPE_SIZE (t2
) == NULL
)
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
)
1437 switch (TREE_CODE (t1
))
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
);
1451 for (;tv1
&& tv2
; tv1
= TREE_CHAIN (tv1
), tv2
= TREE_CHAIN (tv2
))
1453 if (TREE_PURPOSE (tv1
) != TREE_PURPOSE (tv2
))
1455 if (simple_cst_equal (TREE_VALUE (tv1
), TREE_VALUE (tv2
)) != 1)
1462 if (tv1
== NULL_TREE
&& tv2
== NULL_TREE
)
1466 if (tv1
== NULL_TREE
|| tv2
== NULL_TREE
)
1472 if (list_length (TYPE_VALUES (t1
)) != list_length (TYPE_VALUES (t2
)))
1478 for (s1
= TYPE_VALUES (t1
); s1
; s1
= TREE_CHAIN (s1
))
1480 s2
= purpose_member (TREE_PURPOSE (s1
), TYPE_VALUES (t2
));
1482 || simple_cst_equal (TREE_VALUE (s1
), TREE_VALUE (s2
)) != 1)
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
)))
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
))
1506 if (DECL_NAME (s1
) != DECL_NAME (s2
))
1508 result
= comptypes_internal (TREE_TYPE (s1
), TREE_TYPE (s2
),
1509 enum_and_int_p
, different_types_p
);
1511 if (result
!= 1 && !DECL_NAME (s1
))
1519 needs_warning
= true;
1521 if (TREE_CODE (s1
) == FIELD_DECL
1522 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1
),
1523 DECL_FIELD_BIT_OFFSET (s2
)) != 1)
1531 tu
->val
= needs_warning
? 2 : 1;
1535 for (s1
= TYPE_FIELDS (t1
); s1
; s1
= DECL_CHAIN (s1
))
1539 for (s2
= TYPE_FIELDS (t2
); s2
; s2
= DECL_CHAIN (s2
))
1540 if (DECL_NAME (s1
) == DECL_NAME (s2
))
1544 result
= comptypes_internal (TREE_TYPE (s1
), TREE_TYPE (s2
),
1548 if (result
!= 1 && !DECL_NAME (s1
))
1556 needs_warning
= true;
1558 if (TREE_CODE (s1
) == FIELD_DECL
1559 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1
),
1560 DECL_FIELD_BIT_OFFSET (s2
)) != 1)
1572 tu
->val
= needs_warning
? 2 : 10;
1578 struct tagged_tu_seen_cache
*tu
= alloc_tagged_tu_seen_cache (t1
, t2
);
1580 for (s1
= TYPE_FIELDS (t1
), s2
= TYPE_FIELDS (t2
);
1582 s1
= DECL_CHAIN (s1
), s2
= DECL_CHAIN (s2
))
1585 if (TREE_CODE (s1
) != TREE_CODE (s2
)
1586 || DECL_NAME (s1
) != DECL_NAME (s2
))
1588 result
= comptypes_internal (TREE_TYPE (s1
), TREE_TYPE (s2
),
1589 enum_and_int_p
, different_types_p
);
1593 needs_warning
= true;
1595 if (TREE_CODE (s1
) == FIELD_DECL
1596 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1
),
1597 DECL_FIELD_BIT_OFFSET (s2
)) != 1)
1603 tu
->val
= needs_warning
? 2 : 1;
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. */
1621 function_types_compatible_p (const_tree f1
, const_tree f2
,
1622 bool *enum_and_int_p
, bool *different_types_p
)
1625 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1630 ret1
= TREE_TYPE (f1
);
1631 ret2
= TREE_TYPE (f2
);
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
);
1647 args1
= TYPE_ARG_TYPES (f1
);
1648 args2
= TYPE_ARG_TYPES (f2
);
1650 if (different_types_p
!= NULL
1651 && (args1
== NULL_TREE
) != (args2
== NULL_TREE
))
1652 *different_types_p
= true;
1654 /* An unspecified parmlist matches any specified parmlist
1655 whose argument types don't need default promotions. */
1657 if (args1
== NULL_TREE
)
1659 if (!self_promoting_args_p (args2
))
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)
1670 if (args2
== NULL_TREE
)
1672 if (!self_promoting_args_p (args1
))
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)
1681 /* Both types have argument lists: compare them and propagate results. */
1682 val1
= type_lists_compatible_p (args1
, args2
, enum_and_int_p
,
1684 return val1
!= 1 ? val1
: val
;
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. */
1693 type_lists_compatible_p (const_tree args1
, const_tree args2
,
1694 bool *enum_and_int_p
, bool *different_types_p
)
1696 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1702 tree a1
, mv1
, a2
, mv2
;
1703 if (args1
== NULL_TREE
&& args2
== NULL_TREE
)
1705 /* If one list is shorter than the other,
1706 they fail to match. */
1707 if (args1
== NULL_TREE
|| args2
== NULL_TREE
)
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
),
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
),
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
)
1730 if (c_type_promotes_to (a2
) != a2
)
1733 else if (a2
== NULL_TREE
)
1735 if (c_type_promotes_to (a1
) != a1
)
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
)
1742 else if (!(newval
= comptypes_internal (mv1
, mv2
, enum_and_int_p
,
1743 different_types_p
)))
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
),
1757 for (memb
= TYPE_FIELDS (a1
);
1758 memb
; memb
= DECL_CHAIN (memb
))
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
),
1766 : TYPE_MAIN_VARIANT (mv3
));
1767 if (comptypes_internal (mv3
, mv2
, enum_and_int_p
,
1771 if (memb
== NULL_TREE
)
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
),
1782 for (memb
= TYPE_FIELDS (a2
);
1783 memb
; memb
= DECL_CHAIN (memb
))
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
),
1791 : TYPE_MAIN_VARIANT (mv3
));
1792 if (comptypes_internal (mv3
, mv1
, enum_and_int_p
,
1796 if (memb
== NULL_TREE
)
1803 /* comptypes said ok, but record if it said to warn. */
1807 args1
= TREE_CHAIN (args1
);
1808 args2
= TREE_CHAIN (args2
);
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
1818 c_size_in_bytes (const_tree type
)
1820 enum tree_code code
= TREE_CODE (type
);
1822 if (code
== FUNCTION_TYPE
|| code
== VOID_TYPE
|| code
== ERROR_MARK
1823 || !COMPLETE_TYPE_P (type
))
1824 return size_one_node
;
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
)
1832 /* Return either DECL or its known constant value (if it has one). */
1835 decl_constant_value_1 (tree decl
, bool in_init
)
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
);
1853 /* Return either DECL or its known constant value (if it has one).
1854 Like the above, but always return decl outside of functions. */
1857 decl_constant_value (tree decl
)
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
;
1864 /* Convert the array expression EXP to a pointer. */
1866 array_to_pointer_conversion (location_t loc
, tree exp
)
1868 tree orig_exp
= exp
;
1869 tree type
= TREE_TYPE (exp
);
1871 tree restype
= TREE_TYPE (type
);
1874 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
1876 STRIP_TYPE_NOPS (exp
);
1878 if (TREE_NO_WARNING (orig_exp
))
1879 TREE_NO_WARNING (exp
) = 1;
1881 ptrtype
= build_pointer_type (restype
);
1883 if (INDIRECT_REF_P (exp
))
1884 return convert (ptrtype
, TREE_OPERAND (exp
, 0));
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
)
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++");
1898 adr
= build_unary_op (loc
, ADDR_EXPR
, exp
, true);
1899 return convert (ptrtype
, adr
);
1902 /* Convert the function expression EXP to a pointer. */
1904 function_to_pointer_conversion (location_t loc
, tree exp
)
1906 tree orig_exp
= exp
;
1908 gcc_assert (TREE_CODE (TREE_TYPE (exp
)) == FUNCTION_TYPE
);
1910 STRIP_TYPE_NOPS (exp
);
1912 if (TREE_NO_WARNING (orig_exp
))
1913 TREE_NO_WARNING (exp
) = 1;
1915 return build_unary_op (loc
, ADDR_EXPR
, exp
, false);
1918 /* Mark EXP as read, not just set, for set but not used -Wunused
1919 warning purposes. */
1922 mark_exp_read (tree exp
)
1924 switch (TREE_CODE (exp
))
1928 DECL_READ_P (exp
) = 1;
1937 case VIEW_CONVERT_EXPR
:
1938 mark_exp_read (TREE_OPERAND (exp
, 0));
1941 case C_MAYBE_CONST_EXPR
:
1942 mark_exp_read (TREE_OPERAND (exp
, 1));
1949 /* Perform the default conversion of arrays and functions to pointers.
1950 Return the result of converting EXP. For any other expression, just
1953 LOC is the location of the expression. */
1956 default_function_array_conversion (location_t loc
, struct c_expr exp
)
1958 tree orig_exp
= exp
.value
;
1959 tree type
= TREE_TYPE (exp
.value
);
1960 enum tree_code code
= TREE_CODE (type
);
1966 bool not_lvalue
= false;
1967 bool lvalue_array_p
;
1969 while ((TREE_CODE (exp
.value
) == NON_LVALUE_EXPR
1970 || CONVERT_EXPR_P (exp
.value
))
1971 && TREE_TYPE (TREE_OPERAND (exp
.value
, 0)) == type
)
1973 if (TREE_CODE (exp
.value
) == NON_LVALUE_EXPR
)
1975 exp
.value
= TREE_OPERAND (exp
.value
, 0);
1978 if (TREE_NO_WARNING (orig_exp
))
1979 TREE_NO_WARNING (exp
.value
) = 1;
1981 lvalue_array_p
= !not_lvalue
&& lvalue_p (exp
.value
);
1982 if (!flag_isoc99
&& !lvalue_array_p
)
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. */
1991 exp
.value
= array_to_pointer_conversion (loc
, exp
.value
);
1995 exp
.value
= function_to_pointer_conversion (loc
, exp
.value
);
2005 default_function_array_read_conversion (location_t loc
, struct c_expr exp
)
2007 mark_exp_read (exp
.value
);
2008 return default_function_array_conversion (loc
, exp
);
2011 /* Return whether EXPR should be treated as an atomic lvalue for the
2012 purposes of load and store handling. */
2015 really_atomic_lvalue (tree expr
)
2017 if (error_operand_p (expr
))
2019 if (!TYPE_ATOMIC (TREE_TYPE (expr
)))
2021 if (!lvalue_p (expr
))
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
))
2033 if (TREE_CODE (expr
) == COMPONENT_REF
2034 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
2036 expr
= TREE_OPERAND (expr
, 0);
2038 if (DECL_P (expr
) && C_DECL_REGISTER (expr
))
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. */
2048 convert_lvalue_to_rvalue (location_t loc
, struct c_expr exp
,
2049 bool convert_p
, bool read_p
)
2052 mark_exp_read (exp
.value
);
2054 exp
= default_function_array_conversion (loc
, exp
);
2055 if (really_atomic_lvalue (exp
.value
))
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
);
2063 gcc_assert (TYPE_ATOMIC (expr_type
));
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);
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;
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
);
2084 /* EXPR is always read. */
2085 mark_exp_read (exp
.value
);
2087 /* Return tmp which contains the value loaded. */
2088 exp
.value
= build4 (TARGET_EXPR
, nonatomic_type
, tmp
, func_call
,
2089 NULL_TREE
, NULL_TREE
);
2094 /* EXP is an expression of integer type. Apply the integer promotions
2095 to it and return the promoted value. */
2098 perform_integral_promotions (tree exp
)
2100 tree type
= TREE_TYPE (exp
);
2101 enum tree_code code
= TREE_CODE (type
);
2103 gcc_assert (INTEGRAL_TYPE_P (type
));
2105 /* Normally convert enums to int,
2106 but convert wide enums to something wider. */
2107 if (code
== ENUMERAL_TYPE
)
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
)));
2115 return convert (type
, exp
);
2118 /* ??? This should no longer be needed now bit-fields have their
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
);
2128 if (c_promoting_integer_type_p (type
))
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
);
2135 return convert (integer_type_node
, exp
);
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. */
2147 default_conversion (tree exp
)
2150 tree type
= TREE_TYPE (exp
);
2151 enum tree_code code
= TREE_CODE (type
);
2154 mark_exp_read (exp
);
2156 /* Functions and arrays have been converted during parsing. */
2157 gcc_assert (code
!= FUNCTION_TYPE
);
2158 if (code
== ARRAY_TYPE
)
2161 /* Constants can be used directly unless they're not loadable. */
2162 if (TREE_CODE (exp
) == CONST_DECL
)
2163 exp
= DECL_INITIAL (exp
);
2165 /* Strip no-op conversions. */
2167 STRIP_TYPE_NOPS (exp
);
2169 if (TREE_NO_WARNING (orig_exp
))
2170 TREE_NO_WARNING (exp
) = 1;
2172 if (code
== VOID_TYPE
)
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
;
2179 exp
= require_complete_type (EXPR_LOC_OR_LOC (exp
, input_location
), exp
);
2180 if (exp
== error_mark_node
)
2181 return error_mark_node
;
2183 promoted_type
= targetm
.promoted_type (type
);
2185 return convert (promoted_type
, exp
);
2187 if (INTEGRAL_TYPE_P (type
))
2188 return perform_integral_promotions (exp
);
2193 /* Look up COMPONENT in a structure or union TYPE.
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. */
2203 lookup_field (tree type
, tree component
)
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. */
2212 if (TYPE_LANG_SPECIFIC (type
) && TYPE_LANG_SPECIFIC (type
)->s
)
2215 tree
*field_array
= &TYPE_LANG_SPECIFIC (type
)->s
->elts
[0];
2217 field
= TYPE_FIELDS (type
);
2219 top
= TYPE_LANG_SPECIFIC (type
)->s
->len
;
2220 while (top
- bot
> 1)
2222 half
= (top
- bot
+ 1) >> 1;
2223 field
= field_array
[bot
+half
];
2225 if (DECL_NAME (field
) == NULL_TREE
)
2227 /* Step through all anon unions in linear fashion. */
2228 while (DECL_NAME (field_array
[bot
]) == NULL_TREE
)
2230 field
= field_array
[bot
++];
2231 if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (field
)))
2233 tree anon
= lookup_field (TREE_TYPE (field
), component
);
2236 return tree_cons (NULL_TREE
, field
, anon
);
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
)))
2245 && (DECL_NAME (TYPE_NAME (TREE_TYPE (field
)))
2251 /* Entire record is only anon unions. */
2255 /* Restart the binary search, with new lower bound. */
2259 if (DECL_NAME (field
) == component
)
2261 if (DECL_NAME (field
) < component
)
2267 if (DECL_NAME (field_array
[bot
]) == component
)
2268 field
= field_array
[bot
];
2269 else if (DECL_NAME (field
) != component
)
2274 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
2276 if (DECL_NAME (field
) == NULL_TREE
2277 && RECORD_OR_UNION_TYPE_P (TREE_TYPE (field
)))
2279 tree anon
= lookup_field (TREE_TYPE (field
), component
);
2282 return tree_cons (NULL_TREE
, field
, anon
);
2284 /* The Plan 9 compiler permits referring directly to an
2285 anonymous struct/union field using a typedef
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
)))
2295 if (DECL_NAME (field
) == component
)
2299 if (field
== NULL_TREE
)
2303 return tree_cons (NULL_TREE
, field
, NULL_TREE
);
2306 /* Recursively append candidate IDENTIFIER_NODEs to CANDIDATES. */
2309 lookup_field_fuzzy_find_candidates (tree type
, tree component
,
2310 vec
<tree
> *candidates
)
2313 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
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
,
2320 if (DECL_NAME (field
))
2321 candidates
->safe_push (DECL_NAME (field
));
2325 /* Like "lookup_field", but find the closest matching IDENTIFIER_NODE,
2326 rather than returning a TREE_LIST for an exact match. */
2329 lookup_field_fuzzy (tree type
, tree component
)
2331 gcc_assert (TREE_CODE (component
) == IDENTIFIER_NODE
);
2333 /* First, gather a list of candidates. */
2334 auto_vec
<tree
> candidates
;
2336 lookup_field_fuzzy_find_candidates (type
, component
,
2339 return find_closest_identifier (component
, &candidates
);
2342 /* Support function for build_component_ref's error-handling.
2344 Given DATUM_TYPE, and "DATUM.COMPONENT", where DATUM is *not* a
2345 struct or union, should we suggest "DATUM->COMPONENT" as a hint? */
2348 should_suggest_deref_p (tree datum_type
)
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 ())
2356 /* Only suggest it for pointers... */
2357 if (TREE_CODE (datum_type
) != POINTER_TYPE
)
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
)
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
2375 build_component_ref (location_t loc
, tree datum
, tree component
,
2376 location_t component_loc
)
2378 tree type
= TREE_TYPE (datum
);
2379 enum tree_code code
= TREE_CODE (type
);
2382 bool datum_lvalue
= lvalue_p (datum
);
2384 if (!objc_is_public (datum
, component
))
2385 return error_mark_node
;
2387 /* Detect Objective-C property syntax object.property. */
2388 if (c_dialect_objc ()
2389 && (ref
= objc_maybe_build_component_ref (datum
, component
)))
2392 /* See if there is a field or component with name COMPONENT. */
2394 if (code
== RECORD_TYPE
|| code
== UNION_TYPE
)
2396 if (!COMPLETE_TYPE_P (type
))
2398 c_incomplete_type_error (loc
, NULL_TREE
, type
);
2399 return error_mark_node
;
2402 field
= lookup_field (type
, component
);
2406 tree guessed_id
= lookup_field_fuzzy (type
, component
);
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
);
2421 error_at (loc
, "%qT has no member named %qE", type
, component
);
2422 return error_mark_node
;
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)
2429 if (code
== RECORD_TYPE
)
2430 warning_at (loc
, 0, "accessing a member %qE of an atomic "
2431 "structure %qE", component
, datum
);
2433 warning_at (loc
, 0, "accessing a member %qE of an atomic "
2434 "union %qE", component
, datum
);
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. */
2444 tree subdatum
= TREE_VALUE (field
);
2447 bool use_datum_quals
;
2449 if (TREE_TYPE (subdatum
) == error_mark_node
)
2450 return error_mark_node
;
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
);
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
);
2464 ref
= build3 (COMPONENT_REF
, subtype
, datum
, subdatum
,
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;
2474 if (TREE_DEPRECATED (subdatum
))
2475 warn_deprecated_use (subdatum
, NULL_TREE
);
2479 field
= TREE_CHAIN (field
);
2485 else if (should_suggest_deref_p (type
))
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 ("->");
2493 "%qE is a pointer; did you mean to use %<->%>?",
2495 return error_mark_node
;
2497 else if (code
!= ERROR_MARK
)
2499 "request for member %qE in something not a structure or union",
2502 return error_mark_node
;
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.
2509 LOC is the location to use for the generated tree. */
2512 build_indirect_ref (location_t loc
, tree ptr
, ref_operator errstring
)
2514 tree pointer
= default_conversion (ptr
);
2515 tree type
= TREE_TYPE (pointer
);
2518 if (TREE_CODE (type
) == POINTER_TYPE
)
2520 if (CONVERT_EXPR_P (pointer
)
2521 || TREE_CODE (pointer
) == VIEW_CONVERT_EXPR
)
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;
2532 if (TREE_CODE (pointer
) == ADDR_EXPR
2533 && (TREE_TYPE (TREE_OPERAND (pointer
, 0))
2534 == TREE_TYPE (type
)))
2536 ref
= TREE_OPERAND (pointer
, 0);
2537 protected_set_expr_location (ref
, loc
);
2542 tree t
= TREE_TYPE (type
);
2544 ref
= build1 (INDIRECT_REF
, t
, pointer
);
2546 if (!COMPLETE_OR_VOID_TYPE_P (t
) && TREE_CODE (t
) != ARRAY_TYPE
)
2548 if (!C_TYPE_ERROR_REPORTED (TREE_TYPE (ptr
)))
2550 error_at (loc
, "dereferencing pointer to incomplete type "
2552 C_TYPE_ERROR_REPORTED (TREE_TYPE (ptr
)) = 1;
2554 return error_mark_node
;
2556 if (VOID_TYPE_P (t
) && c_inhibit_evaluation_warnings
== 0)
2557 warning_at (loc
, 0, "dereferencing %<void *%> pointer");
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
);
2574 else if (TREE_CODE (pointer
) != ERROR_MARK
)
2575 invalid_indirection_error (loc
, type
, errstring
);
2577 return error_mark_node
;
2580 /* This handles expressions of the form "a[i]", which denotes
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
2589 For vector types, allow vector[i] but not i[vector], and create
2590 *(((type*)&vectortype) + i) for the expression.
2592 LOC is the location to use for the returned expression. */
2595 build_array_ref (location_t loc
, tree array
, tree index
)
2598 bool swapped
= false;
2599 if (TREE_TYPE (array
) == error_mark_node
2600 || TREE_TYPE (index
) == error_mark_node
)
2601 return error_mark_node
;
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
)))
2608 if (TREE_CODE (TREE_TYPE (index
)) != ARRAY_TYPE
2609 && TREE_CODE (TREE_TYPE (index
)) != POINTER_TYPE
)
2612 "subscripted value is neither array nor pointer nor vector");
2614 return error_mark_node
;
2616 std::swap (array
, index
);
2620 if (!INTEGRAL_TYPE_P (TREE_TYPE (index
)))
2622 error_at (loc
, "array subscript is not an integer");
2623 return error_mark_node
;
2626 if (TREE_CODE (TREE_TYPE (TREE_TYPE (array
))) == FUNCTION_TYPE
)
2628 error_at (loc
, "subscripted value is pointer to function");
2629 return error_mark_node
;
2632 /* ??? Existing practice has been to warn only when the char
2633 index is syntactically the index, not for char[array]. */
2635 warn_array_subscript_with_type_char (loc
, index
);
2637 /* Apply default promotions *after* noticing character types. */
2638 index
= default_conversion (index
);
2639 if (index
== error_mark_node
)
2640 return error_mark_node
;
2642 gcc_assert (TREE_CODE (TREE_TYPE (index
)) == INTEGER_TYPE
);
2644 bool was_vector
= VECTOR_TYPE_P (TREE_TYPE (array
));
2645 bool non_lvalue
= convert_vector_to_array_for_subscript (loc
, &array
, index
);
2647 if (TREE_CODE (TREE_TYPE (array
)) == ARRAY_TYPE
)
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
))
2659 if (!c_mark_addressable (array
, true))
2660 return error_mark_node
;
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
))))
2670 if (!c_mark_addressable (array
))
2671 return error_mark_node
;
2674 if ((pedantic
|| warn_c90_c99_compat
)
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 "
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
);
2709 ret
= non_lvalue_loc (loc
, ret
);
2714 tree ar
= default_conversion (array
);
2716 if (ar
== error_mark_node
)
2719 gcc_assert (TREE_CODE (TREE_TYPE (ar
)) == POINTER_TYPE
);
2720 gcc_assert (TREE_CODE (TREE_TYPE (TREE_TYPE (ar
))) != FUNCTION_TYPE
);
2722 ret
= build_indirect_ref (loc
, build_binary_op (loc
, PLUS_EXPR
, ar
,
2726 ret
= non_lvalue_loc (loc
, ret
);
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. */
2738 build_external_ref (location_t loc
, tree id
, bool fun
, tree
*type
)
2741 tree decl
= lookup_name (id
);
2743 /* In Objective-C, an instance variable (ivar) may be preferred to
2744 whatever lookup_name() found. */
2745 decl
= objc_lookup_ivar (decl
, id
);
2748 if (decl
&& decl
!= error_mark_node
)
2751 *type
= TREE_TYPE (ref
);
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
;
2762 undeclared_variable (loc
, id
);
2763 return error_mark_node
;
2766 if (TREE_TYPE (ref
) == error_mark_node
)
2767 return error_mark_node
;
2769 if (TREE_DEPRECATED (ref
))
2770 warn_deprecated_use (ref
, NULL_TREE
);
2772 /* Recursive call does not count as usage. */
2773 if (ref
!= current_function_decl
)
2775 TREE_USED (ref
) = 1;
2778 if (TREE_CODE (ref
) == FUNCTION_DECL
&& !in_alignof
)
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
);
2788 if (TREE_CODE (ref
) == CONST_DECL
)
2790 used_types_insert (TREE_TYPE (ref
));
2793 && TREE_CODE (TREE_TYPE (ref
)) == ENUMERAL_TYPE
2794 && C_TYPE_DEFINED_IN_STRUCT (TREE_TYPE (ref
)))
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");
2802 ref
= DECL_INITIAL (ref
);
2803 TREE_CONSTANT (ref
) = 1;
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
))
2810 tree context
= decl_function_context (ref
);
2812 if (context
!= NULL_TREE
&& context
!= current_function_decl
)
2813 DECL_NONLOCAL (ref
) = 1;
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
,
2831 /* Record details of decls possibly used inside sizeof or typeof. */
2832 struct maybe_used_decl
2836 /* The level seen at (in_sizeof + in_typeof). */
2838 /* The next one at this level or above, or NULL. */
2839 struct maybe_used_decl
*next
;
2842 static struct maybe_used_decl
*maybe_used_decls
;
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
2850 record_maybe_used_decl (tree decl
)
2852 struct maybe_used_decl
*t
= XOBNEW (&parser_obstack
, struct maybe_used_decl
);
2854 t
->level
= in_sizeof
+ in_typeof
;
2855 t
->next
= maybe_used_decls
;
2856 maybe_used_decls
= t
;
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). */
2865 pop_maybe_used (bool used
)
2867 struct maybe_used_decl
*p
= maybe_used_decls
;
2868 int cur_level
= in_sizeof
+ in_typeof
;
2869 while (p
&& p
->level
> cur_level
)
2874 C_DECL_USED (p
->decl
) = 1;
2876 p
->level
= cur_level
;
2880 if (!used
|| cur_level
== 0)
2881 maybe_used_decls
= p
;
2884 /* Return the result of sizeof applied to EXPR. */
2887 c_expr_sizeof_expr (location_t loc
, struct c_expr expr
)
2890 if (expr
.value
== error_mark_node
)
2892 ret
.value
= error_mark_node
;
2893 ret
.original_code
= ERROR_MARK
;
2894 ret
.original_type
= NULL
;
2895 pop_maybe_used (false);
2899 bool expr_const_operands
= true;
2901 if (TREE_CODE (expr
.value
) == PARM_DECL
2902 && C_ARRAY_PARAMETER (expr
.value
))
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");
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
)))
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
);
2925 pop_maybe_used (C_TYPE_VARIABLE_SIZE (TREE_TYPE (folded_expr
)));
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. */
2935 c_expr_sizeof_type (location_t loc
, struct c_type_name
*t
)
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
))
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. */
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
;
2963 pop_maybe_used (type
!= error_mark_node
2964 ? C_TYPE_VARIABLE_SIZE (type
) : false);
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. */
2975 build_function_call (location_t loc
, tree function
, tree params
)
2977 vec
<tree
, va_gc
> *v
;
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
);
2988 /* Give a note about the location of the declaration of DECL. */
2991 inform_declaration (tree decl
)
2993 if (decl
&& (TREE_CODE (decl
) != FUNCTION_DECL
|| !DECL_IS_BUILTIN (decl
)))
2994 inform (DECL_SOURCE_LOCATION (decl
), "declared here");
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
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
)
3010 tree fntype
, fundecl
= NULL_TREE
;
3011 tree name
= NULL_TREE
, result
;
3017 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
3018 STRIP_TYPE_NOPS (function
);
3020 /* Convert anything with function type to a pointer-to-function. */
3021 if (TREE_CODE (function
) == FUNCTION_DECL
)
3023 name
= DECL_NAME (function
);
3026 tm_malloc_replacement (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))
3033 if (TREE_CODE (TREE_TYPE (function
)) == FUNCTION_TYPE
)
3034 function
= function_to_pointer_conversion (loc
, function
);
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]);
3041 function
= c_fully_fold (function
, false, NULL
);
3043 fntype
= TREE_TYPE (function
);
3045 if (TREE_CODE (fntype
) == ERROR_MARK
)
3046 return error_mark_node
;
3048 if (!(TREE_CODE (fntype
) == POINTER_TYPE
3049 && TREE_CODE (TREE_TYPE (fntype
)) == FUNCTION_TYPE
))
3051 if (!flag_diagnostics_show_caret
)
3053 "called object %qE is not a function or function pointer",
3055 else if (DECL_P (function
))
3058 "called object %qD is not a function or function pointer",
3060 inform_declaration (function
);
3064 "called object is not a function or function pointer");
3065 return error_mark_node
;
3068 if (fundecl
&& TREE_THIS_VOLATILE (fundecl
))
3069 current_function_returns_abnormally
= 1;
3071 /* fntype now gets the type of function pointed to. */
3072 fntype
= TREE_TYPE (fntype
);
3074 /* Convert the parameters to the types declared in the
3075 function prototype, or apply default promotions. */
3077 nargs
= convert_arguments (loc
, arg_loc
, TYPE_ARG_TYPES (fntype
), params
,
3078 origtypes
, function
, fundecl
);
3080 return error_mark_node
;
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
)))
3089 tree return_type
= TREE_TYPE (fntype
);
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");
3096 if (VOID_TYPE_P (return_type
)
3097 && TYPE_QUALS (return_type
) != TYPE_UNQUALIFIED
)
3099 "function with qualified void return type called");
3102 argarray
= vec_safe_address (params
);
3104 /* Check that arguments to builtin functions match the expectations. */
3106 && DECL_BUILT_IN (fundecl
)
3107 && DECL_BUILT_IN_CLASS (fundecl
) == BUILT_IN_NORMAL
3108 && !check_builtin_function_arguments (loc
, arg_loc
, fundecl
, nargs
,
3110 return error_mark_node
;
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
);
3116 if (name
!= NULL_TREE
3117 && !strncmp (IDENTIFIER_POINTER (name
), "__builtin_", 10))
3119 if (require_constant_value
)
3121 = fold_build_call_array_initializer_loc (loc
, TREE_TYPE (fntype
),
3122 function
, nargs
, argarray
);
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
);
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
3135 if (warned_p
&& TREE_CODE (result
) == CALL_EXPR
)
3136 TREE_NO_WARNING (result
) = 1;
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
))
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
);
3148 if (VOID_TYPE_P (TREE_TYPE (result
)))
3150 if (TYPE_QUALS (TREE_TYPE (result
)) != TYPE_UNQUALIFIED
)
3152 "function with qualified void return type called");
3155 return require_complete_type (loc
, result
);
3158 /* Like build_function_call_vec, but call also resolve_overloaded_builtin. */
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
)
3165 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
3166 STRIP_TYPE_NOPS (function
);
3168 /* Convert anything with function type to a pointer-to-function. */
3169 if (TREE_CODE (function
) == FUNCTION_DECL
)
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
);
3179 return build_function_call_vec (loc
, arg_loc
, function
, params
, origtypes
);
3182 /* Convert the argument expressions in the vector VALUES
3183 to the types in the list TYPELIST.
3185 If TYPELIST is exhausted, or when an element has NULL as its type,
3186 perform the default conversions.
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.
3192 FUNCTION is a tree for the called function. It is used only for
3193 error messages, where it is formatted with %qE.
3195 This is also where warnings about wrong number of args are generated.
3197 ARG_LOC are locations of function arguments (if any).
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
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
)
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;
3217 /* Change pointer to function to the function itself for
3219 if (TREE_CODE (function
) == ADDR_EXPR
3220 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
3221 function
= TREE_OPERAND (function
, 0);
3223 /* Handle an ObjC selector specially for diagnostics. */
3224 selector
= objc_message_selector ();
3226 /* For type-generic built-in functions, determine whether excess
3227 precision should be removed (classification) or not
3230 && DECL_BUILT_IN (fundecl
)
3231 && DECL_BUILT_IN_CLASS (fundecl
) == BUILT_IN_NORMAL
)
3233 switch (DECL_FUNCTION_CODE (fundecl
))
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;
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;
3257 /* Scan the given expressions and types, producing individual
3258 converted arguments. */
3260 for (typetail
= typelist
, parmnum
= 0;
3261 values
&& values
->iterate (parmnum
, &val
);
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;
3272 /* Some __atomic_* builtins have additional hidden argument at
3275 = !arg_loc
.is_empty () && values
->length () == arg_loc
.length ()
3276 ? expansion_point_location_if_in_system_header (arg_loc
[parmnum
])
3279 if (type
== void_type_node
)
3282 error_at (loc
, "too many arguments to method %qE", selector
);
3284 error_at (loc
, "too many arguments to function %qE", function
);
3285 inform_declaration (fundecl
);
3286 return error_args
? -1 : (int) parmnum
;
3289 if (selector
&& argnum
> 2)
3295 npc
= null_pointer_constant_p (val
);
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
3303 if (TREE_CODE (val
) == EXCESS_PRECISION_EXPR
3304 && (type
|| !type_generic
|| !type_generic_remove_excess_precision
))
3306 val
= TREE_OPERAND (val
, 0);
3307 excess_precision
= true;
3309 val
= c_fully_fold (val
, false, NULL
);
3310 STRIP_TYPE_NOPS (val
);
3312 val
= require_complete_type (ploc
, val
);
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
)))
3327 /* Promote this argument, unless it has a _FloatN or
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
))
3333 promote_float_arg
= false;
3338 if (type
!= NULL_TREE
)
3340 /* Formal parm type is specified by a function prototype. */
3342 if (type
== error_mark_node
|| !COMPLETE_TYPE_P (type
))
3344 error_at (ploc
, "type of formal parameter %d is incomplete",
3352 /* Optionally warn about conversions that
3353 differ from the default conversions. */
3354 if (warn_traditional_conversion
|| warn_traditional
)
3356 unsigned int formal_prec
= TYPE_PRECISION (type
);
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",
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",
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",
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",
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",
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",
3394 /* ??? At some point, messages should be written about
3395 conversions between complex types, but that's too messy
3397 else if (TREE_CODE (type
) == REAL_TYPE
3398 && TREE_CODE (valtype
) == REAL_TYPE
)
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",
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
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
)
3421 <= TYPE_PRECISION (valtype
)
3422 || (type
== dfloat128_type_node
3424 != dfloat64_type_node
3426 != dfloat32_type_node
)))
3427 || (type
== dfloat64_type_node
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
);
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
))
3443 tree would_have_been
= default_conversion (val
);
3444 tree type1
= TREE_TYPE (would_have_been
);
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. */
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",
3459 else if (TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (type1
))
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
)
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. */
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
))
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",
3484 warning_at (ploc
, OPT_Wtraditional_conversion
,
3485 "passing argument %d of %qE "
3486 "as signed due to prototype",
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
,
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
);
3507 else if (promote_float_arg
)
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
);
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
3528 parmval
= convert (valtype
, val
);
3529 else if ((invalid_func_diag
=
3530 targetm
.calls
.invalid_arg_for_unprototyped_fn (typelist
, fundecl
, val
)))
3532 error (invalid_func_diag
);
3535 else if (TREE_CODE (val
) == ADDR_EXPR
&& reject_gcc_builtin (val
))
3540 /* Convert `short' and `char' to full-size `int'. */
3541 parmval
= default_conversion (val
);
3543 (*values
)[parmnum
] = parmval
;
3544 if (parmval
== error_mark_node
)
3548 typetail
= TREE_CHAIN (typetail
);
3551 gcc_assert (parmnum
== vec_safe_length (values
));
3553 if (typetail
!= NULL_TREE
&& TREE_VALUE (typetail
) != void_type_node
)
3555 error_at (loc
, "too few arguments to function %qE", function
);
3556 inform_declaration (fundecl
);
3560 return error_args
? -1 : (int) parmnum
;
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.
3568 LOC is the location to use for the tree generated.
3572 parser_build_unary_op (location_t loc
, enum tree_code code
, struct c_expr arg
)
3574 struct c_expr result
;
3576 result
.original_code
= code
;
3577 result
.original_type
= NULL
;
3579 if (reject_gcc_builtin (arg
.value
))
3581 result
.value
= error_mark_node
;
3585 result
.value
= build_unary_op (loc
, code
, arg
.value
, false);
3587 if (TREE_OVERFLOW_P (result
.value
) && !TREE_OVERFLOW_P (arg
.value
))
3588 overflow_warning (loc
, result
.value
, arg
.value
);
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 ());
3600 /* Returns true if TYPE is a character type, *not* including wchar_t. */
3603 char_type_p (tree type
)
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
);
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.
3618 LOCATION is the location of the binary operator. */
3621 parser_build_binary_op (location_t location
, enum tree_code code
,
3622 struct c_expr arg1
, struct c_expr arg2
)
3624 struct c_expr result
;
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
));
3635 result
.value
= build_binary_op (location
, code
,
3636 arg1
.value
, arg2
.value
, true);
3637 result
.original_code
= code
;
3638 result
.original_type
= NULL
;
3640 if (TREE_CODE (result
.value
) == ERROR_MARK
)
3642 set_c_expr_source_range (&result
,
3644 arg2
.get_finish ());
3648 if (location
!= UNKNOWN_LOCATION
)
3649 protected_set_expr_location (result
.value
, location
);
3651 set_c_expr_source_range (&result
,
3653 arg2
.get_finish ());
3655 /* Check for cases such as x+y<<z which users are likely
3657 if (warn_parentheses
)
3658 warn_about_parentheses (location
, code
, code1
, arg1
.value
, code2
,
3661 if (warn_logical_op
)
3662 warn_logical_operator (location
, code
, TREE_TYPE (result
.value
),
3663 code1
, arg1
.value
, code2
, arg2
.value
);
3665 if (warn_tautological_compare
)
3667 tree lhs
= arg1
.value
;
3668 tree rhs
= arg2
.value
;
3669 if (TREE_CODE (lhs
) == C_MAYBE_CONST_EXPR
)
3671 if (C_MAYBE_CONST_EXPR_PRE (lhs
) != NULL_TREE
3672 && TREE_SIDE_EFFECTS (C_MAYBE_CONST_EXPR_PRE (lhs
)))
3675 lhs
= C_MAYBE_CONST_EXPR_EXPR (lhs
);
3677 if (TREE_CODE (rhs
) == C_MAYBE_CONST_EXPR
)
3679 if (C_MAYBE_CONST_EXPR_PRE (rhs
) != NULL_TREE
3680 && TREE_SIDE_EFFECTS (C_MAYBE_CONST_EXPR_PRE (rhs
)))
3683 rhs
= C_MAYBE_CONST_EXPR_EXPR (rhs
);
3685 if (lhs
!= NULL_TREE
&& rhs
!= NULL_TREE
)
3686 warn_tautological_cmp (location
, code
, lhs
, rhs
);
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))))
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
)
3703 t
= TREE_OPERAND (arg1
.value
, 0);
3706 if (TREE_TYPE (t
) != integer_type_node
)
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);
3717 if (TREE_CODE (TREE_TYPE (t
)) != BOOLEAN_TYPE
)
3718 warn_logical_not_parentheses (location
, code
, arg1
.value
, arg2
.value
);
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
)
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 "
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 "
3745 inform (arg2
.get_start (), "did you mean to dereference the pointer?");
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");
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
);
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",
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. */
3775 pointer_diff (location_t loc
, tree op0
, tree op1
, tree
*instrument_expr
)
3777 tree restype
= ptrdiff_type_node
;
3778 tree result
, inttype
;
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
;
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. */
3790 addr_space_t as_common
;
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
))
3799 common_type
= common_pointer_type (TREE_TYPE (op0
), TREE_TYPE (op1
));
3800 op0
= convert (common_type
, op0
);
3801 op1
= convert (common_type
, op1
);
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);
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");
3819 if (sanitize_flags_p (SANITIZE_POINTER_SUBTRACT
))
3821 gcc_assert (current_function_decl
!= NULL_TREE
);
3823 op0
= save_expr (op0
);
3824 op1
= save_expr (op1
);
3826 tree tt
= builtin_decl_explicit (BUILT_IN_ASAN_POINTER_SUBTRACT
);
3827 *instrument_expr
= build_call_expr_loc (loc
, tt
, 2, op0
, op1
);
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. */
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);
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
);
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");
3854 op1
= c_size_in_bytes (target_type
);
3856 if (pointer_to_zero_sized_aggr_p (TREE_TYPE (orig_op1
)))
3857 error_at (loc
, "arithmetic on pointer to an empty aggregate");
3859 /* Divide by the size, in easiest possible way. */
3860 result
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, inttype
,
3861 op0
, convert (inttype
, op1
));
3863 /* Convert to final result type if necessary. */
3864 return convert (restype
, result
);
3867 /* Expand atomic compound assignments into an appropriate sequence as
3868 specified by the C11 standard section 6.5.16.2.
3874 This sequence is used for all types for which these operations are
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.
3889 __atomic_load (addr, &old, SEQ_CST);
3890 feholdexcept (&fenv);
3892 newval = old op val;
3893 if (__atomic_compare_exchange_strong (addr, &old, &newval, SEQ_CST,
3896 feclearexcept (FE_ALL_EXCEPT);
3899 feupdateenv (&fenv);
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.
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
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
3921 build_atomic_assign (location_t loc
, tree lhs
, enum tree_code modifycode
,
3922 tree rhs
, bool return_old_p
)
3924 tree fndecl
, func_call
;
3925 vec
<tree
, va_gc
> *params
;
3926 tree val
, nonatomic_lhs_type
, nonatomic_rhs_type
, newval
, newval_addr
;
3929 tree stmt
, goto_stmt
;
3930 tree loop_label
, loop_decl
, done_label
, done_decl
;
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
;
3939 gcc_assert (TYPE_ATOMIC (lhs_type
));
3942 gcc_assert (modifycode
== PLUS_EXPR
|| modifycode
== MINUS_EXPR
);
3944 /* Allocate enough vector items for a compare_exchange. */
3945 vec_alloc (params
, 6);
3947 /* Create a compound statement to hold the sequence of statements
3949 compound_stmt
= c_begin_compound_stmt (false);
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
)
3955 gcc_assert (modifycode
!= NOP_EXPR
);
3956 rhs
= TREE_OPERAND (rhs
, 0);
3958 rhs_type
= TREE_TYPE (rhs
);
3960 /* Fold the RHS if it hasn't already been folded. */
3961 if (modifycode
!= NOP_EXPR
)
3962 rhs
= c_fully_fold (rhs
, false, NULL
);
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
,
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
,
3975 SET_EXPR_LOCATION (rhs
, loc
);
3978 /* NOP_EXPR indicates it's a straight store of the RHS. Simply issue
3980 if (modifycode
== NOP_EXPR
)
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
);
3991 /* Finish the compound statement. */
3992 compound_stmt
= c_end_compound_stmt (loc
, compound_stmt
, false);
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
);
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
)
4005 built_in_function fncode
;
4009 case POINTER_PLUS_EXPR
:
4010 fncode
= (return_old_p
4011 ? BUILT_IN_ATOMIC_FETCH_ADD_N
4012 : BUILT_IN_ATOMIC_ADD_FETCH_N
);
4015 fncode
= (return_old_p
4016 ? BUILT_IN_ATOMIC_FETCH_SUB_N
4017 : BUILT_IN_ATOMIC_SUB_FETCH_N
);
4020 fncode
= (return_old_p
4021 ? BUILT_IN_ATOMIC_FETCH_AND_N
4022 : BUILT_IN_ATOMIC_AND_FETCH_N
);
4025 fncode
= (return_old_p
4026 ? BUILT_IN_ATOMIC_FETCH_OR_N
4027 : BUILT_IN_ATOMIC_OR_FETCH_N
);
4030 fncode
= (return_old_p
4031 ? BUILT_IN_ATOMIC_FETCH_XOR_N
4032 : BUILT_IN_ATOMIC_XOR_FETCH_N
);
4038 /* We can only use "_1" through "_16" variants of the atomic fetch
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)
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
))
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
))
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
));
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
);
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
);
4077 /* Finish the compound statement. */
4078 compound_stmt
= c_end_compound_stmt (loc
, compound_stmt
, false);
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
);
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;
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;
4097 loop_decl
= create_artificial_label (loc
);
4098 loop_label
= build1 (LABEL_EXPR
, void_type_node
, loop_decl
);
4100 done_decl
= create_artificial_label (loc
);
4101 done_label
= build1 (LABEL_EXPR
, void_type_node
, done_decl
);
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
,
4112 params
->truncate (0);
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
;
4120 targetm
.atomic_assign_expand_fenv (&hold_call
, &clear_call
, &update_call
);
4123 add_stmt (hold_call
);
4126 add_stmt (loop_label
);
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
)
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
);
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
,
4143 if (rhs
!= error_mark_node
)
4145 rhs
= build4 (TARGET_EXPR
, nonatomic_lhs_type
, newval
, rhs
, NULL_TREE
,
4147 SET_EXPR_LOCATION (rhs
, loc
);
4151 /* if (__atomic_compare_exchange (addr, &old, &new, false, SEQ_CST, SEQ_CST))
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
);
4162 goto_stmt
= build1 (GOTO_EXPR
, void_type_node
, done_decl
);
4163 SET_EXPR_LOCATION (goto_stmt
, loc
);
4165 stmt
= build3 (COND_EXPR
, void_type_node
, func_call
, goto_stmt
, NULL_TREE
);
4166 SET_EXPR_LOCATION (stmt
, loc
);
4170 add_stmt (clear_call
);
4173 goto_stmt
= build1 (GOTO_EXPR
, void_type_node
, loop_decl
);
4174 SET_EXPR_LOCATION (goto_stmt
, loc
);
4175 add_stmt (goto_stmt
);
4178 add_stmt (done_label
);
4181 add_stmt (update_call
);
4183 /* Finish the compound statement. */
4184 compound_stmt
= c_end_compound_stmt (loc
, compound_stmt
, false);
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
);
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
4201 LOCATION is the location of the operator. */
4204 build_unary_op (location_t location
, enum tree_code code
, tree xarg
,
4207 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
4209 tree argtype
= NULL_TREE
;
4210 enum tree_code typecode
;
4212 tree ret
= error_mark_node
;
4213 tree eptype
= NULL_TREE
;
4214 const char *invalid_op_diag
;
4217 int_operands
= EXPR_INT_CONST_OPERANDS (xarg
);
4219 arg
= remove_c_maybe_const_expr (arg
);
4221 if (code
!= ADDR_EXPR
)
4222 arg
= require_complete_type (location
, arg
);
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
;
4230 if ((invalid_op_diag
4231 = targetm
.invalid_unary_op (code
, TREE_TYPE (xarg
))))
4233 error_at (location
, invalid_op_diag
);
4234 return error_mark_node
;
4237 if (TREE_CODE (arg
) == EXCESS_PRECISION_EXPR
)
4239 eptype
= TREE_TYPE (arg
);
4240 arg
= TREE_OPERAND (arg
, 0);
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
))
4253 error_at (location
, "wrong type argument to unary plus");
4254 return error_mark_node
;
4256 else if (!noconvert
)
4257 arg
= default_conversion (arg
);
4258 arg
= non_lvalue_loc (location
, arg
);
4262 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
4263 || typecode
== FIXED_POINT_TYPE
|| typecode
== COMPLEX_TYPE
4264 || typecode
== VECTOR_TYPE
))
4266 error_at (location
, "wrong type argument to unary minus");
4267 return error_mark_node
;
4269 else if (!noconvert
)
4270 arg
= default_conversion (arg
);
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
))))
4281 /* Warn if the expression has boolean value. */
4282 while (TREE_CODE (e
) == COMPOUND_EXPR
)
4283 e
= TREE_OPERAND (e
, 1);
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"))
4290 gcc_rich_location
richloc (location
);
4291 richloc
.add_fixit_insert_before (location
, "!");
4292 inform (&richloc
, "did you mean to use logical not?");
4295 arg
= default_conversion (arg
);
4297 else if (typecode
== COMPLEX_TYPE
)
4300 pedwarn (location
, OPT_Wpedantic
,
4301 "ISO C does not support %<~%> for complex conjugation");
4303 arg
= default_conversion (arg
);
4307 error_at (location
, "wrong type argument to bit-complement");
4308 return error_mark_node
;
4313 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
))
4315 error_at (location
, "wrong type argument to abs");
4316 return error_mark_node
;
4318 else if (!noconvert
)
4319 arg
= default_conversion (arg
);
4323 if (!(typecode
== INTEGER_TYPE
))
4325 error_at (location
, "wrong type argument to absu");
4326 return error_mark_node
;
4328 else if (!noconvert
)
4329 arg
= default_conversion (arg
);
4333 /* Conjugating a real value is a no-op, but allow it anyway. */
4334 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
4335 || typecode
== COMPLEX_TYPE
))
4337 error_at (location
, "wrong type argument to conjugation");
4338 return error_mark_node
;
4340 else if (!noconvert
)
4341 arg
= default_conversion (arg
);
4344 case TRUTH_NOT_EXPR
:
4345 if (typecode
!= INTEGER_TYPE
&& typecode
!= FIXED_POINT_TYPE
4346 && typecode
!= REAL_TYPE
&& typecode
!= POINTER_TYPE
4347 && typecode
!= COMPLEX_TYPE
)
4350 "wrong type argument to unary exclamation mark");
4351 return error_mark_node
;
4355 arg
= c_objc_common_truthvalue_conversion (location
, xarg
);
4356 arg
= remove_c_maybe_const_expr (arg
);
4359 arg
= c_objc_common_truthvalue_conversion (location
, arg
);
4360 ret
= invert_truthvalue_loc (location
, arg
);
4361 /* If the TRUTH_NOT_EXPR has been folded, reset the location. */
4362 if (EXPR_P (ret
) && EXPR_HAS_LOCATION (ret
))
4363 location
= EXPR_LOCATION (ret
);
4364 goto return_build_unary_op
;
4368 ret
= build_real_imag_expr (location
, code
, arg
);
4369 if (ret
== error_mark_node
)
4370 return error_mark_node
;
4371 if (eptype
&& TREE_CODE (eptype
) == COMPLEX_TYPE
)
4372 eptype
= TREE_TYPE (eptype
);
4373 goto return_build_unary_op
;
4375 case PREINCREMENT_EXPR
:
4376 case POSTINCREMENT_EXPR
:
4377 case PREDECREMENT_EXPR
:
4378 case POSTDECREMENT_EXPR
:
4380 if (TREE_CODE (arg
) == C_MAYBE_CONST_EXPR
)
4382 tree inner
= build_unary_op (location
, code
,
4383 C_MAYBE_CONST_EXPR_EXPR (arg
),
4385 if (inner
== error_mark_node
)
4386 return error_mark_node
;
4387 ret
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (inner
),
4388 C_MAYBE_CONST_EXPR_PRE (arg
), inner
);
4389 gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (arg
));
4390 C_MAYBE_CONST_EXPR_NON_CONST (ret
) = 1;
4391 goto return_build_unary_op
;
4394 /* Complain about anything that is not a true lvalue. In
4395 Objective-C, skip this check for property_refs. */
4396 if (!objc_is_property_ref (arg
)
4397 && !lvalue_or_else (location
,
4398 arg
, ((code
== PREINCREMENT_EXPR
4399 || code
== POSTINCREMENT_EXPR
)
4402 return error_mark_node
;
4404 if (warn_cxx_compat
&& TREE_CODE (TREE_TYPE (arg
)) == ENUMERAL_TYPE
)
4406 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
4407 warning_at (location
, OPT_Wc___compat
,
4408 "increment of enumeration value is invalid in C++");
4410 warning_at (location
, OPT_Wc___compat
,
4411 "decrement of enumeration value is invalid in C++");
4414 if (TREE_CODE (TREE_TYPE (arg
)) == BOOLEAN_TYPE
)
4416 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
4417 warning_at (location
, OPT_Wbool_operation
,
4418 "increment of a boolean expression");
4420 warning_at (location
, OPT_Wbool_operation
,
4421 "decrement of a boolean expression");
4424 /* Ensure the argument is fully folded inside any SAVE_EXPR. */
4425 arg
= c_fully_fold (arg
, false, NULL
, true);
4428 atomic_op
= really_atomic_lvalue (arg
);
4430 /* Increment or decrement the real part of the value,
4431 and don't change the imaginary part. */
4432 if (typecode
== COMPLEX_TYPE
)
4436 pedwarn (location
, OPT_Wpedantic
,
4437 "ISO C does not support %<++%> and %<--%> on complex types");
4441 arg
= stabilize_reference (arg
);
4442 real
= build_unary_op (EXPR_LOCATION (arg
), REALPART_EXPR
, arg
,
4444 imag
= build_unary_op (EXPR_LOCATION (arg
), IMAGPART_EXPR
, arg
,
4446 real
= build_unary_op (EXPR_LOCATION (arg
), code
, real
, true);
4447 if (real
== error_mark_node
|| imag
== error_mark_node
)
4448 return error_mark_node
;
4449 ret
= build2 (COMPLEX_EXPR
, TREE_TYPE (arg
),
4451 goto return_build_unary_op
;
4455 /* Report invalid types. */
4457 if (typecode
!= POINTER_TYPE
&& typecode
!= FIXED_POINT_TYPE
4458 && typecode
!= INTEGER_TYPE
&& typecode
!= REAL_TYPE
4459 && typecode
!= COMPLEX_TYPE
&& typecode
!= VECTOR_TYPE
)
4461 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
4462 error_at (location
, "wrong type argument to increment");
4464 error_at (location
, "wrong type argument to decrement");
4466 return error_mark_node
;
4472 argtype
= TREE_TYPE (arg
);
4474 /* Compute the increment. */
4476 if (typecode
== POINTER_TYPE
)
4478 /* If pointer target is an incomplete type,
4479 we just cannot know how to do the arithmetic. */
4480 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (argtype
)))
4482 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
4484 "increment of pointer to an incomplete type %qT",
4485 TREE_TYPE (argtype
));
4488 "decrement of pointer to an incomplete type %qT",
4489 TREE_TYPE (argtype
));
4491 else if (TREE_CODE (TREE_TYPE (argtype
)) == FUNCTION_TYPE
4492 || TREE_CODE (TREE_TYPE (argtype
)) == VOID_TYPE
)
4494 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
4495 pedwarn (location
, OPT_Wpointer_arith
,
4496 "wrong type argument to increment");
4498 pedwarn (location
, OPT_Wpointer_arith
,
4499 "wrong type argument to decrement");
4502 inc
= c_size_in_bytes (TREE_TYPE (argtype
));
4503 inc
= convert_to_ptrofftype_loc (location
, inc
);
4505 else if (FRACT_MODE_P (TYPE_MODE (argtype
)))
4507 /* For signed fract types, we invert ++ to -- or
4508 -- to ++, and change inc from 1 to -1, because
4509 it is not possible to represent 1 in signed fract constants.
4510 For unsigned fract types, the result always overflows and
4511 we get an undefined (original) or the maximum value. */
4512 if (code
== PREINCREMENT_EXPR
)
4513 code
= PREDECREMENT_EXPR
;
4514 else if (code
== PREDECREMENT_EXPR
)
4515 code
= PREINCREMENT_EXPR
;
4516 else if (code
== POSTINCREMENT_EXPR
)
4517 code
= POSTDECREMENT_EXPR
;
4518 else /* code == POSTDECREMENT_EXPR */
4519 code
= POSTINCREMENT_EXPR
;
4521 inc
= integer_minus_one_node
;
4522 inc
= convert (argtype
, inc
);
4526 inc
= VECTOR_TYPE_P (argtype
)
4527 ? build_one_cst (argtype
)
4529 inc
= convert (argtype
, inc
);
4532 /* If 'arg' is an Objective-C PROPERTY_REF expression, then we
4533 need to ask Objective-C to build the increment or decrement
4534 expression for it. */
4535 if (objc_is_property_ref (arg
))
4536 return objc_build_incr_expr_for_property_ref (location
, code
,
4539 /* Report a read-only lvalue. */
4540 if (TYPE_READONLY (argtype
))
4542 readonly_error (location
, arg
,
4543 ((code
== PREINCREMENT_EXPR
4544 || code
== POSTINCREMENT_EXPR
)
4545 ? lv_increment
: lv_decrement
));
4546 return error_mark_node
;
4548 else if (TREE_READONLY (arg
))
4549 readonly_warning (arg
,
4550 ((code
== PREINCREMENT_EXPR
4551 || code
== POSTINCREMENT_EXPR
)
4552 ? lv_increment
: lv_decrement
));
4554 /* If the argument is atomic, use the special code sequences for
4555 atomic compound assignment. */
4558 arg
= stabilize_reference (arg
);
4559 ret
= build_atomic_assign (location
, arg
,
4560 ((code
== PREINCREMENT_EXPR
4561 || code
== POSTINCREMENT_EXPR
)
4564 (FRACT_MODE_P (TYPE_MODE (argtype
))
4566 : integer_one_node
),
4567 (code
== POSTINCREMENT_EXPR
4568 || code
== POSTDECREMENT_EXPR
));
4569 goto return_build_unary_op
;
4572 if (TREE_CODE (TREE_TYPE (arg
)) == BOOLEAN_TYPE
)
4573 val
= boolean_increment (code
, arg
);
4575 val
= build2 (code
, TREE_TYPE (arg
), arg
, inc
);
4576 TREE_SIDE_EFFECTS (val
) = 1;
4577 if (TREE_CODE (val
) != code
)
4578 TREE_NO_WARNING (val
) = 1;
4580 goto return_build_unary_op
;
4584 /* Note that this operation never does default_conversion. */
4586 /* The operand of unary '&' must be an lvalue (which excludes
4587 expressions of type void), or, in C99, the result of a [] or
4588 unary '*' operator. */
4589 if (VOID_TYPE_P (TREE_TYPE (arg
))
4590 && TYPE_QUALS (TREE_TYPE (arg
)) == TYPE_UNQUALIFIED
4591 && (!INDIRECT_REF_P (arg
) || !flag_isoc99
))
4592 pedwarn (location
, 0, "taking address of expression of type %<void%>");
4594 /* Let &* cancel out to simplify resulting code. */
4595 if (INDIRECT_REF_P (arg
))
4597 /* Don't let this be an lvalue. */
4598 if (lvalue_p (TREE_OPERAND (arg
, 0)))
4599 return non_lvalue_loc (location
, TREE_OPERAND (arg
, 0));
4600 ret
= TREE_OPERAND (arg
, 0);
4601 goto return_build_unary_op
;
4604 /* Anything not already handled and not a true memory reference
4605 or a non-lvalue array is an error. */
4606 if (typecode
!= FUNCTION_TYPE
&& !noconvert
4607 && !lvalue_or_else (location
, arg
, lv_addressof
))
4608 return error_mark_node
;
4610 /* Move address operations inside C_MAYBE_CONST_EXPR to simplify
4612 if (TREE_CODE (arg
) == C_MAYBE_CONST_EXPR
)
4614 tree inner
= build_unary_op (location
, code
,
4615 C_MAYBE_CONST_EXPR_EXPR (arg
),
4617 ret
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (inner
),
4618 C_MAYBE_CONST_EXPR_PRE (arg
), inner
);
4619 gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (arg
));
4620 C_MAYBE_CONST_EXPR_NON_CONST (ret
)
4621 = C_MAYBE_CONST_EXPR_NON_CONST (arg
);
4622 goto return_build_unary_op
;
4625 /* Ordinary case; arg is a COMPONENT_REF or a decl. */
4626 argtype
= TREE_TYPE (arg
);
4628 /* If the lvalue is const or volatile, merge that into the type
4629 to which the address will point. This is only needed
4630 for function types. */
4631 if ((DECL_P (arg
) || REFERENCE_CLASS_P (arg
))
4632 && (TREE_READONLY (arg
) || TREE_THIS_VOLATILE (arg
))
4633 && TREE_CODE (argtype
) == FUNCTION_TYPE
)
4635 int orig_quals
= TYPE_QUALS (strip_array_types (argtype
));
4636 int quals
= orig_quals
;
4638 if (TREE_READONLY (arg
))
4639 quals
|= TYPE_QUAL_CONST
;
4640 if (TREE_THIS_VOLATILE (arg
))
4641 quals
|= TYPE_QUAL_VOLATILE
;
4643 argtype
= c_build_qualified_type (argtype
, quals
);
4646 switch (TREE_CODE (arg
))
4649 if (DECL_C_BIT_FIELD (TREE_OPERAND (arg
, 1)))
4651 error_at (location
, "cannot take address of bit-field %qD",
4652 TREE_OPERAND (arg
, 1));
4653 return error_mark_node
;
4659 if (TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (TREE_OPERAND (arg
, 0))))
4661 if (!AGGREGATE_TYPE_P (TREE_TYPE (arg
))
4662 && !VECTOR_TYPE_P (TREE_TYPE (arg
)))
4664 error_at (location
, "cannot take address of scalar with "
4665 "reverse storage order");
4666 return error_mark_node
;
4669 if (TREE_CODE (TREE_TYPE (arg
)) == ARRAY_TYPE
4670 && TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (arg
)))
4671 warning_at (location
, OPT_Wscalar_storage_order
,
4672 "address of array with reverse scalar storage "
4680 if (!c_mark_addressable (arg
))
4681 return error_mark_node
;
4683 gcc_assert (TREE_CODE (arg
) != COMPONENT_REF
4684 || !DECL_C_BIT_FIELD (TREE_OPERAND (arg
, 1)));
4686 argtype
= build_pointer_type (argtype
);
4688 /* ??? Cope with user tricks that amount to offsetof. Delete this
4689 when we have proper support for integer constant expressions. */
4690 val
= get_base_address (arg
);
4691 if (val
&& INDIRECT_REF_P (val
)
4692 && TREE_CONSTANT (TREE_OPERAND (val
, 0)))
4694 ret
= fold_offsetof (arg
, argtype
);
4695 goto return_build_unary_op
;
4698 val
= build1 (ADDR_EXPR
, argtype
, arg
);
4701 goto return_build_unary_op
;
4707 if (argtype
== NULL_TREE
)
4708 argtype
= TREE_TYPE (arg
);
4709 if (TREE_CODE (arg
) == INTEGER_CST
)
4710 ret
= (require_constant_value
4711 ? fold_build1_initializer_loc (location
, code
, argtype
, arg
)
4712 : fold_build1_loc (location
, code
, argtype
, arg
));
4714 ret
= build1 (code
, argtype
, arg
);
4715 return_build_unary_op
:
4716 gcc_assert (ret
!= error_mark_node
);
4717 if (TREE_CODE (ret
) == INTEGER_CST
&& !TREE_OVERFLOW (ret
)
4718 && !(TREE_CODE (xarg
) == INTEGER_CST
&& !TREE_OVERFLOW (xarg
)))
4719 ret
= build1 (NOP_EXPR
, TREE_TYPE (ret
), ret
);
4720 else if (TREE_CODE (ret
) != INTEGER_CST
&& int_operands
)
4721 ret
= note_integer_operands (ret
);
4723 ret
= build1 (EXCESS_PRECISION_EXPR
, eptype
, ret
);
4724 protected_set_expr_location (ret
, location
);
4728 /* Return nonzero if REF is an lvalue valid for this language.
4729 Lvalues can be assigned, unless their type has TYPE_READONLY.
4730 Lvalues can have their address taken, unless they have C_DECL_REGISTER. */
4733 lvalue_p (const_tree ref
)
4735 const enum tree_code code
= TREE_CODE (ref
);
4742 return lvalue_p (TREE_OPERAND (ref
, 0));
4744 case C_MAYBE_CONST_EXPR
:
4745 return lvalue_p (TREE_OPERAND (ref
, 1));
4747 case COMPOUND_LITERAL_EXPR
:
4757 return (TREE_CODE (TREE_TYPE (ref
)) != FUNCTION_TYPE
4758 && TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
);
4761 return TREE_CODE (TREE_TYPE (ref
)) == ARRAY_TYPE
;
4768 /* Give a warning for storing in something that is read-only in GCC
4769 terms but not const in ISO C terms. */
4772 readonly_warning (tree arg
, enum lvalue_use use
)
4777 warning (0, "assignment of read-only location %qE", arg
);
4780 warning (0, "increment of read-only location %qE", arg
);
4783 warning (0, "decrement of read-only location %qE", arg
);
4792 /* Return nonzero if REF is an lvalue valid for this language;
4793 otherwise, print an error message and return zero. USE says
4794 how the lvalue is being used and so selects the error message.
4795 LOCATION is the location at which any error should be reported. */
4798 lvalue_or_else (location_t loc
, const_tree ref
, enum lvalue_use use
)
4800 int win
= lvalue_p (ref
);
4803 lvalue_error (loc
, use
);
4808 /* Mark EXP saying that we need to be able to take the
4809 address of it; it should not be allocated in a register.
4810 Returns true if successful. ARRAY_REF_P is true if this
4811 is for ARRAY_REF construction - in that case we don't want
4812 to look through VIEW_CONVERT_EXPR from VECTOR_TYPE to ARRAY_TYPE,
4813 it is fine to use ARRAY_REFs for vector subscripts on vector
4814 register variables. */
4817 c_mark_addressable (tree exp
, bool array_ref_p
)
4822 switch (TREE_CODE (x
))
4824 case VIEW_CONVERT_EXPR
:
4826 && TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
4827 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (x
, 0))))
4835 x
= TREE_OPERAND (x
, 0);
4838 case COMPOUND_LITERAL_EXPR
:
4839 TREE_ADDRESSABLE (x
) = 1;
4840 TREE_ADDRESSABLE (COMPOUND_LITERAL_EXPR_DECL (x
)) = 1;
4844 TREE_ADDRESSABLE (x
) = 1;
4851 if (C_DECL_REGISTER (x
)
4852 && DECL_NONLOCAL (x
))
4854 if (TREE_PUBLIC (x
) || is_global_var (x
))
4857 ("global register variable %qD used in nested function", x
);
4860 pedwarn (input_location
, 0, "register variable %qD used in nested function", x
);
4862 else if (C_DECL_REGISTER (x
))
4864 if (TREE_PUBLIC (x
) || is_global_var (x
))
4865 error ("address of global register variable %qD requested", x
);
4867 error ("address of register variable %qD requested", x
);
4873 TREE_ADDRESSABLE (x
) = 1;
4880 /* Convert EXPR to TYPE, warning about conversion problems with
4881 constants. SEMANTIC_TYPE is the type this conversion would use
4882 without excess precision. If SEMANTIC_TYPE is NULL, this function
4883 is equivalent to convert_and_check. This function is a wrapper that
4884 handles conversions that may be different than
4885 the usual ones because of excess precision. */
4888 ep_convert_and_check (location_t loc
, tree type
, tree expr
,
4891 if (TREE_TYPE (expr
) == type
)
4894 /* For C11, integer conversions may have results with excess
4896 if (flag_isoc11
|| !semantic_type
)
4897 return convert_and_check (loc
, type
, expr
);
4899 if (TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
4900 && TREE_TYPE (expr
) != semantic_type
)
4902 /* For integers, we need to check the real conversion, not
4903 the conversion to the excess precision type. */
4904 expr
= convert_and_check (loc
, semantic_type
, expr
);
4906 /* Result type is the excess precision type, which should be
4907 large enough, so do not check. */
4908 return convert (type
, expr
);
4911 /* Build and return a conditional expression IFEXP ? OP1 : OP2. If
4912 IFEXP_BCP then the condition is a call to __builtin_constant_p, and
4913 if folded to an integer constant then the unselected half may
4914 contain arbitrary operations not normally permitted in constant
4915 expressions. Set the location of the expression to LOC. */
4918 build_conditional_expr (location_t colon_loc
, tree ifexp
, bool ifexp_bcp
,
4919 tree op1
, tree op1_original_type
, location_t op1_loc
,
4920 tree op2
, tree op2_original_type
, location_t op2_loc
)
4924 enum tree_code code1
;
4925 enum tree_code code2
;
4926 tree result_type
= NULL
;
4927 tree semantic_result_type
= NULL
;
4928 tree orig_op1
= op1
, orig_op2
= op2
;
4929 bool int_const
, op1_int_operands
, op2_int_operands
, int_operands
;
4930 bool ifexp_int_operands
;
4933 op1_int_operands
= EXPR_INT_CONST_OPERANDS (orig_op1
);
4934 if (op1_int_operands
)
4935 op1
= remove_c_maybe_const_expr (op1
);
4936 op2_int_operands
= EXPR_INT_CONST_OPERANDS (orig_op2
);
4937 if (op2_int_operands
)
4938 op2
= remove_c_maybe_const_expr (op2
);
4939 ifexp_int_operands
= EXPR_INT_CONST_OPERANDS (ifexp
);
4940 if (ifexp_int_operands
)
4941 ifexp
= remove_c_maybe_const_expr (ifexp
);
4943 /* Promote both alternatives. */
4945 if (TREE_CODE (TREE_TYPE (op1
)) != VOID_TYPE
)
4946 op1
= default_conversion (op1
);
4947 if (TREE_CODE (TREE_TYPE (op2
)) != VOID_TYPE
)
4948 op2
= default_conversion (op2
);
4950 if (TREE_CODE (ifexp
) == ERROR_MARK
4951 || TREE_CODE (TREE_TYPE (op1
)) == ERROR_MARK
4952 || TREE_CODE (TREE_TYPE (op2
)) == ERROR_MARK
)
4953 return error_mark_node
;
4955 type1
= TREE_TYPE (op1
);
4956 code1
= TREE_CODE (type1
);
4957 type2
= TREE_TYPE (op2
);
4958 code2
= TREE_CODE (type2
);
4960 if (code1
== POINTER_TYPE
&& reject_gcc_builtin (op1
))
4961 return error_mark_node
;
4963 if (code2
== POINTER_TYPE
&& reject_gcc_builtin (op2
))
4964 return error_mark_node
;
4966 /* C90 does not permit non-lvalue arrays in conditional expressions.
4967 In C99 they will be pointers by now. */
4968 if (code1
== ARRAY_TYPE
|| code2
== ARRAY_TYPE
)
4970 error_at (colon_loc
, "non-lvalue array in conditional expression");
4971 return error_mark_node
;
4974 if ((TREE_CODE (op1
) == EXCESS_PRECISION_EXPR
4975 || TREE_CODE (op2
) == EXCESS_PRECISION_EXPR
)
4976 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
4977 || code1
== COMPLEX_TYPE
)
4978 && (code2
== INTEGER_TYPE
|| code2
== REAL_TYPE
4979 || code2
== COMPLEX_TYPE
))
4981 semantic_result_type
= c_common_type (type1
, type2
);
4982 if (TREE_CODE (op1
) == EXCESS_PRECISION_EXPR
)
4984 op1
= TREE_OPERAND (op1
, 0);
4985 type1
= TREE_TYPE (op1
);
4986 gcc_assert (TREE_CODE (type1
) == code1
);
4988 if (TREE_CODE (op2
) == EXCESS_PRECISION_EXPR
)
4990 op2
= TREE_OPERAND (op2
, 0);
4991 type2
= TREE_TYPE (op2
);
4992 gcc_assert (TREE_CODE (type2
) == code2
);
4996 if (warn_cxx_compat
)
4998 tree t1
= op1_original_type
? op1_original_type
: TREE_TYPE (orig_op1
);
4999 tree t2
= op2_original_type
? op2_original_type
: TREE_TYPE (orig_op2
);
5001 if (TREE_CODE (t1
) == ENUMERAL_TYPE
5002 && TREE_CODE (t2
) == ENUMERAL_TYPE
5003 && TYPE_MAIN_VARIANT (t1
) != TYPE_MAIN_VARIANT (t2
))
5004 warning_at (colon_loc
, OPT_Wc___compat
,
5005 ("different enum types in conditional is "
5006 "invalid in C++: %qT vs %qT"),
5010 /* Quickly detect the usual case where op1 and op2 have the same type
5012 if (TYPE_MAIN_VARIANT (type1
) == TYPE_MAIN_VARIANT (type2
))
5015 result_type
= type1
;
5017 result_type
= TYPE_MAIN_VARIANT (type1
);
5019 else if ((code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
5020 || code1
== COMPLEX_TYPE
)
5021 && (code2
== INTEGER_TYPE
|| code2
== REAL_TYPE
5022 || code2
== COMPLEX_TYPE
))
5024 /* In C11, a conditional expression between a floating-point
5025 type and an integer type should convert the integer type to
5026 the evaluation format of the floating-point type, with
5027 possible excess precision. */
5028 tree eptype1
= type1
;
5029 tree eptype2
= type2
;
5033 if (ANY_INTEGRAL_TYPE_P (type1
)
5034 && (eptype
= excess_precision_type (type2
)) != NULL_TREE
)
5037 if (!semantic_result_type
)
5038 semantic_result_type
= c_common_type (type1
, type2
);
5040 else if (ANY_INTEGRAL_TYPE_P (type2
)
5041 && (eptype
= excess_precision_type (type1
)) != NULL_TREE
)
5044 if (!semantic_result_type
)
5045 semantic_result_type
= c_common_type (type1
, type2
);
5048 result_type
= c_common_type (eptype1
, eptype2
);
5049 if (result_type
== error_mark_node
)
5050 return error_mark_node
;
5051 do_warn_double_promotion (result_type
, type1
, type2
,
5052 "implicit conversion from %qT to %qT to "
5053 "match other result of conditional",
5056 /* If -Wsign-compare, warn here if type1 and type2 have
5057 different signedness. We'll promote the signed to unsigned
5058 and later code won't know it used to be different.
5059 Do this check on the original types, so that explicit casts
5060 will be considered, but default promotions won't. */
5061 if (c_inhibit_evaluation_warnings
== 0)
5063 int unsigned_op1
= TYPE_UNSIGNED (TREE_TYPE (orig_op1
));
5064 int unsigned_op2
= TYPE_UNSIGNED (TREE_TYPE (orig_op2
));
5066 if (unsigned_op1
^ unsigned_op2
)
5070 /* Do not warn if the result type is signed, since the
5071 signed type will only be chosen if it can represent
5072 all the values of the unsigned type. */
5073 if (!TYPE_UNSIGNED (result_type
))
5077 bool op1_maybe_const
= true;
5078 bool op2_maybe_const
= true;
5080 /* Do not warn if the signed quantity is an
5081 unsuffixed integer literal (or some static
5082 constant expression involving such literals) and
5083 it is non-negative. This warning requires the
5084 operands to be folded for best results, so do
5085 that folding in this case even without
5086 warn_sign_compare to avoid warning options
5087 possibly affecting code generation. */
5088 c_inhibit_evaluation_warnings
5089 += (ifexp
== truthvalue_false_node
);
5090 op1
= c_fully_fold (op1
, require_constant_value
,
5092 c_inhibit_evaluation_warnings
5093 -= (ifexp
== truthvalue_false_node
);
5095 c_inhibit_evaluation_warnings
5096 += (ifexp
== truthvalue_true_node
);
5097 op2
= c_fully_fold (op2
, require_constant_value
,
5099 c_inhibit_evaluation_warnings
5100 -= (ifexp
== truthvalue_true_node
);
5102 if (warn_sign_compare
)
5105 && tree_expr_nonnegative_warnv_p (op1
, &ovf
))
5107 && tree_expr_nonnegative_warnv_p (op2
, &ovf
)))
5109 else if (unsigned_op2
)
5110 warning_at (op1_loc
, OPT_Wsign_compare
,
5111 "operand of ?: changes signedness from "
5112 "%qT to %qT due to unsignedness of other "
5113 "operand", TREE_TYPE (orig_op1
),
5114 TREE_TYPE (orig_op2
));
5116 warning_at (op2_loc
, OPT_Wsign_compare
,
5117 "operand of ?: changes signedness from "
5118 "%qT to %qT due to unsignedness of other "
5119 "operand", TREE_TYPE (orig_op2
),
5120 TREE_TYPE (orig_op1
));
5122 if (!op1_maybe_const
|| TREE_CODE (op1
) != INTEGER_CST
)
5123 op1
= c_wrap_maybe_const (op1
, !op1_maybe_const
);
5124 if (!op2_maybe_const
|| TREE_CODE (op2
) != INTEGER_CST
)
5125 op2
= c_wrap_maybe_const (op2
, !op2_maybe_const
);
5130 else if (code1
== VOID_TYPE
|| code2
== VOID_TYPE
)
5132 if (code1
!= VOID_TYPE
|| code2
!= VOID_TYPE
)
5133 pedwarn (colon_loc
, OPT_Wpedantic
,
5134 "ISO C forbids conditional expr with only one void side");
5135 result_type
= void_type_node
;
5137 else if (code1
== POINTER_TYPE
&& code2
== POINTER_TYPE
)
5139 addr_space_t as1
= TYPE_ADDR_SPACE (TREE_TYPE (type1
));
5140 addr_space_t as2
= TYPE_ADDR_SPACE (TREE_TYPE (type2
));
5141 addr_space_t as_common
;
5143 if (comp_target_types (colon_loc
, type1
, type2
))
5144 result_type
= common_pointer_type (type1
, type2
);
5145 else if (null_pointer_constant_p (orig_op1
))
5146 result_type
= type2
;
5147 else if (null_pointer_constant_p (orig_op2
))
5148 result_type
= type1
;
5149 else if (!addr_space_superset (as1
, as2
, &as_common
))
5151 error_at (colon_loc
, "pointers to disjoint address spaces "
5152 "used in conditional expression");
5153 return error_mark_node
;
5155 else if (VOID_TYPE_P (TREE_TYPE (type1
))
5156 && !TYPE_ATOMIC (TREE_TYPE (type1
)))
5158 if ((TREE_CODE (TREE_TYPE (type2
)) == ARRAY_TYPE
)
5159 && (TYPE_QUALS (strip_array_types (TREE_TYPE (type2
)))
5160 & ~TYPE_QUALS (TREE_TYPE (type1
))))
5161 warning_at (colon_loc
, OPT_Wdiscarded_array_qualifiers
,
5162 "pointer to array loses qualifier "
5163 "in conditional expression");
5165 if (TREE_CODE (TREE_TYPE (type2
)) == FUNCTION_TYPE
)
5166 pedwarn (colon_loc
, OPT_Wpedantic
,
5167 "ISO C forbids conditional expr between "
5168 "%<void *%> and function pointer");
5169 result_type
= build_pointer_type (qualify_type (TREE_TYPE (type1
),
5170 TREE_TYPE (type2
)));
5172 else if (VOID_TYPE_P (TREE_TYPE (type2
))
5173 && !TYPE_ATOMIC (TREE_TYPE (type2
)))
5175 if ((TREE_CODE (TREE_TYPE (type1
)) == ARRAY_TYPE
)
5176 && (TYPE_QUALS (strip_array_types (TREE_TYPE (type1
)))
5177 & ~TYPE_QUALS (TREE_TYPE (type2
))))
5178 warning_at (colon_loc
, OPT_Wdiscarded_array_qualifiers
,
5179 "pointer to array loses qualifier "
5180 "in conditional expression");
5182 if (TREE_CODE (TREE_TYPE (type1
)) == FUNCTION_TYPE
)
5183 pedwarn (colon_loc
, OPT_Wpedantic
,
5184 "ISO C forbids conditional expr between "
5185 "%<void *%> and function pointer");
5186 result_type
= build_pointer_type (qualify_type (TREE_TYPE (type2
),
5187 TREE_TYPE (type1
)));
5189 /* Objective-C pointer comparisons are a bit more lenient. */
5190 else if (objc_have_common_type (type1
, type2
, -3, NULL_TREE
))
5191 result_type
= objc_common_type (type1
, type2
);
5194 int qual
= ENCODE_QUAL_ADDR_SPACE (as_common
);
5196 pedwarn (colon_loc
, 0,
5197 "pointer type mismatch in conditional expression");
5198 result_type
= build_pointer_type
5199 (build_qualified_type (void_type_node
, qual
));
5202 else if (code1
== POINTER_TYPE
&& code2
== INTEGER_TYPE
)
5204 if (!null_pointer_constant_p (orig_op2
))
5205 pedwarn (colon_loc
, 0,
5206 "pointer/integer type mismatch in conditional expression");
5209 op2
= null_pointer_node
;
5211 result_type
= type1
;
5213 else if (code2
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
5215 if (!null_pointer_constant_p (orig_op1
))
5216 pedwarn (colon_loc
, 0,
5217 "pointer/integer type mismatch in conditional expression");
5220 op1
= null_pointer_node
;
5222 result_type
= type2
;
5227 if (flag_cond_mismatch
)
5228 result_type
= void_type_node
;
5231 error_at (colon_loc
, "type mismatch in conditional expression");
5232 return error_mark_node
;
5236 /* Merge const and volatile flags of the incoming types. */
5238 = build_type_variant (result_type
,
5239 TYPE_READONLY (type1
) || TYPE_READONLY (type2
),
5240 TYPE_VOLATILE (type1
) || TYPE_VOLATILE (type2
));
5242 op1
= ep_convert_and_check (colon_loc
, result_type
, op1
,
5243 semantic_result_type
);
5244 op2
= ep_convert_and_check (colon_loc
, result_type
, op2
,
5245 semantic_result_type
);
5247 if (ifexp_bcp
&& ifexp
== truthvalue_true_node
)
5249 op2_int_operands
= true;
5250 op1
= c_fully_fold (op1
, require_constant_value
, NULL
);
5252 if (ifexp_bcp
&& ifexp
== truthvalue_false_node
)
5254 op1_int_operands
= true;
5255 op2
= c_fully_fold (op2
, require_constant_value
, NULL
);
5257 int_const
= int_operands
= (ifexp_int_operands
5259 && op2_int_operands
);
5262 int_const
= ((ifexp
== truthvalue_true_node
5263 && TREE_CODE (orig_op1
) == INTEGER_CST
5264 && !TREE_OVERFLOW (orig_op1
))
5265 || (ifexp
== truthvalue_false_node
5266 && TREE_CODE (orig_op2
) == INTEGER_CST
5267 && !TREE_OVERFLOW (orig_op2
)));
5270 /* Need to convert condition operand into a vector mask. */
5271 if (VECTOR_TYPE_P (TREE_TYPE (ifexp
)))
5273 tree vectype
= TREE_TYPE (ifexp
);
5274 tree elem_type
= TREE_TYPE (vectype
);
5275 tree zero
= build_int_cst (elem_type
, 0);
5276 tree zero_vec
= build_vector_from_val (vectype
, zero
);
5277 tree cmp_type
= build_same_sized_truth_vector_type (vectype
);
5278 ifexp
= build2 (NE_EXPR
, cmp_type
, ifexp
, zero_vec
);
5281 if (int_const
|| (ifexp_bcp
&& TREE_CODE (ifexp
) == INTEGER_CST
))
5282 ret
= fold_build3_loc (colon_loc
, COND_EXPR
, result_type
, ifexp
, op1
, op2
);
5287 /* Use c_fully_fold here, since C_MAYBE_CONST_EXPR might be
5288 nested inside of the expression. */
5289 op1
= c_fully_fold (op1
, false, NULL
);
5290 op2
= c_fully_fold (op2
, false, NULL
);
5292 ret
= build3 (COND_EXPR
, result_type
, ifexp
, op1
, op2
);
5294 ret
= note_integer_operands (ret
);
5296 if (semantic_result_type
)
5297 ret
= build1 (EXCESS_PRECISION_EXPR
, semantic_result_type
, ret
);
5299 protected_set_expr_location (ret
, colon_loc
);
5301 /* If the OP1 and OP2 are the same and don't have side-effects,
5302 warn here, because the COND_EXPR will be turned into OP1. */
5303 if (warn_duplicated_branches
5304 && TREE_CODE (ret
) == COND_EXPR
5305 && (op1
== op2
|| operand_equal_p (op1
, op2
, 0)))
5306 warning_at (EXPR_LOCATION (ret
), OPT_Wduplicated_branches
,
5307 "this condition has identical branches");
5312 /* Return a compound expression that performs two expressions and
5313 returns the value of the second of them.
5315 LOC is the location of the COMPOUND_EXPR. */
5318 build_compound_expr (location_t loc
, tree expr1
, tree expr2
)
5320 bool expr1_int_operands
, expr2_int_operands
;
5321 tree eptype
= NULL_TREE
;
5324 expr1_int_operands
= EXPR_INT_CONST_OPERANDS (expr1
);
5325 if (expr1_int_operands
)
5326 expr1
= remove_c_maybe_const_expr (expr1
);
5327 expr2_int_operands
= EXPR_INT_CONST_OPERANDS (expr2
);
5328 if (expr2_int_operands
)
5329 expr2
= remove_c_maybe_const_expr (expr2
);
5331 if (TREE_CODE (expr1
) == EXCESS_PRECISION_EXPR
)
5332 expr1
= TREE_OPERAND (expr1
, 0);
5333 if (TREE_CODE (expr2
) == EXCESS_PRECISION_EXPR
)
5335 eptype
= TREE_TYPE (expr2
);
5336 expr2
= TREE_OPERAND (expr2
, 0);
5339 if (!TREE_SIDE_EFFECTS (expr1
))
5341 /* The left-hand operand of a comma expression is like an expression
5342 statement: with -Wunused, we should warn if it doesn't have
5343 any side-effects, unless it was explicitly cast to (void). */
5344 if (warn_unused_value
)
5346 if (VOID_TYPE_P (TREE_TYPE (expr1
))
5347 && CONVERT_EXPR_P (expr1
))
5349 else if (VOID_TYPE_P (TREE_TYPE (expr1
))
5350 && TREE_CODE (expr1
) == COMPOUND_EXPR
5351 && CONVERT_EXPR_P (TREE_OPERAND (expr1
, 1)))
5352 ; /* (void) a, (void) b, c */
5354 warning_at (loc
, OPT_Wunused_value
,
5355 "left-hand operand of comma expression has no effect");
5358 else if (TREE_CODE (expr1
) == COMPOUND_EXPR
5359 && warn_unused_value
)
5362 location_t cloc
= loc
;
5363 while (TREE_CODE (r
) == COMPOUND_EXPR
)
5365 if (EXPR_HAS_LOCATION (r
))
5366 cloc
= EXPR_LOCATION (r
);
5367 r
= TREE_OPERAND (r
, 1);
5369 if (!TREE_SIDE_EFFECTS (r
)
5370 && !VOID_TYPE_P (TREE_TYPE (r
))
5371 && !CONVERT_EXPR_P (r
))
5372 warning_at (cloc
, OPT_Wunused_value
,
5373 "right-hand operand of comma expression has no effect");
5376 /* With -Wunused, we should also warn if the left-hand operand does have
5377 side-effects, but computes a value which is not used. For example, in
5378 `foo() + bar(), baz()' the result of the `+' operator is not used,
5379 so we should issue a warning. */
5380 else if (warn_unused_value
)
5381 warn_if_unused_value (expr1
, loc
);
5383 if (expr2
== error_mark_node
)
5384 return error_mark_node
;
5386 ret
= build2 (COMPOUND_EXPR
, TREE_TYPE (expr2
), expr1
, expr2
);
5389 && expr1_int_operands
5390 && expr2_int_operands
)
5391 ret
= note_integer_operands (ret
);
5394 ret
= build1 (EXCESS_PRECISION_EXPR
, eptype
, ret
);
5396 protected_set_expr_location (ret
, loc
);
5400 /* Issue -Wcast-qual warnings when appropriate. TYPE is the type to
5401 which we are casting. OTYPE is the type of the expression being
5402 cast. Both TYPE and OTYPE are pointer types. LOC is the location
5403 of the cast. -Wcast-qual appeared on the command line. Named
5404 address space qualifiers are not handled here, because they result
5405 in different warnings. */
5408 handle_warn_cast_qual (location_t loc
, tree type
, tree otype
)
5410 tree in_type
= type
;
5411 tree in_otype
= otype
;
5416 /* Check that the qualifiers on IN_TYPE are a superset of the
5417 qualifiers of IN_OTYPE. The outermost level of POINTER_TYPE
5418 nodes is uninteresting and we stop as soon as we hit a
5419 non-POINTER_TYPE node on either type. */
5422 in_otype
= TREE_TYPE (in_otype
);
5423 in_type
= TREE_TYPE (in_type
);
5425 /* GNU C allows cv-qualified function types. 'const' means the
5426 function is very pure, 'volatile' means it can't return. We
5427 need to warn when such qualifiers are added, not when they're
5429 if (TREE_CODE (in_otype
) == FUNCTION_TYPE
5430 && TREE_CODE (in_type
) == FUNCTION_TYPE
)
5431 added
|= (TYPE_QUALS_NO_ADDR_SPACE (in_type
)
5432 & ~TYPE_QUALS_NO_ADDR_SPACE (in_otype
));
5434 discarded
|= (TYPE_QUALS_NO_ADDR_SPACE (in_otype
)
5435 & ~TYPE_QUALS_NO_ADDR_SPACE (in_type
));
5437 while (TREE_CODE (in_type
) == POINTER_TYPE
5438 && TREE_CODE (in_otype
) == POINTER_TYPE
);
5441 warning_at (loc
, OPT_Wcast_qual
,
5442 "cast adds %q#v qualifier to function type", added
);
5445 /* There are qualifiers present in IN_OTYPE that are not present
5447 warning_at (loc
, OPT_Wcast_qual
,
5448 "cast discards %qv qualifier from pointer target type",
5451 if (added
|| discarded
)
5454 /* A cast from **T to const **T is unsafe, because it can cause a
5455 const value to be changed with no additional warning. We only
5456 issue this warning if T is the same on both sides, and we only
5457 issue the warning if there are the same number of pointers on
5458 both sides, as otherwise the cast is clearly unsafe anyhow. A
5459 cast is unsafe when a qualifier is added at one level and const
5460 is not present at all outer levels.
5462 To issue this warning, we check at each level whether the cast
5463 adds new qualifiers not already seen. We don't need to special
5464 case function types, as they won't have the same
5465 TYPE_MAIN_VARIANT. */
5467 if (TYPE_MAIN_VARIANT (in_type
) != TYPE_MAIN_VARIANT (in_otype
))
5469 if (TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
)
5474 is_const
= TYPE_READONLY (TREE_TYPE (in_type
));
5477 in_type
= TREE_TYPE (in_type
);
5478 in_otype
= TREE_TYPE (in_otype
);
5479 if ((TYPE_QUALS (in_type
) &~ TYPE_QUALS (in_otype
)) != 0
5482 warning_at (loc
, OPT_Wcast_qual
,
5483 "to be safe all intermediate pointers in cast from "
5484 "%qT to %qT must be %<const%> qualified",
5489 is_const
= TYPE_READONLY (in_type
);
5491 while (TREE_CODE (in_type
) == POINTER_TYPE
);
5494 /* Heuristic check if two parameter types can be considered ABI-equivalent. */
5497 c_safe_arg_type_equiv_p (tree t1
, tree t2
)
5499 t1
= TYPE_MAIN_VARIANT (t1
);
5500 t2
= TYPE_MAIN_VARIANT (t2
);
5502 if (TREE_CODE (t1
) == POINTER_TYPE
5503 && TREE_CODE (t2
) == POINTER_TYPE
)
5506 /* The signedness of the parameter matters only when an integral
5507 type smaller than int is promoted to int, otherwise only the
5508 precision of the parameter matters.
5509 This check should make sure that the callee does not see
5510 undefined values in argument registers. */
5511 if (INTEGRAL_TYPE_P (t1
)
5512 && INTEGRAL_TYPE_P (t2
)
5513 && TYPE_PRECISION (t1
) == TYPE_PRECISION (t2
)
5514 && (TYPE_UNSIGNED (t1
) == TYPE_UNSIGNED (t2
)
5515 || !targetm
.calls
.promote_prototypes (NULL_TREE
)
5516 || TYPE_PRECISION (t1
) >= TYPE_PRECISION (integer_type_node
)))
5519 return comptypes (t1
, t2
);
5522 /* Check if a type cast between two function types can be considered safe. */
5525 c_safe_function_type_cast_p (tree t1
, tree t2
)
5527 if (TREE_TYPE (t1
) == void_type_node
&&
5528 TYPE_ARG_TYPES (t1
) == void_list_node
)
5531 if (TREE_TYPE (t2
) == void_type_node
&&
5532 TYPE_ARG_TYPES (t2
) == void_list_node
)
5535 if (!c_safe_arg_type_equiv_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
5538 for (t1
= TYPE_ARG_TYPES (t1
), t2
= TYPE_ARG_TYPES (t2
);
5540 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
5541 if (!c_safe_arg_type_equiv_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
5547 /* Build an expression representing a cast to type TYPE of expression EXPR.
5548 LOC is the location of the cast-- typically the open paren of the cast. */
5551 build_c_cast (location_t loc
, tree type
, tree expr
)
5555 if (TREE_CODE (expr
) == EXCESS_PRECISION_EXPR
)
5556 expr
= TREE_OPERAND (expr
, 0);
5560 if (type
== error_mark_node
|| expr
== error_mark_node
)
5561 return error_mark_node
;
5563 /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
5564 only in <protocol> qualifications. But when constructing cast expressions,
5565 the protocols do matter and must be kept around. */
5566 if (objc_is_object_ptr (type
) && objc_is_object_ptr (TREE_TYPE (expr
)))
5567 return build1 (NOP_EXPR
, type
, expr
);
5569 type
= TYPE_MAIN_VARIANT (type
);
5571 if (TREE_CODE (type
) == ARRAY_TYPE
)
5573 error_at (loc
, "cast specifies array type");
5574 return error_mark_node
;
5577 if (TREE_CODE (type
) == FUNCTION_TYPE
)
5579 error_at (loc
, "cast specifies function type");
5580 return error_mark_node
;
5583 if (!VOID_TYPE_P (type
))
5585 value
= require_complete_type (loc
, value
);
5586 if (value
== error_mark_node
)
5587 return error_mark_node
;
5590 if (type
== TYPE_MAIN_VARIANT (TREE_TYPE (value
)))
5592 if (RECORD_OR_UNION_TYPE_P (type
))
5593 pedwarn (loc
, OPT_Wpedantic
,
5594 "ISO C forbids casting nonscalar to the same type");
5596 /* Convert to remove any qualifiers from VALUE's type. */
5597 value
= convert (type
, value
);
5599 else if (TREE_CODE (type
) == UNION_TYPE
)
5603 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
5604 if (TREE_TYPE (field
) != error_mark_node
5605 && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field
)),
5606 TYPE_MAIN_VARIANT (TREE_TYPE (value
))))
5612 bool maybe_const
= true;
5614 pedwarn (loc
, OPT_Wpedantic
, "ISO C forbids casts to union type");
5615 t
= c_fully_fold (value
, false, &maybe_const
);
5616 t
= build_constructor_single (type
, field
, t
);
5618 t
= c_wrap_maybe_const (t
, true);
5619 t
= digest_init (loc
, type
, t
,
5620 NULL_TREE
, false, true, 0);
5621 TREE_CONSTANT (t
) = TREE_CONSTANT (value
);
5624 error_at (loc
, "cast to union type from type not present in union");
5625 return error_mark_node
;
5631 if (type
== void_type_node
)
5633 tree t
= build1 (CONVERT_EXPR
, type
, value
);
5634 SET_EXPR_LOCATION (t
, loc
);
5638 otype
= TREE_TYPE (value
);
5640 /* Optionally warn about potentially worrisome casts. */
5642 && TREE_CODE (type
) == POINTER_TYPE
5643 && TREE_CODE (otype
) == POINTER_TYPE
)
5644 handle_warn_cast_qual (loc
, type
, otype
);
5646 /* Warn about conversions between pointers to disjoint
5648 if (TREE_CODE (type
) == POINTER_TYPE
5649 && TREE_CODE (otype
) == POINTER_TYPE
5650 && !null_pointer_constant_p (value
))
5652 addr_space_t as_to
= TYPE_ADDR_SPACE (TREE_TYPE (type
));
5653 addr_space_t as_from
= TYPE_ADDR_SPACE (TREE_TYPE (otype
));
5654 addr_space_t as_common
;
5656 if (!addr_space_superset (as_to
, as_from
, &as_common
))
5658 if (ADDR_SPACE_GENERIC_P (as_from
))
5659 warning_at (loc
, 0, "cast to %s address space pointer "
5660 "from disjoint generic address space pointer",
5661 c_addr_space_name (as_to
));
5663 else if (ADDR_SPACE_GENERIC_P (as_to
))
5664 warning_at (loc
, 0, "cast to generic address space pointer "
5665 "from disjoint %s address space pointer",
5666 c_addr_space_name (as_from
));
5669 warning_at (loc
, 0, "cast to %s address space pointer "
5670 "from disjoint %s address space pointer",
5671 c_addr_space_name (as_to
),
5672 c_addr_space_name (as_from
));
5676 /* Warn about possible alignment problems. */
5677 if ((STRICT_ALIGNMENT
|| warn_cast_align
== 2)
5678 && TREE_CODE (type
) == POINTER_TYPE
5679 && TREE_CODE (otype
) == POINTER_TYPE
5680 && TREE_CODE (TREE_TYPE (otype
)) != VOID_TYPE
5681 && TREE_CODE (TREE_TYPE (otype
)) != FUNCTION_TYPE
5682 /* Don't warn about opaque types, where the actual alignment
5683 restriction is unknown. */
5684 && !(RECORD_OR_UNION_TYPE_P (TREE_TYPE (otype
))
5685 && TYPE_MODE (TREE_TYPE (otype
)) == VOIDmode
)
5686 && min_align_of_type (TREE_TYPE (type
))
5687 > min_align_of_type (TREE_TYPE (otype
)))
5688 warning_at (loc
, OPT_Wcast_align
,
5689 "cast increases required alignment of target type");
5691 if (TREE_CODE (type
) == INTEGER_TYPE
5692 && TREE_CODE (otype
) == POINTER_TYPE
5693 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
))
5694 /* Unlike conversion of integers to pointers, where the
5695 warning is disabled for converting constants because
5696 of cases such as SIG_*, warn about converting constant
5697 pointers to integers. In some cases it may cause unwanted
5698 sign extension, and a warning is appropriate. */
5699 warning_at (loc
, OPT_Wpointer_to_int_cast
,
5700 "cast from pointer to integer of different size");
5702 if (TREE_CODE (value
) == CALL_EXPR
5703 && TREE_CODE (type
) != TREE_CODE (otype
))
5704 warning_at (loc
, OPT_Wbad_function_cast
,
5705 "cast from function call of type %qT "
5706 "to non-matching type %qT", otype
, type
);
5708 if (TREE_CODE (type
) == POINTER_TYPE
5709 && TREE_CODE (otype
) == INTEGER_TYPE
5710 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
)
5711 /* Don't warn about converting any constant. */
5712 && !TREE_CONSTANT (value
))
5714 OPT_Wint_to_pointer_cast
, "cast to pointer from integer "
5715 "of different size");
5717 if (warn_strict_aliasing
<= 2)
5718 strict_aliasing_warning (EXPR_LOCATION (value
), type
, expr
);
5720 /* If pedantic, warn for conversions between function and object
5721 pointer types, except for converting a null pointer constant
5722 to function pointer type. */
5724 && TREE_CODE (type
) == POINTER_TYPE
5725 && TREE_CODE (otype
) == POINTER_TYPE
5726 && TREE_CODE (TREE_TYPE (otype
)) == FUNCTION_TYPE
5727 && TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
)
5728 pedwarn (loc
, OPT_Wpedantic
, "ISO C forbids "
5729 "conversion of function pointer to object pointer type");
5732 && TREE_CODE (type
) == POINTER_TYPE
5733 && TREE_CODE (otype
) == POINTER_TYPE
5734 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
5735 && TREE_CODE (TREE_TYPE (otype
)) != FUNCTION_TYPE
5736 && !null_pointer_constant_p (value
))
5737 pedwarn (loc
, OPT_Wpedantic
, "ISO C forbids "
5738 "conversion of object pointer to function pointer type");
5740 if (TREE_CODE (type
) == POINTER_TYPE
5741 && TREE_CODE (otype
) == POINTER_TYPE
5742 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
5743 && TREE_CODE (TREE_TYPE (otype
)) == FUNCTION_TYPE
5744 && !c_safe_function_type_cast_p (TREE_TYPE (type
),
5746 warning_at (loc
, OPT_Wcast_function_type
,
5747 "cast between incompatible function types"
5748 " from %qT to %qT", otype
, type
);
5751 value
= convert (type
, value
);
5753 /* Ignore any integer overflow caused by the cast. */
5754 if (TREE_CODE (value
) == INTEGER_CST
&& !FLOAT_TYPE_P (otype
))
5756 if (CONSTANT_CLASS_P (ovalue
) && TREE_OVERFLOW (ovalue
))
5758 if (!TREE_OVERFLOW (value
))
5760 /* Avoid clobbering a shared constant. */
5761 value
= copy_node (value
);
5762 TREE_OVERFLOW (value
) = TREE_OVERFLOW (ovalue
);
5765 else if (TREE_OVERFLOW (value
))
5766 /* Reset VALUE's overflow flags, ensuring constant sharing. */
5767 value
= wide_int_to_tree (TREE_TYPE (value
), wi::to_wide (value
));
5771 /* Don't let a cast be an lvalue. */
5772 if (lvalue_p (value
))
5773 value
= non_lvalue_loc (loc
, value
);
5775 /* Don't allow the results of casting to floating-point or complex
5776 types be confused with actual constants, or casts involving
5777 integer and pointer types other than direct integer-to-integer
5778 and integer-to-pointer be confused with integer constant
5779 expressions and null pointer constants. */
5780 if (TREE_CODE (value
) == REAL_CST
5781 || TREE_CODE (value
) == COMPLEX_CST
5782 || (TREE_CODE (value
) == INTEGER_CST
5783 && !((TREE_CODE (expr
) == INTEGER_CST
5784 && INTEGRAL_TYPE_P (TREE_TYPE (expr
)))
5785 || TREE_CODE (expr
) == REAL_CST
5786 || TREE_CODE (expr
) == COMPLEX_CST
)))
5787 value
= build1 (NOP_EXPR
, type
, value
);
5789 protected_set_expr_location (value
, loc
);
5793 /* Interpret a cast of expression EXPR to type TYPE. LOC is the
5794 location of the open paren of the cast, or the position of the cast
5797 c_cast_expr (location_t loc
, struct c_type_name
*type_name
, tree expr
)
5800 tree type_expr
= NULL_TREE
;
5801 bool type_expr_const
= true;
5803 int saved_wsp
= warn_strict_prototypes
;
5805 /* This avoids warnings about unprototyped casts on
5806 integers. E.g. "#define SIG_DFL (void(*)())0". */
5807 if (TREE_CODE (expr
) == INTEGER_CST
)
5808 warn_strict_prototypes
= 0;
5809 type
= groktypename (type_name
, &type_expr
, &type_expr_const
);
5810 warn_strict_prototypes
= saved_wsp
;
5812 if (TREE_CODE (expr
) == ADDR_EXPR
&& !VOID_TYPE_P (type
)
5813 && reject_gcc_builtin (expr
))
5814 return error_mark_node
;
5816 ret
= build_c_cast (loc
, type
, expr
);
5819 bool inner_expr_const
= true;
5820 ret
= c_fully_fold (ret
, require_constant_value
, &inner_expr_const
);
5821 ret
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (ret
), type_expr
, ret
);
5822 C_MAYBE_CONST_EXPR_NON_CONST (ret
) = !(type_expr_const
5823 && inner_expr_const
);
5824 SET_EXPR_LOCATION (ret
, loc
);
5827 if (!EXPR_HAS_LOCATION (ret
))
5828 protected_set_expr_location (ret
, loc
);
5830 /* C++ does not permits types to be defined in a cast, but it
5831 allows references to incomplete types. */
5832 if (warn_cxx_compat
&& type_name
->specs
->typespec_kind
== ctsk_tagdef
)
5833 warning_at (loc
, OPT_Wc___compat
,
5834 "defining a type in a cast is invalid in C++");
5839 /* Build an assignment expression of lvalue LHS from value RHS.
5840 If LHS_ORIGTYPE is not NULL, it is the original type of LHS, which
5841 may differ from TREE_TYPE (LHS) for an enum bitfield.
5842 MODIFYCODE is the code for a binary operator that we use
5843 to combine the old value of LHS with RHS to get the new value.
5844 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5845 If RHS_ORIGTYPE is not NULL_TREE, it is the original type of RHS,
5846 which may differ from TREE_TYPE (RHS) for an enum value.
5848 LOCATION is the location of the MODIFYCODE operator.
5849 RHS_LOC is the location of the RHS. */
5852 build_modify_expr (location_t location
, tree lhs
, tree lhs_origtype
,
5853 enum tree_code modifycode
,
5854 location_t rhs_loc
, tree rhs
, tree rhs_origtype
)
5858 tree rhseval
= NULL_TREE
;
5859 tree lhstype
= TREE_TYPE (lhs
);
5860 tree olhstype
= lhstype
;
5864 /* Types that aren't fully specified cannot be used in assignments. */
5865 lhs
= require_complete_type (location
, lhs
);
5867 /* Avoid duplicate error messages from operands that had errors. */
5868 if (TREE_CODE (lhs
) == ERROR_MARK
|| TREE_CODE (rhs
) == ERROR_MARK
)
5869 return error_mark_node
;
5871 /* Ensure an error for assigning a non-lvalue array to an array in
5873 if (TREE_CODE (lhstype
) == ARRAY_TYPE
)
5875 error_at (location
, "assignment to expression with array type");
5876 return error_mark_node
;
5879 /* For ObjC properties, defer this check. */
5880 if (!objc_is_property_ref (lhs
) && !lvalue_or_else (location
, lhs
, lv_assign
))
5881 return error_mark_node
;
5883 is_atomic_op
= really_atomic_lvalue (lhs
);
5887 if (TREE_CODE (lhs
) == C_MAYBE_CONST_EXPR
)
5889 tree inner
= build_modify_expr (location
, C_MAYBE_CONST_EXPR_EXPR (lhs
),
5890 lhs_origtype
, modifycode
, rhs_loc
, rhs
,
5892 if (inner
== error_mark_node
)
5893 return error_mark_node
;
5894 result
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (inner
),
5895 C_MAYBE_CONST_EXPR_PRE (lhs
), inner
);
5896 gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (lhs
));
5897 C_MAYBE_CONST_EXPR_NON_CONST (result
) = 1;
5898 protected_set_expr_location (result
, location
);
5902 /* If a binary op has been requested, combine the old LHS value with the RHS
5903 producing the value we should actually store into the LHS. */
5905 if (modifycode
!= NOP_EXPR
)
5907 lhs
= c_fully_fold (lhs
, false, NULL
, true);
5908 lhs
= stabilize_reference (lhs
);
5910 /* Construct the RHS for any non-atomic compound assignemnt. */
5913 /* If in LHS op= RHS the RHS has side-effects, ensure they
5914 are preevaluated before the rest of the assignment expression's
5915 side-effects, because RHS could contain e.g. function calls
5917 if (TREE_SIDE_EFFECTS (rhs
))
5919 if (TREE_CODE (rhs
) == EXCESS_PRECISION_EXPR
)
5920 newrhs
= save_expr (TREE_OPERAND (rhs
, 0));
5922 newrhs
= save_expr (rhs
);
5924 if (TREE_CODE (rhs
) == EXCESS_PRECISION_EXPR
)
5925 newrhs
= build1 (EXCESS_PRECISION_EXPR
, TREE_TYPE (rhs
),
5928 newrhs
= build_binary_op (location
,
5929 modifycode
, lhs
, newrhs
, true);
5931 /* The original type of the right hand side is no longer
5933 rhs_origtype
= NULL_TREE
;
5937 if (c_dialect_objc ())
5939 /* Check if we are modifying an Objective-C property reference;
5940 if so, we need to generate setter calls. */
5941 if (TREE_CODE (newrhs
) == EXCESS_PRECISION_EXPR
)
5942 result
= objc_maybe_build_modify_expr (lhs
, TREE_OPERAND (newrhs
, 0));
5944 result
= objc_maybe_build_modify_expr (lhs
, newrhs
);
5948 /* Else, do the check that we postponed for Objective-C. */
5949 if (!lvalue_or_else (location
, lhs
, lv_assign
))
5950 return error_mark_node
;
5953 /* Give an error for storing in something that is 'const'. */
5955 if (TYPE_READONLY (lhstype
)
5956 || (RECORD_OR_UNION_TYPE_P (lhstype
)
5957 && C_TYPE_FIELDS_READONLY (lhstype
)))
5959 readonly_error (location
, lhs
, lv_assign
);
5960 return error_mark_node
;
5962 else if (TREE_READONLY (lhs
))
5963 readonly_warning (lhs
, lv_assign
);
5965 /* If storing into a structure or union member,
5966 it has probably been given type `int'.
5967 Compute the type that would go with
5968 the actual amount of storage the member occupies. */
5970 if (TREE_CODE (lhs
) == COMPONENT_REF
5971 && (TREE_CODE (lhstype
) == INTEGER_TYPE
5972 || TREE_CODE (lhstype
) == BOOLEAN_TYPE
5973 || TREE_CODE (lhstype
) == REAL_TYPE
5974 || TREE_CODE (lhstype
) == ENUMERAL_TYPE
))
5975 lhstype
= TREE_TYPE (get_unwidened (lhs
, 0));
5977 /* If storing in a field that is in actuality a short or narrower than one,
5978 we must store in the field in its actual type. */
5980 if (lhstype
!= TREE_TYPE (lhs
))
5982 lhs
= copy_node (lhs
);
5983 TREE_TYPE (lhs
) = lhstype
;
5986 /* Issue -Wc++-compat warnings about an assignment to an enum type
5987 when LHS does not have its original type. This happens for,
5988 e.g., an enum bitfield in a struct. */
5990 && lhs_origtype
!= NULL_TREE
5991 && lhs_origtype
!= lhstype
5992 && TREE_CODE (lhs_origtype
) == ENUMERAL_TYPE
)
5994 tree checktype
= (rhs_origtype
!= NULL_TREE
5997 if (checktype
!= error_mark_node
5998 && (TYPE_MAIN_VARIANT (checktype
) != TYPE_MAIN_VARIANT (lhs_origtype
)
5999 || (is_atomic_op
&& modifycode
!= NOP_EXPR
)))
6000 warning_at (location
, OPT_Wc___compat
,
6001 "enum conversion in assignment is invalid in C++");
6004 /* If the lhs is atomic, remove that qualifier. */
6007 lhstype
= build_qualified_type (lhstype
,
6008 (TYPE_QUALS (lhstype
)
6009 & ~TYPE_QUAL_ATOMIC
));
6010 olhstype
= build_qualified_type (olhstype
,
6011 (TYPE_QUALS (lhstype
)
6012 & ~TYPE_QUAL_ATOMIC
));
6015 /* Convert new value to destination type. Fold it first, then
6016 restore any excess precision information, for the sake of
6017 conversion warnings. */
6019 if (!(is_atomic_op
&& modifycode
!= NOP_EXPR
))
6021 tree rhs_semantic_type
= NULL_TREE
;
6022 if (TREE_CODE (newrhs
) == EXCESS_PRECISION_EXPR
)
6024 rhs_semantic_type
= TREE_TYPE (newrhs
);
6025 newrhs
= TREE_OPERAND (newrhs
, 0);
6027 npc
= null_pointer_constant_p (newrhs
);
6028 newrhs
= c_fully_fold (newrhs
, false, NULL
);
6029 if (rhs_semantic_type
)
6030 newrhs
= build1 (EXCESS_PRECISION_EXPR
, rhs_semantic_type
, newrhs
);
6031 newrhs
= convert_for_assignment (location
, rhs_loc
, lhstype
, newrhs
,
6032 rhs_origtype
, ic_assign
, npc
,
6033 NULL_TREE
, NULL_TREE
, 0);
6034 if (TREE_CODE (newrhs
) == ERROR_MARK
)
6035 return error_mark_node
;
6038 /* Emit ObjC write barrier, if necessary. */
6039 if (c_dialect_objc () && flag_objc_gc
)
6041 result
= objc_generate_write_barrier (lhs
, modifycode
, newrhs
);
6044 protected_set_expr_location (result
, location
);
6049 /* Scan operands. */
6052 result
= build_atomic_assign (location
, lhs
, modifycode
, newrhs
, false);
6055 result
= build2 (MODIFY_EXPR
, lhstype
, lhs
, newrhs
);
6056 TREE_SIDE_EFFECTS (result
) = 1;
6057 protected_set_expr_location (result
, location
);
6060 /* If we got the LHS in a different type for storing in,
6061 convert the result back to the nominal type of LHS
6062 so that the value we return always has the same type
6063 as the LHS argument. */
6065 if (olhstype
== TREE_TYPE (result
))
6068 result
= convert_for_assignment (location
, rhs_loc
, olhstype
, result
,
6069 rhs_origtype
, ic_assign
, false, NULL_TREE
,
6071 protected_set_expr_location (result
, location
);
6075 result
= build2 (COMPOUND_EXPR
, TREE_TYPE (result
), rhseval
, result
);
6079 /* Return whether STRUCT_TYPE has an anonymous field with type TYPE.
6080 This is used to implement -fplan9-extensions. */
6083 find_anonymous_field_with_type (tree struct_type
, tree type
)
6088 gcc_assert (RECORD_OR_UNION_TYPE_P (struct_type
));
6090 for (field
= TYPE_FIELDS (struct_type
);
6092 field
= TREE_CHAIN (field
))
6094 tree fieldtype
= (TYPE_ATOMIC (TREE_TYPE (field
))
6095 ? c_build_qualified_type (TREE_TYPE (field
),
6097 : TYPE_MAIN_VARIANT (TREE_TYPE (field
)));
6098 if (DECL_NAME (field
) == NULL
6099 && comptypes (type
, fieldtype
))
6105 else if (DECL_NAME (field
) == NULL
6106 && RECORD_OR_UNION_TYPE_P (TREE_TYPE (field
))
6107 && find_anonymous_field_with_type (TREE_TYPE (field
), type
))
6117 /* RHS is an expression whose type is pointer to struct. If there is
6118 an anonymous field in RHS with type TYPE, then return a pointer to
6119 that field in RHS. This is used with -fplan9-extensions. This
6120 returns NULL if no conversion could be found. */
6123 convert_to_anonymous_field (location_t location
, tree type
, tree rhs
)
6125 tree rhs_struct_type
, lhs_main_type
;
6126 tree field
, found_field
;
6127 bool found_sub_field
;
6130 gcc_assert (POINTER_TYPE_P (TREE_TYPE (rhs
)));
6131 rhs_struct_type
= TREE_TYPE (TREE_TYPE (rhs
));
6132 gcc_assert (RECORD_OR_UNION_TYPE_P (rhs_struct_type
));
6134 gcc_assert (POINTER_TYPE_P (type
));
6135 lhs_main_type
= (TYPE_ATOMIC (TREE_TYPE (type
))
6136 ? c_build_qualified_type (TREE_TYPE (type
),
6138 : TYPE_MAIN_VARIANT (TREE_TYPE (type
)));
6140 found_field
= NULL_TREE
;
6141 found_sub_field
= false;
6142 for (field
= TYPE_FIELDS (rhs_struct_type
);
6144 field
= TREE_CHAIN (field
))
6146 if (DECL_NAME (field
) != NULL_TREE
6147 || !RECORD_OR_UNION_TYPE_P (TREE_TYPE (field
)))
6149 tree fieldtype
= (TYPE_ATOMIC (TREE_TYPE (field
))
6150 ? c_build_qualified_type (TREE_TYPE (field
),
6152 : TYPE_MAIN_VARIANT (TREE_TYPE (field
)));
6153 if (comptypes (lhs_main_type
, fieldtype
))
6155 if (found_field
!= NULL_TREE
)
6157 found_field
= field
;
6159 else if (find_anonymous_field_with_type (TREE_TYPE (field
),
6162 if (found_field
!= NULL_TREE
)
6164 found_field
= field
;
6165 found_sub_field
= true;
6169 if (found_field
== NULL_TREE
)
6172 ret
= fold_build3_loc (location
, COMPONENT_REF
, TREE_TYPE (found_field
),
6173 build_fold_indirect_ref (rhs
), found_field
,
6175 ret
= build_fold_addr_expr_loc (location
, ret
);
6177 if (found_sub_field
)
6179 ret
= convert_to_anonymous_field (location
, type
, ret
);
6180 gcc_assert (ret
!= NULL_TREE
);
6186 /* Issue an error message for a bad initializer component.
6187 GMSGID identifies the message.
6188 The component name is taken from the spelling stack. */
6191 error_init (location_t loc
, const char *gmsgid
)
6195 /* The gmsgid may be a format string with %< and %>. */
6196 error_at (loc
, gmsgid
);
6197 ofwhat
= print_spelling ((char *) alloca (spelling_length () + 1));
6199 inform (loc
, "(near initialization for %qs)", ofwhat
);
6202 /* Issue a pedantic warning for a bad initializer component. OPT is
6203 the option OPT_* (from options.h) controlling this warning or 0 if
6204 it is unconditionally given. GMSGID identifies the message. The
6205 component name is taken from the spelling stack. */
6207 static void ATTRIBUTE_GCC_DIAG (3,0)
6208 pedwarn_init (location_t loc
, int opt
, const char *gmsgid
, ...)
6210 /* Use the location where a macro was expanded rather than where
6211 it was defined to make sure macros defined in system headers
6212 but used incorrectly elsewhere are diagnosed. */
6213 source_location exploc
= expansion_point_location_if_in_system_header (loc
);
6216 va_start (ap
, gmsgid
);
6217 bool warned
= emit_diagnostic_valist (DK_PEDWARN
, exploc
, opt
, gmsgid
, &ap
);
6219 char *ofwhat
= print_spelling ((char *) alloca (spelling_length () + 1));
6220 if (*ofwhat
&& warned
)
6221 inform (exploc
, "(near initialization for %qs)", ofwhat
);
6224 /* Issue a warning for a bad initializer component.
6226 OPT is the OPT_W* value corresponding to the warning option that
6227 controls this warning. GMSGID identifies the message. The
6228 component name is taken from the spelling stack. */
6231 warning_init (location_t loc
, int opt
, const char *gmsgid
)
6236 /* Use the location where a macro was expanded rather than where
6237 it was defined to make sure macros defined in system headers
6238 but used incorrectly elsewhere are diagnosed. */
6239 source_location exploc
= expansion_point_location_if_in_system_header (loc
);
6241 /* The gmsgid may be a format string with %< and %>. */
6242 warned
= warning_at (exploc
, opt
, gmsgid
);
6243 ofwhat
= print_spelling ((char *) alloca (spelling_length () + 1));
6244 if (*ofwhat
&& warned
)
6245 inform (exploc
, "(near initialization for %qs)", ofwhat
);
6248 /* If TYPE is an array type and EXPR is a parenthesized string
6249 constant, warn if pedantic that EXPR is being used to initialize an
6250 object of type TYPE. */
6253 maybe_warn_string_init (location_t loc
, tree type
, struct c_expr expr
)
6256 && TREE_CODE (type
) == ARRAY_TYPE
6257 && TREE_CODE (expr
.value
) == STRING_CST
6258 && expr
.original_code
!= STRING_CST
)
6259 pedwarn_init (loc
, OPT_Wpedantic
,
6260 "array initialized from parenthesized string constant");
6263 /* Attempt to locate the parameter with the given index within FNDECL,
6264 returning DECL_SOURCE_LOCATION (FNDECL) if it can't be found. */
6267 get_fndecl_argument_location (tree fndecl
, int argnum
)
6272 /* Locate param by index within DECL_ARGUMENTS (fndecl). */
6273 for (i
= 0, param
= DECL_ARGUMENTS (fndecl
);
6274 i
< argnum
&& param
;
6275 i
++, param
= TREE_CHAIN (param
))
6278 /* If something went wrong (e.g. if we have a builtin and thus no arguments),
6279 return DECL_SOURCE_LOCATION (FNDECL). */
6281 return DECL_SOURCE_LOCATION (fndecl
);
6283 return DECL_SOURCE_LOCATION (param
);
6286 /* Issue a note about a mismatching argument for parameter PARMNUM
6287 to FUNDECL, for types EXPECTED_TYPE and ACTUAL_TYPE.
6288 Attempt to issue the note at the pertinent parameter of the decl;
6289 failing that issue it at the location of FUNDECL; failing that
6290 issue it at PLOC. */
6293 inform_for_arg (tree fundecl
, location_t ploc
, int parmnum
,
6294 tree expected_type
, tree actual_type
)
6297 if (fundecl
&& !DECL_IS_BUILTIN (fundecl
))
6298 loc
= get_fndecl_argument_location (fundecl
, parmnum
- 1);
6303 "expected %qT but argument is of type %qT",
6304 expected_type
, actual_type
);
6307 /* Convert value RHS to type TYPE as preparation for an assignment to
6308 an lvalue of type TYPE. If ORIGTYPE is not NULL_TREE, it is the
6309 original type of RHS; this differs from TREE_TYPE (RHS) for enum
6310 types. NULL_POINTER_CONSTANT says whether RHS was a null pointer
6311 constant before any folding.
6312 The real work of conversion is done by `convert'.
6313 The purpose of this function is to generate error messages
6314 for assignments that are not allowed in C.
6315 ERRTYPE says whether it is argument passing, assignment,
6316 initialization or return.
6318 In the following example, '~' denotes where EXPR_LOC and '^' where
6321 f (var); [ic_argpass]
6323 x = var; [ic_assign]
6325 int x = var; [ic_init]
6327 return x; [ic_return]
6330 FUNCTION is a tree for the function being called.
6331 PARMNUM is the number of the argument, for printing in error messages. */
6334 convert_for_assignment (location_t location
, location_t expr_loc
, tree type
,
6335 tree rhs
, tree origtype
, enum impl_conv errtype
,
6336 bool null_pointer_constant
, tree fundecl
,
6337 tree function
, int parmnum
)
6339 enum tree_code codel
= TREE_CODE (type
);
6340 tree orig_rhs
= rhs
;
6342 enum tree_code coder
;
6343 tree rname
= NULL_TREE
;
6344 bool objc_ok
= false;
6346 /* Use the expansion point location to handle cases such as user's
6347 function returning a wrong-type macro defined in a system header. */
6348 location
= expansion_point_location_if_in_system_header (location
);
6350 if (errtype
== ic_argpass
)
6353 /* Change pointer to function to the function itself for
6355 if (TREE_CODE (function
) == ADDR_EXPR
6356 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
6357 function
= TREE_OPERAND (function
, 0);
6359 /* Handle an ObjC selector specially for diagnostics. */
6360 selector
= objc_message_selector ();
6362 if (selector
&& parmnum
> 2)
6369 /* This macro is used to emit diagnostics to ensure that all format
6370 strings are complete sentences, visible to gettext and checked at
6372 #define PEDWARN_FOR_ASSIGNMENT(LOCATION, PLOC, OPT, AR, AS, IN, RE) \
6377 if (pedwarn (PLOC, OPT, AR, parmnum, rname)) \
6378 inform_for_arg (fundecl, (PLOC), parmnum, type, rhstype); \
6381 pedwarn (LOCATION, OPT, AS); \
6384 pedwarn_init (LOCATION, OPT, IN); \
6387 pedwarn (LOCATION, OPT, RE); \
6390 gcc_unreachable (); \
6394 /* This macro is used to emit diagnostics to ensure that all format
6395 strings are complete sentences, visible to gettext and checked at
6396 compile time. It is the same as PEDWARN_FOR_ASSIGNMENT but with an
6397 extra parameter to enumerate qualifiers. */
6398 #define PEDWARN_FOR_QUALIFIERS(LOCATION, PLOC, OPT, AR, AS, IN, RE, QUALS) \
6403 if (pedwarn (PLOC, OPT, AR, parmnum, rname, QUALS)) \
6404 inform_for_arg (fundecl, (PLOC), parmnum, type, rhstype); \
6407 pedwarn (LOCATION, OPT, AS, QUALS); \
6410 pedwarn (LOCATION, OPT, IN, QUALS); \
6413 pedwarn (LOCATION, OPT, RE, QUALS); \
6416 gcc_unreachable (); \
6420 /* This macro is used to emit diagnostics to ensure that all format
6421 strings are complete sentences, visible to gettext and checked at
6422 compile time. It is the same as PEDWARN_FOR_QUALIFIERS but uses
6423 warning_at instead of pedwarn. */
6424 #define WARNING_FOR_QUALIFIERS(LOCATION, PLOC, OPT, AR, AS, IN, RE, QUALS) \
6429 if (warning_at (PLOC, OPT, AR, parmnum, rname, QUALS)) \
6430 inform_for_arg (fundecl, (PLOC), parmnum, type, rhstype); \
6433 warning_at (LOCATION, OPT, AS, QUALS); \
6436 warning_at (LOCATION, OPT, IN, QUALS); \
6439 warning_at (LOCATION, OPT, RE, QUALS); \
6442 gcc_unreachable (); \
6446 if (TREE_CODE (rhs
) == EXCESS_PRECISION_EXPR
)
6447 rhs
= TREE_OPERAND (rhs
, 0);
6449 rhstype
= TREE_TYPE (rhs
);
6450 coder
= TREE_CODE (rhstype
);
6452 if (coder
== ERROR_MARK
)
6453 return error_mark_node
;
6455 if (c_dialect_objc ())
6478 objc_ok
= objc_compare_types (type
, rhstype
, parmno
, rname
);
6481 if (warn_cxx_compat
)
6483 tree checktype
= origtype
!= NULL_TREE
? origtype
: rhstype
;
6484 if (checktype
!= error_mark_node
6485 && TREE_CODE (type
) == ENUMERAL_TYPE
6486 && TYPE_MAIN_VARIANT (checktype
) != TYPE_MAIN_VARIANT (type
))
6490 if (pedwarn (expr_loc
, OPT_Wc___compat
, "enum conversion when "
6491 "passing argument %d of %qE is invalid in C++",
6493 inform ((fundecl
&& !DECL_IS_BUILTIN (fundecl
))
6494 ? DECL_SOURCE_LOCATION (fundecl
) : expr_loc
,
6495 "expected %qT but argument is of type %qT",
6499 pedwarn (location
, OPT_Wc___compat
, "enum conversion from %qT to "
6500 "%qT in assignment is invalid in C++", rhstype
, type
);
6503 pedwarn_init (location
, OPT_Wc___compat
, "enum conversion from "
6504 "%qT to %qT in initialization is invalid in C++",
6508 pedwarn (location
, OPT_Wc___compat
, "enum conversion from %qT to "
6509 "%qT in return is invalid in C++", rhstype
, type
);
6516 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (rhstype
))
6519 if (coder
== VOID_TYPE
)
6521 /* Except for passing an argument to an unprototyped function,
6522 this is a constraint violation. When passing an argument to
6523 an unprototyped function, it is compile-time undefined;
6524 making it a constraint in that case was rejected in
6526 error_at (location
, "void value not ignored as it ought to be");
6527 return error_mark_node
;
6529 rhs
= require_complete_type (location
, rhs
);
6530 if (rhs
== error_mark_node
)
6531 return error_mark_node
;
6533 if (coder
== POINTER_TYPE
&& reject_gcc_builtin (rhs
))
6534 return error_mark_node
;
6536 /* A non-reference type can convert to a reference. This handles
6537 va_start, va_copy and possibly port built-ins. */
6538 if (codel
== REFERENCE_TYPE
&& coder
!= REFERENCE_TYPE
)
6540 if (!lvalue_p (rhs
))
6542 error_at (location
, "cannot pass rvalue to reference parameter");
6543 return error_mark_node
;
6545 if (!c_mark_addressable (rhs
))
6546 return error_mark_node
;
6547 rhs
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (rhs
)), rhs
);
6548 SET_EXPR_LOCATION (rhs
, location
);
6550 rhs
= convert_for_assignment (location
, expr_loc
,
6551 build_pointer_type (TREE_TYPE (type
)),
6552 rhs
, origtype
, errtype
,
6553 null_pointer_constant
, fundecl
, function
,
6555 if (rhs
== error_mark_node
)
6556 return error_mark_node
;
6558 rhs
= build1 (NOP_EXPR
, type
, rhs
);
6559 SET_EXPR_LOCATION (rhs
, location
);
6562 /* Some types can interconvert without explicit casts. */
6563 else if (codel
== VECTOR_TYPE
&& coder
== VECTOR_TYPE
6564 && vector_types_convertible_p (type
, TREE_TYPE (rhs
), true))
6565 return convert (type
, rhs
);
6566 /* Arithmetic types all interconvert, and enum is treated like int. */
6567 else if ((codel
== INTEGER_TYPE
|| codel
== REAL_TYPE
6568 || codel
== FIXED_POINT_TYPE
6569 || codel
== ENUMERAL_TYPE
|| codel
== COMPLEX_TYPE
6570 || codel
== BOOLEAN_TYPE
)
6571 && (coder
== INTEGER_TYPE
|| coder
== REAL_TYPE
6572 || coder
== FIXED_POINT_TYPE
6573 || coder
== ENUMERAL_TYPE
|| coder
== COMPLEX_TYPE
6574 || coder
== BOOLEAN_TYPE
))
6577 bool save
= in_late_binary_op
;
6578 if (codel
== BOOLEAN_TYPE
|| codel
== COMPLEX_TYPE
6579 || (coder
== REAL_TYPE
6580 && (codel
== INTEGER_TYPE
|| codel
== ENUMERAL_TYPE
)
6581 && sanitize_flags_p (SANITIZE_FLOAT_CAST
)))
6582 in_late_binary_op
= true;
6583 ret
= convert_and_check (expr_loc
!= UNKNOWN_LOCATION
6584 ? expr_loc
: location
, type
, orig_rhs
);
6585 in_late_binary_op
= save
;
6589 /* Aggregates in different TUs might need conversion. */
6590 if ((codel
== RECORD_TYPE
|| codel
== UNION_TYPE
)
6592 && comptypes (type
, rhstype
))
6593 return convert_and_check (expr_loc
!= UNKNOWN_LOCATION
6594 ? expr_loc
: location
, type
, rhs
);
6596 /* Conversion to a transparent union or record from its member types.
6597 This applies only to function arguments. */
6598 if (((codel
== UNION_TYPE
|| codel
== RECORD_TYPE
)
6599 && TYPE_TRANSPARENT_AGGR (type
))
6600 && errtype
== ic_argpass
)
6602 tree memb
, marginal_memb
= NULL_TREE
;
6604 for (memb
= TYPE_FIELDS (type
); memb
; memb
= DECL_CHAIN (memb
))
6606 tree memb_type
= TREE_TYPE (memb
);
6608 if (comptypes (TYPE_MAIN_VARIANT (memb_type
),
6609 TYPE_MAIN_VARIANT (rhstype
)))
6612 if (TREE_CODE (memb_type
) != POINTER_TYPE
)
6615 if (coder
== POINTER_TYPE
)
6617 tree ttl
= TREE_TYPE (memb_type
);
6618 tree ttr
= TREE_TYPE (rhstype
);
6620 /* Any non-function converts to a [const][volatile] void *
6621 and vice versa; otherwise, targets must be the same.
6622 Meanwhile, the lhs target must have all the qualifiers of
6624 if ((VOID_TYPE_P (ttl
) && !TYPE_ATOMIC (ttl
))
6625 || (VOID_TYPE_P (ttr
) && !TYPE_ATOMIC (ttr
))
6626 || comp_target_types (location
, memb_type
, rhstype
))
6628 int lquals
= TYPE_QUALS (ttl
) & ~TYPE_QUAL_ATOMIC
;
6629 int rquals
= TYPE_QUALS (ttr
) & ~TYPE_QUAL_ATOMIC
;
6630 /* If this type won't generate any warnings, use it. */
6631 if (lquals
== rquals
6632 || ((TREE_CODE (ttr
) == FUNCTION_TYPE
6633 && TREE_CODE (ttl
) == FUNCTION_TYPE
)
6634 ? ((lquals
| rquals
) == rquals
)
6635 : ((lquals
| rquals
) == lquals
)))
6638 /* Keep looking for a better type, but remember this one. */
6640 marginal_memb
= memb
;
6644 /* Can convert integer zero to any pointer type. */
6645 if (null_pointer_constant
)
6647 rhs
= null_pointer_node
;
6652 if (memb
|| marginal_memb
)
6656 /* We have only a marginally acceptable member type;
6657 it needs a warning. */
6658 tree ttl
= TREE_TYPE (TREE_TYPE (marginal_memb
));
6659 tree ttr
= TREE_TYPE (rhstype
);
6661 /* Const and volatile mean something different for function
6662 types, so the usual warnings are not appropriate. */
6663 if (TREE_CODE (ttr
) == FUNCTION_TYPE
6664 && TREE_CODE (ttl
) == FUNCTION_TYPE
)
6666 /* Because const and volatile on functions are
6667 restrictions that say the function will not do
6668 certain things, it is okay to use a const or volatile
6669 function where an ordinary one is wanted, but not
6671 if (TYPE_QUALS_NO_ADDR_SPACE (ttl
)
6672 & ~TYPE_QUALS_NO_ADDR_SPACE (ttr
))
6673 PEDWARN_FOR_QUALIFIERS (location
, expr_loc
,
6674 OPT_Wdiscarded_qualifiers
,
6675 G_("passing argument %d of %qE "
6676 "makes %q#v qualified function "
6677 "pointer from unqualified"),
6678 G_("assignment makes %q#v qualified "
6679 "function pointer from "
6681 G_("initialization makes %q#v qualified "
6682 "function pointer from "
6684 G_("return makes %q#v qualified function "
6685 "pointer from unqualified"),
6686 TYPE_QUALS (ttl
) & ~TYPE_QUALS (ttr
));
6688 else if (TYPE_QUALS_NO_ADDR_SPACE (ttr
)
6689 & ~TYPE_QUALS_NO_ADDR_SPACE (ttl
))
6690 PEDWARN_FOR_QUALIFIERS (location
, expr_loc
,
6691 OPT_Wdiscarded_qualifiers
,
6692 G_("passing argument %d of %qE discards "
6693 "%qv qualifier from pointer target type"),
6694 G_("assignment discards %qv qualifier "
6695 "from pointer target type"),
6696 G_("initialization discards %qv qualifier "
6697 "from pointer target type"),
6698 G_("return discards %qv qualifier from "
6699 "pointer target type"),
6700 TYPE_QUALS (ttr
) & ~TYPE_QUALS (ttl
));
6702 memb
= marginal_memb
;
6705 if (!fundecl
|| !DECL_IN_SYSTEM_HEADER (fundecl
))
6706 pedwarn (location
, OPT_Wpedantic
,
6707 "ISO C prohibits argument conversion to union type");
6709 rhs
= fold_convert_loc (location
, TREE_TYPE (memb
), rhs
);
6710 return build_constructor_single (type
, memb
, rhs
);
6714 /* Conversions among pointers */
6715 else if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
6716 && (coder
== codel
))
6718 tree ttl
= TREE_TYPE (type
);
6719 tree ttr
= TREE_TYPE (rhstype
);
6722 bool is_opaque_pointer
;
6723 int target_cmp
= 0; /* Cache comp_target_types () result. */
6727 if (TREE_CODE (mvl
) != ARRAY_TYPE
)
6728 mvl
= (TYPE_ATOMIC (mvl
)
6729 ? c_build_qualified_type (TYPE_MAIN_VARIANT (mvl
),
6731 : TYPE_MAIN_VARIANT (mvl
));
6732 if (TREE_CODE (mvr
) != ARRAY_TYPE
)
6733 mvr
= (TYPE_ATOMIC (mvr
)
6734 ? c_build_qualified_type (TYPE_MAIN_VARIANT (mvr
),
6736 : TYPE_MAIN_VARIANT (mvr
));
6737 /* Opaque pointers are treated like void pointers. */
6738 is_opaque_pointer
= vector_targets_convertible_p (ttl
, ttr
);
6740 /* The Plan 9 compiler permits a pointer to a struct to be
6741 automatically converted into a pointer to an anonymous field
6742 within the struct. */
6743 if (flag_plan9_extensions
6744 && RECORD_OR_UNION_TYPE_P (mvl
)
6745 && RECORD_OR_UNION_TYPE_P (mvr
)
6748 tree new_rhs
= convert_to_anonymous_field (location
, type
, rhs
);
6749 if (new_rhs
!= NULL_TREE
)
6752 rhstype
= TREE_TYPE (rhs
);
6753 coder
= TREE_CODE (rhstype
);
6754 ttr
= TREE_TYPE (rhstype
);
6755 mvr
= TYPE_MAIN_VARIANT (ttr
);
6759 /* C++ does not allow the implicit conversion void* -> T*. However,
6760 for the purpose of reducing the number of false positives, we
6761 tolerate the special case of
6765 where NULL is typically defined in C to be '(void *) 0'. */
6766 if (VOID_TYPE_P (ttr
) && rhs
!= null_pointer_node
&& !VOID_TYPE_P (ttl
))
6767 warning_at (errtype
== ic_argpass
? expr_loc
: location
,
6769 "request for implicit conversion "
6770 "from %qT to %qT not permitted in C++", rhstype
, type
);
6772 /* See if the pointers point to incompatible address spaces. */
6773 asl
= TYPE_ADDR_SPACE (ttl
);
6774 asr
= TYPE_ADDR_SPACE (ttr
);
6775 if (!null_pointer_constant_p (rhs
)
6776 && asr
!= asl
&& !targetm
.addr_space
.subset_p (asr
, asl
))
6781 error_at (expr_loc
, "passing argument %d of %qE from pointer to "
6782 "non-enclosed address space", parmnum
, rname
);
6785 error_at (location
, "assignment from pointer to "
6786 "non-enclosed address space");
6789 error_at (location
, "initialization from pointer to "
6790 "non-enclosed address space");
6793 error_at (location
, "return from pointer to "
6794 "non-enclosed address space");
6799 return error_mark_node
;
6802 /* Check if the right-hand side has a format attribute but the
6803 left-hand side doesn't. */
6804 if (warn_suggest_attribute_format
6805 && check_missing_format_attribute (type
, rhstype
))
6810 warning_at (expr_loc
, OPT_Wsuggest_attribute_format
,
6811 "argument %d of %qE might be "
6812 "a candidate for a format attribute",
6816 warning_at (location
, OPT_Wsuggest_attribute_format
,
6817 "assignment left-hand side might be "
6818 "a candidate for a format attribute");
6821 warning_at (location
, OPT_Wsuggest_attribute_format
,
6822 "initialization left-hand side might be "
6823 "a candidate for a format attribute");
6826 warning_at (location
, OPT_Wsuggest_attribute_format
,
6827 "return type might be "
6828 "a candidate for a format attribute");
6835 /* Any non-function converts to a [const][volatile] void *
6836 and vice versa; otherwise, targets must be the same.
6837 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
6838 if ((VOID_TYPE_P (ttl
) && !TYPE_ATOMIC (ttl
))
6839 || (VOID_TYPE_P (ttr
) && !TYPE_ATOMIC (ttr
))
6840 || (target_cmp
= comp_target_types (location
, type
, rhstype
))
6841 || is_opaque_pointer
6842 || ((c_common_unsigned_type (mvl
)
6843 == c_common_unsigned_type (mvr
))
6844 && (c_common_signed_type (mvl
)
6845 == c_common_signed_type (mvr
))
6846 && TYPE_ATOMIC (mvl
) == TYPE_ATOMIC (mvr
)))
6848 /* Warn about loss of qualifers from pointers to arrays with
6849 qualifiers on the element type. */
6850 if (TREE_CODE (ttr
) == ARRAY_TYPE
)
6852 ttr
= strip_array_types (ttr
);
6853 ttl
= strip_array_types (ttl
);
6855 if (TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC (ttr
)
6856 & ~TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC (ttl
))
6857 WARNING_FOR_QUALIFIERS (location
, expr_loc
,
6858 OPT_Wdiscarded_array_qualifiers
,
6859 G_("passing argument %d of %qE discards "
6860 "%qv qualifier from pointer target type"),
6861 G_("assignment discards %qv qualifier "
6862 "from pointer target type"),
6863 G_("initialization discards %qv qualifier "
6864 "from pointer target type"),
6865 G_("return discards %qv qualifier from "
6866 "pointer target type"),
6867 TYPE_QUALS (ttr
) & ~TYPE_QUALS (ttl
));
6870 && ((VOID_TYPE_P (ttl
) && TREE_CODE (ttr
) == FUNCTION_TYPE
)
6873 && !null_pointer_constant
6874 && TREE_CODE (ttl
) == FUNCTION_TYPE
)))
6875 PEDWARN_FOR_ASSIGNMENT (location
, expr_loc
, OPT_Wpedantic
,
6876 G_("ISO C forbids passing argument %d of "
6877 "%qE between function pointer "
6879 G_("ISO C forbids assignment between "
6880 "function pointer and %<void *%>"),
6881 G_("ISO C forbids initialization between "
6882 "function pointer and %<void *%>"),
6883 G_("ISO C forbids return between function "
6884 "pointer and %<void *%>"));
6885 /* Const and volatile mean something different for function types,
6886 so the usual warnings are not appropriate. */
6887 else if (TREE_CODE (ttr
) != FUNCTION_TYPE
6888 && TREE_CODE (ttl
) != FUNCTION_TYPE
)
6890 /* Don't warn about loss of qualifier for conversions from
6891 qualified void* to pointers to arrays with corresponding
6892 qualifier on the element type. */
6894 ttl
= strip_array_types (ttl
);
6896 /* Assignments between atomic and non-atomic objects are OK. */
6897 if (TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC (ttr
)
6898 & ~TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC (ttl
))
6900 PEDWARN_FOR_QUALIFIERS (location
, expr_loc
,
6901 OPT_Wdiscarded_qualifiers
,
6902 G_("passing argument %d of %qE discards "
6903 "%qv qualifier from pointer target type"),
6904 G_("assignment discards %qv qualifier "
6905 "from pointer target type"),
6906 G_("initialization discards %qv qualifier "
6907 "from pointer target type"),
6908 G_("return discards %qv qualifier from "
6909 "pointer target type"),
6910 TYPE_QUALS (ttr
) & ~TYPE_QUALS (ttl
));
6912 /* If this is not a case of ignoring a mismatch in signedness,
6914 else if (VOID_TYPE_P (ttl
) || VOID_TYPE_P (ttr
)
6917 /* If there is a mismatch, do warn. */
6918 else if (warn_pointer_sign
)
6922 if (pedwarn (expr_loc
, OPT_Wpointer_sign
,
6923 "pointer targets in passing argument %d of "
6924 "%qE differ in signedness", parmnum
, rname
))
6925 inform ((fundecl
&& !DECL_IS_BUILTIN (fundecl
))
6926 ? DECL_SOURCE_LOCATION (fundecl
) : expr_loc
,
6927 "expected %qT but argument is of type %qT",
6931 pedwarn (location
, OPT_Wpointer_sign
,
6932 "pointer targets in assignment from %qT to %qT "
6933 "differ in signedness", rhstype
, type
);
6936 pedwarn_init (location
, OPT_Wpointer_sign
,
6937 "pointer targets in initialization of %qT "
6938 "from %qT differ in signedness", type
,
6942 pedwarn (location
, OPT_Wpointer_sign
, "pointer targets in "
6943 "returning %qT from a function with return type "
6944 "%qT differ in signedness", rhstype
, type
);
6950 else if (TREE_CODE (ttl
) == FUNCTION_TYPE
6951 && TREE_CODE (ttr
) == FUNCTION_TYPE
)
6953 /* Because const and volatile on functions are restrictions
6954 that say the function will not do certain things,
6955 it is okay to use a const or volatile function
6956 where an ordinary one is wanted, but not vice-versa. */
6957 if (TYPE_QUALS_NO_ADDR_SPACE (ttl
)
6958 & ~TYPE_QUALS_NO_ADDR_SPACE (ttr
))
6959 PEDWARN_FOR_QUALIFIERS (location
, expr_loc
,
6960 OPT_Wdiscarded_qualifiers
,
6961 G_("passing argument %d of %qE makes "
6962 "%q#v qualified function pointer "
6963 "from unqualified"),
6964 G_("assignment makes %q#v qualified function "
6965 "pointer from unqualified"),
6966 G_("initialization makes %q#v qualified "
6967 "function pointer from unqualified"),
6968 G_("return makes %q#v qualified function "
6969 "pointer from unqualified"),
6970 TYPE_QUALS (ttl
) & ~TYPE_QUALS (ttr
));
6973 /* Avoid warning about the volatile ObjC EH puts on decls. */
6979 if (pedwarn (expr_loc
, OPT_Wincompatible_pointer_types
,
6980 "passing argument %d of %qE from incompatible "
6981 "pointer type", parmnum
, rname
))
6982 inform_for_arg (fundecl
, expr_loc
, parmnum
, type
, rhstype
);
6985 pedwarn (location
, OPT_Wincompatible_pointer_types
,
6986 "assignment to %qT from incompatible pointer type %qT",
6990 pedwarn_init (location
, OPT_Wincompatible_pointer_types
,
6991 "initialization of %qT from incompatible pointer "
6992 "type %qT", type
, rhstype
);
6995 pedwarn (location
, OPT_Wincompatible_pointer_types
,
6996 "returning %qT from a function with incompatible "
6997 "return type %qT", rhstype
, type
);
7004 return convert (type
, rhs
);
7006 else if (codel
== POINTER_TYPE
&& coder
== ARRAY_TYPE
)
7008 /* ??? This should not be an error when inlining calls to
7009 unprototyped functions. */
7010 error_at (location
, "invalid use of non-lvalue array");
7011 return error_mark_node
;
7013 else if (codel
== POINTER_TYPE
&& coder
== INTEGER_TYPE
)
7015 /* An explicit constant 0 can convert to a pointer,
7016 or one that results from arithmetic, even including
7017 a cast to integer type. */
7018 if (!null_pointer_constant
)
7022 if (pedwarn (expr_loc
, OPT_Wint_conversion
,
7023 "passing argument %d of %qE makes pointer from "
7024 "integer without a cast", parmnum
, rname
))
7025 inform_for_arg (fundecl
, expr_loc
, parmnum
, type
, rhstype
);
7028 pedwarn (location
, OPT_Wint_conversion
,
7029 "assignment to %qT from %qT makes pointer from integer "
7030 "without a cast", type
, rhstype
);
7033 pedwarn_init (location
, OPT_Wint_conversion
,
7034 "initialization of %qT from %qT makes pointer from "
7035 "integer without a cast", type
, rhstype
);
7038 pedwarn (location
, OPT_Wint_conversion
, "returning %qT from a "
7039 "function with return type %qT makes pointer from "
7040 "integer without a cast", rhstype
, type
);
7046 return convert (type
, rhs
);
7048 else if (codel
== INTEGER_TYPE
&& coder
== POINTER_TYPE
)
7053 if (pedwarn (expr_loc
, OPT_Wint_conversion
,
7054 "passing argument %d of %qE makes integer from "
7055 "pointer without a cast", parmnum
, rname
))
7056 inform_for_arg (fundecl
, expr_loc
, parmnum
, type
, rhstype
);
7059 pedwarn (location
, OPT_Wint_conversion
,
7060 "assignment to %qT from %qT makes integer from pointer "
7061 "without a cast", type
, rhstype
);
7064 pedwarn_init (location
, OPT_Wint_conversion
,
7065 "initialization of %qT from %qT makes integer from "
7066 "pointer without a cast", type
, rhstype
);
7069 pedwarn (location
, OPT_Wint_conversion
, "returning %qT from a "
7070 "function with return type %qT makes integer from "
7071 "pointer without a cast", rhstype
, type
);
7077 return convert (type
, rhs
);
7079 else if (codel
== BOOLEAN_TYPE
&& coder
== POINTER_TYPE
)
7082 bool save
= in_late_binary_op
;
7083 in_late_binary_op
= true;
7084 ret
= convert (type
, rhs
);
7085 in_late_binary_op
= save
;
7092 error_at (expr_loc
, "incompatible type for argument %d of %qE", parmnum
,
7094 inform_for_arg (fundecl
, expr_loc
, parmnum
, type
, rhstype
);
7097 error_at (location
, "incompatible types when assigning to type %qT from "
7098 "type %qT", type
, rhstype
);
7102 "incompatible types when initializing type %qT using type %qT",
7107 "incompatible types when returning type %qT but %qT was "
7108 "expected", rhstype
, type
);
7114 return error_mark_node
;
7117 /* If VALUE is a compound expr all of whose expressions are constant, then
7118 return its value. Otherwise, return error_mark_node.
7120 This is for handling COMPOUND_EXPRs as initializer elements
7121 which is allowed with a warning when -pedantic is specified. */
7124 valid_compound_expr_initializer (tree value
, tree endtype
)
7126 if (TREE_CODE (value
) == COMPOUND_EXPR
)
7128 if (valid_compound_expr_initializer (TREE_OPERAND (value
, 0), endtype
)
7130 return error_mark_node
;
7131 return valid_compound_expr_initializer (TREE_OPERAND (value
, 1),
7134 else if (!initializer_constant_valid_p (value
, endtype
))
7135 return error_mark_node
;
7140 /* Perform appropriate conversions on the initial value of a variable,
7141 store it in the declaration DECL,
7142 and print any error messages that are appropriate.
7143 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
7144 If the init is invalid, store an ERROR_MARK.
7146 INIT_LOC is the location of the initial value. */
7149 store_init_value (location_t init_loc
, tree decl
, tree init
, tree origtype
)
7154 /* If variable's type was invalidly declared, just ignore it. */
7156 type
= TREE_TYPE (decl
);
7157 if (TREE_CODE (type
) == ERROR_MARK
)
7160 /* Digest the specified initializer into an expression. */
7163 npc
= null_pointer_constant_p (init
);
7164 value
= digest_init (init_loc
, type
, init
, origtype
, npc
,
7165 true, TREE_STATIC (decl
));
7167 /* Store the expression if valid; else report error. */
7169 if (!in_system_header_at (input_location
)
7170 && AGGREGATE_TYPE_P (TREE_TYPE (decl
)) && !TREE_STATIC (decl
))
7171 warning (OPT_Wtraditional
, "traditional C rejects automatic "
7172 "aggregate initialization");
7174 if (value
!= error_mark_node
|| TREE_CODE (decl
) != FUNCTION_DECL
)
7175 DECL_INITIAL (decl
) = value
;
7177 /* ANSI wants warnings about out-of-range constant initializers. */
7178 STRIP_TYPE_NOPS (value
);
7179 if (TREE_STATIC (decl
))
7180 constant_expression_warning (value
);
7182 /* Check if we need to set array size from compound literal size. */
7183 if (TREE_CODE (type
) == ARRAY_TYPE
7184 && TYPE_DOMAIN (type
) == NULL_TREE
7185 && value
!= error_mark_node
)
7187 tree inside_init
= init
;
7189 STRIP_TYPE_NOPS (inside_init
);
7190 inside_init
= fold (inside_init
);
7192 if (TREE_CODE (inside_init
) == COMPOUND_LITERAL_EXPR
)
7194 tree cldecl
= COMPOUND_LITERAL_EXPR_DECL (inside_init
);
7196 if (TYPE_DOMAIN (TREE_TYPE (cldecl
)))
7198 /* For int foo[] = (int [3]){1}; we need to set array size
7199 now since later on array initializer will be just the
7200 brace enclosed list of the compound literal. */
7201 tree etype
= strip_array_types (TREE_TYPE (decl
));
7202 type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
7203 TYPE_DOMAIN (type
) = TYPE_DOMAIN (TREE_TYPE (cldecl
));
7205 layout_decl (cldecl
, 0);
7207 = c_build_qualified_type (type
, TYPE_QUALS (etype
));
7213 /* Methods for storing and printing names for error messages. */
7215 /* Implement a spelling stack that allows components of a name to be pushed
7216 and popped. Each element on the stack is this structure. */
7223 unsigned HOST_WIDE_INT i
;
7228 #define SPELLING_STRING 1
7229 #define SPELLING_MEMBER 2
7230 #define SPELLING_BOUNDS 3
7232 static struct spelling
*spelling
; /* Next stack element (unused). */
7233 static struct spelling
*spelling_base
; /* Spelling stack base. */
7234 static int spelling_size
; /* Size of the spelling stack. */
7236 /* Macros to save and restore the spelling stack around push_... functions.
7237 Alternative to SAVE_SPELLING_STACK. */
7239 #define SPELLING_DEPTH() (spelling - spelling_base)
7240 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
7242 /* Push an element on the spelling stack with type KIND and assign VALUE
7245 #define PUSH_SPELLING(KIND, VALUE, MEMBER) \
7247 int depth = SPELLING_DEPTH (); \
7249 if (depth >= spelling_size) \
7251 spelling_size += 10; \
7252 spelling_base = XRESIZEVEC (struct spelling, spelling_base, \
7254 RESTORE_SPELLING_DEPTH (depth); \
7257 spelling->kind = (KIND); \
7258 spelling->MEMBER = (VALUE); \
7262 /* Push STRING on the stack. Printed literally. */
7265 push_string (const char *string
)
7267 PUSH_SPELLING (SPELLING_STRING
, string
, u
.s
);
7270 /* Push a member name on the stack. Printed as '.' STRING. */
7273 push_member_name (tree decl
)
7275 const char *const string
7277 ? identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl
)))
7278 : _("<anonymous>"));
7279 PUSH_SPELLING (SPELLING_MEMBER
, string
, u
.s
);
7282 /* Push an array bounds on the stack. Printed as [BOUNDS]. */
7285 push_array_bounds (unsigned HOST_WIDE_INT bounds
)
7287 PUSH_SPELLING (SPELLING_BOUNDS
, bounds
, u
.i
);
7290 /* Compute the maximum size in bytes of the printed spelling. */
7293 spelling_length (void)
7298 for (p
= spelling_base
; p
< spelling
; p
++)
7300 if (p
->kind
== SPELLING_BOUNDS
)
7303 size
+= strlen (p
->u
.s
) + 1;
7309 /* Print the spelling to BUFFER and return it. */
7312 print_spelling (char *buffer
)
7317 for (p
= spelling_base
; p
< spelling
; p
++)
7318 if (p
->kind
== SPELLING_BOUNDS
)
7320 sprintf (d
, "[" HOST_WIDE_INT_PRINT_UNSIGNED
"]", p
->u
.i
);
7326 if (p
->kind
== SPELLING_MEMBER
)
7328 for (s
= p
->u
.s
; (*d
= *s
++); d
++)
7335 /* Digest the parser output INIT as an initializer for type TYPE.
7336 Return a C expression of type TYPE to represent the initial value.
7338 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
7340 NULL_POINTER_CONSTANT is true if INIT is a null pointer constant.
7342 If INIT is a string constant, STRICT_STRING is true if it is
7343 unparenthesized or we should not warn here for it being parenthesized.
7344 For other types of INIT, STRICT_STRING is not used.
7346 INIT_LOC is the location of the INIT.
7348 REQUIRE_CONSTANT requests an error if non-constant initializers or
7349 elements are seen. */
7352 digest_init (location_t init_loc
, tree type
, tree init
, tree origtype
,
7353 bool null_pointer_constant
, bool strict_string
,
7354 int require_constant
)
7356 enum tree_code code
= TREE_CODE (type
);
7357 tree inside_init
= init
;
7358 tree semantic_type
= NULL_TREE
;
7359 bool maybe_const
= true;
7361 if (type
== error_mark_node
7363 || error_operand_p (init
))
7364 return error_mark_node
;
7366 STRIP_TYPE_NOPS (inside_init
);
7368 if (TREE_CODE (inside_init
) == EXCESS_PRECISION_EXPR
)
7370 semantic_type
= TREE_TYPE (inside_init
);
7371 inside_init
= TREE_OPERAND (inside_init
, 0);
7373 inside_init
= c_fully_fold (inside_init
, require_constant
, &maybe_const
);
7375 /* Initialization of an array of chars from a string constant
7376 optionally enclosed in braces. */
7378 if (code
== ARRAY_TYPE
&& inside_init
7379 && TREE_CODE (inside_init
) == STRING_CST
)
7382 = (TYPE_ATOMIC (TREE_TYPE (type
))
7383 ? c_build_qualified_type (TYPE_MAIN_VARIANT (TREE_TYPE (type
)),
7385 : TYPE_MAIN_VARIANT (TREE_TYPE (type
)));
7386 /* Note that an array could be both an array of character type
7387 and an array of wchar_t if wchar_t is signed char or unsigned
7389 bool char_array
= (typ1
== char_type_node
7390 || typ1
== signed_char_type_node
7391 || typ1
== unsigned_char_type_node
);
7392 bool wchar_array
= !!comptypes (typ1
, wchar_type_node
);
7393 bool char16_array
= !!comptypes (typ1
, char16_type_node
);
7394 bool char32_array
= !!comptypes (typ1
, char32_type_node
);
7396 if (char_array
|| wchar_array
|| char16_array
|| char32_array
)
7399 tree typ2
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init
)));
7400 expr
.value
= inside_init
;
7401 expr
.original_code
= (strict_string
? STRING_CST
: ERROR_MARK
);
7402 expr
.original_type
= NULL
;
7403 maybe_warn_string_init (init_loc
, type
, expr
);
7405 if (TYPE_DOMAIN (type
) && !TYPE_MAX_VALUE (TYPE_DOMAIN (type
)))
7406 pedwarn_init (init_loc
, OPT_Wpedantic
,
7407 "initialization of a flexible array member");
7409 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init
)),
7410 TYPE_MAIN_VARIANT (type
)))
7415 if (typ2
!= char_type_node
)
7417 error_init (init_loc
, "char-array initialized from wide "
7419 return error_mark_node
;
7424 if (typ2
== char_type_node
)
7426 error_init (init_loc
, "wide character array initialized "
7427 "from non-wide string");
7428 return error_mark_node
;
7430 else if (!comptypes(typ1
, typ2
))
7432 error_init (init_loc
, "wide character array initialized "
7433 "from incompatible wide string");
7434 return error_mark_node
;
7438 TREE_TYPE (inside_init
) = type
;
7439 if (TYPE_DOMAIN (type
) != NULL_TREE
7440 && TYPE_SIZE (type
) != NULL_TREE
7441 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
7443 unsigned HOST_WIDE_INT len
= TREE_STRING_LENGTH (inside_init
);
7445 /* Subtract the size of a single (possibly wide) character
7446 because it's ok to ignore the terminating null char
7447 that is counted in the length of the constant. */
7448 if (compare_tree_int (TYPE_SIZE_UNIT (type
),
7449 (len
- (TYPE_PRECISION (typ1
)
7450 / BITS_PER_UNIT
))) < 0)
7451 pedwarn_init (init_loc
, 0,
7452 ("initializer-string for array of chars "
7454 else if (warn_cxx_compat
7455 && compare_tree_int (TYPE_SIZE_UNIT (type
), len
) < 0)
7456 warning_at (init_loc
, OPT_Wc___compat
,
7457 ("initializer-string for array chars "
7458 "is too long for C++"));
7463 else if (INTEGRAL_TYPE_P (typ1
))
7465 error_init (init_loc
, "array of inappropriate type initialized "
7466 "from string constant");
7467 return error_mark_node
;
7471 /* Build a VECTOR_CST from a *constant* vector constructor. If the
7472 vector constructor is not constant (e.g. {1,2,3,foo()}) then punt
7473 below and handle as a constructor. */
7474 if (code
== VECTOR_TYPE
7475 && VECTOR_TYPE_P (TREE_TYPE (inside_init
))
7476 && vector_types_convertible_p (TREE_TYPE (inside_init
), type
, true)
7477 && TREE_CONSTANT (inside_init
))
7479 if (TREE_CODE (inside_init
) == VECTOR_CST
7480 && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init
)),
7481 TYPE_MAIN_VARIANT (type
)))
7484 if (TREE_CODE (inside_init
) == CONSTRUCTOR
)
7486 unsigned HOST_WIDE_INT ix
;
7488 bool constant_p
= true;
7490 /* Iterate through elements and check if all constructor
7491 elements are *_CSTs. */
7492 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (inside_init
), ix
, value
)
7493 if (!CONSTANT_CLASS_P (value
))
7500 return build_vector_from_ctor (type
,
7501 CONSTRUCTOR_ELTS (inside_init
));
7505 if (warn_sequence_point
)
7506 verify_sequence_points (inside_init
);
7508 /* Any type can be initialized
7509 from an expression of the same type, optionally with braces. */
7511 if (inside_init
&& TREE_TYPE (inside_init
) != NULL_TREE
7512 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init
)),
7513 TYPE_MAIN_VARIANT (type
))
7514 || (code
== ARRAY_TYPE
7515 && comptypes (TREE_TYPE (inside_init
), type
))
7516 || (code
== VECTOR_TYPE
7517 && comptypes (TREE_TYPE (inside_init
), type
))
7518 || (code
== POINTER_TYPE
7519 && TREE_CODE (TREE_TYPE (inside_init
)) == ARRAY_TYPE
7520 && comptypes (TREE_TYPE (TREE_TYPE (inside_init
)),
7521 TREE_TYPE (type
)))))
7523 if (code
== POINTER_TYPE
)
7525 if (TREE_CODE (TREE_TYPE (inside_init
)) == ARRAY_TYPE
)
7527 if (TREE_CODE (inside_init
) == STRING_CST
7528 || TREE_CODE (inside_init
) == COMPOUND_LITERAL_EXPR
)
7529 inside_init
= array_to_pointer_conversion
7530 (init_loc
, inside_init
);
7533 error_init (init_loc
, "invalid use of non-lvalue array");
7534 return error_mark_node
;
7539 if (code
== VECTOR_TYPE
)
7540 /* Although the types are compatible, we may require a
7542 inside_init
= convert (type
, inside_init
);
7544 if (require_constant
7545 && TREE_CODE (inside_init
) == COMPOUND_LITERAL_EXPR
)
7547 /* As an extension, allow initializing objects with static storage
7548 duration with compound literals (which are then treated just as
7549 the brace enclosed list they contain). Also allow this for
7550 vectors, as we can only assign them with compound literals. */
7551 if (flag_isoc99
&& code
!= VECTOR_TYPE
)
7552 pedwarn_init (init_loc
, OPT_Wpedantic
, "initializer element "
7554 tree decl
= COMPOUND_LITERAL_EXPR_DECL (inside_init
);
7555 inside_init
= DECL_INITIAL (decl
);
7558 if (code
== ARRAY_TYPE
&& TREE_CODE (inside_init
) != STRING_CST
7559 && TREE_CODE (inside_init
) != CONSTRUCTOR
)
7561 error_init (init_loc
, "array initialized from non-constant array "
7563 return error_mark_node
;
7566 /* Compound expressions can only occur here if -Wpedantic or
7567 -pedantic-errors is specified. In the later case, we always want
7568 an error. In the former case, we simply want a warning. */
7569 if (require_constant
&& pedantic
7570 && TREE_CODE (inside_init
) == COMPOUND_EXPR
)
7573 = valid_compound_expr_initializer (inside_init
,
7574 TREE_TYPE (inside_init
));
7575 if (inside_init
== error_mark_node
)
7576 error_init (init_loc
, "initializer element is not constant");
7578 pedwarn_init (init_loc
, OPT_Wpedantic
,
7579 "initializer element is not constant");
7580 if (flag_pedantic_errors
)
7581 inside_init
= error_mark_node
;
7583 else if (require_constant
7584 && !initializer_constant_valid_p (inside_init
,
7585 TREE_TYPE (inside_init
)))
7587 error_init (init_loc
, "initializer element is not constant");
7588 inside_init
= error_mark_node
;
7590 else if (require_constant
&& !maybe_const
)
7591 pedwarn_init (init_loc
, OPT_Wpedantic
,
7592 "initializer element is not a constant expression");
7594 /* Added to enable additional -Wsuggest-attribute=format warnings. */
7595 if (TREE_CODE (TREE_TYPE (inside_init
)) == POINTER_TYPE
)
7596 inside_init
= convert_for_assignment (init_loc
, UNKNOWN_LOCATION
,
7597 type
, inside_init
, origtype
,
7598 ic_init
, null_pointer_constant
,
7599 NULL_TREE
, NULL_TREE
, 0);
7603 /* Handle scalar types, including conversions. */
7605 if (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== FIXED_POINT_TYPE
7606 || code
== POINTER_TYPE
|| code
== ENUMERAL_TYPE
|| code
== BOOLEAN_TYPE
7607 || code
== COMPLEX_TYPE
|| code
== VECTOR_TYPE
)
7609 if (TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
7610 && (TREE_CODE (init
) == STRING_CST
7611 || TREE_CODE (init
) == COMPOUND_LITERAL_EXPR
))
7612 inside_init
= init
= array_to_pointer_conversion (init_loc
, init
);
7614 inside_init
= build1 (EXCESS_PRECISION_EXPR
, semantic_type
,
7617 = convert_for_assignment (init_loc
, UNKNOWN_LOCATION
, type
,
7618 inside_init
, origtype
, ic_init
,
7619 null_pointer_constant
, NULL_TREE
, NULL_TREE
,
7622 /* Check to see if we have already given an error message. */
7623 if (inside_init
== error_mark_node
)
7625 else if (require_constant
&& !TREE_CONSTANT (inside_init
))
7627 error_init (init_loc
, "initializer element is not constant");
7628 inside_init
= error_mark_node
;
7630 else if (require_constant
7631 && !initializer_constant_valid_p (inside_init
,
7632 TREE_TYPE (inside_init
)))
7634 error_init (init_loc
, "initializer element is not computable at "
7636 inside_init
= error_mark_node
;
7638 else if (require_constant
&& !maybe_const
)
7639 pedwarn_init (init_loc
, OPT_Wpedantic
,
7640 "initializer element is not a constant expression");
7645 /* Come here only for records and arrays. */
7647 if (COMPLETE_TYPE_P (type
) && TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
7649 error_init (init_loc
, "variable-sized object may not be initialized");
7650 return error_mark_node
;
7653 error_init (init_loc
, "invalid initializer");
7654 return error_mark_node
;
7657 /* Handle initializers that use braces. */
7659 /* Type of object we are accumulating a constructor for.
7660 This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */
7661 static tree constructor_type
;
7663 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
7665 static tree constructor_fields
;
7667 /* For an ARRAY_TYPE, this is the specified index
7668 at which to store the next element we get. */
7669 static tree constructor_index
;
7671 /* For an ARRAY_TYPE, this is the maximum index. */
7672 static tree constructor_max_index
;
7674 /* For a RECORD_TYPE, this is the first field not yet written out. */
7675 static tree constructor_unfilled_fields
;
7677 /* For an ARRAY_TYPE, this is the index of the first element
7678 not yet written out. */
7679 static tree constructor_unfilled_index
;
7681 /* In a RECORD_TYPE, the byte index of the next consecutive field.
7682 This is so we can generate gaps between fields, when appropriate. */
7683 static tree constructor_bit_index
;
7685 /* If we are saving up the elements rather than allocating them,
7686 this is the list of elements so far (in reverse order,
7687 most recent first). */
7688 static vec
<constructor_elt
, va_gc
> *constructor_elements
;
7690 /* 1 if constructor should be incrementally stored into a constructor chain,
7691 0 if all the elements should be kept in AVL tree. */
7692 static int constructor_incremental
;
7694 /* 1 if so far this constructor's elements are all compile-time constants. */
7695 static int constructor_constant
;
7697 /* 1 if so far this constructor's elements are all valid address constants. */
7698 static int constructor_simple
;
7700 /* 1 if this constructor has an element that cannot be part of a
7701 constant expression. */
7702 static int constructor_nonconst
;
7704 /* 1 if this constructor is erroneous so far. */
7705 static int constructor_erroneous
;
7707 /* 1 if this constructor is the universal zero initializer { 0 }. */
7708 static int constructor_zeroinit
;
7710 /* Structure for managing pending initializer elements, organized as an
7715 struct init_node
*left
, *right
;
7716 struct init_node
*parent
;
7723 /* Tree of pending elements at this constructor level.
7724 These are elements encountered out of order
7725 which belong at places we haven't reached yet in actually
7727 Will never hold tree nodes across GC runs. */
7728 static struct init_node
*constructor_pending_elts
;
7730 /* The SPELLING_DEPTH of this constructor. */
7731 static int constructor_depth
;
7733 /* DECL node for which an initializer is being read.
7734 0 means we are reading a constructor expression
7735 such as (struct foo) {...}. */
7736 static tree constructor_decl
;
7738 /* Nonzero if this is an initializer for a top-level decl. */
7739 static int constructor_top_level
;
7741 /* Nonzero if there were any member designators in this initializer. */
7742 static int constructor_designated
;
7744 /* Nesting depth of designator list. */
7745 static int designator_depth
;
7747 /* Nonzero if there were diagnosed errors in this designator list. */
7748 static int designator_erroneous
;
7751 /* This stack has a level for each implicit or explicit level of
7752 structuring in the initializer, including the outermost one. It
7753 saves the values of most of the variables above. */
7755 struct constructor_range_stack
;
7757 struct constructor_stack
7759 struct constructor_stack
*next
;
7764 tree unfilled_index
;
7765 tree unfilled_fields
;
7767 vec
<constructor_elt
, va_gc
> *elements
;
7768 struct init_node
*pending_elts
;
7771 /* If value nonzero, this value should replace the entire
7772 constructor at this level. */
7773 struct c_expr replacement_value
;
7774 struct constructor_range_stack
*range_stack
;
7783 int designator_depth
;
7786 static struct constructor_stack
*constructor_stack
;
7788 /* This stack represents designators from some range designator up to
7789 the last designator in the list. */
7791 struct constructor_range_stack
7793 struct constructor_range_stack
*next
, *prev
;
7794 struct constructor_stack
*stack
;
7801 static struct constructor_range_stack
*constructor_range_stack
;
7803 /* This stack records separate initializers that are nested.
7804 Nested initializers can't happen in ANSI C, but GNU C allows them
7805 in cases like { ... (struct foo) { ... } ... }. */
7807 struct initializer_stack
7809 struct initializer_stack
*next
;
7811 struct constructor_stack
*constructor_stack
;
7812 struct constructor_range_stack
*constructor_range_stack
;
7813 vec
<constructor_elt
, va_gc
> *elements
;
7814 struct spelling
*spelling
;
7815 struct spelling
*spelling_base
;
7818 char require_constant_value
;
7819 char require_constant_elements
;
7820 rich_location
*missing_brace_richloc
;
7823 static struct initializer_stack
*initializer_stack
;
7825 /* Prepare to parse and output the initializer for variable DECL. */
7828 start_init (tree decl
, tree asmspec_tree ATTRIBUTE_UNUSED
, int top_level
,
7829 rich_location
*richloc
)
7832 struct initializer_stack
*p
= XNEW (struct initializer_stack
);
7834 p
->decl
= constructor_decl
;
7835 p
->require_constant_value
= require_constant_value
;
7836 p
->require_constant_elements
= require_constant_elements
;
7837 p
->constructor_stack
= constructor_stack
;
7838 p
->constructor_range_stack
= constructor_range_stack
;
7839 p
->elements
= constructor_elements
;
7840 p
->spelling
= spelling
;
7841 p
->spelling_base
= spelling_base
;
7842 p
->spelling_size
= spelling_size
;
7843 p
->top_level
= constructor_top_level
;
7844 p
->next
= initializer_stack
;
7845 p
->missing_brace_richloc
= richloc
;
7846 initializer_stack
= p
;
7848 constructor_decl
= decl
;
7849 constructor_designated
= 0;
7850 constructor_top_level
= top_level
;
7852 if (decl
!= NULL_TREE
&& decl
!= error_mark_node
)
7854 require_constant_value
= TREE_STATIC (decl
);
7855 require_constant_elements
7856 = ((TREE_STATIC (decl
) || (pedantic
&& !flag_isoc99
))
7857 /* For a scalar, you can always use any value to initialize,
7858 even within braces. */
7859 && AGGREGATE_TYPE_P (TREE_TYPE (decl
)));
7860 locus
= identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl
)));
7864 require_constant_value
= 0;
7865 require_constant_elements
= 0;
7866 locus
= _("(anonymous)");
7869 constructor_stack
= 0;
7870 constructor_range_stack
= 0;
7872 found_missing_braces
= 0;
7876 RESTORE_SPELLING_DEPTH (0);
7879 push_string (locus
);
7885 struct initializer_stack
*p
= initializer_stack
;
7887 /* Free the whole constructor stack of this initializer. */
7888 while (constructor_stack
)
7890 struct constructor_stack
*q
= constructor_stack
;
7891 constructor_stack
= q
->next
;
7895 gcc_assert (!constructor_range_stack
);
7897 /* Pop back to the data of the outer initializer (if any). */
7898 free (spelling_base
);
7900 constructor_decl
= p
->decl
;
7901 require_constant_value
= p
->require_constant_value
;
7902 require_constant_elements
= p
->require_constant_elements
;
7903 constructor_stack
= p
->constructor_stack
;
7904 constructor_range_stack
= p
->constructor_range_stack
;
7905 constructor_elements
= p
->elements
;
7906 spelling
= p
->spelling
;
7907 spelling_base
= p
->spelling_base
;
7908 spelling_size
= p
->spelling_size
;
7909 constructor_top_level
= p
->top_level
;
7910 initializer_stack
= p
->next
;
7914 /* Call here when we see the initializer is surrounded by braces.
7915 This is instead of a call to push_init_level;
7916 it is matched by a call to pop_init_level.
7918 TYPE is the type to initialize, for a constructor expression.
7919 For an initializer for a decl, TYPE is zero. */
7922 really_start_incremental_init (tree type
)
7924 struct constructor_stack
*p
= XNEW (struct constructor_stack
);
7926 if (type
== NULL_TREE
)
7927 type
= TREE_TYPE (constructor_decl
);
7929 if (VECTOR_TYPE_P (type
)
7930 && TYPE_VECTOR_OPAQUE (type
))
7931 error ("opaque vector types cannot be initialized");
7933 p
->type
= constructor_type
;
7934 p
->fields
= constructor_fields
;
7935 p
->index
= constructor_index
;
7936 p
->max_index
= constructor_max_index
;
7937 p
->unfilled_index
= constructor_unfilled_index
;
7938 p
->unfilled_fields
= constructor_unfilled_fields
;
7939 p
->bit_index
= constructor_bit_index
;
7940 p
->elements
= constructor_elements
;
7941 p
->constant
= constructor_constant
;
7942 p
->simple
= constructor_simple
;
7943 p
->nonconst
= constructor_nonconst
;
7944 p
->erroneous
= constructor_erroneous
;
7945 p
->pending_elts
= constructor_pending_elts
;
7946 p
->depth
= constructor_depth
;
7947 p
->replacement_value
.value
= 0;
7948 p
->replacement_value
.original_code
= ERROR_MARK
;
7949 p
->replacement_value
.original_type
= NULL
;
7953 p
->incremental
= constructor_incremental
;
7954 p
->designated
= constructor_designated
;
7955 p
->designator_depth
= designator_depth
;
7957 constructor_stack
= p
;
7959 constructor_constant
= 1;
7960 constructor_simple
= 1;
7961 constructor_nonconst
= 0;
7962 constructor_depth
= SPELLING_DEPTH ();
7963 constructor_elements
= NULL
;
7964 constructor_pending_elts
= 0;
7965 constructor_type
= type
;
7966 constructor_incremental
= 1;
7967 constructor_designated
= 0;
7968 constructor_zeroinit
= 1;
7969 designator_depth
= 0;
7970 designator_erroneous
= 0;
7972 if (RECORD_OR_UNION_TYPE_P (constructor_type
))
7974 constructor_fields
= TYPE_FIELDS (constructor_type
);
7975 /* Skip any nameless bit fields at the beginning. */
7976 while (constructor_fields
!= NULL_TREE
7977 && DECL_UNNAMED_BIT_FIELD (constructor_fields
))
7978 constructor_fields
= DECL_CHAIN (constructor_fields
);
7980 constructor_unfilled_fields
= constructor_fields
;
7981 constructor_bit_index
= bitsize_zero_node
;
7983 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
7985 if (TYPE_DOMAIN (constructor_type
))
7987 constructor_max_index
7988 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type
));
7990 /* Detect non-empty initializations of zero-length arrays. */
7991 if (constructor_max_index
== NULL_TREE
7992 && TYPE_SIZE (constructor_type
))
7993 constructor_max_index
= integer_minus_one_node
;
7995 /* constructor_max_index needs to be an INTEGER_CST. Attempts
7996 to initialize VLAs will cause a proper error; avoid tree
7997 checking errors as well by setting a safe value. */
7998 if (constructor_max_index
7999 && TREE_CODE (constructor_max_index
) != INTEGER_CST
)
8000 constructor_max_index
= integer_minus_one_node
;
8003 = convert (bitsizetype
,
8004 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type
)));
8008 constructor_index
= bitsize_zero_node
;
8009 constructor_max_index
= NULL_TREE
;
8012 constructor_unfilled_index
= constructor_index
;
8014 else if (VECTOR_TYPE_P (constructor_type
))
8016 /* Vectors are like simple fixed-size arrays. */
8017 constructor_max_index
=
8018 bitsize_int (TYPE_VECTOR_SUBPARTS (constructor_type
) - 1);
8019 constructor_index
= bitsize_zero_node
;
8020 constructor_unfilled_index
= constructor_index
;
8024 /* Handle the case of int x = {5}; */
8025 constructor_fields
= constructor_type
;
8026 constructor_unfilled_fields
= constructor_type
;
8030 extern location_t last_init_list_comma
;
8032 /* Called when we see an open brace for a nested initializer. Finish
8033 off any pending levels with implicit braces. */
8035 finish_implicit_inits (location_t loc
, struct obstack
*braced_init_obstack
)
8037 while (constructor_stack
->implicit
)
8039 if (RECORD_OR_UNION_TYPE_P (constructor_type
)
8040 && constructor_fields
== NULL_TREE
)
8041 process_init_element (input_location
,
8042 pop_init_level (loc
, 1, braced_init_obstack
,
8043 last_init_list_comma
),
8044 true, braced_init_obstack
);
8045 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
8046 && constructor_max_index
8047 && tree_int_cst_lt (constructor_max_index
,
8049 process_init_element (input_location
,
8050 pop_init_level (loc
, 1, braced_init_obstack
,
8051 last_init_list_comma
),
8052 true, braced_init_obstack
);
8058 /* Push down into a subobject, for initialization.
8059 If this is for an explicit set of braces, IMPLICIT is 0.
8060 If it is because the next element belongs at a lower level,
8061 IMPLICIT is 1 (or 2 if the push is because of designator list). */
8064 push_init_level (location_t loc
, int implicit
,
8065 struct obstack
*braced_init_obstack
)
8067 struct constructor_stack
*p
;
8068 tree value
= NULL_TREE
;
8070 /* Unless this is an explicit brace, we need to preserve previous
8074 if (RECORD_OR_UNION_TYPE_P (constructor_type
) && constructor_fields
)
8075 value
= find_init_member (constructor_fields
, braced_init_obstack
);
8076 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
8077 value
= find_init_member (constructor_index
, braced_init_obstack
);
8080 p
= XNEW (struct constructor_stack
);
8081 p
->type
= constructor_type
;
8082 p
->fields
= constructor_fields
;
8083 p
->index
= constructor_index
;
8084 p
->max_index
= constructor_max_index
;
8085 p
->unfilled_index
= constructor_unfilled_index
;
8086 p
->unfilled_fields
= constructor_unfilled_fields
;
8087 p
->bit_index
= constructor_bit_index
;
8088 p
->elements
= constructor_elements
;
8089 p
->constant
= constructor_constant
;
8090 p
->simple
= constructor_simple
;
8091 p
->nonconst
= constructor_nonconst
;
8092 p
->erroneous
= constructor_erroneous
;
8093 p
->pending_elts
= constructor_pending_elts
;
8094 p
->depth
= constructor_depth
;
8095 p
->replacement_value
.value
= NULL_TREE
;
8096 p
->replacement_value
.original_code
= ERROR_MARK
;
8097 p
->replacement_value
.original_type
= NULL
;
8098 p
->implicit
= implicit
;
8100 p
->incremental
= constructor_incremental
;
8101 p
->designated
= constructor_designated
;
8102 p
->designator_depth
= designator_depth
;
8103 p
->next
= constructor_stack
;
8105 constructor_stack
= p
;
8107 constructor_constant
= 1;
8108 constructor_simple
= 1;
8109 constructor_nonconst
= 0;
8110 constructor_depth
= SPELLING_DEPTH ();
8111 constructor_elements
= NULL
;
8112 constructor_incremental
= 1;
8113 constructor_designated
= 0;
8114 constructor_pending_elts
= 0;
8117 p
->range_stack
= constructor_range_stack
;
8118 constructor_range_stack
= 0;
8119 designator_depth
= 0;
8120 designator_erroneous
= 0;
8123 /* Don't die if an entire brace-pair level is superfluous
8124 in the containing level. */
8125 if (constructor_type
== NULL_TREE
)
8127 else if (RECORD_OR_UNION_TYPE_P (constructor_type
))
8129 /* Don't die if there are extra init elts at the end. */
8130 if (constructor_fields
== NULL_TREE
)
8131 constructor_type
= NULL_TREE
;
8134 constructor_type
= TREE_TYPE (constructor_fields
);
8135 push_member_name (constructor_fields
);
8136 constructor_depth
++;
8138 /* If upper initializer is designated, then mark this as
8139 designated too to prevent bogus warnings. */
8140 constructor_designated
= p
->designated
;
8142 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
8144 constructor_type
= TREE_TYPE (constructor_type
);
8145 push_array_bounds (tree_to_uhwi (constructor_index
));
8146 constructor_depth
++;
8149 if (constructor_type
== NULL_TREE
)
8151 error_init (loc
, "extra brace group at end of initializer");
8152 constructor_fields
= NULL_TREE
;
8153 constructor_unfilled_fields
= NULL_TREE
;
8157 if (value
&& TREE_CODE (value
) == CONSTRUCTOR
)
8159 constructor_constant
= TREE_CONSTANT (value
);
8160 constructor_simple
= TREE_STATIC (value
);
8161 constructor_nonconst
= CONSTRUCTOR_NON_CONST (value
);
8162 constructor_elements
= CONSTRUCTOR_ELTS (value
);
8163 if (!vec_safe_is_empty (constructor_elements
)
8164 && (TREE_CODE (constructor_type
) == RECORD_TYPE
8165 || TREE_CODE (constructor_type
) == ARRAY_TYPE
))
8166 set_nonincremental_init (braced_init_obstack
);
8171 found_missing_braces
= 1;
8172 if (initializer_stack
->missing_brace_richloc
)
8173 initializer_stack
->missing_brace_richloc
->add_fixit_insert_before
8177 if (RECORD_OR_UNION_TYPE_P (constructor_type
))
8179 constructor_fields
= TYPE_FIELDS (constructor_type
);
8180 /* Skip any nameless bit fields at the beginning. */
8181 while (constructor_fields
!= NULL_TREE
8182 && DECL_UNNAMED_BIT_FIELD (constructor_fields
))
8183 constructor_fields
= DECL_CHAIN (constructor_fields
);
8185 constructor_unfilled_fields
= constructor_fields
;
8186 constructor_bit_index
= bitsize_zero_node
;
8188 else if (VECTOR_TYPE_P (constructor_type
))
8190 /* Vectors are like simple fixed-size arrays. */
8191 constructor_max_index
=
8192 bitsize_int (TYPE_VECTOR_SUBPARTS (constructor_type
) - 1);
8193 constructor_index
= bitsize_int (0);
8194 constructor_unfilled_index
= constructor_index
;
8196 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
8198 if (TYPE_DOMAIN (constructor_type
))
8200 constructor_max_index
8201 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type
));
8203 /* Detect non-empty initializations of zero-length arrays. */
8204 if (constructor_max_index
== NULL_TREE
8205 && TYPE_SIZE (constructor_type
))
8206 constructor_max_index
= integer_minus_one_node
;
8208 /* constructor_max_index needs to be an INTEGER_CST. Attempts
8209 to initialize VLAs will cause a proper error; avoid tree
8210 checking errors as well by setting a safe value. */
8211 if (constructor_max_index
8212 && TREE_CODE (constructor_max_index
) != INTEGER_CST
)
8213 constructor_max_index
= integer_minus_one_node
;
8216 = convert (bitsizetype
,
8217 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type
)));
8220 constructor_index
= bitsize_zero_node
;
8222 constructor_unfilled_index
= constructor_index
;
8223 if (value
&& TREE_CODE (value
) == STRING_CST
)
8225 /* We need to split the char/wchar array into individual
8226 characters, so that we don't have to special case it
8228 set_nonincremental_init_from_string (value
, braced_init_obstack
);
8233 if (constructor_type
!= error_mark_node
)
8234 warning_init (input_location
, 0, "braces around scalar initializer");
8235 constructor_fields
= constructor_type
;
8236 constructor_unfilled_fields
= constructor_type
;
8240 /* At the end of an implicit or explicit brace level,
8241 finish up that level of constructor. If a single expression
8242 with redundant braces initialized that level, return the
8243 c_expr structure for that expression. Otherwise, the original_code
8244 element is set to ERROR_MARK.
8245 If we were outputting the elements as they are read, return 0 as the value
8246 from inner levels (process_init_element ignores that),
8247 but return error_mark_node as the value from the outermost level
8248 (that's what we want to put in DECL_INITIAL).
8249 Otherwise, return a CONSTRUCTOR expression as the value. */
8252 pop_init_level (location_t loc
, int implicit
,
8253 struct obstack
*braced_init_obstack
,
8254 location_t insert_before
)
8256 struct constructor_stack
*p
;
8258 ret
.value
= NULL_TREE
;
8259 ret
.original_code
= ERROR_MARK
;
8260 ret
.original_type
= NULL
;
8264 /* When we come to an explicit close brace,
8265 pop any inner levels that didn't have explicit braces. */
8266 while (constructor_stack
->implicit
)
8267 process_init_element (input_location
,
8268 pop_init_level (loc
, 1, braced_init_obstack
,
8270 true, braced_init_obstack
);
8271 gcc_assert (!constructor_range_stack
);
8274 if (initializer_stack
->missing_brace_richloc
)
8275 initializer_stack
->missing_brace_richloc
->add_fixit_insert_before
8276 (insert_before
, "}");
8278 /* Now output all pending elements. */
8279 constructor_incremental
= 1;
8280 output_pending_init_elements (1, braced_init_obstack
);
8282 p
= constructor_stack
;
8284 /* Error for initializing a flexible array member, or a zero-length
8285 array member in an inappropriate context. */
8286 if (constructor_type
&& constructor_fields
8287 && TREE_CODE (constructor_type
) == ARRAY_TYPE
8288 && TYPE_DOMAIN (constructor_type
)
8289 && !TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type
)))
8291 /* Silently discard empty initializations. The parser will
8292 already have pedwarned for empty brackets. */
8293 if (integer_zerop (constructor_unfilled_index
))
8294 constructor_type
= NULL_TREE
;
8297 gcc_assert (!TYPE_SIZE (constructor_type
));
8299 if (constructor_depth
> 2)
8300 error_init (loc
, "initialization of flexible array member in a nested context");
8302 pedwarn_init (loc
, OPT_Wpedantic
,
8303 "initialization of a flexible array member");
8305 /* We have already issued an error message for the existence
8306 of a flexible array member not at the end of the structure.
8307 Discard the initializer so that we do not die later. */
8308 if (DECL_CHAIN (constructor_fields
) != NULL_TREE
)
8309 constructor_type
= NULL_TREE
;
8313 switch (vec_safe_length (constructor_elements
))
8316 /* Initialization with { } counts as zeroinit. */
8317 constructor_zeroinit
= 1;
8320 /* This might be zeroinit as well. */
8321 if (integer_zerop ((*constructor_elements
)[0].value
))
8322 constructor_zeroinit
= 1;
8325 /* If the constructor has more than one element, it can't be { 0 }. */
8326 constructor_zeroinit
= 0;
8330 /* Warn when some structs are initialized with direct aggregation. */
8331 if (!implicit
&& found_missing_braces
&& warn_missing_braces
8332 && !constructor_zeroinit
)
8334 gcc_assert (initializer_stack
->missing_brace_richloc
);
8335 warning_at (initializer_stack
->missing_brace_richloc
,
8336 OPT_Wmissing_braces
,
8337 "missing braces around initializer");
8340 /* Warn when some struct elements are implicitly initialized to zero. */
8341 if (warn_missing_field_initializers
8343 && TREE_CODE (constructor_type
) == RECORD_TYPE
8344 && constructor_unfilled_fields
)
8346 /* Do not warn for flexible array members or zero-length arrays. */
8347 while (constructor_unfilled_fields
8348 && (!DECL_SIZE (constructor_unfilled_fields
)
8349 || integer_zerop (DECL_SIZE (constructor_unfilled_fields
))))
8350 constructor_unfilled_fields
= DECL_CHAIN (constructor_unfilled_fields
);
8352 if (constructor_unfilled_fields
8353 /* Do not warn if this level of the initializer uses member
8354 designators; it is likely to be deliberate. */
8355 && !constructor_designated
8356 /* Do not warn about initializing with { 0 } or with { }. */
8357 && !constructor_zeroinit
)
8359 if (warning_at (input_location
, OPT_Wmissing_field_initializers
,
8360 "missing initializer for field %qD of %qT",
8361 constructor_unfilled_fields
,
8363 inform (DECL_SOURCE_LOCATION (constructor_unfilled_fields
),
8364 "%qD declared here", constructor_unfilled_fields
);
8368 /* Pad out the end of the structure. */
8369 if (p
->replacement_value
.value
)
8370 /* If this closes a superfluous brace pair,
8371 just pass out the element between them. */
8372 ret
= p
->replacement_value
;
8373 else if (constructor_type
== NULL_TREE
)
8375 else if (!RECORD_OR_UNION_TYPE_P (constructor_type
)
8376 && TREE_CODE (constructor_type
) != ARRAY_TYPE
8377 && !VECTOR_TYPE_P (constructor_type
))
8379 /* A nonincremental scalar initializer--just return
8380 the element, after verifying there is just one. */
8381 if (vec_safe_is_empty (constructor_elements
))
8383 if (!constructor_erroneous
)
8384 error_init (loc
, "empty scalar initializer");
8385 ret
.value
= error_mark_node
;
8387 else if (vec_safe_length (constructor_elements
) != 1)
8389 error_init (loc
, "extra elements in scalar initializer");
8390 ret
.value
= (*constructor_elements
)[0].value
;
8393 ret
.value
= (*constructor_elements
)[0].value
;
8397 if (constructor_erroneous
)
8398 ret
.value
= error_mark_node
;
8401 ret
.value
= build_constructor (constructor_type
,
8402 constructor_elements
);
8403 if (constructor_constant
)
8404 TREE_CONSTANT (ret
.value
) = 1;
8405 if (constructor_constant
&& constructor_simple
)
8406 TREE_STATIC (ret
.value
) = 1;
8407 if (constructor_nonconst
)
8408 CONSTRUCTOR_NON_CONST (ret
.value
) = 1;
8412 if (ret
.value
&& TREE_CODE (ret
.value
) != CONSTRUCTOR
)
8414 if (constructor_nonconst
)
8415 ret
.original_code
= C_MAYBE_CONST_EXPR
;
8416 else if (ret
.original_code
== C_MAYBE_CONST_EXPR
)
8417 ret
.original_code
= ERROR_MARK
;
8420 constructor_type
= p
->type
;
8421 constructor_fields
= p
->fields
;
8422 constructor_index
= p
->index
;
8423 constructor_max_index
= p
->max_index
;
8424 constructor_unfilled_index
= p
->unfilled_index
;
8425 constructor_unfilled_fields
= p
->unfilled_fields
;
8426 constructor_bit_index
= p
->bit_index
;
8427 constructor_elements
= p
->elements
;
8428 constructor_constant
= p
->constant
;
8429 constructor_simple
= p
->simple
;
8430 constructor_nonconst
= p
->nonconst
;
8431 constructor_erroneous
= p
->erroneous
;
8432 constructor_incremental
= p
->incremental
;
8433 constructor_designated
= p
->designated
;
8434 designator_depth
= p
->designator_depth
;
8435 constructor_pending_elts
= p
->pending_elts
;
8436 constructor_depth
= p
->depth
;
8438 constructor_range_stack
= p
->range_stack
;
8439 RESTORE_SPELLING_DEPTH (constructor_depth
);
8441 constructor_stack
= p
->next
;
8444 if (ret
.value
== NULL_TREE
&& constructor_stack
== 0)
8445 ret
.value
= error_mark_node
;
8449 /* Common handling for both array range and field name designators.
8450 ARRAY argument is nonzero for array ranges. Returns false for success. */
8453 set_designator (location_t loc
, bool array
,
8454 struct obstack
*braced_init_obstack
)
8457 enum tree_code subcode
;
8459 /* Don't die if an entire brace-pair level is superfluous
8460 in the containing level. */
8461 if (constructor_type
== NULL_TREE
)
8464 /* If there were errors in this designator list already, bail out
8466 if (designator_erroneous
)
8469 if (!designator_depth
)
8471 gcc_assert (!constructor_range_stack
);
8473 /* Designator list starts at the level of closest explicit
8475 while (constructor_stack
->implicit
)
8476 process_init_element (input_location
,
8477 pop_init_level (loc
, 1, braced_init_obstack
,
8478 last_init_list_comma
),
8479 true, braced_init_obstack
);
8480 constructor_designated
= 1;
8484 switch (TREE_CODE (constructor_type
))
8488 subtype
= TREE_TYPE (constructor_fields
);
8489 if (subtype
!= error_mark_node
)
8490 subtype
= TYPE_MAIN_VARIANT (subtype
);
8493 subtype
= TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type
));
8499 subcode
= TREE_CODE (subtype
);
8500 if (array
&& subcode
!= ARRAY_TYPE
)
8502 error_init (loc
, "array index in non-array initializer");
8505 else if (!array
&& subcode
!= RECORD_TYPE
&& subcode
!= UNION_TYPE
)
8507 error_init (loc
, "field name not in record or union initializer");
8511 constructor_designated
= 1;
8512 finish_implicit_inits (loc
, braced_init_obstack
);
8513 push_init_level (loc
, 2, braced_init_obstack
);
8517 /* If there are range designators in designator list, push a new designator
8518 to constructor_range_stack. RANGE_END is end of such stack range or
8519 NULL_TREE if there is no range designator at this level. */
8522 push_range_stack (tree range_end
, struct obstack
* braced_init_obstack
)
8524 struct constructor_range_stack
*p
;
8526 p
= (struct constructor_range_stack
*)
8527 obstack_alloc (braced_init_obstack
,
8528 sizeof (struct constructor_range_stack
));
8529 p
->prev
= constructor_range_stack
;
8531 p
->fields
= constructor_fields
;
8532 p
->range_start
= constructor_index
;
8533 p
->index
= constructor_index
;
8534 p
->stack
= constructor_stack
;
8535 p
->range_end
= range_end
;
8536 if (constructor_range_stack
)
8537 constructor_range_stack
->next
= p
;
8538 constructor_range_stack
= p
;
8541 /* Within an array initializer, specify the next index to be initialized.
8542 FIRST is that index. If LAST is nonzero, then initialize a range
8543 of indices, running from FIRST through LAST. */
8546 set_init_index (location_t loc
, tree first
, tree last
,
8547 struct obstack
*braced_init_obstack
)
8549 if (set_designator (loc
, true, braced_init_obstack
))
8552 designator_erroneous
= 1;
8554 if (!INTEGRAL_TYPE_P (TREE_TYPE (first
))
8555 || (last
&& !INTEGRAL_TYPE_P (TREE_TYPE (last
))))
8557 error_init (loc
, "array index in initializer not of integer type");
8561 if (TREE_CODE (first
) != INTEGER_CST
)
8563 first
= c_fully_fold (first
, false, NULL
);
8564 if (TREE_CODE (first
) == INTEGER_CST
)
8565 pedwarn_init (loc
, OPT_Wpedantic
,
8566 "array index in initializer is not "
8567 "an integer constant expression");
8570 if (last
&& TREE_CODE (last
) != INTEGER_CST
)
8572 last
= c_fully_fold (last
, false, NULL
);
8573 if (TREE_CODE (last
) == INTEGER_CST
)
8574 pedwarn_init (loc
, OPT_Wpedantic
,
8575 "array index in initializer is not "
8576 "an integer constant expression");
8579 if (TREE_CODE (first
) != INTEGER_CST
)
8580 error_init (loc
, "nonconstant array index in initializer");
8581 else if (last
!= NULL_TREE
&& TREE_CODE (last
) != INTEGER_CST
)
8582 error_init (loc
, "nonconstant array index in initializer");
8583 else if (TREE_CODE (constructor_type
) != ARRAY_TYPE
)
8584 error_init (loc
, "array index in non-array initializer");
8585 else if (tree_int_cst_sgn (first
) == -1)
8586 error_init (loc
, "array index in initializer exceeds array bounds");
8587 else if (constructor_max_index
8588 && tree_int_cst_lt (constructor_max_index
, first
))
8589 error_init (loc
, "array index in initializer exceeds array bounds");
8592 constant_expression_warning (first
);
8594 constant_expression_warning (last
);
8595 constructor_index
= convert (bitsizetype
, first
);
8596 if (tree_int_cst_lt (constructor_index
, first
))
8598 constructor_index
= copy_node (constructor_index
);
8599 TREE_OVERFLOW (constructor_index
) = 1;
8604 if (tree_int_cst_equal (first
, last
))
8606 else if (tree_int_cst_lt (last
, first
))
8608 error_init (loc
, "empty index range in initializer");
8613 last
= convert (bitsizetype
, last
);
8614 if (constructor_max_index
!= NULL_TREE
8615 && tree_int_cst_lt (constructor_max_index
, last
))
8617 error_init (loc
, "array index range in initializer exceeds "
8625 designator_erroneous
= 0;
8626 if (constructor_range_stack
|| last
)
8627 push_range_stack (last
, braced_init_obstack
);
8631 /* Within a struct initializer, specify the next field to be initialized. */
8634 set_init_label (location_t loc
, tree fieldname
, location_t fieldname_loc
,
8635 struct obstack
*braced_init_obstack
)
8639 if (set_designator (loc
, false, braced_init_obstack
))
8642 designator_erroneous
= 1;
8644 if (!RECORD_OR_UNION_TYPE_P (constructor_type
))
8646 error_init (loc
, "field name not in record or union initializer");
8650 field
= lookup_field (constructor_type
, fieldname
);
8652 if (field
== NULL_TREE
)
8654 tree guessed_id
= lookup_field_fuzzy (constructor_type
, fieldname
);
8657 gcc_rich_location
rich_loc (fieldname_loc
);
8658 rich_loc
.add_fixit_misspelled_id (fieldname_loc
, guessed_id
);
8659 error_at (&rich_loc
,
8660 "%qT has no member named %qE; did you mean %qE?",
8661 constructor_type
, fieldname
, guessed_id
);
8664 error_at (fieldname_loc
, "%qT has no member named %qE",
8665 constructor_type
, fieldname
);
8670 constructor_fields
= TREE_VALUE (field
);
8672 designator_erroneous
= 0;
8673 if (constructor_range_stack
)
8674 push_range_stack (NULL_TREE
, braced_init_obstack
);
8675 field
= TREE_CHAIN (field
);
8678 if (set_designator (loc
, false, braced_init_obstack
))
8682 while (field
!= NULL_TREE
);
8685 /* Add a new initializer to the tree of pending initializers. PURPOSE
8686 identifies the initializer, either array index or field in a structure.
8687 VALUE is the value of that index or field. If ORIGTYPE is not
8688 NULL_TREE, it is the original type of VALUE.
8690 IMPLICIT is true if value comes from pop_init_level (1),
8691 the new initializer has been merged with the existing one
8692 and thus no warnings should be emitted about overriding an
8693 existing initializer. */
8696 add_pending_init (location_t loc
, tree purpose
, tree value
, tree origtype
,
8697 bool implicit
, struct obstack
*braced_init_obstack
)
8699 struct init_node
*p
, **q
, *r
;
8701 q
= &constructor_pending_elts
;
8704 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
8709 if (tree_int_cst_lt (purpose
, p
->purpose
))
8711 else if (tree_int_cst_lt (p
->purpose
, purpose
))
8717 if (TREE_SIDE_EFFECTS (p
->value
))
8718 warning_init (loc
, OPT_Woverride_init_side_effects
,
8719 "initialized field with side-effects "
8721 else if (warn_override_init
)
8722 warning_init (loc
, OPT_Woverride_init
,
8723 "initialized field overwritten");
8726 p
->origtype
= origtype
;
8735 bitpos
= bit_position (purpose
);
8739 if (tree_int_cst_lt (bitpos
, bit_position (p
->purpose
)))
8741 else if (p
->purpose
!= purpose
)
8747 if (TREE_SIDE_EFFECTS (p
->value
))
8748 warning_init (loc
, OPT_Woverride_init_side_effects
,
8749 "initialized field with side-effects "
8751 else if (warn_override_init
)
8752 warning_init (loc
, OPT_Woverride_init
,
8753 "initialized field overwritten");
8756 p
->origtype
= origtype
;
8762 r
= (struct init_node
*) obstack_alloc (braced_init_obstack
,
8763 sizeof (struct init_node
));
8764 r
->purpose
= purpose
;
8766 r
->origtype
= origtype
;
8776 struct init_node
*s
;
8780 if (p
->balance
== 0)
8782 else if (p
->balance
< 0)
8789 p
->left
->parent
= p
;
8806 constructor_pending_elts
= r
;
8811 struct init_node
*t
= r
->right
;
8815 r
->right
->parent
= r
;
8820 p
->left
->parent
= p
;
8823 p
->balance
= t
->balance
< 0;
8824 r
->balance
= -(t
->balance
> 0);
8839 constructor_pending_elts
= t
;
8845 /* p->balance == +1; growth of left side balances the node. */
8850 else /* r == p->right */
8852 if (p
->balance
== 0)
8853 /* Growth propagation from right side. */
8855 else if (p
->balance
> 0)
8862 p
->right
->parent
= p
;
8879 constructor_pending_elts
= r
;
8881 else /* r->balance == -1 */
8884 struct init_node
*t
= r
->left
;
8888 r
->left
->parent
= r
;
8893 p
->right
->parent
= p
;
8896 r
->balance
= (t
->balance
< 0);
8897 p
->balance
= -(t
->balance
> 0);
8912 constructor_pending_elts
= t
;
8918 /* p->balance == -1; growth of right side balances the node. */
8929 /* Build AVL tree from a sorted chain. */
8932 set_nonincremental_init (struct obstack
* braced_init_obstack
)
8934 unsigned HOST_WIDE_INT ix
;
8937 if (TREE_CODE (constructor_type
) != RECORD_TYPE
8938 && TREE_CODE (constructor_type
) != ARRAY_TYPE
)
8941 FOR_EACH_CONSTRUCTOR_ELT (constructor_elements
, ix
, index
, value
)
8942 add_pending_init (input_location
, index
, value
, NULL_TREE
, true,
8943 braced_init_obstack
);
8944 constructor_elements
= NULL
;
8945 if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
8947 constructor_unfilled_fields
= TYPE_FIELDS (constructor_type
);
8948 /* Skip any nameless bit fields at the beginning. */
8949 while (constructor_unfilled_fields
!= NULL_TREE
8950 && DECL_UNNAMED_BIT_FIELD (constructor_unfilled_fields
))
8951 constructor_unfilled_fields
= TREE_CHAIN (constructor_unfilled_fields
);
8954 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
8956 if (TYPE_DOMAIN (constructor_type
))
8957 constructor_unfilled_index
8958 = convert (bitsizetype
,
8959 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type
)));
8961 constructor_unfilled_index
= bitsize_zero_node
;
8963 constructor_incremental
= 0;
8966 /* Build AVL tree from a string constant. */
8969 set_nonincremental_init_from_string (tree str
,
8970 struct obstack
* braced_init_obstack
)
8972 tree value
, purpose
, type
;
8973 HOST_WIDE_INT val
[2];
8974 const char *p
, *end
;
8975 int byte
, wchar_bytes
, charwidth
, bitpos
;
8977 gcc_assert (TREE_CODE (constructor_type
) == ARRAY_TYPE
);
8979 wchar_bytes
= TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str
))) / BITS_PER_UNIT
;
8980 charwidth
= TYPE_PRECISION (char_type_node
);
8981 gcc_assert ((size_t) wchar_bytes
* charwidth
8982 <= ARRAY_SIZE (val
) * HOST_BITS_PER_WIDE_INT
);
8983 type
= TREE_TYPE (constructor_type
);
8984 p
= TREE_STRING_POINTER (str
);
8985 end
= p
+ TREE_STRING_LENGTH (str
);
8987 for (purpose
= bitsize_zero_node
;
8989 && !(constructor_max_index
8990 && tree_int_cst_lt (constructor_max_index
, purpose
));
8991 purpose
= size_binop (PLUS_EXPR
, purpose
, bitsize_one_node
))
8993 if (wchar_bytes
== 1)
8995 val
[0] = (unsigned char) *p
++;
9002 for (byte
= 0; byte
< wchar_bytes
; byte
++)
9004 if (BYTES_BIG_ENDIAN
)
9005 bitpos
= (wchar_bytes
- byte
- 1) * charwidth
;
9007 bitpos
= byte
* charwidth
;
9008 val
[bitpos
/ HOST_BITS_PER_WIDE_INT
]
9009 |= ((unsigned HOST_WIDE_INT
) ((unsigned char) *p
++))
9010 << (bitpos
% HOST_BITS_PER_WIDE_INT
);
9014 if (!TYPE_UNSIGNED (type
))
9016 bitpos
= ((wchar_bytes
- 1) * charwidth
) + HOST_BITS_PER_CHAR
;
9017 if (bitpos
< HOST_BITS_PER_WIDE_INT
)
9019 if (val
[0] & (HOST_WIDE_INT_1
<< (bitpos
- 1)))
9021 val
[0] |= HOST_WIDE_INT_M1U
<< bitpos
;
9025 else if (bitpos
== HOST_BITS_PER_WIDE_INT
)
9030 else if (val
[1] & (HOST_WIDE_INT_1
9031 << (bitpos
- 1 - HOST_BITS_PER_WIDE_INT
)))
9032 val
[1] |= HOST_WIDE_INT_M1U
<< (bitpos
- HOST_BITS_PER_WIDE_INT
);
9035 value
= wide_int_to_tree (type
,
9036 wide_int::from_array (val
, 2,
9037 HOST_BITS_PER_WIDE_INT
* 2));
9038 add_pending_init (input_location
, purpose
, value
, NULL_TREE
, true,
9039 braced_init_obstack
);
9042 constructor_incremental
= 0;
9045 /* Return value of FIELD in pending initializer or NULL_TREE if the field was
9046 not initialized yet. */
9049 find_init_member (tree field
, struct obstack
* braced_init_obstack
)
9051 struct init_node
*p
;
9053 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
9055 if (constructor_incremental
9056 && tree_int_cst_lt (field
, constructor_unfilled_index
))
9057 set_nonincremental_init (braced_init_obstack
);
9059 p
= constructor_pending_elts
;
9062 if (tree_int_cst_lt (field
, p
->purpose
))
9064 else if (tree_int_cst_lt (p
->purpose
, field
))
9070 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
9072 tree bitpos
= bit_position (field
);
9074 if (constructor_incremental
9075 && (!constructor_unfilled_fields
9076 || tree_int_cst_lt (bitpos
,
9077 bit_position (constructor_unfilled_fields
))))
9078 set_nonincremental_init (braced_init_obstack
);
9080 p
= constructor_pending_elts
;
9083 if (field
== p
->purpose
)
9085 else if (tree_int_cst_lt (bitpos
, bit_position (p
->purpose
)))
9091 else if (TREE_CODE (constructor_type
) == UNION_TYPE
)
9093 if (!vec_safe_is_empty (constructor_elements
)
9094 && (constructor_elements
->last ().index
== field
))
9095 return constructor_elements
->last ().value
;
9100 /* "Output" the next constructor element.
9101 At top level, really output it to assembler code now.
9102 Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
9103 If ORIGTYPE is not NULL_TREE, it is the original type of VALUE.
9104 TYPE is the data type that the containing data type wants here.
9105 FIELD is the field (a FIELD_DECL) or the index that this element fills.
9106 If VALUE is a string constant, STRICT_STRING is true if it is
9107 unparenthesized or we should not warn here for it being parenthesized.
9108 For other types of VALUE, STRICT_STRING is not used.
9110 PENDING if true means output pending elements that belong
9111 right after this element. (PENDING is normally true;
9112 it is false while outputting pending elements, to avoid recursion.)
9114 IMPLICIT is true if value comes from pop_init_level (1),
9115 the new initializer has been merged with the existing one
9116 and thus no warnings should be emitted about overriding an
9117 existing initializer. */
9120 output_init_element (location_t loc
, tree value
, tree origtype
,
9121 bool strict_string
, tree type
, tree field
, bool pending
,
9122 bool implicit
, struct obstack
* braced_init_obstack
)
9124 tree semantic_type
= NULL_TREE
;
9125 bool maybe_const
= true;
9128 if (type
== error_mark_node
|| value
== error_mark_node
)
9130 constructor_erroneous
= 1;
9133 if (TREE_CODE (TREE_TYPE (value
)) == ARRAY_TYPE
9134 && (TREE_CODE (value
) == STRING_CST
9135 || TREE_CODE (value
) == COMPOUND_LITERAL_EXPR
)
9136 && !(TREE_CODE (value
) == STRING_CST
9137 && TREE_CODE (type
) == ARRAY_TYPE
9138 && INTEGRAL_TYPE_P (TREE_TYPE (type
)))
9139 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value
)),
9140 TYPE_MAIN_VARIANT (type
)))
9141 value
= array_to_pointer_conversion (input_location
, value
);
9143 if (TREE_CODE (value
) == COMPOUND_LITERAL_EXPR
9144 && require_constant_value
&& pending
)
9146 /* As an extension, allow initializing objects with static storage
9147 duration with compound literals (which are then treated just as
9148 the brace enclosed list they contain). */
9150 pedwarn_init (loc
, OPT_Wpedantic
, "initializer element is not "
9152 tree decl
= COMPOUND_LITERAL_EXPR_DECL (value
);
9153 value
= DECL_INITIAL (decl
);
9156 npc
= null_pointer_constant_p (value
);
9157 if (TREE_CODE (value
) == EXCESS_PRECISION_EXPR
)
9159 semantic_type
= TREE_TYPE (value
);
9160 value
= TREE_OPERAND (value
, 0);
9162 value
= c_fully_fold (value
, require_constant_value
, &maybe_const
);
9164 if (value
== error_mark_node
)
9165 constructor_erroneous
= 1;
9166 else if (!TREE_CONSTANT (value
))
9167 constructor_constant
= 0;
9168 else if (!initializer_constant_valid_p (value
,
9170 AGGREGATE_TYPE_P (constructor_type
)
9171 && TYPE_REVERSE_STORAGE_ORDER
9173 || (RECORD_OR_UNION_TYPE_P (constructor_type
)
9174 && DECL_C_BIT_FIELD (field
)
9175 && TREE_CODE (value
) != INTEGER_CST
))
9176 constructor_simple
= 0;
9178 constructor_nonconst
= 1;
9180 /* Digest the initializer and issue any errors about incompatible
9181 types before issuing errors about non-constant initializers. */
9182 tree new_value
= value
;
9184 new_value
= build1 (EXCESS_PRECISION_EXPR
, semantic_type
, value
);
9185 new_value
= digest_init (loc
, type
, new_value
, origtype
, npc
, strict_string
,
9186 require_constant_value
);
9187 if (new_value
== error_mark_node
)
9189 constructor_erroneous
= 1;
9192 if (require_constant_value
|| require_constant_elements
)
9193 constant_expression_warning (new_value
);
9195 /* Proceed to check the constness of the original initializer. */
9196 if (!initializer_constant_valid_p (value
, TREE_TYPE (value
)))
9198 if (require_constant_value
)
9200 error_init (loc
, "initializer element is not constant");
9201 value
= error_mark_node
;
9203 else if (require_constant_elements
)
9204 pedwarn (loc
, OPT_Wpedantic
,
9205 "initializer element is not computable at load time");
9207 else if (!maybe_const
9208 && (require_constant_value
|| require_constant_elements
))
9209 pedwarn_init (loc
, OPT_Wpedantic
,
9210 "initializer element is not a constant expression");
9212 /* Issue -Wc++-compat warnings about initializing a bitfield with
9215 && field
!= NULL_TREE
9216 && TREE_CODE (field
) == FIELD_DECL
9217 && DECL_BIT_FIELD_TYPE (field
) != NULL_TREE
9218 && (TYPE_MAIN_VARIANT (DECL_BIT_FIELD_TYPE (field
))
9219 != TYPE_MAIN_VARIANT (type
))
9220 && TREE_CODE (DECL_BIT_FIELD_TYPE (field
)) == ENUMERAL_TYPE
)
9222 tree checktype
= origtype
!= NULL_TREE
? origtype
: TREE_TYPE (value
);
9223 if (checktype
!= error_mark_node
9224 && (TYPE_MAIN_VARIANT (checktype
)
9225 != TYPE_MAIN_VARIANT (DECL_BIT_FIELD_TYPE (field
))))
9226 warning_init (loc
, OPT_Wc___compat
,
9227 "enum conversion in initialization is invalid in C++");
9230 /* If this field is empty and does not have side effects (and is not at
9231 the end of structure), don't do anything other than checking the
9234 && (TREE_TYPE (field
) == error_mark_node
9235 || (COMPLETE_TYPE_P (TREE_TYPE (field
))
9236 && integer_zerop (TYPE_SIZE (TREE_TYPE (field
)))
9237 && !TREE_SIDE_EFFECTS (new_value
)
9238 && (TREE_CODE (constructor_type
) == ARRAY_TYPE
9239 || DECL_CHAIN (field
)))))
9242 /* Finally, set VALUE to the initializer value digested above. */
9245 /* If this element doesn't come next in sequence,
9246 put it on constructor_pending_elts. */
9247 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
9248 && (!constructor_incremental
9249 || !tree_int_cst_equal (field
, constructor_unfilled_index
)))
9251 if (constructor_incremental
9252 && tree_int_cst_lt (field
, constructor_unfilled_index
))
9253 set_nonincremental_init (braced_init_obstack
);
9255 add_pending_init (loc
, field
, value
, origtype
, implicit
,
9256 braced_init_obstack
);
9259 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
9260 && (!constructor_incremental
9261 || field
!= constructor_unfilled_fields
))
9263 /* We do this for records but not for unions. In a union,
9264 no matter which field is specified, it can be initialized
9265 right away since it starts at the beginning of the union. */
9266 if (constructor_incremental
)
9268 if (!constructor_unfilled_fields
)
9269 set_nonincremental_init (braced_init_obstack
);
9272 tree bitpos
, unfillpos
;
9274 bitpos
= bit_position (field
);
9275 unfillpos
= bit_position (constructor_unfilled_fields
);
9277 if (tree_int_cst_lt (bitpos
, unfillpos
))
9278 set_nonincremental_init (braced_init_obstack
);
9282 add_pending_init (loc
, field
, value
, origtype
, implicit
,
9283 braced_init_obstack
);
9286 else if (TREE_CODE (constructor_type
) == UNION_TYPE
9287 && !vec_safe_is_empty (constructor_elements
))
9291 if (TREE_SIDE_EFFECTS (constructor_elements
->last ().value
))
9292 warning_init (loc
, OPT_Woverride_init_side_effects
,
9293 "initialized field with side-effects overwritten");
9294 else if (warn_override_init
)
9295 warning_init (loc
, OPT_Woverride_init
,
9296 "initialized field overwritten");
9299 /* We can have just one union field set. */
9300 constructor_elements
= NULL
;
9303 /* Otherwise, output this element either to
9304 constructor_elements or to the assembler file. */
9306 constructor_elt celt
= {field
, value
};
9307 vec_safe_push (constructor_elements
, celt
);
9309 /* Advance the variable that indicates sequential elements output. */
9310 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
9311 constructor_unfilled_index
9312 = size_binop_loc (input_location
, PLUS_EXPR
, constructor_unfilled_index
,
9314 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
9316 constructor_unfilled_fields
9317 = DECL_CHAIN (constructor_unfilled_fields
);
9319 /* Skip any nameless bit fields. */
9320 while (constructor_unfilled_fields
!= NULL_TREE
9321 && DECL_UNNAMED_BIT_FIELD (constructor_unfilled_fields
))
9322 constructor_unfilled_fields
=
9323 DECL_CHAIN (constructor_unfilled_fields
);
9325 else if (TREE_CODE (constructor_type
) == UNION_TYPE
)
9326 constructor_unfilled_fields
= NULL_TREE
;
9328 /* Now output any pending elements which have become next. */
9330 output_pending_init_elements (0, braced_init_obstack
);
9333 /* For two FIELD_DECLs in the same chain, return -1 if field1
9334 comes before field2, 1 if field1 comes after field2 and
9335 0 if field1 == field2. */
9338 init_field_decl_cmp (tree field1
, tree field2
)
9340 if (field1
== field2
)
9343 tree bitpos1
= bit_position (field1
);
9344 tree bitpos2
= bit_position (field2
);
9345 if (tree_int_cst_equal (bitpos1
, bitpos2
))
9347 /* If one of the fields has non-zero bitsize, then that
9348 field must be the last one in a sequence of zero
9349 sized fields, fields after it will have bigger
9351 if (TREE_TYPE (field1
) != error_mark_node
9352 && COMPLETE_TYPE_P (TREE_TYPE (field1
))
9353 && integer_nonzerop (TREE_TYPE (field1
)))
9355 if (TREE_TYPE (field2
) != error_mark_node
9356 && COMPLETE_TYPE_P (TREE_TYPE (field2
))
9357 && integer_nonzerop (TREE_TYPE (field2
)))
9359 /* Otherwise, fallback to DECL_CHAIN walk to find out
9360 which field comes earlier. Walk chains of both
9361 fields, so that if field1 and field2 are close to each
9362 other in either order, it is found soon even for large
9363 sequences of zero sized fields. */
9364 tree f1
= field1
, f2
= field2
;
9367 f1
= DECL_CHAIN (f1
);
9368 f2
= DECL_CHAIN (f2
);
9369 if (f1
== NULL_TREE
)
9374 if (f2
== NULL_TREE
)
9380 if (!tree_int_cst_equal (bit_position (f1
), bitpos1
))
9382 if (!tree_int_cst_equal (bit_position (f2
), bitpos1
))
9386 else if (tree_int_cst_lt (bitpos1
, bitpos2
))
9392 /* Output any pending elements which have become next.
9393 As we output elements, constructor_unfilled_{fields,index}
9394 advances, which may cause other elements to become next;
9395 if so, they too are output.
9397 If ALL is 0, we return when there are
9398 no more pending elements to output now.
9400 If ALL is 1, we output space as necessary so that
9401 we can output all the pending elements. */
9403 output_pending_init_elements (int all
, struct obstack
* braced_init_obstack
)
9405 struct init_node
*elt
= constructor_pending_elts
;
9410 /* Look through the whole pending tree.
9411 If we find an element that should be output now,
9412 output it. Otherwise, set NEXT to the element
9413 that comes first among those still pending. */
9418 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
9420 if (tree_int_cst_equal (elt
->purpose
,
9421 constructor_unfilled_index
))
9422 output_init_element (input_location
, elt
->value
, elt
->origtype
,
9423 true, TREE_TYPE (constructor_type
),
9424 constructor_unfilled_index
, false, false,
9425 braced_init_obstack
);
9426 else if (tree_int_cst_lt (constructor_unfilled_index
,
9429 /* Advance to the next smaller node. */
9434 /* We have reached the smallest node bigger than the
9435 current unfilled index. Fill the space first. */
9436 next
= elt
->purpose
;
9442 /* Advance to the next bigger node. */
9447 /* We have reached the biggest node in a subtree. Find
9448 the parent of it, which is the next bigger node. */
9449 while (elt
->parent
&& elt
->parent
->right
== elt
)
9452 if (elt
&& tree_int_cst_lt (constructor_unfilled_index
,
9455 next
= elt
->purpose
;
9461 else if (RECORD_OR_UNION_TYPE_P (constructor_type
))
9463 /* If the current record is complete we are done. */
9464 if (constructor_unfilled_fields
== NULL_TREE
)
9467 int cmp
= init_field_decl_cmp (constructor_unfilled_fields
,
9470 output_init_element (input_location
, elt
->value
, elt
->origtype
,
9471 true, TREE_TYPE (elt
->purpose
),
9472 elt
->purpose
, false, false,
9473 braced_init_obstack
);
9476 /* Advance to the next smaller node. */
9481 /* We have reached the smallest node bigger than the
9482 current unfilled field. Fill the space first. */
9483 next
= elt
->purpose
;
9489 /* Advance to the next bigger node. */
9494 /* We have reached the biggest node in a subtree. Find
9495 the parent of it, which is the next bigger node. */
9496 while (elt
->parent
&& elt
->parent
->right
== elt
)
9500 && init_field_decl_cmp (constructor_unfilled_fields
,
9503 next
= elt
->purpose
;
9511 /* Ordinarily return, but not if we want to output all
9512 and there are elements left. */
9513 if (!(all
&& next
!= NULL_TREE
))
9516 /* If it's not incremental, just skip over the gap, so that after
9517 jumping to retry we will output the next successive element. */
9518 if (RECORD_OR_UNION_TYPE_P (constructor_type
))
9519 constructor_unfilled_fields
= next
;
9520 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
9521 constructor_unfilled_index
= next
;
9523 /* ELT now points to the node in the pending tree with the next
9524 initializer to output. */
9528 /* Add one non-braced element to the current constructor level.
9529 This adjusts the current position within the constructor's type.
9530 This may also start or terminate implicit levels
9531 to handle a partly-braced initializer.
9533 Once this has found the correct level for the new element,
9534 it calls output_init_element.
9536 IMPLICIT is true if value comes from pop_init_level (1),
9537 the new initializer has been merged with the existing one
9538 and thus no warnings should be emitted about overriding an
9539 existing initializer. */
9542 process_init_element (location_t loc
, struct c_expr value
, bool implicit
,
9543 struct obstack
* braced_init_obstack
)
9545 tree orig_value
= value
.value
;
9547 = (orig_value
!= NULL_TREE
&& TREE_CODE (orig_value
) == STRING_CST
);
9548 bool strict_string
= value
.original_code
== STRING_CST
;
9549 bool was_designated
= designator_depth
!= 0;
9551 designator_depth
= 0;
9552 designator_erroneous
= 0;
9554 if (!implicit
&& value
.value
&& !integer_zerop (value
.value
))
9555 constructor_zeroinit
= 0;
9557 /* Handle superfluous braces around string cst as in
9558 char x[] = {"foo"}; */
9562 && TREE_CODE (constructor_type
) == ARRAY_TYPE
9563 && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type
))
9564 && integer_zerop (constructor_unfilled_index
))
9566 if (constructor_stack
->replacement_value
.value
)
9567 error_init (loc
, "excess elements in char array initializer");
9568 constructor_stack
->replacement_value
= value
;
9572 if (constructor_stack
->replacement_value
.value
!= NULL_TREE
)
9574 error_init (loc
, "excess elements in struct initializer");
9578 /* Ignore elements of a brace group if it is entirely superfluous
9579 and has already been diagnosed. */
9580 if (constructor_type
== NULL_TREE
)
9583 if (!implicit
&& warn_designated_init
&& !was_designated
9584 && TREE_CODE (constructor_type
) == RECORD_TYPE
9585 && lookup_attribute ("designated_init",
9586 TYPE_ATTRIBUTES (constructor_type
)))
9588 OPT_Wdesignated_init
,
9589 "positional initialization of field "
9590 "in %<struct%> declared with %<designated_init%> attribute");
9592 /* If we've exhausted any levels that didn't have braces,
9594 while (constructor_stack
->implicit
)
9596 if (RECORD_OR_UNION_TYPE_P (constructor_type
)
9597 && constructor_fields
== NULL_TREE
)
9598 process_init_element (loc
,
9599 pop_init_level (loc
, 1, braced_init_obstack
,
9600 last_init_list_comma
),
9601 true, braced_init_obstack
);
9602 else if ((TREE_CODE (constructor_type
) == ARRAY_TYPE
9603 || VECTOR_TYPE_P (constructor_type
))
9604 && constructor_max_index
9605 && tree_int_cst_lt (constructor_max_index
,
9607 process_init_element (loc
,
9608 pop_init_level (loc
, 1, braced_init_obstack
,
9609 last_init_list_comma
),
9610 true, braced_init_obstack
);
9615 /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */
9616 if (constructor_range_stack
)
9618 /* If value is a compound literal and we'll be just using its
9619 content, don't put it into a SAVE_EXPR. */
9620 if (TREE_CODE (value
.value
) != COMPOUND_LITERAL_EXPR
9621 || !require_constant_value
)
9623 tree semantic_type
= NULL_TREE
;
9624 if (TREE_CODE (value
.value
) == EXCESS_PRECISION_EXPR
)
9626 semantic_type
= TREE_TYPE (value
.value
);
9627 value
.value
= TREE_OPERAND (value
.value
, 0);
9629 value
.value
= save_expr (value
.value
);
9631 value
.value
= build1 (EXCESS_PRECISION_EXPR
, semantic_type
,
9638 if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
9641 enum tree_code fieldcode
;
9643 if (constructor_fields
== NULL_TREE
)
9645 pedwarn_init (loc
, 0, "excess elements in struct initializer");
9649 fieldtype
= TREE_TYPE (constructor_fields
);
9650 if (fieldtype
!= error_mark_node
)
9651 fieldtype
= TYPE_MAIN_VARIANT (fieldtype
);
9652 fieldcode
= TREE_CODE (fieldtype
);
9654 /* Error for non-static initialization of a flexible array member. */
9655 if (fieldcode
== ARRAY_TYPE
9656 && !require_constant_value
9657 && TYPE_SIZE (fieldtype
) == NULL_TREE
9658 && DECL_CHAIN (constructor_fields
) == NULL_TREE
)
9660 error_init (loc
, "non-static initialization of a flexible "
9665 /* Error for initialization of a flexible array member with
9666 a string constant if the structure is in an array. E.g.:
9667 struct S { int x; char y[]; };
9668 struct S s[] = { { 1, "foo" } };
9671 && fieldcode
== ARRAY_TYPE
9672 && constructor_depth
> 1
9673 && TYPE_SIZE (fieldtype
) == NULL_TREE
9674 && DECL_CHAIN (constructor_fields
) == NULL_TREE
)
9676 bool in_array_p
= false;
9677 for (struct constructor_stack
*p
= constructor_stack
;
9678 p
&& p
->type
; p
= p
->next
)
9679 if (TREE_CODE (p
->type
) == ARRAY_TYPE
)
9686 error_init (loc
, "initialization of flexible array "
9687 "member in a nested context");
9692 /* Accept a string constant to initialize a subarray. */
9693 if (value
.value
!= NULL_TREE
9694 && fieldcode
== ARRAY_TYPE
9695 && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype
))
9697 value
.value
= orig_value
;
9698 /* Otherwise, if we have come to a subaggregate,
9699 and we don't have an element of its type, push into it. */
9700 else if (value
.value
!= NULL_TREE
9701 && value
.value
!= error_mark_node
9702 && TYPE_MAIN_VARIANT (TREE_TYPE (value
.value
)) != fieldtype
9703 && (fieldcode
== RECORD_TYPE
|| fieldcode
== ARRAY_TYPE
9704 || fieldcode
== UNION_TYPE
|| fieldcode
== VECTOR_TYPE
))
9706 push_init_level (loc
, 1, braced_init_obstack
);
9712 push_member_name (constructor_fields
);
9713 output_init_element (loc
, value
.value
, value
.original_type
,
9714 strict_string
, fieldtype
,
9715 constructor_fields
, true, implicit
,
9716 braced_init_obstack
);
9717 RESTORE_SPELLING_DEPTH (constructor_depth
);
9720 /* Do the bookkeeping for an element that was
9721 directly output as a constructor. */
9723 /* For a record, keep track of end position of last field. */
9724 if (DECL_SIZE (constructor_fields
))
9725 constructor_bit_index
9726 = size_binop_loc (input_location
, PLUS_EXPR
,
9727 bit_position (constructor_fields
),
9728 DECL_SIZE (constructor_fields
));
9730 /* If the current field was the first one not yet written out,
9731 it isn't now, so update. */
9732 if (constructor_unfilled_fields
== constructor_fields
)
9734 constructor_unfilled_fields
= DECL_CHAIN (constructor_fields
);
9735 /* Skip any nameless bit fields. */
9736 while (constructor_unfilled_fields
!= 0
9737 && (DECL_UNNAMED_BIT_FIELD
9738 (constructor_unfilled_fields
)))
9739 constructor_unfilled_fields
=
9740 DECL_CHAIN (constructor_unfilled_fields
);
9744 constructor_fields
= DECL_CHAIN (constructor_fields
);
9745 /* Skip any nameless bit fields at the beginning. */
9746 while (constructor_fields
!= NULL_TREE
9747 && DECL_UNNAMED_BIT_FIELD (constructor_fields
))
9748 constructor_fields
= DECL_CHAIN (constructor_fields
);
9750 else if (TREE_CODE (constructor_type
) == UNION_TYPE
)
9753 enum tree_code fieldcode
;
9755 if (constructor_fields
== NULL_TREE
)
9757 pedwarn_init (loc
, 0,
9758 "excess elements in union initializer");
9762 fieldtype
= TREE_TYPE (constructor_fields
);
9763 if (fieldtype
!= error_mark_node
)
9764 fieldtype
= TYPE_MAIN_VARIANT (fieldtype
);
9765 fieldcode
= TREE_CODE (fieldtype
);
9767 /* Warn that traditional C rejects initialization of unions.
9768 We skip the warning if the value is zero. This is done
9769 under the assumption that the zero initializer in user
9770 code appears conditioned on e.g. __STDC__ to avoid
9771 "missing initializer" warnings and relies on default
9772 initialization to zero in the traditional C case.
9773 We also skip the warning if the initializer is designated,
9774 again on the assumption that this must be conditional on
9775 __STDC__ anyway (and we've already complained about the
9776 member-designator already). */
9777 if (!in_system_header_at (input_location
) && !constructor_designated
9778 && !(value
.value
&& (integer_zerop (value
.value
)
9779 || real_zerop (value
.value
))))
9780 warning (OPT_Wtraditional
, "traditional C rejects initialization "
9783 /* Accept a string constant to initialize a subarray. */
9784 if (value
.value
!= NULL_TREE
9785 && fieldcode
== ARRAY_TYPE
9786 && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype
))
9788 value
.value
= orig_value
;
9789 /* Otherwise, if we have come to a subaggregate,
9790 and we don't have an element of its type, push into it. */
9791 else if (value
.value
!= NULL_TREE
9792 && value
.value
!= error_mark_node
9793 && TYPE_MAIN_VARIANT (TREE_TYPE (value
.value
)) != fieldtype
9794 && (fieldcode
== RECORD_TYPE
|| fieldcode
== ARRAY_TYPE
9795 || fieldcode
== UNION_TYPE
|| fieldcode
== VECTOR_TYPE
))
9797 push_init_level (loc
, 1, braced_init_obstack
);
9803 push_member_name (constructor_fields
);
9804 output_init_element (loc
, value
.value
, value
.original_type
,
9805 strict_string
, fieldtype
,
9806 constructor_fields
, true, implicit
,
9807 braced_init_obstack
);
9808 RESTORE_SPELLING_DEPTH (constructor_depth
);
9811 /* Do the bookkeeping for an element that was
9812 directly output as a constructor. */
9814 constructor_bit_index
= DECL_SIZE (constructor_fields
);
9815 constructor_unfilled_fields
= DECL_CHAIN (constructor_fields
);
9818 constructor_fields
= NULL_TREE
;
9820 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
9822 tree elttype
= TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type
));
9823 enum tree_code eltcode
= TREE_CODE (elttype
);
9825 /* Accept a string constant to initialize a subarray. */
9826 if (value
.value
!= NULL_TREE
9827 && eltcode
== ARRAY_TYPE
9828 && INTEGRAL_TYPE_P (TREE_TYPE (elttype
))
9830 value
.value
= orig_value
;
9831 /* Otherwise, if we have come to a subaggregate,
9832 and we don't have an element of its type, push into it. */
9833 else if (value
.value
!= NULL_TREE
9834 && value
.value
!= error_mark_node
9835 && TYPE_MAIN_VARIANT (TREE_TYPE (value
.value
)) != elttype
9836 && (eltcode
== RECORD_TYPE
|| eltcode
== ARRAY_TYPE
9837 || eltcode
== UNION_TYPE
|| eltcode
== VECTOR_TYPE
))
9839 push_init_level (loc
, 1, braced_init_obstack
);
9843 if (constructor_max_index
!= NULL_TREE
9844 && (tree_int_cst_lt (constructor_max_index
, constructor_index
)
9845 || integer_all_onesp (constructor_max_index
)))
9847 pedwarn_init (loc
, 0,
9848 "excess elements in array initializer");
9852 /* Now output the actual element. */
9855 push_array_bounds (tree_to_uhwi (constructor_index
));
9856 output_init_element (loc
, value
.value
, value
.original_type
,
9857 strict_string
, elttype
,
9858 constructor_index
, true, implicit
,
9859 braced_init_obstack
);
9860 RESTORE_SPELLING_DEPTH (constructor_depth
);
9864 = size_binop_loc (input_location
, PLUS_EXPR
,
9865 constructor_index
, bitsize_one_node
);
9868 /* If we are doing the bookkeeping for an element that was
9869 directly output as a constructor, we must update
9870 constructor_unfilled_index. */
9871 constructor_unfilled_index
= constructor_index
;
9873 else if (VECTOR_TYPE_P (constructor_type
))
9875 tree elttype
= TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type
));
9877 /* Do a basic check of initializer size. Note that vectors
9878 always have a fixed size derived from their type. */
9879 if (tree_int_cst_lt (constructor_max_index
, constructor_index
))
9881 pedwarn_init (loc
, 0,
9882 "excess elements in vector initializer");
9886 /* Now output the actual element. */
9889 if (TREE_CODE (value
.value
) == VECTOR_CST
)
9890 elttype
= TYPE_MAIN_VARIANT (constructor_type
);
9891 output_init_element (loc
, value
.value
, value
.original_type
,
9892 strict_string
, elttype
,
9893 constructor_index
, true, implicit
,
9894 braced_init_obstack
);
9898 = size_binop_loc (input_location
,
9899 PLUS_EXPR
, constructor_index
, bitsize_one_node
);
9902 /* If we are doing the bookkeeping for an element that was
9903 directly output as a constructor, we must update
9904 constructor_unfilled_index. */
9905 constructor_unfilled_index
= constructor_index
;
9908 /* Handle the sole element allowed in a braced initializer
9909 for a scalar variable. */
9910 else if (constructor_type
!= error_mark_node
9911 && constructor_fields
== NULL_TREE
)
9913 pedwarn_init (loc
, 0,
9914 "excess elements in scalar initializer");
9920 output_init_element (loc
, value
.value
, value
.original_type
,
9921 strict_string
, constructor_type
,
9922 NULL_TREE
, true, implicit
,
9923 braced_init_obstack
);
9924 constructor_fields
= NULL_TREE
;
9927 /* Handle range initializers either at this level or anywhere higher
9928 in the designator stack. */
9929 if (constructor_range_stack
)
9931 struct constructor_range_stack
*p
, *range_stack
;
9934 range_stack
= constructor_range_stack
;
9935 constructor_range_stack
= 0;
9936 while (constructor_stack
!= range_stack
->stack
)
9938 gcc_assert (constructor_stack
->implicit
);
9939 process_init_element (loc
,
9940 pop_init_level (loc
, 1,
9941 braced_init_obstack
,
9942 last_init_list_comma
),
9943 true, braced_init_obstack
);
9945 for (p
= range_stack
;
9946 !p
->range_end
|| tree_int_cst_equal (p
->index
, p
->range_end
);
9949 gcc_assert (constructor_stack
->implicit
);
9950 process_init_element (loc
,
9951 pop_init_level (loc
, 1,
9952 braced_init_obstack
,
9953 last_init_list_comma
),
9954 true, braced_init_obstack
);
9957 p
->index
= size_binop_loc (input_location
,
9958 PLUS_EXPR
, p
->index
, bitsize_one_node
);
9959 if (tree_int_cst_equal (p
->index
, p
->range_end
) && !p
->prev
)
9964 constructor_index
= p
->index
;
9965 constructor_fields
= p
->fields
;
9966 if (finish
&& p
->range_end
&& p
->index
== p
->range_start
)
9974 finish_implicit_inits (loc
, braced_init_obstack
);
9975 push_init_level (loc
, 2, braced_init_obstack
);
9976 p
->stack
= constructor_stack
;
9977 if (p
->range_end
&& tree_int_cst_equal (p
->index
, p
->range_end
))
9978 p
->index
= p
->range_start
;
9982 constructor_range_stack
= range_stack
;
9989 constructor_range_stack
= 0;
9992 /* Build a complete asm-statement, whose components are a CV_QUALIFIER
9993 (guaranteed to be 'volatile' or null) and ARGS (represented using
9994 an ASM_EXPR node). */
9996 build_asm_stmt (tree cv_qualifier
, tree args
)
9998 if (!ASM_VOLATILE_P (args
) && cv_qualifier
)
9999 ASM_VOLATILE_P (args
) = 1;
10000 return add_stmt (args
);
10003 /* Build an asm-expr, whose components are a STRING, some OUTPUTS,
10004 some INPUTS, and some CLOBBERS. The latter three may be NULL.
10005 SIMPLE indicates whether there was anything at all after the
10006 string in the asm expression -- asm("blah") and asm("blah" : )
10007 are subtly different. We use a ASM_EXPR node to represent this. */
10009 build_asm_expr (location_t loc
, tree string
, tree outputs
, tree inputs
,
10010 tree clobbers
, tree labels
, bool simple
)
10015 const char *constraint
;
10016 const char **oconstraints
;
10017 bool allows_mem
, allows_reg
, is_inout
;
10018 int ninputs
, noutputs
;
10020 ninputs
= list_length (inputs
);
10021 noutputs
= list_length (outputs
);
10022 oconstraints
= (const char **) alloca (noutputs
* sizeof (const char *));
10024 string
= resolve_asm_operand_names (string
, outputs
, inputs
, labels
);
10026 /* Remove output conversions that change the type but not the mode. */
10027 for (i
= 0, tail
= outputs
; tail
; ++i
, tail
= TREE_CHAIN (tail
))
10029 tree output
= TREE_VALUE (tail
);
10031 output
= c_fully_fold (output
, false, NULL
, true);
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
);
10041 if (!lvalue_or_else (loc
, output
, lv_asm
))
10042 output
= error_mark_node
;
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
);
10051 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail
)));
10052 oconstraints
[i
] = constraint
;
10054 if (parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
10055 &allows_mem
, &allows_reg
, &is_inout
))
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
)))
10065 error_at (loc
, "invalid use of void expression");
10066 output
= error_mark_node
;
10070 output
= error_mark_node
;
10072 TREE_VALUE (tail
) = output
;
10075 for (i
= 0, tail
= inputs
; tail
; ++i
, tail
= TREE_CHAIN (tail
))
10079 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail
)));
10080 input
= TREE_VALUE (tail
);
10082 if (parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
10083 oconstraints
, &allows_mem
, &allows_reg
))
10085 /* If the operand is going to end up in memory,
10086 mark it addressable. */
10087 if (!allows_reg
&& allows_mem
)
10089 input
= c_fully_fold (input
, false, NULL
, true);
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
;
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
);
10105 if (input
!= error_mark_node
&& VOID_TYPE_P (TREE_TYPE (input
)))
10107 error_at (loc
, "invalid use of void expression");
10108 input
= error_mark_node
;
10113 input
= error_mark_node
;
10115 TREE_VALUE (tail
) = input
;
10118 /* ASMs with labels cannot have outputs. This should have been
10119 enforced by the parser. */
10120 gcc_assert (outputs
== NULL
|| labels
== NULL
);
10122 args
= build_stmt (loc
, ASM_EXPR
, string
, outputs
, inputs
, clobbers
, labels
);
10124 /* asm statements without outputs, including simple ones, are treated
10126 ASM_INPUT_P (args
) = simple
;
10127 ASM_VOLATILE_P (args
) = (noutputs
== 0);
10132 /* Generate a goto statement to LABEL. LOC is the location of the
10136 c_finish_goto_label (location_t loc
, tree label
)
10138 tree decl
= lookup_label_for_goto (loc
, label
);
10141 TREE_USED (decl
) = 1;
10143 add_stmt (build_predict_expr (PRED_GOTO
, NOT_TAKEN
));
10144 tree t
= build1 (GOTO_EXPR
, void_type_node
, decl
);
10145 SET_EXPR_LOCATION (t
, loc
);
10146 return add_stmt (t
);
10150 /* Generate a computed goto statement to EXPR. LOC is the location of
10154 c_finish_goto_ptr (location_t loc
, tree expr
)
10157 pedwarn (loc
, OPT_Wpedantic
, "ISO C forbids %<goto *expr;%>");
10158 expr
= c_fully_fold (expr
, false, NULL
);
10159 expr
= convert (ptr_type_node
, expr
);
10160 t
= build1 (GOTO_EXPR
, void_type_node
, expr
);
10161 SET_EXPR_LOCATION (t
, loc
);
10162 return add_stmt (t
);
10165 /* Generate a C `return' statement. RETVAL is the expression for what
10166 to return, or a null pointer for `return;' with no value. LOC is
10167 the location of the return statement, or the location of the expression,
10168 if the statement has any. If ORIGTYPE is not NULL_TREE, it
10169 is the original type of RETVAL. */
10172 c_finish_return (location_t loc
, tree retval
, tree origtype
)
10174 tree valtype
= TREE_TYPE (TREE_TYPE (current_function_decl
)), ret_stmt
;
10175 bool no_warning
= false;
10178 /* Use the expansion point to handle cases such as returning NULL
10179 in a function returning void. */
10180 source_location xloc
= expansion_point_location_if_in_system_header (loc
);
10182 if (TREE_THIS_VOLATILE (current_function_decl
))
10183 warning_at (xloc
, 0,
10184 "function declared %<noreturn%> has a %<return%> statement");
10188 tree semantic_type
= NULL_TREE
;
10189 npc
= null_pointer_constant_p (retval
);
10190 if (TREE_CODE (retval
) == EXCESS_PRECISION_EXPR
)
10192 semantic_type
= TREE_TYPE (retval
);
10193 retval
= TREE_OPERAND (retval
, 0);
10195 retval
= c_fully_fold (retval
, false, NULL
);
10197 retval
= build1 (EXCESS_PRECISION_EXPR
, semantic_type
, retval
);
10202 current_function_returns_null
= 1;
10203 if ((warn_return_type
>= 0 || flag_isoc99
)
10204 && valtype
!= NULL_TREE
&& TREE_CODE (valtype
) != VOID_TYPE
)
10208 warned_here
= pedwarn
10209 (loc
, warn_return_type
>= 0 ? OPT_Wreturn_type
: 0,
10210 "%<return%> with no value, in function returning non-void");
10212 warned_here
= warning_at
10213 (loc
, OPT_Wreturn_type
,
10214 "%<return%> with no value, in function returning non-void");
10217 inform (DECL_SOURCE_LOCATION (current_function_decl
),
10221 else if (valtype
== NULL_TREE
|| TREE_CODE (valtype
) == VOID_TYPE
)
10223 current_function_returns_null
= 1;
10225 if (TREE_CODE (TREE_TYPE (retval
)) != VOID_TYPE
)
10226 warned_here
= pedwarn
10227 (xloc
, warn_return_type
>= 0 ? OPT_Wreturn_type
: 0,
10228 "%<return%> with a value, in function returning void");
10230 warned_here
= pedwarn
10231 (xloc
, OPT_Wpedantic
, "ISO C forbids "
10232 "%<return%> with expression, in function returning void");
10234 inform (DECL_SOURCE_LOCATION (current_function_decl
),
10239 tree t
= convert_for_assignment (loc
, UNKNOWN_LOCATION
, valtype
,
10240 retval
, origtype
, ic_return
,
10241 npc
, NULL_TREE
, NULL_TREE
, 0);
10242 tree res
= DECL_RESULT (current_function_decl
);
10246 current_function_returns_value
= 1;
10247 if (t
== error_mark_node
)
10250 save
= in_late_binary_op
;
10251 if (TREE_CODE (TREE_TYPE (res
)) == BOOLEAN_TYPE
10252 || TREE_CODE (TREE_TYPE (res
)) == COMPLEX_TYPE
10253 || (TREE_CODE (TREE_TYPE (t
)) == REAL_TYPE
10254 && (TREE_CODE (TREE_TYPE (res
)) == INTEGER_TYPE
10255 || TREE_CODE (TREE_TYPE (res
)) == ENUMERAL_TYPE
)
10256 && sanitize_flags_p (SANITIZE_FLOAT_CAST
)))
10257 in_late_binary_op
= true;
10258 inner
= t
= convert (TREE_TYPE (res
), t
);
10259 in_late_binary_op
= save
;
10261 /* Strip any conversions, additions, and subtractions, and see if
10262 we are returning the address of a local variable. Warn if so. */
10265 switch (TREE_CODE (inner
))
10268 case NON_LVALUE_EXPR
:
10270 case POINTER_PLUS_EXPR
:
10271 inner
= TREE_OPERAND (inner
, 0);
10275 /* If the second operand of the MINUS_EXPR has a pointer
10276 type (or is converted from it), this may be valid, so
10277 don't give a warning. */
10279 tree op1
= TREE_OPERAND (inner
, 1);
10281 while (!POINTER_TYPE_P (TREE_TYPE (op1
))
10282 && (CONVERT_EXPR_P (op1
)
10283 || TREE_CODE (op1
) == NON_LVALUE_EXPR
))
10284 op1
= TREE_OPERAND (op1
, 0);
10286 if (POINTER_TYPE_P (TREE_TYPE (op1
)))
10289 inner
= TREE_OPERAND (inner
, 0);
10294 inner
= TREE_OPERAND (inner
, 0);
10296 while (REFERENCE_CLASS_P (inner
)
10297 && !INDIRECT_REF_P (inner
))
10298 inner
= TREE_OPERAND (inner
, 0);
10301 && !DECL_EXTERNAL (inner
)
10302 && !TREE_STATIC (inner
)
10303 && DECL_CONTEXT (inner
) == current_function_decl
)
10305 if (TREE_CODE (inner
) == LABEL_DECL
)
10306 warning_at (loc
, OPT_Wreturn_local_addr
,
10307 "function returns address of label");
10310 warning_at (loc
, OPT_Wreturn_local_addr
,
10311 "function returns address of local variable");
10312 tree zero
= build_zero_cst (TREE_TYPE (res
));
10313 t
= build2 (COMPOUND_EXPR
, TREE_TYPE (res
), t
, zero
);
10325 retval
= build2 (MODIFY_EXPR
, TREE_TYPE (res
), res
, t
);
10326 SET_EXPR_LOCATION (retval
, loc
);
10328 if (warn_sequence_point
)
10329 verify_sequence_points (retval
);
10332 ret_stmt
= build_stmt (loc
, RETURN_EXPR
, retval
);
10333 TREE_NO_WARNING (ret_stmt
) |= no_warning
;
10334 return add_stmt (ret_stmt
);
10338 /* The SWITCH_EXPR being built. */
10341 /* The original type of the testing expression, i.e. before the
10342 default conversion is applied. */
10345 /* A splay-tree mapping the low element of a case range to the high
10346 element, or NULL_TREE if there is no high element. Used to
10347 determine whether or not a new case label duplicates an old case
10348 label. We need a tree, rather than simply a hash table, because
10349 of the GNU case range extension. */
10352 /* The bindings at the point of the switch. This is used for
10353 warnings crossing decls when branching to a case label. */
10354 struct c_spot_bindings
*bindings
;
10356 /* The next node on the stack. */
10357 struct c_switch
*next
;
10359 /* Remember whether the controlling expression had boolean type
10360 before integer promotions for the sake of -Wswitch-bool. */
10363 /* Remember whether there was a case value that is outside the
10364 range of the ORIG_TYPE. */
10365 bool outside_range_p
;
10368 /* A stack of the currently active switch statements. The innermost
10369 switch statement is on the top of the stack. There is no need to
10370 mark the stack for garbage collection because it is only active
10371 during the processing of the body of a function, and we never
10372 collect at that point. */
10374 struct c_switch
*c_switch_stack
;
10376 /* Start a C switch statement, testing expression EXP. Return the new
10377 SWITCH_EXPR. SWITCH_LOC is the location of the `switch'.
10378 SWITCH_COND_LOC is the location of the switch's condition.
10379 EXPLICIT_CAST_P is true if the expression EXP has an explicit cast. */
10382 c_start_case (location_t switch_loc
,
10383 location_t switch_cond_loc
,
10384 tree exp
, bool explicit_cast_p
)
10386 tree orig_type
= error_mark_node
;
10387 bool bool_cond_p
= false;
10388 struct c_switch
*cs
;
10390 if (exp
!= error_mark_node
)
10392 orig_type
= TREE_TYPE (exp
);
10394 if (!INTEGRAL_TYPE_P (orig_type
))
10396 if (orig_type
!= error_mark_node
)
10398 error_at (switch_cond_loc
, "switch quantity not an integer");
10399 orig_type
= error_mark_node
;
10401 exp
= integer_zero_node
;
10405 tree type
= TYPE_MAIN_VARIANT (orig_type
);
10408 /* Warn if the condition has boolean value. */
10409 while (TREE_CODE (e
) == COMPOUND_EXPR
)
10410 e
= TREE_OPERAND (e
, 1);
10412 if ((TREE_CODE (type
) == BOOLEAN_TYPE
10413 || truth_value_p (TREE_CODE (e
)))
10414 /* Explicit cast to int suppresses this warning. */
10415 && !(TREE_CODE (type
) == INTEGER_TYPE
10416 && explicit_cast_p
))
10417 bool_cond_p
= true;
10419 if (!in_system_header_at (input_location
)
10420 && (type
== long_integer_type_node
10421 || type
== long_unsigned_type_node
))
10422 warning_at (switch_cond_loc
,
10423 OPT_Wtraditional
, "%<long%> switch expression not "
10424 "converted to %<int%> in ISO C");
10426 exp
= c_fully_fold (exp
, false, NULL
);
10427 exp
= default_conversion (exp
);
10429 if (warn_sequence_point
)
10430 verify_sequence_points (exp
);
10434 /* Add this new SWITCH_EXPR to the stack. */
10435 cs
= XNEW (struct c_switch
);
10436 cs
->switch_expr
= build2 (SWITCH_EXPR
, orig_type
, exp
, NULL_TREE
);
10437 SET_EXPR_LOCATION (cs
->switch_expr
, switch_loc
);
10438 cs
->orig_type
= orig_type
;
10439 cs
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
10440 cs
->bindings
= c_get_switch_bindings ();
10441 cs
->bool_cond_p
= bool_cond_p
;
10442 cs
->outside_range_p
= false;
10443 cs
->next
= c_switch_stack
;
10444 c_switch_stack
= cs
;
10446 return add_stmt (cs
->switch_expr
);
10449 /* Process a case label at location LOC. */
10452 do_case (location_t loc
, tree low_value
, tree high_value
)
10454 tree label
= NULL_TREE
;
10456 if (low_value
&& TREE_CODE (low_value
) != INTEGER_CST
)
10458 low_value
= c_fully_fold (low_value
, false, NULL
);
10459 if (TREE_CODE (low_value
) == INTEGER_CST
)
10460 pedwarn (loc
, OPT_Wpedantic
,
10461 "case label is not an integer constant expression");
10464 if (high_value
&& TREE_CODE (high_value
) != INTEGER_CST
)
10466 high_value
= c_fully_fold (high_value
, false, NULL
);
10467 if (TREE_CODE (high_value
) == INTEGER_CST
)
10468 pedwarn (input_location
, OPT_Wpedantic
,
10469 "case label is not an integer constant expression");
10472 if (c_switch_stack
== NULL
)
10475 error_at (loc
, "case label not within a switch statement");
10477 error_at (loc
, "%<default%> label not within a switch statement");
10481 if (c_check_switch_jump_warnings (c_switch_stack
->bindings
,
10482 EXPR_LOCATION (c_switch_stack
->switch_expr
),
10486 label
= c_add_case_label (loc
, c_switch_stack
->cases
,
10487 SWITCH_COND (c_switch_stack
->switch_expr
),
10488 c_switch_stack
->orig_type
,
10489 low_value
, high_value
,
10490 &c_switch_stack
->outside_range_p
);
10491 if (label
== error_mark_node
)
10496 /* Finish the switch statement. TYPE is the original type of the
10497 controlling expression of the switch, or NULL_TREE. */
10500 c_finish_case (tree body
, tree type
)
10502 struct c_switch
*cs
= c_switch_stack
;
10503 location_t switch_location
;
10505 SWITCH_BODY (cs
->switch_expr
) = body
;
10507 /* Emit warnings as needed. */
10508 switch_location
= EXPR_LOCATION (cs
->switch_expr
);
10509 c_do_switch_warnings (cs
->cases
, switch_location
,
10510 type
? type
: TREE_TYPE (cs
->switch_expr
),
10511 SWITCH_COND (cs
->switch_expr
),
10512 cs
->bool_cond_p
, cs
->outside_range_p
);
10513 if (c_switch_covers_all_cases_p (cs
->cases
, TREE_TYPE (cs
->switch_expr
)))
10514 SWITCH_ALL_CASES_P (cs
->switch_expr
) = 1;
10516 /* Pop the stack. */
10517 c_switch_stack
= cs
->next
;
10518 splay_tree_delete (cs
->cases
);
10519 c_release_switch_bindings (cs
->bindings
);
10523 /* Emit an if statement. IF_LOCUS is the location of the 'if'. COND,
10524 THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK
10528 c_finish_if_stmt (location_t if_locus
, tree cond
, tree then_block
,
10533 stmt
= build3 (COND_EXPR
, void_type_node
, cond
, then_block
, else_block
);
10534 SET_EXPR_LOCATION (stmt
, if_locus
);
10538 /* Emit a general-purpose loop construct. START_LOCUS is the location of
10539 the beginning of the loop. COND is the loop condition. COND_IS_FIRST
10540 is false for DO loops. INCR is the FOR increment expression. BODY is
10541 the statement controlled by the loop. BLAB is the break label. CLAB is
10542 the continue label. Everything is allowed to be NULL. */
10545 c_finish_loop (location_t start_locus
, tree cond
, tree incr
, tree body
,
10546 tree blab
, tree clab
, bool cond_is_first
)
10548 tree entry
= NULL
, exit
= NULL
, t
;
10550 /* If the condition is zero don't generate a loop construct. */
10551 if (cond
&& integer_zerop (cond
))
10555 t
= build_and_jump (&blab
);
10556 SET_EXPR_LOCATION (t
, start_locus
);
10562 tree top
= build1 (LABEL_EXPR
, void_type_node
, NULL_TREE
);
10564 /* If we have an exit condition, then we build an IF with gotos either
10565 out of the loop, or to the top of it. If there's no exit condition,
10566 then we just build a jump back to the top. */
10567 exit
= build_and_jump (&LABEL_EXPR_LABEL (top
));
10569 if (cond
&& !integer_nonzerop (cond
))
10571 /* Canonicalize the loop condition to the end. This means
10572 generating a branch to the loop condition. Reuse the
10573 continue label, if possible. */
10578 entry
= build1 (LABEL_EXPR
, void_type_node
, NULL_TREE
);
10579 t
= build_and_jump (&LABEL_EXPR_LABEL (entry
));
10582 t
= build1 (GOTO_EXPR
, void_type_node
, clab
);
10583 SET_EXPR_LOCATION (t
, start_locus
);
10587 t
= build_and_jump (&blab
);
10589 exit
= fold_build3_loc (start_locus
,
10590 COND_EXPR
, void_type_node
, cond
, exit
, t
);
10592 exit
= fold_build3_loc (input_location
,
10593 COND_EXPR
, void_type_node
, cond
, exit
, t
);
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
)
10603 SET_EXPR_LOCATION (exit
, loc
);
10612 add_stmt (build1 (LABEL_EXPR
, void_type_node
, clab
));
10620 add_stmt (build1 (LABEL_EXPR
, void_type_node
, blab
));
10624 c_finish_bc_stmt (location_t loc
, tree
*label_p
, bool is_break
)
10627 tree label
= *label_p
;
10629 /* In switch statements break is sometimes stylistically used after
10630 a return statement. This can lead to spurious warnings about
10631 control reaching the end of a non-void function when it is
10632 inlined. Note that we are calling block_may_fallthru with
10633 language specific tree nodes; this works because
10634 block_may_fallthru returns true when given something it does not
10636 skip
= !block_may_fallthru (cur_stmt_list
);
10641 *label_p
= label
= create_artificial_label (loc
);
10643 else if (TREE_CODE (label
) == LABEL_DECL
)
10645 else switch (TREE_INT_CST_LOW (label
))
10649 error_at (loc
, "break statement not within loop or switch");
10651 error_at (loc
, "continue statement not within a loop");
10655 gcc_assert (is_break
);
10656 error_at (loc
, "break statement used with OpenMP for loop");
10661 error ("break statement within %<#pragma simd%> loop body");
10663 error ("continue statement within %<#pragma simd%> loop body");
10667 gcc_unreachable ();
10674 add_stmt (build_predict_expr (PRED_CONTINUE
, NOT_TAKEN
));
10676 return add_stmt (build1 (GOTO_EXPR
, void_type_node
, label
));
10679 /* A helper routine for c_process_expr_stmt and c_finish_stmt_expr. */
10682 emit_side_effect_warnings (location_t loc
, tree expr
)
10684 if (expr
== error_mark_node
)
10686 else if (!TREE_SIDE_EFFECTS (expr
))
10688 if (!VOID_TYPE_P (TREE_TYPE (expr
)) && !TREE_NO_WARNING (expr
))
10689 warning_at (loc
, OPT_Wunused_value
, "statement with no effect");
10691 else if (TREE_CODE (expr
) == COMPOUND_EXPR
)
10694 location_t cloc
= loc
;
10695 while (TREE_CODE (r
) == COMPOUND_EXPR
)
10697 if (EXPR_HAS_LOCATION (r
))
10698 cloc
= EXPR_LOCATION (r
);
10699 r
= TREE_OPERAND (r
, 1);
10701 if (!TREE_SIDE_EFFECTS (r
)
10702 && !VOID_TYPE_P (TREE_TYPE (r
))
10703 && !CONVERT_EXPR_P (r
)
10704 && !TREE_NO_WARNING (r
)
10705 && !TREE_NO_WARNING (expr
))
10706 warning_at (cloc
, OPT_Wunused_value
,
10707 "right-hand operand of comma expression has no effect");
10710 warn_if_unused_value (expr
, loc
);
10713 /* Process an expression as if it were a complete statement. Emit
10714 diagnostics, but do not call ADD_STMT. LOC is the location of the
10718 c_process_expr_stmt (location_t loc
, tree expr
)
10725 expr
= c_fully_fold (expr
, false, NULL
);
10727 if (warn_sequence_point
)
10728 verify_sequence_points (expr
);
10730 if (TREE_TYPE (expr
) != error_mark_node
10731 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr
))
10732 && TREE_CODE (TREE_TYPE (expr
)) != ARRAY_TYPE
)
10733 error_at (loc
, "expression statement has incomplete type");
10735 /* If we're not processing a statement expression, warn about unused values.
10736 Warnings for statement expressions will be emitted later, once we figure
10737 out which is the result. */
10738 if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list
)
10739 && warn_unused_value
)
10740 emit_side_effect_warnings (EXPR_LOC_OR_LOC (expr
, loc
), expr
);
10743 while (TREE_CODE (exprv
) == COMPOUND_EXPR
)
10744 exprv
= TREE_OPERAND (exprv
, 1);
10745 while (CONVERT_EXPR_P (exprv
))
10746 exprv
= TREE_OPERAND (exprv
, 0);
10748 || handled_component_p (exprv
)
10749 || TREE_CODE (exprv
) == ADDR_EXPR
)
10750 mark_exp_read (exprv
);
10752 /* If the expression is not of a type to which we cannot assign a line
10753 number, wrap the thing in a no-op NOP_EXPR. */
10754 if (DECL_P (expr
) || CONSTANT_CLASS_P (expr
))
10756 expr
= build1 (NOP_EXPR
, TREE_TYPE (expr
), expr
);
10757 SET_EXPR_LOCATION (expr
, loc
);
10763 /* Emit an expression as a statement. LOC is the location of the
10767 c_finish_expr_stmt (location_t loc
, tree expr
)
10770 return add_stmt (c_process_expr_stmt (loc
, expr
));
10775 /* Do the opposite and emit a statement as an expression. To begin,
10776 create a new binding level and return it. */
10779 c_begin_stmt_expr (void)
10783 /* We must force a BLOCK for this level so that, if it is not expanded
10784 later, there is a way to turn off the entire subtree of blocks that
10785 are contained in it. */
10786 keep_next_level ();
10787 ret
= c_begin_compound_stmt (true);
10789 c_bindings_start_stmt_expr (c_switch_stack
== NULL
10791 : c_switch_stack
->bindings
);
10793 /* Mark the current statement list as belonging to a statement list. */
10794 STATEMENT_LIST_STMT_EXPR (ret
) = 1;
10799 /* LOC is the location of the compound statement to which this body
10803 c_finish_stmt_expr (location_t loc
, tree body
)
10805 tree last
, type
, tmp
, val
;
10808 body
= c_end_compound_stmt (loc
, body
, true);
10810 c_bindings_end_stmt_expr (c_switch_stack
== NULL
10812 : c_switch_stack
->bindings
);
10814 /* Locate the last statement in BODY. See c_end_compound_stmt
10815 about always returning a BIND_EXPR. */
10816 last_p
= &BIND_EXPR_BODY (body
);
10817 last
= BIND_EXPR_BODY (body
);
10819 continue_searching
:
10820 if (TREE_CODE (last
) == STATEMENT_LIST
)
10822 tree_stmt_iterator l
= tsi_last (last
);
10824 while (!tsi_end_p (l
) && TREE_CODE (tsi_stmt (l
)) == DEBUG_BEGIN_STMT
)
10827 /* This can happen with degenerate cases like ({ }). No value. */
10831 /* If we're supposed to generate side effects warnings, process
10832 all of the statements except the last. */
10833 if (warn_unused_value
)
10835 for (tree_stmt_iterator i
= tsi_start (last
);
10836 tsi_stmt (i
) != tsi_stmt (l
); tsi_next (&i
))
10839 tree t
= tsi_stmt (i
);
10841 tloc
= EXPR_HAS_LOCATION (t
) ? EXPR_LOCATION (t
) : loc
;
10842 emit_side_effect_warnings (tloc
, t
);
10845 last_p
= tsi_stmt_ptr (l
);
10849 /* If the end of the list is exception related, then the list was split
10850 by a call to push_cleanup. Continue searching. */
10851 if (TREE_CODE (last
) == TRY_FINALLY_EXPR
10852 || TREE_CODE (last
) == TRY_CATCH_EXPR
)
10854 last_p
= &TREE_OPERAND (last
, 0);
10856 goto continue_searching
;
10859 if (last
== error_mark_node
)
10862 /* In the case that the BIND_EXPR is not necessary, return the
10863 expression out from inside it. */
10864 if ((last
== BIND_EXPR_BODY (body
)
10865 /* Skip nested debug stmts. */
10866 || last
== expr_first (BIND_EXPR_BODY (body
)))
10867 && BIND_EXPR_VARS (body
) == NULL
)
10869 /* Even if this looks constant, do not allow it in a constant
10871 last
= c_wrap_maybe_const (last
, true);
10872 /* Do not warn if the return value of a statement expression is
10874 TREE_NO_WARNING (last
) = 1;
10878 /* Extract the type of said expression. */
10879 type
= TREE_TYPE (last
);
10881 /* If we're not returning a value at all, then the BIND_EXPR that
10882 we already have is a fine expression to return. */
10883 if (!type
|| VOID_TYPE_P (type
))
10886 /* Now that we've located the expression containing the value, it seems
10887 silly to make voidify_wrapper_expr repeat the process. Create a
10888 temporary of the appropriate type and stick it in a TARGET_EXPR. */
10889 tmp
= create_tmp_var_raw (type
);
10891 /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt. This avoids
10892 tree_expr_nonnegative_p giving up immediately. */
10894 if (TREE_CODE (val
) == NOP_EXPR
10895 && TREE_TYPE (val
) == TREE_TYPE (TREE_OPERAND (val
, 0)))
10896 val
= TREE_OPERAND (val
, 0);
10898 *last_p
= build2 (MODIFY_EXPR
, void_type_node
, tmp
, val
);
10899 SET_EXPR_LOCATION (*last_p
, EXPR_LOCATION (last
));
10902 tree t
= build4 (TARGET_EXPR
, type
, tmp
, body
, NULL_TREE
, NULL_TREE
);
10903 SET_EXPR_LOCATION (t
, loc
);
10908 /* Begin and end compound statements. This is as simple as pushing
10909 and popping new statement lists from the tree. */
10912 c_begin_compound_stmt (bool do_scope
)
10914 tree stmt
= push_stmt_list ();
10920 /* End a compound statement. STMT is the statement. LOC is the
10921 location of the compound statement-- this is usually the location
10922 of the opening brace. */
10925 c_end_compound_stmt (location_t loc
, tree stmt
, bool do_scope
)
10931 if (c_dialect_objc ())
10932 objc_clear_super_receiver ();
10933 block
= pop_scope ();
10936 stmt
= pop_stmt_list (stmt
);
10937 stmt
= c_build_bind_expr (loc
, block
, stmt
);
10939 /* If this compound statement is nested immediately inside a statement
10940 expression, then force a BIND_EXPR to be created. Otherwise we'll
10941 do the wrong thing for ({ { 1; } }) or ({ 1; { } }). In particular,
10942 STATEMENT_LISTs merge, and thus we can lose track of what statement
10943 was really last. */
10944 if (building_stmt_list_p ()
10945 && STATEMENT_LIST_STMT_EXPR (cur_stmt_list
)
10946 && TREE_CODE (stmt
) != BIND_EXPR
)
10948 stmt
= build3 (BIND_EXPR
, void_type_node
, NULL
, stmt
, NULL
);
10949 TREE_SIDE_EFFECTS (stmt
) = 1;
10950 SET_EXPR_LOCATION (stmt
, loc
);
10956 /* Queue a cleanup. CLEANUP is an expression/statement to be executed
10957 when the current scope is exited. EH_ONLY is true when this is not
10958 meant to apply to normal control flow transfer. */
10961 push_cleanup (tree decl
, tree cleanup
, bool eh_only
)
10963 enum tree_code code
;
10967 code
= eh_only
? TRY_CATCH_EXPR
: TRY_FINALLY_EXPR
;
10968 stmt
= build_stmt (DECL_SOURCE_LOCATION (decl
), code
, NULL
, cleanup
);
10970 stmt_expr
= STATEMENT_LIST_STMT_EXPR (cur_stmt_list
);
10971 list
= push_stmt_list ();
10972 TREE_OPERAND (stmt
, 0) = list
;
10973 STATEMENT_LIST_STMT_EXPR (list
) = stmt_expr
;
10976 /* Build a vector comparison of ARG0 and ARG1 using CODE opcode
10977 into a value of TYPE type. Comparison is done via VEC_COND_EXPR. */
10980 build_vec_cmp (tree_code code
, tree type
,
10981 tree arg0
, tree arg1
)
10983 tree zero_vec
= build_zero_cst (type
);
10984 tree minus_one_vec
= build_minus_one_cst (type
);
10985 tree cmp_type
= build_same_sized_truth_vector_type (type
);
10986 tree cmp
= build2 (code
, cmp_type
, arg0
, arg1
);
10987 return build3 (VEC_COND_EXPR
, type
, cmp
, minus_one_vec
, zero_vec
);
10990 /* Build a binary-operation expression without default conversions.
10991 CODE is the kind of expression to build.
10992 LOCATION is the operator's location.
10993 This function differs from `build' in several ways:
10994 the data type of the result is computed and recorded in it,
10995 warnings are generated if arg data types are invalid,
10996 special handling for addition and subtraction of pointers is known,
10997 and some optimization is done (operations on narrow ints
10998 are done in the narrower type when that gives the same result).
10999 Constant folding is also done before the result is returned.
11001 Note that the operands will never have enumeral types, or function
11002 or array types, because either they will have the default conversions
11003 performed or they have both just been converted to some other type in which
11004 the arithmetic is to be done. */
11007 build_binary_op (location_t location
, enum tree_code code
,
11008 tree orig_op0
, tree orig_op1
, bool convert_p
)
11010 tree type0
, type1
, orig_type0
, orig_type1
;
11012 enum tree_code code0
, code1
;
11014 tree ret
= error_mark_node
;
11015 const char *invalid_op_diag
;
11016 bool op0_int_operands
, op1_int_operands
;
11017 bool int_const
, int_const_or_overflow
, int_operands
;
11019 /* Expression code to give to the expression when it is built.
11020 Normally this is CODE, which is what the caller asked for,
11021 but in some special cases we change it. */
11022 enum tree_code resultcode
= code
;
11024 /* Data type in which the computation is to be performed.
11025 In the simplest cases this is the common type of the arguments. */
11026 tree result_type
= NULL
;
11028 /* When the computation is in excess precision, the type of the
11029 final EXCESS_PRECISION_EXPR. */
11030 tree semantic_result_type
= NULL
;
11032 /* Nonzero means operands have already been type-converted
11033 in whatever way is necessary.
11034 Zero means they need to be converted to RESULT_TYPE. */
11037 /* Nonzero means create the expression with this type, rather than
11039 tree build_type
= NULL_TREE
;
11041 /* Nonzero means after finally constructing the expression
11042 convert it to this type. */
11043 tree final_type
= NULL_TREE
;
11045 /* Nonzero if this is an operation like MIN or MAX which can
11046 safely be computed in short if both args are promoted shorts.
11047 Also implies COMMON.
11048 -1 indicates a bitwise operation; this makes a difference
11049 in the exact conditions for when it is safe to do the operation
11050 in a narrower mode. */
11053 /* Nonzero if this is a comparison operation;
11054 if both args are promoted shorts, compare the original shorts.
11055 Also implies COMMON. */
11056 int short_compare
= 0;
11058 /* Nonzero if this is a right-shift operation, which can be computed on the
11059 original short and then promoted if the operand is a promoted short. */
11060 int short_shift
= 0;
11062 /* Nonzero means set RESULT_TYPE to the common type of the args. */
11065 /* True means types are compatible as far as ObjC is concerned. */
11068 /* True means this is an arithmetic operation that may need excess
11070 bool may_need_excess_precision
;
11072 /* True means this is a boolean operation that converts both its
11073 operands to truth-values. */
11074 bool boolean_op
= false;
11076 /* Remember whether we're doing / or %. */
11077 bool doing_div_or_mod
= false;
11079 /* Remember whether we're doing << or >>. */
11080 bool doing_shift
= false;
11082 /* Tree holding instrumentation expression. */
11083 tree instrument_expr
= NULL
;
11085 if (location
== UNKNOWN_LOCATION
)
11086 location
= input_location
;
11091 op0_int_operands
= EXPR_INT_CONST_OPERANDS (orig_op0
);
11092 if (op0_int_operands
)
11093 op0
= remove_c_maybe_const_expr (op0
);
11094 op1_int_operands
= EXPR_INT_CONST_OPERANDS (orig_op1
);
11095 if (op1_int_operands
)
11096 op1
= remove_c_maybe_const_expr (op1
);
11097 int_operands
= (op0_int_operands
&& op1_int_operands
);
11100 int_const_or_overflow
= (TREE_CODE (orig_op0
) == INTEGER_CST
11101 && TREE_CODE (orig_op1
) == INTEGER_CST
);
11102 int_const
= (int_const_or_overflow
11103 && !TREE_OVERFLOW (orig_op0
)
11104 && !TREE_OVERFLOW (orig_op1
));
11107 int_const
= int_const_or_overflow
= false;
11109 /* Do not apply default conversion in mixed vector/scalar expression. */
11111 && VECTOR_TYPE_P (TREE_TYPE (op0
)) == VECTOR_TYPE_P (TREE_TYPE (op1
)))
11113 op0
= default_conversion (op0
);
11114 op1
= default_conversion (op1
);
11117 orig_type0
= type0
= TREE_TYPE (op0
);
11119 orig_type1
= type1
= TREE_TYPE (op1
);
11121 /* The expression codes of the data types of the arguments tell us
11122 whether the arguments are integers, floating, pointers, etc. */
11123 code0
= TREE_CODE (type0
);
11124 code1
= TREE_CODE (type1
);
11126 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
11127 STRIP_TYPE_NOPS (op0
);
11128 STRIP_TYPE_NOPS (op1
);
11130 /* If an error was already reported for one of the arguments,
11131 avoid reporting another error. */
11133 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
11134 return error_mark_node
;
11136 if (code0
== POINTER_TYPE
11137 && reject_gcc_builtin (op0
, EXPR_LOCATION (orig_op0
)))
11138 return error_mark_node
;
11140 if (code1
== POINTER_TYPE
11141 && reject_gcc_builtin (op1
, EXPR_LOCATION (orig_op1
)))
11142 return error_mark_node
;
11144 if ((invalid_op_diag
11145 = targetm
.invalid_binary_op (code
, type0
, type1
)))
11147 error_at (location
, invalid_op_diag
);
11148 return error_mark_node
;
11156 case TRUNC_DIV_EXPR
:
11157 case CEIL_DIV_EXPR
:
11158 case FLOOR_DIV_EXPR
:
11159 case ROUND_DIV_EXPR
:
11160 case EXACT_DIV_EXPR
:
11161 may_need_excess_precision
= true;
11164 may_need_excess_precision
= false;
11167 if (TREE_CODE (op0
) == EXCESS_PRECISION_EXPR
)
11169 op0
= TREE_OPERAND (op0
, 0);
11170 type0
= TREE_TYPE (op0
);
11172 else if (may_need_excess_precision
11173 && (eptype
= excess_precision_type (type0
)) != NULL_TREE
)
11176 op0
= convert (eptype
, op0
);
11178 if (TREE_CODE (op1
) == EXCESS_PRECISION_EXPR
)
11180 op1
= TREE_OPERAND (op1
, 0);
11181 type1
= TREE_TYPE (op1
);
11183 else if (may_need_excess_precision
11184 && (eptype
= excess_precision_type (type1
)) != NULL_TREE
)
11187 op1
= convert (eptype
, op1
);
11190 objc_ok
= objc_compare_types (type0
, type1
, -3, NULL_TREE
);
11192 /* In case when one of the operands of the binary operation is
11193 a vector and another is a scalar -- convert scalar to vector. */
11194 if ((code0
== VECTOR_TYPE
) != (code1
== VECTOR_TYPE
))
11196 enum stv_conv convert_flag
= scalar_to_vector (location
, code
, op0
, op1
,
11199 switch (convert_flag
)
11202 return error_mark_node
;
11205 bool maybe_const
= true;
11207 sc
= c_fully_fold (op0
, false, &maybe_const
);
11208 sc
= save_expr (sc
);
11209 sc
= convert (TREE_TYPE (type1
), sc
);
11210 op0
= build_vector_from_val (type1
, sc
);
11212 op0
= c_wrap_maybe_const (op0
, true);
11213 orig_type0
= type0
= TREE_TYPE (op0
);
11214 code0
= TREE_CODE (type0
);
11218 case stv_secondarg
:
11220 bool maybe_const
= true;
11222 sc
= c_fully_fold (op1
, false, &maybe_const
);
11223 sc
= save_expr (sc
);
11224 sc
= convert (TREE_TYPE (type0
), sc
);
11225 op1
= build_vector_from_val (type0
, sc
);
11227 op1
= c_wrap_maybe_const (op1
, true);
11228 orig_type1
= type1
= TREE_TYPE (op1
);
11229 code1
= TREE_CODE (type1
);
11241 /* Handle the pointer + int case. */
11242 if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
11244 ret
= pointer_int_sum (location
, PLUS_EXPR
, op0
, op1
);
11245 goto return_build_binary_op
;
11247 else if (code1
== POINTER_TYPE
&& code0
== INTEGER_TYPE
)
11249 ret
= pointer_int_sum (location
, PLUS_EXPR
, op1
, op0
);
11250 goto return_build_binary_op
;
11257 /* Subtraction of two similar pointers.
11258 We must subtract them as integers, then divide by object size. */
11259 if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
11260 && comp_target_types (location
, type0
, type1
))
11262 ret
= pointer_diff (location
, op0
, op1
, &instrument_expr
);
11263 goto return_build_binary_op
;
11265 /* Handle pointer minus int. Just like pointer plus int. */
11266 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
11268 ret
= pointer_int_sum (location
, MINUS_EXPR
, op0
, op1
);
11269 goto return_build_binary_op
;
11279 case TRUNC_DIV_EXPR
:
11280 case CEIL_DIV_EXPR
:
11281 case FLOOR_DIV_EXPR
:
11282 case ROUND_DIV_EXPR
:
11283 case EXACT_DIV_EXPR
:
11284 doing_div_or_mod
= true;
11285 warn_for_div_by_zero (location
, op1
);
11287 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
11288 || code0
== FIXED_POINT_TYPE
11289 || code0
== COMPLEX_TYPE
|| code0
== VECTOR_TYPE
)
11290 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
11291 || code1
== FIXED_POINT_TYPE
11292 || code1
== COMPLEX_TYPE
|| code1
== VECTOR_TYPE
))
11294 enum tree_code tcode0
= code0
, tcode1
= code1
;
11296 if (code0
== COMPLEX_TYPE
|| code0
== VECTOR_TYPE
)
11297 tcode0
= TREE_CODE (TREE_TYPE (TREE_TYPE (op0
)));
11298 if (code1
== COMPLEX_TYPE
|| code1
== VECTOR_TYPE
)
11299 tcode1
= TREE_CODE (TREE_TYPE (TREE_TYPE (op1
)));
11301 if (!((tcode0
== INTEGER_TYPE
&& tcode1
== INTEGER_TYPE
)
11302 || (tcode0
== FIXED_POINT_TYPE
&& tcode1
== FIXED_POINT_TYPE
)))
11303 resultcode
= RDIV_EXPR
;
11305 /* Although it would be tempting to shorten always here, that
11306 loses on some targets, since the modulo instruction is
11307 undefined if the quotient can't be represented in the
11308 computation mode. We shorten only if unsigned or if
11309 dividing by something we know != -1. */
11310 shorten
= (TYPE_UNSIGNED (TREE_TYPE (orig_op0
))
11311 || (TREE_CODE (op1
) == INTEGER_CST
11312 && !integer_all_onesp (op1
)));
11320 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
11322 /* Allow vector types which are not floating point types. */
11323 else if (code0
== VECTOR_TYPE
11324 && code1
== VECTOR_TYPE
11325 && !VECTOR_FLOAT_TYPE_P (type0
)
11326 && !VECTOR_FLOAT_TYPE_P (type1
))
11330 case TRUNC_MOD_EXPR
:
11331 case FLOOR_MOD_EXPR
:
11332 doing_div_or_mod
= true;
11333 warn_for_div_by_zero (location
, op1
);
11335 if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
11336 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
11337 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
)
11339 else if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
11341 /* Although it would be tempting to shorten always here, that loses
11342 on some targets, since the modulo instruction is undefined if the
11343 quotient can't be represented in the computation mode. We shorten
11344 only if unsigned or if dividing by something we know != -1. */
11345 shorten
= (TYPE_UNSIGNED (TREE_TYPE (orig_op0
))
11346 || (TREE_CODE (op1
) == INTEGER_CST
11347 && !integer_all_onesp (op1
)));
11352 case TRUTH_ANDIF_EXPR
:
11353 case TRUTH_ORIF_EXPR
:
11354 case TRUTH_AND_EXPR
:
11355 case TRUTH_OR_EXPR
:
11356 case TRUTH_XOR_EXPR
:
11357 if ((code0
== INTEGER_TYPE
|| code0
== POINTER_TYPE
11358 || code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
11359 || code0
== FIXED_POINT_TYPE
)
11360 && (code1
== INTEGER_TYPE
|| code1
== POINTER_TYPE
11361 || code1
== REAL_TYPE
|| code1
== COMPLEX_TYPE
11362 || code1
== FIXED_POINT_TYPE
))
11364 /* Result of these operations is always an int,
11365 but that does not mean the operands should be
11366 converted to ints! */
11367 result_type
= integer_type_node
;
11368 if (op0_int_operands
)
11370 op0
= c_objc_common_truthvalue_conversion (location
, orig_op0
);
11371 op0
= remove_c_maybe_const_expr (op0
);
11374 op0
= c_objc_common_truthvalue_conversion (location
, op0
);
11375 if (op1_int_operands
)
11377 op1
= c_objc_common_truthvalue_conversion (location
, orig_op1
);
11378 op1
= remove_c_maybe_const_expr (op1
);
11381 op1
= c_objc_common_truthvalue_conversion (location
, op1
);
11385 if (code
== TRUTH_ANDIF_EXPR
)
11387 int_const_or_overflow
= (int_operands
11388 && TREE_CODE (orig_op0
) == INTEGER_CST
11389 && (op0
== truthvalue_false_node
11390 || TREE_CODE (orig_op1
) == INTEGER_CST
));
11391 int_const
= (int_const_or_overflow
11392 && !TREE_OVERFLOW (orig_op0
)
11393 && (op0
== truthvalue_false_node
11394 || !TREE_OVERFLOW (orig_op1
)));
11396 else if (code
== TRUTH_ORIF_EXPR
)
11398 int_const_or_overflow
= (int_operands
11399 && TREE_CODE (orig_op0
) == INTEGER_CST
11400 && (op0
== truthvalue_true_node
11401 || TREE_CODE (orig_op1
) == INTEGER_CST
));
11402 int_const
= (int_const_or_overflow
11403 && !TREE_OVERFLOW (orig_op0
)
11404 && (op0
== truthvalue_true_node
11405 || !TREE_OVERFLOW (orig_op1
)));
11409 /* Shift operations: result has same type as first operand;
11410 always convert second operand to int.
11411 Also set SHORT_SHIFT if shifting rightward. */
11414 if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
11415 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
11416 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
11417 && known_eq (TYPE_VECTOR_SUBPARTS (type0
),
11418 TYPE_VECTOR_SUBPARTS (type1
)))
11420 result_type
= type0
;
11423 else if ((code0
== INTEGER_TYPE
|| code0
== FIXED_POINT_TYPE
11424 || (code0
== VECTOR_TYPE
11425 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
))
11426 && code1
== INTEGER_TYPE
)
11428 doing_shift
= true;
11429 if (TREE_CODE (op1
) == INTEGER_CST
)
11431 if (tree_int_cst_sgn (op1
) < 0)
11434 if (c_inhibit_evaluation_warnings
== 0)
11435 warning_at (location
, OPT_Wshift_count_negative
,
11436 "right shift count is negative");
11438 else if (code0
== VECTOR_TYPE
)
11440 if (compare_tree_int (op1
,
11441 TYPE_PRECISION (TREE_TYPE (type0
)))
11445 if (c_inhibit_evaluation_warnings
== 0)
11446 warning_at (location
, OPT_Wshift_count_overflow
,
11447 "right shift count >= width of vector element");
11452 if (!integer_zerop (op1
))
11455 if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0)
11458 if (c_inhibit_evaluation_warnings
== 0)
11459 warning_at (location
, OPT_Wshift_count_overflow
,
11460 "right shift count >= width of type");
11465 /* Use the type of the value to be shifted. */
11466 result_type
= type0
;
11467 /* Avoid converting op1 to result_type later. */
11473 if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
11474 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
11475 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
11476 && known_eq (TYPE_VECTOR_SUBPARTS (type0
),
11477 TYPE_VECTOR_SUBPARTS (type1
)))
11479 result_type
= type0
;
11482 else if ((code0
== INTEGER_TYPE
|| code0
== FIXED_POINT_TYPE
11483 || (code0
== VECTOR_TYPE
11484 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
))
11485 && code1
== INTEGER_TYPE
)
11487 doing_shift
= true;
11488 if (TREE_CODE (op0
) == INTEGER_CST
11489 && tree_int_cst_sgn (op0
) < 0)
11491 /* Don't reject a left shift of a negative value in a context
11492 where a constant expression is needed in C90. */
11495 if (c_inhibit_evaluation_warnings
== 0)
11496 warning_at (location
, OPT_Wshift_negative_value
,
11497 "left shift of negative value");
11499 if (TREE_CODE (op1
) == INTEGER_CST
)
11501 if (tree_int_cst_sgn (op1
) < 0)
11504 if (c_inhibit_evaluation_warnings
== 0)
11505 warning_at (location
, OPT_Wshift_count_negative
,
11506 "left shift count is negative");
11508 else if (code0
== VECTOR_TYPE
)
11510 if (compare_tree_int (op1
,
11511 TYPE_PRECISION (TREE_TYPE (type0
)))
11515 if (c_inhibit_evaluation_warnings
== 0)
11516 warning_at (location
, OPT_Wshift_count_overflow
,
11517 "left shift count >= width of vector element");
11520 else if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0)
11523 if (c_inhibit_evaluation_warnings
== 0)
11524 warning_at (location
, OPT_Wshift_count_overflow
,
11525 "left shift count >= width of type");
11527 else if (TREE_CODE (op0
) == INTEGER_CST
11528 && maybe_warn_shift_overflow (location
, op0
, op1
)
11533 /* Use the type of the value to be shifted. */
11534 result_type
= type0
;
11535 /* Avoid converting op1 to result_type later. */
11542 if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
)
11545 if (!vector_types_compatible_elements_p (type0
, type1
))
11547 error_at (location
, "comparing vectors with different "
11549 return error_mark_node
;
11552 if (maybe_ne (TYPE_VECTOR_SUBPARTS (type0
),
11553 TYPE_VECTOR_SUBPARTS (type1
)))
11555 error_at (location
, "comparing vectors with different "
11556 "number of elements");
11557 return error_mark_node
;
11560 /* It's not precisely specified how the usual arithmetic
11561 conversions apply to the vector types. Here, we use
11562 the unsigned type if one of the operands is signed and
11563 the other one is unsigned. */
11564 if (TYPE_UNSIGNED (type0
) != TYPE_UNSIGNED (type1
))
11566 if (!TYPE_UNSIGNED (type0
))
11567 op0
= build1 (VIEW_CONVERT_EXPR
, type1
, op0
);
11569 op1
= build1 (VIEW_CONVERT_EXPR
, type0
, op1
);
11570 warning_at (location
, OPT_Wsign_compare
, "comparison between "
11571 "types %qT and %qT", type0
, type1
);
11574 /* Always construct signed integer vector type. */
11575 intt
= c_common_type_for_size (GET_MODE_BITSIZE
11577 (TREE_TYPE (type0
))), 0);
11580 error_at (location
, "could not find an integer type "
11581 "of the same size as %qT",
11582 TREE_TYPE (type0
));
11583 return error_mark_node
;
11585 result_type
= build_opaque_vector_type (intt
,
11586 TYPE_VECTOR_SUBPARTS (type0
));
11588 ret
= build_vec_cmp (resultcode
, result_type
, op0
, op1
);
11589 goto return_build_binary_op
;
11591 if (FLOAT_TYPE_P (type0
) || FLOAT_TYPE_P (type1
))
11592 warning_at (location
,
11594 "comparing floating point with == or != is unsafe");
11595 /* Result of comparison is always int,
11596 but don't convert the args to int! */
11597 build_type
= integer_type_node
;
11598 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
11599 || code0
== FIXED_POINT_TYPE
|| code0
== COMPLEX_TYPE
)
11600 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
11601 || code1
== FIXED_POINT_TYPE
|| code1
== COMPLEX_TYPE
))
11603 else if (code0
== POINTER_TYPE
&& null_pointer_constant_p (orig_op1
))
11605 if (TREE_CODE (op0
) == ADDR_EXPR
11606 && decl_with_nonnull_addr_p (TREE_OPERAND (op0
, 0))
11607 && !from_macro_expansion_at (location
))
11609 if (code
== EQ_EXPR
)
11610 warning_at (location
,
11612 "the comparison will always evaluate as %<false%> "
11613 "for the address of %qD will never be NULL",
11614 TREE_OPERAND (op0
, 0));
11616 warning_at (location
,
11618 "the comparison will always evaluate as %<true%> "
11619 "for the address of %qD will never be NULL",
11620 TREE_OPERAND (op0
, 0));
11622 result_type
= type0
;
11624 else if (code1
== POINTER_TYPE
&& null_pointer_constant_p (orig_op0
))
11626 if (TREE_CODE (op1
) == ADDR_EXPR
11627 && decl_with_nonnull_addr_p (TREE_OPERAND (op1
, 0))
11628 && !from_macro_expansion_at (location
))
11630 if (code
== EQ_EXPR
)
11631 warning_at (location
,
11633 "the comparison will always evaluate as %<false%> "
11634 "for the address of %qD will never be NULL",
11635 TREE_OPERAND (op1
, 0));
11637 warning_at (location
,
11639 "the comparison will always evaluate as %<true%> "
11640 "for the address of %qD will never be NULL",
11641 TREE_OPERAND (op1
, 0));
11643 result_type
= type1
;
11645 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
11647 tree tt0
= TREE_TYPE (type0
);
11648 tree tt1
= TREE_TYPE (type1
);
11649 addr_space_t as0
= TYPE_ADDR_SPACE (tt0
);
11650 addr_space_t as1
= TYPE_ADDR_SPACE (tt1
);
11651 addr_space_t as_common
= ADDR_SPACE_GENERIC
;
11653 /* Anything compares with void *. void * compares with anything.
11654 Otherwise, the targets must be compatible
11655 and both must be object or both incomplete. */
11656 if (comp_target_types (location
, type0
, type1
))
11657 result_type
= common_pointer_type (type0
, type1
);
11658 else if (!addr_space_superset (as0
, as1
, &as_common
))
11660 error_at (location
, "comparison of pointers to "
11661 "disjoint address spaces");
11662 return error_mark_node
;
11664 else if (VOID_TYPE_P (tt0
) && !TYPE_ATOMIC (tt0
))
11666 if (pedantic
&& TREE_CODE (tt1
) == FUNCTION_TYPE
)
11667 pedwarn (location
, OPT_Wpedantic
, "ISO C forbids "
11668 "comparison of %<void *%> with function pointer");
11670 else if (VOID_TYPE_P (tt1
) && !TYPE_ATOMIC (tt1
))
11672 if (pedantic
&& TREE_CODE (tt0
) == FUNCTION_TYPE
)
11673 pedwarn (location
, OPT_Wpedantic
, "ISO C forbids "
11674 "comparison of %<void *%> with function pointer");
11677 /* Avoid warning about the volatile ObjC EH puts on decls. */
11679 pedwarn (location
, 0,
11680 "comparison of distinct pointer types lacks a cast");
11682 if (result_type
== NULL_TREE
)
11684 int qual
= ENCODE_QUAL_ADDR_SPACE (as_common
);
11685 result_type
= build_pointer_type
11686 (build_qualified_type (void_type_node
, qual
));
11689 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
11691 result_type
= type0
;
11692 pedwarn (location
, 0, "comparison between pointer and integer");
11694 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
11696 result_type
= type1
;
11697 pedwarn (location
, 0, "comparison between pointer and integer");
11699 if ((TREE_CODE (TREE_TYPE (orig_op0
)) == BOOLEAN_TYPE
11700 || truth_value_p (TREE_CODE (orig_op0
)))
11701 ^ (TREE_CODE (TREE_TYPE (orig_op1
)) == BOOLEAN_TYPE
11702 || truth_value_p (TREE_CODE (orig_op1
))))
11703 maybe_warn_bool_compare (location
, code
, orig_op0
, orig_op1
);
11710 if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
)
11713 if (!vector_types_compatible_elements_p (type0
, type1
))
11715 error_at (location
, "comparing vectors with different "
11717 return error_mark_node
;
11720 if (maybe_ne (TYPE_VECTOR_SUBPARTS (type0
),
11721 TYPE_VECTOR_SUBPARTS (type1
)))
11723 error_at (location
, "comparing vectors with different "
11724 "number of elements");
11725 return error_mark_node
;
11728 /* It's not precisely specified how the usual arithmetic
11729 conversions apply to the vector types. Here, we use
11730 the unsigned type if one of the operands is signed and
11731 the other one is unsigned. */
11732 if (TYPE_UNSIGNED (type0
) != TYPE_UNSIGNED (type1
))
11734 if (!TYPE_UNSIGNED (type0
))
11735 op0
= build1 (VIEW_CONVERT_EXPR
, type1
, op0
);
11737 op1
= build1 (VIEW_CONVERT_EXPR
, type0
, op1
);
11738 warning_at (location
, OPT_Wsign_compare
, "comparison between "
11739 "types %qT and %qT", type0
, type1
);
11742 /* Always construct signed integer vector type. */
11743 intt
= c_common_type_for_size (GET_MODE_BITSIZE
11745 (TREE_TYPE (type0
))), 0);
11748 error_at (location
, "could not find an integer type "
11749 "of the same size as %qT",
11750 TREE_TYPE (type0
));
11751 return error_mark_node
;
11753 result_type
= build_opaque_vector_type (intt
,
11754 TYPE_VECTOR_SUBPARTS (type0
));
11756 ret
= build_vec_cmp (resultcode
, result_type
, op0
, op1
);
11757 goto return_build_binary_op
;
11759 build_type
= integer_type_node
;
11760 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
11761 || code0
== FIXED_POINT_TYPE
)
11762 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
11763 || code1
== FIXED_POINT_TYPE
))
11765 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
11767 addr_space_t as0
= TYPE_ADDR_SPACE (TREE_TYPE (type0
));
11768 addr_space_t as1
= TYPE_ADDR_SPACE (TREE_TYPE (type1
));
11769 addr_space_t as_common
;
11771 if (comp_target_types (location
, type0
, type1
))
11773 result_type
= common_pointer_type (type0
, type1
);
11774 if (!COMPLETE_TYPE_P (TREE_TYPE (type0
))
11775 != !COMPLETE_TYPE_P (TREE_TYPE (type1
)))
11776 pedwarn (location
, 0,
11777 "comparison of complete and incomplete pointers");
11778 else if (TREE_CODE (TREE_TYPE (type0
)) == FUNCTION_TYPE
)
11779 pedwarn (location
, OPT_Wpedantic
, "ISO C forbids "
11780 "ordered comparisons of pointers to functions");
11781 else if (null_pointer_constant_p (orig_op0
)
11782 || null_pointer_constant_p (orig_op1
))
11783 warning_at (location
, OPT_Wextra
,
11784 "ordered comparison of pointer with null pointer");
11787 else if (!addr_space_superset (as0
, as1
, &as_common
))
11789 error_at (location
, "comparison of pointers to "
11790 "disjoint address spaces");
11791 return error_mark_node
;
11795 int qual
= ENCODE_QUAL_ADDR_SPACE (as_common
);
11796 result_type
= build_pointer_type
11797 (build_qualified_type (void_type_node
, qual
));
11798 pedwarn (location
, 0,
11799 "comparison of distinct pointer types lacks a cast");
11802 else if (code0
== POINTER_TYPE
&& null_pointer_constant_p (orig_op1
))
11804 result_type
= type0
;
11806 pedwarn (location
, OPT_Wpedantic
,
11807 "ordered comparison of pointer with integer zero");
11808 else if (extra_warnings
)
11809 warning_at (location
, OPT_Wextra
,
11810 "ordered comparison of pointer with integer zero");
11812 else if (code1
== POINTER_TYPE
&& null_pointer_constant_p (orig_op0
))
11814 result_type
= type1
;
11816 pedwarn (location
, OPT_Wpedantic
,
11817 "ordered comparison of pointer with integer zero");
11818 else if (extra_warnings
)
11819 warning_at (location
, OPT_Wextra
,
11820 "ordered comparison of pointer with integer zero");
11822 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
11824 result_type
= type0
;
11825 pedwarn (location
, 0, "comparison between pointer and integer");
11827 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
11829 result_type
= type1
;
11830 pedwarn (location
, 0, "comparison between pointer and integer");
11833 if ((code0
== POINTER_TYPE
|| code1
== POINTER_TYPE
)
11834 && sanitize_flags_p (SANITIZE_POINTER_COMPARE
))
11836 op0
= save_expr (op0
);
11837 op1
= save_expr (op1
);
11839 tree tt
= builtin_decl_explicit (BUILT_IN_ASAN_POINTER_COMPARE
);
11840 instrument_expr
= build_call_expr_loc (location
, tt
, 2, op0
, op1
);
11843 if ((TREE_CODE (TREE_TYPE (orig_op0
)) == BOOLEAN_TYPE
11844 || truth_value_p (TREE_CODE (orig_op0
)))
11845 ^ (TREE_CODE (TREE_TYPE (orig_op1
)) == BOOLEAN_TYPE
11846 || truth_value_p (TREE_CODE (orig_op1
))))
11847 maybe_warn_bool_compare (location
, code
, orig_op0
, orig_op1
);
11851 gcc_unreachable ();
11854 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
11855 return error_mark_node
;
11857 if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
11858 && (!tree_int_cst_equal (TYPE_SIZE (type0
), TYPE_SIZE (type1
))
11859 || !vector_types_compatible_elements_p (type0
, type1
)))
11861 gcc_rich_location
richloc (location
);
11862 richloc
.maybe_add_expr (orig_op0
);
11863 richloc
.maybe_add_expr (orig_op1
);
11864 binary_op_error (&richloc
, code
, type0
, type1
);
11865 return error_mark_node
;
11868 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
11869 || code0
== FIXED_POINT_TYPE
|| code0
== VECTOR_TYPE
)
11871 (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
|| code1
== COMPLEX_TYPE
11872 || code1
== FIXED_POINT_TYPE
|| code1
== VECTOR_TYPE
))
11874 bool first_complex
= (code0
== COMPLEX_TYPE
);
11875 bool second_complex
= (code1
== COMPLEX_TYPE
);
11876 int none_complex
= (!first_complex
&& !second_complex
);
11878 if (shorten
|| common
|| short_compare
)
11880 result_type
= c_common_type (type0
, type1
);
11881 do_warn_double_promotion (result_type
, type0
, type1
,
11882 "implicit conversion from %qT to %qT "
11883 "to match other operand of binary "
11886 if (result_type
== error_mark_node
)
11887 return error_mark_node
;
11890 if (first_complex
!= second_complex
11891 && (code
== PLUS_EXPR
11892 || code
== MINUS_EXPR
11893 || code
== MULT_EXPR
11894 || (code
== TRUNC_DIV_EXPR
&& first_complex
))
11895 && TREE_CODE (TREE_TYPE (result_type
)) == REAL_TYPE
11896 && flag_signed_zeros
)
11898 /* An operation on mixed real/complex operands must be
11899 handled specially, but the language-independent code can
11900 more easily optimize the plain complex arithmetic if
11901 -fno-signed-zeros. */
11902 tree real_type
= TREE_TYPE (result_type
);
11904 if (type0
!= orig_type0
|| type1
!= orig_type1
)
11906 gcc_assert (may_need_excess_precision
&& common
);
11907 semantic_result_type
= c_common_type (orig_type0
, orig_type1
);
11911 if (TREE_TYPE (op0
) != result_type
)
11912 op0
= convert_and_check (location
, result_type
, op0
);
11913 if (TREE_TYPE (op1
) != real_type
)
11914 op1
= convert_and_check (location
, real_type
, op1
);
11918 if (TREE_TYPE (op0
) != real_type
)
11919 op0
= convert_and_check (location
, real_type
, op0
);
11920 if (TREE_TYPE (op1
) != result_type
)
11921 op1
= convert_and_check (location
, result_type
, op1
);
11923 if (TREE_CODE (op0
) == ERROR_MARK
|| TREE_CODE (op1
) == ERROR_MARK
)
11924 return error_mark_node
;
11927 op0
= save_expr (op0
);
11928 real
= build_unary_op (EXPR_LOCATION (orig_op0
), REALPART_EXPR
,
11930 imag
= build_unary_op (EXPR_LOCATION (orig_op0
), IMAGPART_EXPR
,
11935 case TRUNC_DIV_EXPR
:
11936 op1
= save_expr (op1
);
11937 imag
= build2 (resultcode
, real_type
, imag
, op1
);
11938 /* Fall through. */
11941 real
= build2 (resultcode
, real_type
, real
, op1
);
11949 op1
= save_expr (op1
);
11950 real
= build_unary_op (EXPR_LOCATION (orig_op1
), REALPART_EXPR
,
11952 imag
= build_unary_op (EXPR_LOCATION (orig_op1
), IMAGPART_EXPR
,
11957 op0
= save_expr (op0
);
11958 imag
= build2 (resultcode
, real_type
, op0
, imag
);
11959 /* Fall through. */
11961 real
= build2 (resultcode
, real_type
, op0
, real
);
11964 real
= build2 (resultcode
, real_type
, op0
, real
);
11965 imag
= build1 (NEGATE_EXPR
, real_type
, imag
);
11971 ret
= build2 (COMPLEX_EXPR
, result_type
, real
, imag
);
11972 goto return_build_binary_op
;
11975 /* For certain operations (which identify themselves by shorten != 0)
11976 if both args were extended from the same smaller type,
11977 do the arithmetic in that type and then extend.
11979 shorten !=0 and !=1 indicates a bitwise operation.
11980 For them, this optimization is safe only if
11981 both args are zero-extended or both are sign-extended.
11982 Otherwise, we might change the result.
11983 Eg, (short)-1 | (unsigned short)-1 is (int)-1
11984 but calculated in (unsigned short) it would be (unsigned short)-1. */
11986 if (shorten
&& none_complex
)
11988 final_type
= result_type
;
11989 result_type
= shorten_binary_op (result_type
, op0
, op1
,
11993 /* Shifts can be shortened if shifting right. */
11998 tree arg0
= get_narrower (op0
, &unsigned_arg
);
12000 final_type
= result_type
;
12002 if (arg0
== op0
&& final_type
== TREE_TYPE (op0
))
12003 unsigned_arg
= TYPE_UNSIGNED (TREE_TYPE (op0
));
12005 if (TYPE_PRECISION (TREE_TYPE (arg0
)) < TYPE_PRECISION (result_type
)
12006 && tree_int_cst_sgn (op1
) > 0
12007 /* We can shorten only if the shift count is less than the
12008 number of bits in the smaller type size. */
12009 && compare_tree_int (op1
, TYPE_PRECISION (TREE_TYPE (arg0
))) < 0
12010 /* We cannot drop an unsigned shift after sign-extension. */
12011 && (!TYPE_UNSIGNED (final_type
) || unsigned_arg
))
12013 /* Do an unsigned shift if the operand was zero-extended. */
12015 = c_common_signed_or_unsigned_type (unsigned_arg
,
12017 /* Convert value-to-be-shifted to that type. */
12018 if (TREE_TYPE (op0
) != result_type
)
12019 op0
= convert (result_type
, op0
);
12024 /* Comparison operations are shortened too but differently.
12025 They identify themselves by setting short_compare = 1. */
12029 /* Don't write &op0, etc., because that would prevent op0
12030 from being kept in a register.
12031 Instead, make copies of the our local variables and
12032 pass the copies by reference, then copy them back afterward. */
12033 tree xop0
= op0
, xop1
= op1
, xresult_type
= result_type
;
12034 enum tree_code xresultcode
= resultcode
;
12036 = shorten_compare (location
, &xop0
, &xop1
, &xresult_type
,
12039 if (val
!= NULL_TREE
)
12042 goto return_build_binary_op
;
12045 op0
= xop0
, op1
= xop1
;
12047 resultcode
= xresultcode
;
12049 if (c_inhibit_evaluation_warnings
== 0)
12051 bool op0_maybe_const
= true;
12052 bool op1_maybe_const
= true;
12053 tree orig_op0_folded
, orig_op1_folded
;
12055 if (in_late_binary_op
)
12057 orig_op0_folded
= orig_op0
;
12058 orig_op1_folded
= orig_op1
;
12062 /* Fold for the sake of possible warnings, as in
12063 build_conditional_expr. This requires the
12064 "original" values to be folded, not just op0 and
12066 c_inhibit_evaluation_warnings
++;
12067 op0
= c_fully_fold (op0
, require_constant_value
,
12069 op1
= c_fully_fold (op1
, require_constant_value
,
12071 c_inhibit_evaluation_warnings
--;
12072 orig_op0_folded
= c_fully_fold (orig_op0
,
12073 require_constant_value
,
12075 orig_op1_folded
= c_fully_fold (orig_op1
,
12076 require_constant_value
,
12080 if (warn_sign_compare
)
12081 warn_for_sign_compare (location
, orig_op0_folded
,
12082 orig_op1_folded
, op0
, op1
,
12083 result_type
, resultcode
);
12084 if (!in_late_binary_op
&& !int_operands
)
12086 if (!op0_maybe_const
|| TREE_CODE (op0
) != INTEGER_CST
)
12087 op0
= c_wrap_maybe_const (op0
, !op0_maybe_const
);
12088 if (!op1_maybe_const
|| TREE_CODE (op1
) != INTEGER_CST
)
12089 op1
= c_wrap_maybe_const (op1
, !op1_maybe_const
);
12095 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
12096 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
12097 Then the expression will be built.
12098 It will be given type FINAL_TYPE if that is nonzero;
12099 otherwise, it will be given type RESULT_TYPE. */
12103 gcc_rich_location
richloc (location
);
12104 richloc
.maybe_add_expr (orig_op0
);
12105 richloc
.maybe_add_expr (orig_op1
);
12106 binary_op_error (&richloc
, code
, TREE_TYPE (op0
), TREE_TYPE (op1
));
12107 return error_mark_node
;
12110 if (build_type
== NULL_TREE
)
12112 build_type
= result_type
;
12113 if ((type0
!= orig_type0
|| type1
!= orig_type1
)
12116 gcc_assert (may_need_excess_precision
&& common
);
12117 semantic_result_type
= c_common_type (orig_type0
, orig_type1
);
12123 op0
= ep_convert_and_check (location
, result_type
, op0
,
12124 semantic_result_type
);
12125 op1
= ep_convert_and_check (location
, result_type
, op1
,
12126 semantic_result_type
);
12128 /* This can happen if one operand has a vector type, and the other
12129 has a different type. */
12130 if (TREE_CODE (op0
) == ERROR_MARK
|| TREE_CODE (op1
) == ERROR_MARK
)
12131 return error_mark_node
;
12134 if (sanitize_flags_p ((SANITIZE_SHIFT
12135 | SANITIZE_DIVIDE
| SANITIZE_FLOAT_DIVIDE
))
12136 && current_function_decl
!= NULL_TREE
12137 && (doing_div_or_mod
|| doing_shift
)
12138 && !require_constant_value
)
12140 /* OP0 and/or OP1 might have side-effects. */
12141 op0
= save_expr (op0
);
12142 op1
= save_expr (op1
);
12143 op0
= c_fully_fold (op0
, false, NULL
);
12144 op1
= c_fully_fold (op1
, false, NULL
);
12145 if (doing_div_or_mod
&& (sanitize_flags_p ((SANITIZE_DIVIDE
12146 | SANITIZE_FLOAT_DIVIDE
))))
12147 instrument_expr
= ubsan_instrument_division (location
, op0
, op1
);
12148 else if (doing_shift
&& sanitize_flags_p (SANITIZE_SHIFT
))
12149 instrument_expr
= ubsan_instrument_shift (location
, code
, op0
, op1
);
12152 /* Treat expressions in initializers specially as they can't trap. */
12153 if (int_const_or_overflow
)
12154 ret
= (require_constant_value
12155 ? fold_build2_initializer_loc (location
, resultcode
, build_type
,
12157 : fold_build2_loc (location
, resultcode
, build_type
, op0
, op1
));
12159 ret
= build2 (resultcode
, build_type
, op0
, op1
);
12160 if (final_type
!= NULL_TREE
)
12161 ret
= convert (final_type
, ret
);
12163 return_build_binary_op
:
12164 gcc_assert (ret
!= error_mark_node
);
12165 if (TREE_CODE (ret
) == INTEGER_CST
&& !TREE_OVERFLOW (ret
) && !int_const
)
12166 ret
= (int_operands
12167 ? note_integer_operands (ret
)
12168 : build1 (NOP_EXPR
, TREE_TYPE (ret
), ret
));
12169 else if (TREE_CODE (ret
) != INTEGER_CST
&& int_operands
12170 && !in_late_binary_op
)
12171 ret
= note_integer_operands (ret
);
12172 protected_set_expr_location (ret
, location
);
12174 if (instrument_expr
!= NULL
)
12175 ret
= fold_build2 (COMPOUND_EXPR
, TREE_TYPE (ret
),
12176 instrument_expr
, ret
);
12178 if (semantic_result_type
)
12179 ret
= build1_loc (location
, EXCESS_PRECISION_EXPR
,
12180 semantic_result_type
, ret
);
12186 /* Convert EXPR to be a truth-value, validating its type for this
12187 purpose. LOCATION is the source location for the expression. */
12190 c_objc_common_truthvalue_conversion (location_t location
, tree expr
)
12192 bool int_const
, int_operands
;
12194 switch (TREE_CODE (TREE_TYPE (expr
)))
12197 error_at (location
, "used array that cannot be converted to pointer where scalar is required");
12198 return error_mark_node
;
12201 error_at (location
, "used struct type value where scalar is required");
12202 return error_mark_node
;
12205 error_at (location
, "used union type value where scalar is required");
12206 return error_mark_node
;
12209 error_at (location
, "void value not ignored as it ought to be");
12210 return error_mark_node
;
12213 if (reject_gcc_builtin (expr
))
12214 return error_mark_node
;
12217 case FUNCTION_TYPE
:
12218 gcc_unreachable ();
12221 error_at (location
, "used vector type where scalar is required");
12222 return error_mark_node
;
12228 int_const
= (TREE_CODE (expr
) == INTEGER_CST
&& !TREE_OVERFLOW (expr
));
12229 int_operands
= EXPR_INT_CONST_OPERANDS (expr
);
12230 if (int_operands
&& TREE_CODE (expr
) != INTEGER_CST
)
12232 expr
= remove_c_maybe_const_expr (expr
);
12233 expr
= build2 (NE_EXPR
, integer_type_node
, expr
,
12234 convert (TREE_TYPE (expr
), integer_zero_node
));
12235 expr
= note_integer_operands (expr
);
12238 /* ??? Should we also give an error for vectors rather than leaving
12239 those to give errors later? */
12240 expr
= c_common_truthvalue_conversion (location
, expr
);
12242 if (TREE_CODE (expr
) == INTEGER_CST
&& int_operands
&& !int_const
)
12244 if (TREE_OVERFLOW (expr
))
12247 return note_integer_operands (expr
);
12249 if (TREE_CODE (expr
) == INTEGER_CST
&& !int_const
)
12250 return build1 (NOP_EXPR
, TREE_TYPE (expr
), expr
);
12255 /* Convert EXPR to a contained DECL, updating *TC, *TI and *SE as
12259 c_expr_to_decl (tree expr
, bool *tc ATTRIBUTE_UNUSED
, bool *se
)
12261 if (TREE_CODE (expr
) == COMPOUND_LITERAL_EXPR
)
12263 tree decl
= COMPOUND_LITERAL_EXPR_DECL (expr
);
12264 /* Executing a compound literal inside a function reinitializes
12266 if (!TREE_STATIC (decl
))
12274 /* Generate OMP construct CODE, with BODY and CLAUSES as its compound
12275 statement. LOC is the location of the construct. */
12278 c_finish_omp_construct (location_t loc
, enum tree_code code
, tree body
,
12281 body
= c_end_compound_stmt (loc
, body
, true);
12283 tree stmt
= make_node (code
);
12284 TREE_TYPE (stmt
) = void_type_node
;
12285 OMP_BODY (stmt
) = body
;
12286 OMP_CLAUSES (stmt
) = clauses
;
12287 SET_EXPR_LOCATION (stmt
, loc
);
12289 return add_stmt (stmt
);
12292 /* Generate OACC_DATA, with CLAUSES and BLOCK as its compound
12293 statement. LOC is the location of the OACC_DATA. */
12296 c_finish_oacc_data (location_t loc
, tree clauses
, tree block
)
12300 block
= c_end_compound_stmt (loc
, block
, true);
12302 stmt
= make_node (OACC_DATA
);
12303 TREE_TYPE (stmt
) = void_type_node
;
12304 OACC_DATA_CLAUSES (stmt
) = clauses
;
12305 OACC_DATA_BODY (stmt
) = block
;
12306 SET_EXPR_LOCATION (stmt
, loc
);
12308 return add_stmt (stmt
);
12311 /* Generate OACC_HOST_DATA, with CLAUSES and BLOCK as its compound
12312 statement. LOC is the location of the OACC_HOST_DATA. */
12315 c_finish_oacc_host_data (location_t loc
, tree clauses
, tree block
)
12319 block
= c_end_compound_stmt (loc
, block
, true);
12321 stmt
= make_node (OACC_HOST_DATA
);
12322 TREE_TYPE (stmt
) = void_type_node
;
12323 OACC_HOST_DATA_CLAUSES (stmt
) = clauses
;
12324 OACC_HOST_DATA_BODY (stmt
) = block
;
12325 SET_EXPR_LOCATION (stmt
, loc
);
12327 return add_stmt (stmt
);
12330 /* Like c_begin_compound_stmt, except force the retention of the BLOCK. */
12333 c_begin_omp_parallel (void)
12337 keep_next_level ();
12338 block
= c_begin_compound_stmt (true);
12343 /* Generate OMP_PARALLEL, with CLAUSES and BLOCK as its compound
12344 statement. LOC is the location of the OMP_PARALLEL. */
12347 c_finish_omp_parallel (location_t loc
, tree clauses
, tree block
)
12351 block
= c_end_compound_stmt (loc
, block
, true);
12353 stmt
= make_node (OMP_PARALLEL
);
12354 TREE_TYPE (stmt
) = void_type_node
;
12355 OMP_PARALLEL_CLAUSES (stmt
) = clauses
;
12356 OMP_PARALLEL_BODY (stmt
) = block
;
12357 SET_EXPR_LOCATION (stmt
, loc
);
12359 return add_stmt (stmt
);
12362 /* Like c_begin_compound_stmt, except force the retention of the BLOCK. */
12365 c_begin_omp_task (void)
12369 keep_next_level ();
12370 block
= c_begin_compound_stmt (true);
12375 /* Generate OMP_TASK, with CLAUSES and BLOCK as its compound
12376 statement. LOC is the location of the #pragma. */
12379 c_finish_omp_task (location_t loc
, tree clauses
, tree block
)
12383 block
= c_end_compound_stmt (loc
, block
, true);
12385 stmt
= make_node (OMP_TASK
);
12386 TREE_TYPE (stmt
) = void_type_node
;
12387 OMP_TASK_CLAUSES (stmt
) = clauses
;
12388 OMP_TASK_BODY (stmt
) = block
;
12389 SET_EXPR_LOCATION (stmt
, loc
);
12391 return add_stmt (stmt
);
12394 /* Generate GOMP_cancel call for #pragma omp cancel. */
12397 c_finish_omp_cancel (location_t loc
, tree clauses
)
12399 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_CANCEL
);
12401 if (omp_find_clause (clauses
, OMP_CLAUSE_PARALLEL
))
12403 else if (omp_find_clause (clauses
, OMP_CLAUSE_FOR
))
12405 else if (omp_find_clause (clauses
, OMP_CLAUSE_SECTIONS
))
12407 else if (omp_find_clause (clauses
, OMP_CLAUSE_TASKGROUP
))
12411 error_at (loc
, "%<#pragma omp cancel%> must specify one of "
12412 "%<parallel%>, %<for%>, %<sections%> or %<taskgroup%> "
12416 tree ifc
= omp_find_clause (clauses
, OMP_CLAUSE_IF
);
12417 if (ifc
!= NULL_TREE
)
12419 tree type
= TREE_TYPE (OMP_CLAUSE_IF_EXPR (ifc
));
12420 ifc
= fold_build2_loc (OMP_CLAUSE_LOCATION (ifc
), NE_EXPR
,
12421 boolean_type_node
, OMP_CLAUSE_IF_EXPR (ifc
),
12422 build_zero_cst (type
));
12425 ifc
= boolean_true_node
;
12426 tree stmt
= build_call_expr_loc (loc
, fn
, 2,
12427 build_int_cst (integer_type_node
, mask
),
12432 /* Generate GOMP_cancellation_point call for
12433 #pragma omp cancellation point. */
12436 c_finish_omp_cancellation_point (location_t loc
, tree clauses
)
12438 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_CANCELLATION_POINT
);
12440 if (omp_find_clause (clauses
, OMP_CLAUSE_PARALLEL
))
12442 else if (omp_find_clause (clauses
, OMP_CLAUSE_FOR
))
12444 else if (omp_find_clause (clauses
, OMP_CLAUSE_SECTIONS
))
12446 else if (omp_find_clause (clauses
, OMP_CLAUSE_TASKGROUP
))
12450 error_at (loc
, "%<#pragma omp cancellation point%> must specify one of "
12451 "%<parallel%>, %<for%>, %<sections%> or %<taskgroup%> "
12455 tree stmt
= build_call_expr_loc (loc
, fn
, 1,
12456 build_int_cst (integer_type_node
, mask
));
12460 /* Helper function for handle_omp_array_sections. Called recursively
12461 to handle multiple array-section-subscripts. C is the clause,
12462 T current expression (initially OMP_CLAUSE_DECL), which is either
12463 a TREE_LIST for array-section-subscript (TREE_PURPOSE is low-bound
12464 expression if specified, TREE_VALUE length expression if specified,
12465 TREE_CHAIN is what it has been specified after, or some decl.
12466 TYPES vector is populated with array section types, MAYBE_ZERO_LEN
12467 set to true if any of the array-section-subscript could have length
12468 of zero (explicit or implicit), FIRST_NON_ONE is the index of the
12469 first array-section-subscript which is known not to have length
12471 map(a[:b][2:1][:c][:2][:d][e:f][2:5])
12472 FIRST_NON_ONE will be 3, array-section-subscript [:b], [2:1] and [:c]
12473 all are or may have length of 1, array-section-subscript [:2] is the
12474 first one known not to have length 1. For array-section-subscript
12475 <= FIRST_NON_ONE we diagnose non-contiguous arrays if low bound isn't
12476 0 or length isn't the array domain max + 1, for > FIRST_NON_ONE we
12477 can if MAYBE_ZERO_LEN is false. MAYBE_ZERO_LEN will be true in the above
12478 case though, as some lengths could be zero. */
12481 handle_omp_array_sections_1 (tree c
, tree t
, vec
<tree
> &types
,
12482 bool &maybe_zero_len
, unsigned int &first_non_one
,
12483 enum c_omp_region_type ort
)
12485 tree ret
, low_bound
, length
, type
;
12486 if (TREE_CODE (t
) != TREE_LIST
)
12488 if (error_operand_p (t
))
12489 return error_mark_node
;
12491 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
12492 && TYPE_ATOMIC (strip_array_types (TREE_TYPE (t
))))
12494 error_at (OMP_CLAUSE_LOCATION (c
), "%<_Atomic%> %qE in %qs clause",
12495 t
, omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
12496 return error_mark_node
;
12498 if (TREE_CODE (t
) == COMPONENT_REF
12499 && ort
== C_ORT_OMP
12500 && (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
12501 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_TO
12502 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FROM
))
12504 if (DECL_BIT_FIELD (TREE_OPERAND (t
, 1)))
12506 error_at (OMP_CLAUSE_LOCATION (c
),
12507 "bit-field %qE in %qs clause",
12508 t
, omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
12509 return error_mark_node
;
12511 while (TREE_CODE (t
) == COMPONENT_REF
)
12513 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == UNION_TYPE
)
12515 error_at (OMP_CLAUSE_LOCATION (c
),
12516 "%qE is a member of a union", t
);
12517 return error_mark_node
;
12519 t
= TREE_OPERAND (t
, 0);
12522 if (!VAR_P (t
) && TREE_CODE (t
) != PARM_DECL
)
12525 error_at (OMP_CLAUSE_LOCATION (c
),
12526 "%qD is not a variable in %qs clause", t
,
12527 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
12529 error_at (OMP_CLAUSE_LOCATION (c
),
12530 "%qE is not a variable in %qs clause", t
,
12531 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
12532 return error_mark_node
;
12534 else if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
12535 && TYPE_ATOMIC (TREE_TYPE (t
)))
12537 error_at (OMP_CLAUSE_LOCATION (c
), "%<_Atomic%> %qD in %qs clause",
12538 t
, omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
12539 return error_mark_node
;
12541 else if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
12543 && DECL_THREAD_LOCAL_P (t
))
12545 error_at (OMP_CLAUSE_LOCATION (c
),
12546 "%qD is threadprivate variable in %qs clause", t
,
12547 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
12548 return error_mark_node
;
12550 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
12551 && TYPE_ATOMIC (TREE_TYPE (t
))
12552 && POINTER_TYPE_P (TREE_TYPE (t
)))
12554 /* If the array section is pointer based and the pointer
12555 itself is _Atomic qualified, we need to atomically load
12558 memset (&expr
, 0, sizeof (expr
));
12560 expr
= convert_lvalue_to_rvalue (OMP_CLAUSE_LOCATION (c
),
12561 expr
, false, false);
12567 ret
= handle_omp_array_sections_1 (c
, TREE_CHAIN (t
), types
,
12568 maybe_zero_len
, first_non_one
, ort
);
12569 if (ret
== error_mark_node
|| ret
== NULL_TREE
)
12572 type
= TREE_TYPE (ret
);
12573 low_bound
= TREE_PURPOSE (t
);
12574 length
= TREE_VALUE (t
);
12576 if (low_bound
== error_mark_node
|| length
== error_mark_node
)
12577 return error_mark_node
;
12579 if (low_bound
&& !INTEGRAL_TYPE_P (TREE_TYPE (low_bound
)))
12581 error_at (OMP_CLAUSE_LOCATION (c
),
12582 "low bound %qE of array section does not have integral type",
12584 return error_mark_node
;
12586 if (length
&& !INTEGRAL_TYPE_P (TREE_TYPE (length
)))
12588 error_at (OMP_CLAUSE_LOCATION (c
),
12589 "length %qE of array section does not have integral type",
12591 return error_mark_node
;
12594 && TREE_CODE (low_bound
) == INTEGER_CST
12595 && TYPE_PRECISION (TREE_TYPE (low_bound
))
12596 > TYPE_PRECISION (sizetype
))
12597 low_bound
= fold_convert (sizetype
, low_bound
);
12599 && TREE_CODE (length
) == INTEGER_CST
12600 && TYPE_PRECISION (TREE_TYPE (length
))
12601 > TYPE_PRECISION (sizetype
))
12602 length
= fold_convert (sizetype
, length
);
12603 if (low_bound
== NULL_TREE
)
12604 low_bound
= integer_zero_node
;
12606 if (length
!= NULL_TREE
)
12608 if (!integer_nonzerop (length
))
12610 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
12611 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
)
12613 if (integer_zerop (length
))
12615 error_at (OMP_CLAUSE_LOCATION (c
),
12616 "zero length array section in %qs clause",
12617 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
12618 return error_mark_node
;
12622 maybe_zero_len
= true;
12624 if (first_non_one
== types
.length ()
12625 && (TREE_CODE (length
) != INTEGER_CST
|| integer_onep (length
)))
12628 if (TREE_CODE (type
) == ARRAY_TYPE
)
12630 if (length
== NULL_TREE
12631 && (TYPE_DOMAIN (type
) == NULL_TREE
12632 || TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) == NULL_TREE
))
12634 error_at (OMP_CLAUSE_LOCATION (c
),
12635 "for unknown bound array type length expression must "
12637 return error_mark_node
;
12639 if (TREE_CODE (low_bound
) == INTEGER_CST
12640 && tree_int_cst_sgn (low_bound
) == -1)
12642 error_at (OMP_CLAUSE_LOCATION (c
),
12643 "negative low bound in array section in %qs clause",
12644 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
12645 return error_mark_node
;
12647 if (length
!= NULL_TREE
12648 && TREE_CODE (length
) == INTEGER_CST
12649 && tree_int_cst_sgn (length
) == -1)
12651 error_at (OMP_CLAUSE_LOCATION (c
),
12652 "negative length in array section in %qs clause",
12653 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
12654 return error_mark_node
;
12656 if (TYPE_DOMAIN (type
)
12657 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
))
12658 && TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)))
12662 = fold_convert (sizetype
, TYPE_MAX_VALUE (TYPE_DOMAIN (type
)));
12663 size
= size_binop (PLUS_EXPR
, size
, size_one_node
);
12664 if (TREE_CODE (low_bound
) == INTEGER_CST
)
12666 if (tree_int_cst_lt (size
, low_bound
))
12668 error_at (OMP_CLAUSE_LOCATION (c
),
12669 "low bound %qE above array section size "
12670 "in %qs clause", low_bound
,
12671 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
12672 return error_mark_node
;
12674 if (tree_int_cst_equal (size
, low_bound
))
12676 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
12677 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
)
12679 error_at (OMP_CLAUSE_LOCATION (c
),
12680 "zero length array section in %qs clause",
12681 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
12682 return error_mark_node
;
12684 maybe_zero_len
= true;
12686 else if (length
== NULL_TREE
12687 && first_non_one
== types
.length ()
12688 && tree_int_cst_equal
12689 (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)),
12693 else if (length
== NULL_TREE
)
12695 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
12696 && OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_REDUCTION
)
12697 maybe_zero_len
= true;
12698 if (first_non_one
== types
.length ())
12701 if (length
&& TREE_CODE (length
) == INTEGER_CST
)
12703 if (tree_int_cst_lt (size
, length
))
12705 error_at (OMP_CLAUSE_LOCATION (c
),
12706 "length %qE above array section size "
12707 "in %qs clause", length
,
12708 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
12709 return error_mark_node
;
12711 if (TREE_CODE (low_bound
) == INTEGER_CST
)
12714 = size_binop (PLUS_EXPR
,
12715 fold_convert (sizetype
, low_bound
),
12716 fold_convert (sizetype
, length
));
12717 if (TREE_CODE (lbpluslen
) == INTEGER_CST
12718 && tree_int_cst_lt (size
, lbpluslen
))
12720 error_at (OMP_CLAUSE_LOCATION (c
),
12721 "high bound %qE above array section size "
12722 "in %qs clause", lbpluslen
,
12723 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
12724 return error_mark_node
;
12729 else if (length
== NULL_TREE
)
12731 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
12732 && OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_REDUCTION
)
12733 maybe_zero_len
= true;
12734 if (first_non_one
== types
.length ())
12738 /* For [lb:] we will need to evaluate lb more than once. */
12739 if (length
== NULL_TREE
&& OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
)
12741 tree lb
= save_expr (low_bound
);
12742 if (lb
!= low_bound
)
12744 TREE_PURPOSE (t
) = lb
;
12749 else if (TREE_CODE (type
) == POINTER_TYPE
)
12751 if (length
== NULL_TREE
)
12753 error_at (OMP_CLAUSE_LOCATION (c
),
12754 "for pointer type length expression must be specified");
12755 return error_mark_node
;
12757 if (length
!= NULL_TREE
12758 && TREE_CODE (length
) == INTEGER_CST
12759 && tree_int_cst_sgn (length
) == -1)
12761 error_at (OMP_CLAUSE_LOCATION (c
),
12762 "negative length in array section in %qs clause",
12763 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
12764 return error_mark_node
;
12766 /* If there is a pointer type anywhere but in the very first
12767 array-section-subscript, the array section can't be contiguous. */
12768 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
12769 && TREE_CODE (TREE_CHAIN (t
)) == TREE_LIST
)
12771 error_at (OMP_CLAUSE_LOCATION (c
),
12772 "array section is not contiguous in %qs clause",
12773 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
12774 return error_mark_node
;
12779 error_at (OMP_CLAUSE_LOCATION (c
),
12780 "%qE does not have pointer or array type", ret
);
12781 return error_mark_node
;
12783 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
)
12784 types
.safe_push (TREE_TYPE (ret
));
12785 /* We will need to evaluate lb more than once. */
12786 tree lb
= save_expr (low_bound
);
12787 if (lb
!= low_bound
)
12789 TREE_PURPOSE (t
) = lb
;
12792 ret
= build_array_ref (OMP_CLAUSE_LOCATION (c
), ret
, low_bound
);
12796 /* Handle array sections for clause C. */
12799 handle_omp_array_sections (tree c
, enum c_omp_region_type ort
)
12801 bool maybe_zero_len
= false;
12802 unsigned int first_non_one
= 0;
12803 auto_vec
<tree
, 10> types
;
12804 tree first
= handle_omp_array_sections_1 (c
, OMP_CLAUSE_DECL (c
), types
,
12805 maybe_zero_len
, first_non_one
,
12807 if (first
== error_mark_node
)
12809 if (first
== NULL_TREE
)
12811 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
)
12813 tree t
= OMP_CLAUSE_DECL (c
);
12814 tree tem
= NULL_TREE
;
12815 /* Need to evaluate side effects in the length expressions
12817 while (TREE_CODE (t
) == TREE_LIST
)
12819 if (TREE_VALUE (t
) && TREE_SIDE_EFFECTS (TREE_VALUE (t
)))
12821 if (tem
== NULL_TREE
)
12822 tem
= TREE_VALUE (t
);
12824 tem
= build2 (COMPOUND_EXPR
, TREE_TYPE (tem
),
12825 TREE_VALUE (t
), tem
);
12827 t
= TREE_CHAIN (t
);
12830 first
= build2 (COMPOUND_EXPR
, TREE_TYPE (first
), tem
, first
);
12831 first
= c_fully_fold (first
, false, NULL
, true);
12832 OMP_CLAUSE_DECL (c
) = first
;
12836 unsigned int num
= types
.length (), i
;
12837 tree t
, side_effects
= NULL_TREE
, size
= NULL_TREE
;
12838 tree condition
= NULL_TREE
;
12840 if (int_size_in_bytes (TREE_TYPE (first
)) <= 0)
12841 maybe_zero_len
= true;
12843 for (i
= num
, t
= OMP_CLAUSE_DECL (c
); i
> 0;
12844 t
= TREE_CHAIN (t
))
12846 tree low_bound
= TREE_PURPOSE (t
);
12847 tree length
= TREE_VALUE (t
);
12851 && TREE_CODE (low_bound
) == INTEGER_CST
12852 && TYPE_PRECISION (TREE_TYPE (low_bound
))
12853 > TYPE_PRECISION (sizetype
))
12854 low_bound
= fold_convert (sizetype
, low_bound
);
12856 && TREE_CODE (length
) == INTEGER_CST
12857 && TYPE_PRECISION (TREE_TYPE (length
))
12858 > TYPE_PRECISION (sizetype
))
12859 length
= fold_convert (sizetype
, length
);
12860 if (low_bound
== NULL_TREE
)
12861 low_bound
= integer_zero_node
;
12862 if (!maybe_zero_len
&& i
> first_non_one
)
12864 if (integer_nonzerop (low_bound
))
12865 goto do_warn_noncontiguous
;
12866 if (length
!= NULL_TREE
12867 && TREE_CODE (length
) == INTEGER_CST
12868 && TYPE_DOMAIN (types
[i
])
12869 && TYPE_MAX_VALUE (TYPE_DOMAIN (types
[i
]))
12870 && TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (types
[i
])))
12874 size
= size_binop (PLUS_EXPR
,
12875 TYPE_MAX_VALUE (TYPE_DOMAIN (types
[i
])),
12877 if (!tree_int_cst_equal (length
, size
))
12879 do_warn_noncontiguous
:
12880 error_at (OMP_CLAUSE_LOCATION (c
),
12881 "array section is not contiguous in %qs "
12883 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
12887 if (length
!= NULL_TREE
12888 && TREE_SIDE_EFFECTS (length
))
12890 if (side_effects
== NULL_TREE
)
12891 side_effects
= length
;
12893 side_effects
= build2 (COMPOUND_EXPR
,
12894 TREE_TYPE (side_effects
),
12895 length
, side_effects
);
12902 if (i
> first_non_one
12903 && ((length
&& integer_nonzerop (length
))
12904 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
))
12907 l
= fold_convert (sizetype
, length
);
12910 l
= size_binop (PLUS_EXPR
,
12911 TYPE_MAX_VALUE (TYPE_DOMAIN (types
[i
])),
12913 l
= size_binop (MINUS_EXPR
, l
,
12914 fold_convert (sizetype
, low_bound
));
12916 if (i
> first_non_one
)
12918 l
= fold_build2 (NE_EXPR
, boolean_type_node
, l
,
12920 if (condition
== NULL_TREE
)
12923 condition
= fold_build2 (BIT_AND_EXPR
, boolean_type_node
,
12926 else if (size
== NULL_TREE
)
12928 size
= size_in_bytes (TREE_TYPE (types
[i
]));
12929 tree eltype
= TREE_TYPE (types
[num
- 1]);
12930 while (TREE_CODE (eltype
) == ARRAY_TYPE
)
12931 eltype
= TREE_TYPE (eltype
);
12932 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
)
12934 if (integer_zerop (size
)
12935 || integer_zerop (size_in_bytes (eltype
)))
12937 error_at (OMP_CLAUSE_LOCATION (c
),
12938 "zero length array section in %qs clause",
12939 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
12940 return error_mark_node
;
12942 size
= size_binop (EXACT_DIV_EXPR
, size
,
12943 size_in_bytes (eltype
));
12945 size
= size_binop (MULT_EXPR
, size
, l
);
12947 size
= fold_build3 (COND_EXPR
, sizetype
, condition
,
12948 size
, size_zero_node
);
12951 size
= size_binop (MULT_EXPR
, size
, l
);
12955 size
= build2 (COMPOUND_EXPR
, sizetype
, side_effects
, size
);
12956 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
)
12958 size
= size_binop (MINUS_EXPR
, size
, size_one_node
);
12959 size
= c_fully_fold (size
, false, NULL
);
12960 tree index_type
= build_index_type (size
);
12961 tree eltype
= TREE_TYPE (first
);
12962 while (TREE_CODE (eltype
) == ARRAY_TYPE
)
12963 eltype
= TREE_TYPE (eltype
);
12964 tree type
= build_array_type (eltype
, index_type
);
12965 tree ptype
= build_pointer_type (eltype
);
12966 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
12967 t
= build_fold_addr_expr (t
);
12968 tree t2
= build_fold_addr_expr (first
);
12969 t2
= fold_convert_loc (OMP_CLAUSE_LOCATION (c
),
12970 ptrdiff_type_node
, t2
);
12971 t2
= fold_build2_loc (OMP_CLAUSE_LOCATION (c
), MINUS_EXPR
,
12972 ptrdiff_type_node
, t2
,
12973 fold_convert_loc (OMP_CLAUSE_LOCATION (c
),
12974 ptrdiff_type_node
, t
));
12975 t2
= c_fully_fold (t2
, false, NULL
);
12976 if (tree_fits_shwi_p (t2
))
12977 t
= build2 (MEM_REF
, type
, t
,
12978 build_int_cst (ptype
, tree_to_shwi (t2
)));
12981 t2
= fold_convert_loc (OMP_CLAUSE_LOCATION (c
), sizetype
, t2
);
12982 t
= build2_loc (OMP_CLAUSE_LOCATION (c
), POINTER_PLUS_EXPR
,
12983 TREE_TYPE (t
), t
, t2
);
12984 t
= build2 (MEM_REF
, type
, t
, build_int_cst (ptype
, 0));
12986 OMP_CLAUSE_DECL (c
) = t
;
12989 first
= c_fully_fold (first
, false, NULL
);
12990 OMP_CLAUSE_DECL (c
) = first
;
12992 size
= c_fully_fold (size
, false, NULL
);
12993 OMP_CLAUSE_SIZE (c
) = size
;
12994 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_MAP
12995 || (TREE_CODE (t
) == COMPONENT_REF
12996 && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
))
12998 gcc_assert (OMP_CLAUSE_MAP_KIND (c
) != GOMP_MAP_FORCE_DEVICEPTR
);
12999 if (ort
== C_ORT_OMP
|| ort
== C_ORT_ACC
)
13000 switch (OMP_CLAUSE_MAP_KIND (c
))
13002 case GOMP_MAP_ALLOC
:
13004 case GOMP_MAP_FROM
:
13005 case GOMP_MAP_TOFROM
:
13006 case GOMP_MAP_ALWAYS_TO
:
13007 case GOMP_MAP_ALWAYS_FROM
:
13008 case GOMP_MAP_ALWAYS_TOFROM
:
13009 case GOMP_MAP_RELEASE
:
13010 case GOMP_MAP_DELETE
:
13011 case GOMP_MAP_FORCE_TO
:
13012 case GOMP_MAP_FORCE_FROM
:
13013 case GOMP_MAP_FORCE_TOFROM
:
13014 case GOMP_MAP_FORCE_PRESENT
:
13015 OMP_CLAUSE_MAP_MAYBE_ZERO_LENGTH_ARRAY_SECTION (c
) = 1;
13020 tree c2
= build_omp_clause (OMP_CLAUSE_LOCATION (c
), OMP_CLAUSE_MAP
);
13021 if (ort
!= C_ORT_OMP
&& ort
!= C_ORT_ACC
)
13022 OMP_CLAUSE_SET_MAP_KIND (c2
, GOMP_MAP_POINTER
);
13023 else if (TREE_CODE (t
) == COMPONENT_REF
)
13024 OMP_CLAUSE_SET_MAP_KIND (c2
, GOMP_MAP_ALWAYS_POINTER
);
13026 OMP_CLAUSE_SET_MAP_KIND (c2
, GOMP_MAP_FIRSTPRIVATE_POINTER
);
13027 if (OMP_CLAUSE_MAP_KIND (c2
) != GOMP_MAP_FIRSTPRIVATE_POINTER
13028 && !c_mark_addressable (t
))
13030 OMP_CLAUSE_DECL (c2
) = t
;
13031 t
= build_fold_addr_expr (first
);
13032 t
= fold_convert_loc (OMP_CLAUSE_LOCATION (c
), ptrdiff_type_node
, t
);
13033 tree ptr
= OMP_CLAUSE_DECL (c2
);
13034 if (!POINTER_TYPE_P (TREE_TYPE (ptr
)))
13035 ptr
= build_fold_addr_expr (ptr
);
13036 t
= fold_build2_loc (OMP_CLAUSE_LOCATION (c
), MINUS_EXPR
,
13037 ptrdiff_type_node
, t
,
13038 fold_convert_loc (OMP_CLAUSE_LOCATION (c
),
13039 ptrdiff_type_node
, ptr
));
13040 t
= c_fully_fold (t
, false, NULL
);
13041 OMP_CLAUSE_SIZE (c2
) = t
;
13042 OMP_CLAUSE_CHAIN (c2
) = OMP_CLAUSE_CHAIN (c
);
13043 OMP_CLAUSE_CHAIN (c
) = c2
;
13048 /* Helper function of finish_omp_clauses. Clone STMT as if we were making
13049 an inline call. But, remap
13050 the OMP_DECL1 VAR_DECL (omp_out resp. omp_orig) to PLACEHOLDER
13051 and OMP_DECL2 VAR_DECL (omp_in resp. omp_priv) to DECL. */
13054 c_clone_omp_udr (tree stmt
, tree omp_decl1
, tree omp_decl2
,
13055 tree decl
, tree placeholder
)
13058 hash_map
<tree
, tree
> decl_map
;
13060 decl_map
.put (omp_decl1
, placeholder
);
13061 decl_map
.put (omp_decl2
, decl
);
13062 memset (&id
, 0, sizeof (id
));
13063 id
.src_fn
= DECL_CONTEXT (omp_decl1
);
13064 id
.dst_fn
= current_function_decl
;
13065 id
.src_cfun
= DECL_STRUCT_FUNCTION (id
.src_fn
);
13066 id
.decl_map
= &decl_map
;
13068 id
.copy_decl
= copy_decl_no_change
;
13069 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
13070 id
.transform_new_cfg
= true;
13071 id
.transform_return_to_modify
= false;
13072 id
.transform_lang_insert_block
= NULL
;
13074 walk_tree (&stmt
, copy_tree_body_r
, &id
, NULL
);
13078 /* Helper function of c_finish_omp_clauses, called via walk_tree.
13079 Find OMP_CLAUSE_PLACEHOLDER (passed in DATA) in *TP. */
13082 c_find_omp_placeholder_r (tree
*tp
, int *, void *data
)
13084 if (*tp
== (tree
) data
)
13089 /* For all elements of CLAUSES, validate them against their constraints.
13090 Remove any elements from the list that are invalid. */
13093 c_finish_omp_clauses (tree clauses
, enum c_omp_region_type ort
)
13095 bitmap_head generic_head
, firstprivate_head
, lastprivate_head
;
13096 bitmap_head aligned_head
, map_head
, map_field_head
, oacc_reduction_head
;
13097 tree c
, t
, type
, *pc
;
13098 tree simdlen
= NULL_TREE
, safelen
= NULL_TREE
;
13099 bool branch_seen
= false;
13100 bool copyprivate_seen
= false;
13101 bool linear_variable_step_check
= false;
13102 tree
*nowait_clause
= NULL
;
13103 bool ordered_seen
= false;
13104 tree schedule_clause
= NULL_TREE
;
13105 bool oacc_async
= false;
13107 bitmap_obstack_initialize (NULL
);
13108 bitmap_initialize (&generic_head
, &bitmap_default_obstack
);
13109 bitmap_initialize (&firstprivate_head
, &bitmap_default_obstack
);
13110 bitmap_initialize (&lastprivate_head
, &bitmap_default_obstack
);
13111 bitmap_initialize (&aligned_head
, &bitmap_default_obstack
);
13112 bitmap_initialize (&map_head
, &bitmap_default_obstack
);
13113 bitmap_initialize (&map_field_head
, &bitmap_default_obstack
);
13114 bitmap_initialize (&oacc_reduction_head
, &bitmap_default_obstack
);
13116 if (ort
& C_ORT_ACC
)
13117 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
13118 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_ASYNC
)
13124 for (pc
= &clauses
, c
= clauses
; c
; c
= *pc
)
13126 bool remove
= false;
13127 bool need_complete
= false;
13128 bool need_implicitly_determined
= false;
13130 switch (OMP_CLAUSE_CODE (c
))
13132 case OMP_CLAUSE_SHARED
:
13133 need_implicitly_determined
= true;
13134 goto check_dup_generic
;
13136 case OMP_CLAUSE_PRIVATE
:
13137 need_complete
= true;
13138 need_implicitly_determined
= true;
13139 goto check_dup_generic
;
13141 case OMP_CLAUSE_REDUCTION
:
13142 need_implicitly_determined
= true;
13143 t
= OMP_CLAUSE_DECL (c
);
13144 if (TREE_CODE (t
) == TREE_LIST
)
13146 if (handle_omp_array_sections (c
, ort
))
13152 t
= OMP_CLAUSE_DECL (c
);
13154 t
= require_complete_type (OMP_CLAUSE_LOCATION (c
), t
);
13155 if (t
== error_mark_node
)
13161 c_mark_addressable (t
);
13162 type
= TREE_TYPE (t
);
13163 if (TREE_CODE (t
) == MEM_REF
)
13164 type
= TREE_TYPE (type
);
13165 if (TREE_CODE (type
) == ARRAY_TYPE
)
13167 tree oatype
= type
;
13168 gcc_assert (TREE_CODE (t
) != MEM_REF
);
13169 while (TREE_CODE (type
) == ARRAY_TYPE
)
13170 type
= TREE_TYPE (type
);
13171 if (integer_zerop (TYPE_SIZE_UNIT (type
)))
13173 error_at (OMP_CLAUSE_LOCATION (c
),
13174 "%qD in %<reduction%> clause is a zero size array",
13179 tree size
= size_binop (EXACT_DIV_EXPR
, TYPE_SIZE_UNIT (oatype
),
13180 TYPE_SIZE_UNIT (type
));
13181 if (integer_zerop (size
))
13183 error_at (OMP_CLAUSE_LOCATION (c
),
13184 "%qD in %<reduction%> clause is a zero size array",
13189 size
= size_binop (MINUS_EXPR
, size
, size_one_node
);
13190 tree index_type
= build_index_type (size
);
13191 tree atype
= build_array_type (type
, index_type
);
13192 tree ptype
= build_pointer_type (type
);
13193 if (TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
13194 t
= build_fold_addr_expr (t
);
13195 t
= build2 (MEM_REF
, atype
, t
, build_int_cst (ptype
, 0));
13196 OMP_CLAUSE_DECL (c
) = t
;
13198 if (TYPE_ATOMIC (type
))
13200 error_at (OMP_CLAUSE_LOCATION (c
),
13201 "%<_Atomic%> %qE in %<reduction%> clause", t
);
13205 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
) == NULL_TREE
13206 && (FLOAT_TYPE_P (type
)
13207 || TREE_CODE (type
) == COMPLEX_TYPE
))
13209 enum tree_code r_code
= OMP_CLAUSE_REDUCTION_CODE (c
);
13210 const char *r_name
= NULL
;
13219 if (TREE_CODE (type
) == COMPLEX_TYPE
)
13223 if (TREE_CODE (type
) == COMPLEX_TYPE
)
13235 case TRUTH_ANDIF_EXPR
:
13236 if (FLOAT_TYPE_P (type
))
13239 case TRUTH_ORIF_EXPR
:
13240 if (FLOAT_TYPE_P (type
))
13244 gcc_unreachable ();
13248 error_at (OMP_CLAUSE_LOCATION (c
),
13249 "%qE has invalid type for %<reduction(%s)%>",
13255 else if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
) == error_mark_node
)
13257 error_at (OMP_CLAUSE_LOCATION (c
),
13258 "user defined reduction not found for %qE", t
);
13262 else if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
13264 tree list
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
);
13265 type
= TYPE_MAIN_VARIANT (type
);
13266 tree placeholder
= build_decl (OMP_CLAUSE_LOCATION (c
),
13267 VAR_DECL
, NULL_TREE
, type
);
13268 tree decl_placeholder
= NULL_TREE
;
13269 OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
) = placeholder
;
13270 DECL_ARTIFICIAL (placeholder
) = 1;
13271 DECL_IGNORED_P (placeholder
) = 1;
13272 if (TREE_CODE (t
) == MEM_REF
)
13274 decl_placeholder
= build_decl (OMP_CLAUSE_LOCATION (c
),
13275 VAR_DECL
, NULL_TREE
, type
);
13276 OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c
) = decl_placeholder
;
13277 DECL_ARTIFICIAL (decl_placeholder
) = 1;
13278 DECL_IGNORED_P (decl_placeholder
) = 1;
13280 if (TREE_ADDRESSABLE (TREE_VEC_ELT (list
, 0)))
13281 c_mark_addressable (placeholder
);
13282 if (TREE_ADDRESSABLE (TREE_VEC_ELT (list
, 1)))
13283 c_mark_addressable (decl_placeholder
? decl_placeholder
13284 : OMP_CLAUSE_DECL (c
));
13285 OMP_CLAUSE_REDUCTION_MERGE (c
)
13286 = c_clone_omp_udr (TREE_VEC_ELT (list
, 2),
13287 TREE_VEC_ELT (list
, 0),
13288 TREE_VEC_ELT (list
, 1),
13289 decl_placeholder
? decl_placeholder
13290 : OMP_CLAUSE_DECL (c
), placeholder
);
13291 OMP_CLAUSE_REDUCTION_MERGE (c
)
13292 = build3_loc (OMP_CLAUSE_LOCATION (c
), BIND_EXPR
,
13293 void_type_node
, NULL_TREE
,
13294 OMP_CLAUSE_REDUCTION_MERGE (c
), NULL_TREE
);
13295 TREE_SIDE_EFFECTS (OMP_CLAUSE_REDUCTION_MERGE (c
)) = 1;
13296 if (TREE_VEC_LENGTH (list
) == 6)
13298 if (TREE_ADDRESSABLE (TREE_VEC_ELT (list
, 3)))
13299 c_mark_addressable (decl_placeholder
? decl_placeholder
13300 : OMP_CLAUSE_DECL (c
));
13301 if (TREE_ADDRESSABLE (TREE_VEC_ELT (list
, 4)))
13302 c_mark_addressable (placeholder
);
13303 tree init
= TREE_VEC_ELT (list
, 5);
13304 if (init
== error_mark_node
)
13305 init
= DECL_INITIAL (TREE_VEC_ELT (list
, 3));
13306 OMP_CLAUSE_REDUCTION_INIT (c
)
13307 = c_clone_omp_udr (init
, TREE_VEC_ELT (list
, 4),
13308 TREE_VEC_ELT (list
, 3),
13309 decl_placeholder
? decl_placeholder
13310 : OMP_CLAUSE_DECL (c
), placeholder
);
13311 if (TREE_VEC_ELT (list
, 5) == error_mark_node
)
13313 tree v
= decl_placeholder
? decl_placeholder
: t
;
13314 OMP_CLAUSE_REDUCTION_INIT (c
)
13315 = build2 (INIT_EXPR
, TREE_TYPE (v
), v
,
13316 OMP_CLAUSE_REDUCTION_INIT (c
));
13318 if (walk_tree (&OMP_CLAUSE_REDUCTION_INIT (c
),
13319 c_find_omp_placeholder_r
,
13320 placeholder
, NULL
))
13321 OMP_CLAUSE_REDUCTION_OMP_ORIG_REF (c
) = 1;
13326 tree v
= decl_placeholder
? decl_placeholder
: t
;
13327 if (AGGREGATE_TYPE_P (TREE_TYPE (v
)))
13328 init
= build_constructor (TREE_TYPE (v
), NULL
);
13330 init
= fold_convert (TREE_TYPE (v
), integer_zero_node
);
13331 OMP_CLAUSE_REDUCTION_INIT (c
)
13332 = build2 (INIT_EXPR
, TREE_TYPE (v
), v
, init
);
13334 OMP_CLAUSE_REDUCTION_INIT (c
)
13335 = build3_loc (OMP_CLAUSE_LOCATION (c
), BIND_EXPR
,
13336 void_type_node
, NULL_TREE
,
13337 OMP_CLAUSE_REDUCTION_INIT (c
), NULL_TREE
);
13338 TREE_SIDE_EFFECTS (OMP_CLAUSE_REDUCTION_INIT (c
)) = 1;
13340 if (TREE_CODE (t
) == MEM_REF
)
13342 if (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (t
))) == NULL_TREE
13343 || TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (t
))))
13346 sorry ("variable length element type in array "
13347 "%<reduction%> clause");
13351 t
= TREE_OPERAND (t
, 0);
13352 if (TREE_CODE (t
) == POINTER_PLUS_EXPR
)
13353 t
= TREE_OPERAND (t
, 0);
13354 if (TREE_CODE (t
) == ADDR_EXPR
)
13355 t
= TREE_OPERAND (t
, 0);
13357 goto check_dup_generic_t
;
13359 case OMP_CLAUSE_COPYPRIVATE
:
13360 copyprivate_seen
= true;
13363 error_at (OMP_CLAUSE_LOCATION (*nowait_clause
),
13364 "%<nowait%> clause must not be used together "
13365 "with %<copyprivate%>");
13366 *nowait_clause
= OMP_CLAUSE_CHAIN (*nowait_clause
);
13367 nowait_clause
= NULL
;
13369 goto check_dup_generic
;
13371 case OMP_CLAUSE_COPYIN
:
13372 t
= OMP_CLAUSE_DECL (c
);
13373 if (!VAR_P (t
) || !DECL_THREAD_LOCAL_P (t
))
13375 error_at (OMP_CLAUSE_LOCATION (c
),
13376 "%qE must be %<threadprivate%> for %<copyin%>", t
);
13380 goto check_dup_generic
;
13382 case OMP_CLAUSE_LINEAR
:
13383 if (ort
!= C_ORT_OMP_DECLARE_SIMD
)
13384 need_implicitly_determined
= true;
13385 t
= OMP_CLAUSE_DECL (c
);
13386 if (ort
!= C_ORT_OMP_DECLARE_SIMD
13387 && OMP_CLAUSE_LINEAR_KIND (c
) != OMP_CLAUSE_LINEAR_DEFAULT
)
13389 error_at (OMP_CLAUSE_LOCATION (c
),
13390 "modifier should not be specified in %<linear%> "
13391 "clause on %<simd%> or %<for%> constructs");
13392 OMP_CLAUSE_LINEAR_KIND (c
) = OMP_CLAUSE_LINEAR_DEFAULT
;
13394 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
))
13395 && TREE_CODE (TREE_TYPE (t
)) != POINTER_TYPE
)
13397 error_at (OMP_CLAUSE_LOCATION (c
),
13398 "linear clause applied to non-integral non-pointer "
13399 "variable with type %qT", TREE_TYPE (t
));
13403 if (TYPE_ATOMIC (TREE_TYPE (t
)))
13405 error_at (OMP_CLAUSE_LOCATION (c
),
13406 "%<_Atomic%> %qD in %<linear%> clause", t
);
13410 if (ort
== C_ORT_OMP_DECLARE_SIMD
)
13412 tree s
= OMP_CLAUSE_LINEAR_STEP (c
);
13413 if (TREE_CODE (s
) == PARM_DECL
)
13415 OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (c
) = 1;
13416 /* map_head bitmap is used as uniform_head if
13418 if (!bitmap_bit_p (&map_head
, DECL_UID (s
)))
13419 linear_variable_step_check
= true;
13420 goto check_dup_generic
;
13422 if (TREE_CODE (s
) != INTEGER_CST
)
13424 error_at (OMP_CLAUSE_LOCATION (c
),
13425 "%<linear%> clause step %qE is neither constant "
13426 "nor a parameter", s
);
13431 if (TREE_CODE (TREE_TYPE (OMP_CLAUSE_DECL (c
))) == POINTER_TYPE
)
13433 tree s
= OMP_CLAUSE_LINEAR_STEP (c
);
13434 s
= pointer_int_sum (OMP_CLAUSE_LOCATION (c
), PLUS_EXPR
,
13435 OMP_CLAUSE_DECL (c
), s
);
13436 s
= fold_build2_loc (OMP_CLAUSE_LOCATION (c
), MINUS_EXPR
,
13437 sizetype
, fold_convert (sizetype
, s
),
13439 (sizetype
, OMP_CLAUSE_DECL (c
)));
13440 if (s
== error_mark_node
)
13442 OMP_CLAUSE_LINEAR_STEP (c
) = s
;
13445 OMP_CLAUSE_LINEAR_STEP (c
)
13446 = fold_convert (TREE_TYPE (t
), OMP_CLAUSE_LINEAR_STEP (c
));
13447 goto check_dup_generic
;
13450 t
= OMP_CLAUSE_DECL (c
);
13451 check_dup_generic_t
:
13452 if (!VAR_P (t
) && TREE_CODE (t
) != PARM_DECL
)
13454 error_at (OMP_CLAUSE_LOCATION (c
),
13455 "%qE is not a variable in clause %qs", t
,
13456 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
13459 else if (ort
== C_ORT_ACC
13460 && OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_REDUCTION
)
13462 if (bitmap_bit_p (&oacc_reduction_head
, DECL_UID (t
)))
13464 error ("%qD appears more than once in reduction clauses", t
);
13468 bitmap_set_bit (&oacc_reduction_head
, DECL_UID (t
));
13470 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
13471 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
))
13472 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
13474 error_at (OMP_CLAUSE_LOCATION (c
),
13475 "%qE appears more than once in data clauses", t
);
13478 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_PRIVATE
13479 && bitmap_bit_p (&map_head
, DECL_UID (t
)))
13481 if (ort
== C_ORT_ACC
)
13482 error ("%qD appears more than once in data clauses", t
);
13484 error ("%qD appears both in data and map clauses", t
);
13488 bitmap_set_bit (&generic_head
, DECL_UID (t
));
13491 case OMP_CLAUSE_FIRSTPRIVATE
:
13492 t
= OMP_CLAUSE_DECL (c
);
13493 need_complete
= true;
13494 need_implicitly_determined
= true;
13495 if (!VAR_P (t
) && TREE_CODE (t
) != PARM_DECL
)
13497 error_at (OMP_CLAUSE_LOCATION (c
),
13498 "%qE is not a variable in clause %<firstprivate%>", t
);
13501 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
13502 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
13504 error_at (OMP_CLAUSE_LOCATION (c
),
13505 "%qE appears more than once in data clauses", t
);
13508 else if (bitmap_bit_p (&map_head
, DECL_UID (t
)))
13510 if (ort
== C_ORT_ACC
)
13511 error ("%qD appears more than once in data clauses", t
);
13513 error ("%qD appears both in data and map clauses", t
);
13517 bitmap_set_bit (&firstprivate_head
, DECL_UID (t
));
13520 case OMP_CLAUSE_LASTPRIVATE
:
13521 t
= OMP_CLAUSE_DECL (c
);
13522 need_complete
= true;
13523 need_implicitly_determined
= true;
13524 if (!VAR_P (t
) && TREE_CODE (t
) != PARM_DECL
)
13526 error_at (OMP_CLAUSE_LOCATION (c
),
13527 "%qE is not a variable in clause %<lastprivate%>", t
);
13530 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
13531 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
13533 error_at (OMP_CLAUSE_LOCATION (c
),
13534 "%qE appears more than once in data clauses", t
);
13538 bitmap_set_bit (&lastprivate_head
, DECL_UID (t
));
13541 case OMP_CLAUSE_ALIGNED
:
13542 t
= OMP_CLAUSE_DECL (c
);
13543 if (!VAR_P (t
) && TREE_CODE (t
) != PARM_DECL
)
13545 error_at (OMP_CLAUSE_LOCATION (c
),
13546 "%qE is not a variable in %<aligned%> clause", t
);
13549 else if (!POINTER_TYPE_P (TREE_TYPE (t
))
13550 && TREE_CODE (TREE_TYPE (t
)) != ARRAY_TYPE
)
13552 error_at (OMP_CLAUSE_LOCATION (c
),
13553 "%qE in %<aligned%> clause is neither a pointer nor "
13557 else if (TYPE_ATOMIC (TREE_TYPE (t
)))
13559 error_at (OMP_CLAUSE_LOCATION (c
),
13560 "%<_Atomic%> %qD in %<aligned%> clause", t
);
13564 else if (bitmap_bit_p (&aligned_head
, DECL_UID (t
)))
13566 error_at (OMP_CLAUSE_LOCATION (c
),
13567 "%qE appears more than once in %<aligned%> clauses",
13572 bitmap_set_bit (&aligned_head
, DECL_UID (t
));
13575 case OMP_CLAUSE_DEPEND
:
13576 t
= OMP_CLAUSE_DECL (c
);
13577 if (t
== NULL_TREE
)
13579 gcc_assert (OMP_CLAUSE_DEPEND_KIND (c
)
13580 == OMP_CLAUSE_DEPEND_SOURCE
);
13583 if (OMP_CLAUSE_DEPEND_KIND (c
) == OMP_CLAUSE_DEPEND_SINK
)
13585 gcc_assert (TREE_CODE (t
) == TREE_LIST
);
13586 for (; t
; t
= TREE_CHAIN (t
))
13588 tree decl
= TREE_VALUE (t
);
13589 if (TREE_CODE (TREE_TYPE (decl
)) == POINTER_TYPE
)
13591 tree offset
= TREE_PURPOSE (t
);
13592 bool neg
= wi::neg_p (wi::to_wide (offset
));
13593 offset
= fold_unary (ABS_EXPR
, TREE_TYPE (offset
), offset
);
13594 tree t2
= pointer_int_sum (OMP_CLAUSE_LOCATION (c
),
13595 neg
? MINUS_EXPR
: PLUS_EXPR
,
13597 t2
= fold_build2_loc (OMP_CLAUSE_LOCATION (c
), MINUS_EXPR
,
13599 fold_convert (sizetype
, t2
),
13600 fold_convert (sizetype
, decl
));
13601 if (t2
== error_mark_node
)
13606 TREE_PURPOSE (t
) = t2
;
13611 if (TREE_CODE (t
) == TREE_LIST
)
13613 if (handle_omp_array_sections (c
, ort
))
13617 if (t
== error_mark_node
)
13619 else if (!VAR_P (t
) && TREE_CODE (t
) != PARM_DECL
)
13621 error_at (OMP_CLAUSE_LOCATION (c
),
13622 "%qE is not a variable in %<depend%> clause", t
);
13625 else if (!c_mark_addressable (t
))
13629 case OMP_CLAUSE_MAP
:
13630 case OMP_CLAUSE_TO
:
13631 case OMP_CLAUSE_FROM
:
13632 case OMP_CLAUSE__CACHE_
:
13633 t
= OMP_CLAUSE_DECL (c
);
13634 if (TREE_CODE (t
) == TREE_LIST
)
13636 if (handle_omp_array_sections (c
, ort
))
13640 t
= OMP_CLAUSE_DECL (c
);
13641 if (!lang_hooks
.types
.omp_mappable_type (TREE_TYPE (t
)))
13643 error_at (OMP_CLAUSE_LOCATION (c
),
13644 "array section does not have mappable type "
13646 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
13649 else if (TYPE_ATOMIC (TREE_TYPE (t
)))
13651 error_at (OMP_CLAUSE_LOCATION (c
),
13652 "%<_Atomic%> %qE in %qs clause", t
,
13653 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
13656 while (TREE_CODE (t
) == ARRAY_REF
)
13657 t
= TREE_OPERAND (t
, 0);
13658 if (TREE_CODE (t
) == COMPONENT_REF
13659 && TREE_CODE (TREE_TYPE (t
)) == ARRAY_TYPE
)
13661 while (TREE_CODE (t
) == COMPONENT_REF
)
13662 t
= TREE_OPERAND (t
, 0);
13663 if (bitmap_bit_p (&map_field_head
, DECL_UID (t
)))
13665 if (bitmap_bit_p (&map_head
, DECL_UID (t
)))
13667 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_MAP
)
13668 error ("%qD appears more than once in motion"
13670 else if (ort
== C_ORT_ACC
)
13671 error ("%qD appears more than once in data"
13674 error ("%qD appears more than once in map"
13680 bitmap_set_bit (&map_head
, DECL_UID (t
));
13681 bitmap_set_bit (&map_field_head
, DECL_UID (t
));
13687 if (t
== error_mark_node
)
13692 if (TREE_CODE (t
) == COMPONENT_REF
13693 && (ort
& C_ORT_OMP
)
13694 && OMP_CLAUSE_CODE (c
) != OMP_CLAUSE__CACHE_
)
13696 if (DECL_BIT_FIELD (TREE_OPERAND (t
, 1)))
13698 error_at (OMP_CLAUSE_LOCATION (c
),
13699 "bit-field %qE in %qs clause",
13700 t
, omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
13703 else if (!lang_hooks
.types
.omp_mappable_type (TREE_TYPE (t
)))
13705 error_at (OMP_CLAUSE_LOCATION (c
),
13706 "%qE does not have a mappable type in %qs clause",
13707 t
, omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
13710 else if (TYPE_ATOMIC (TREE_TYPE (t
)))
13712 error_at (OMP_CLAUSE_LOCATION (c
),
13713 "%<_Atomic%> %qE in %qs clause", t
,
13714 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
13717 while (TREE_CODE (t
) == COMPONENT_REF
)
13719 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0)))
13722 error_at (OMP_CLAUSE_LOCATION (c
),
13723 "%qE is a member of a union", t
);
13727 t
= TREE_OPERAND (t
, 0);
13731 if (VAR_P (t
) || TREE_CODE (t
) == PARM_DECL
)
13733 if (bitmap_bit_p (&map_field_head
, DECL_UID (t
)))
13737 if (!VAR_P (t
) && TREE_CODE (t
) != PARM_DECL
)
13739 error_at (OMP_CLAUSE_LOCATION (c
),
13740 "%qE is not a variable in %qs clause", t
,
13741 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
13744 else if (VAR_P (t
) && DECL_THREAD_LOCAL_P (t
))
13746 error_at (OMP_CLAUSE_LOCATION (c
),
13747 "%qD is threadprivate variable in %qs clause", t
,
13748 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
13751 else if ((OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_MAP
13752 || (OMP_CLAUSE_MAP_KIND (c
)
13753 != GOMP_MAP_FIRSTPRIVATE_POINTER
))
13754 && !c_mark_addressable (t
))
13756 else if (!(OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
13757 && (OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_POINTER
13758 || (OMP_CLAUSE_MAP_KIND (c
)
13759 == GOMP_MAP_FIRSTPRIVATE_POINTER
)
13760 || (OMP_CLAUSE_MAP_KIND (c
)
13761 == GOMP_MAP_FORCE_DEVICEPTR
)))
13762 && t
== OMP_CLAUSE_DECL (c
)
13763 && !lang_hooks
.types
.omp_mappable_type (TREE_TYPE (t
)))
13765 error_at (OMP_CLAUSE_LOCATION (c
),
13766 "%qD does not have a mappable type in %qs clause", t
,
13767 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
13770 else if (TREE_TYPE (t
) == error_mark_node
)
13772 else if (TYPE_ATOMIC (strip_array_types (TREE_TYPE (t
))))
13774 error_at (OMP_CLAUSE_LOCATION (c
),
13775 "%<_Atomic%> %qE in %qs clause", t
,
13776 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
13779 else if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
13780 && OMP_CLAUSE_MAP_KIND (c
) == GOMP_MAP_FIRSTPRIVATE_POINTER
)
13782 if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
13783 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
13785 error ("%qD appears more than once in data clauses", t
);
13788 else if (bitmap_bit_p (&map_head
, DECL_UID (t
)))
13790 if (ort
== C_ORT_ACC
)
13791 error ("%qD appears more than once in data clauses", t
);
13793 error ("%qD appears both in data and map clauses", t
);
13797 bitmap_set_bit (&generic_head
, DECL_UID (t
));
13799 else if (bitmap_bit_p (&map_head
, DECL_UID (t
)))
13801 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_MAP
)
13802 error ("%qD appears more than once in motion clauses", t
);
13803 else if (ort
== C_ORT_ACC
)
13804 error ("%qD appears more than once in data clauses", t
);
13806 error ("%qD appears more than once in map clauses", t
);
13809 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
13810 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
13812 if (ort
== C_ORT_ACC
)
13813 error ("%qD appears more than once in data clauses", t
);
13815 error ("%qD appears both in data and map clauses", t
);
13820 bitmap_set_bit (&map_head
, DECL_UID (t
));
13821 if (t
!= OMP_CLAUSE_DECL (c
)
13822 && TREE_CODE (OMP_CLAUSE_DECL (c
)) == COMPONENT_REF
)
13823 bitmap_set_bit (&map_field_head
, DECL_UID (t
));
13827 case OMP_CLAUSE_TO_DECLARE
:
13828 case OMP_CLAUSE_LINK
:
13829 t
= OMP_CLAUSE_DECL (c
);
13830 if (TREE_CODE (t
) == FUNCTION_DECL
13831 && OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_TO_DECLARE
)
13833 else if (!VAR_P (t
))
13835 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_TO_DECLARE
)
13836 error_at (OMP_CLAUSE_LOCATION (c
),
13837 "%qE is neither a variable nor a function name in "
13839 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
13841 error_at (OMP_CLAUSE_LOCATION (c
),
13842 "%qE is not a variable in clause %qs", t
,
13843 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
13846 else if (DECL_THREAD_LOCAL_P (t
))
13848 error_at (OMP_CLAUSE_LOCATION (c
),
13849 "%qD is threadprivate variable in %qs clause", t
,
13850 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
13853 else if (!lang_hooks
.types
.omp_mappable_type (TREE_TYPE (t
)))
13855 error_at (OMP_CLAUSE_LOCATION (c
),
13856 "%qD does not have a mappable type in %qs clause", t
,
13857 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
13862 if (bitmap_bit_p (&generic_head
, DECL_UID (t
)))
13864 error_at (OMP_CLAUSE_LOCATION (c
),
13865 "%qE appears more than once on the same "
13866 "%<declare target%> directive", t
);
13870 bitmap_set_bit (&generic_head
, DECL_UID (t
));
13873 case OMP_CLAUSE_UNIFORM
:
13874 t
= OMP_CLAUSE_DECL (c
);
13875 if (TREE_CODE (t
) != PARM_DECL
)
13878 error_at (OMP_CLAUSE_LOCATION (c
),
13879 "%qD is not an argument in %<uniform%> clause", t
);
13881 error_at (OMP_CLAUSE_LOCATION (c
),
13882 "%qE is not an argument in %<uniform%> clause", t
);
13886 /* map_head bitmap is used as uniform_head if declare_simd. */
13887 bitmap_set_bit (&map_head
, DECL_UID (t
));
13888 goto check_dup_generic
;
13890 case OMP_CLAUSE_IS_DEVICE_PTR
:
13891 case OMP_CLAUSE_USE_DEVICE_PTR
:
13892 t
= OMP_CLAUSE_DECL (c
);
13893 if (TREE_CODE (TREE_TYPE (t
)) != POINTER_TYPE
13894 && TREE_CODE (TREE_TYPE (t
)) != ARRAY_TYPE
)
13896 error_at (OMP_CLAUSE_LOCATION (c
),
13897 "%qs variable is neither a pointer nor an array",
13898 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
13901 goto check_dup_generic
;
13903 case OMP_CLAUSE_NOWAIT
:
13904 if (copyprivate_seen
)
13906 error_at (OMP_CLAUSE_LOCATION (c
),
13907 "%<nowait%> clause must not be used together "
13908 "with %<copyprivate%>");
13912 nowait_clause
= pc
;
13913 pc
= &OMP_CLAUSE_CHAIN (c
);
13916 case OMP_CLAUSE_IF
:
13917 case OMP_CLAUSE_NUM_THREADS
:
13918 case OMP_CLAUSE_NUM_TEAMS
:
13919 case OMP_CLAUSE_THREAD_LIMIT
:
13920 case OMP_CLAUSE_DEFAULT
:
13921 case OMP_CLAUSE_UNTIED
:
13922 case OMP_CLAUSE_COLLAPSE
:
13923 case OMP_CLAUSE_FINAL
:
13924 case OMP_CLAUSE_MERGEABLE
:
13925 case OMP_CLAUSE_DEVICE
:
13926 case OMP_CLAUSE_DIST_SCHEDULE
:
13927 case OMP_CLAUSE_PARALLEL
:
13928 case OMP_CLAUSE_FOR
:
13929 case OMP_CLAUSE_SECTIONS
:
13930 case OMP_CLAUSE_TASKGROUP
:
13931 case OMP_CLAUSE_PROC_BIND
:
13932 case OMP_CLAUSE_PRIORITY
:
13933 case OMP_CLAUSE_GRAINSIZE
:
13934 case OMP_CLAUSE_NUM_TASKS
:
13935 case OMP_CLAUSE_NOGROUP
:
13936 case OMP_CLAUSE_THREADS
:
13937 case OMP_CLAUSE_SIMD
:
13938 case OMP_CLAUSE_HINT
:
13939 case OMP_CLAUSE_DEFAULTMAP
:
13940 case OMP_CLAUSE_NUM_GANGS
:
13941 case OMP_CLAUSE_NUM_WORKERS
:
13942 case OMP_CLAUSE_VECTOR_LENGTH
:
13943 case OMP_CLAUSE_ASYNC
:
13944 case OMP_CLAUSE_WAIT
:
13945 case OMP_CLAUSE_AUTO
:
13946 case OMP_CLAUSE_INDEPENDENT
:
13947 case OMP_CLAUSE_SEQ
:
13948 case OMP_CLAUSE_GANG
:
13949 case OMP_CLAUSE_WORKER
:
13950 case OMP_CLAUSE_VECTOR
:
13951 case OMP_CLAUSE_TILE
:
13952 case OMP_CLAUSE_IF_PRESENT
:
13953 case OMP_CLAUSE_FINALIZE
:
13954 pc
= &OMP_CLAUSE_CHAIN (c
);
13957 case OMP_CLAUSE_SCHEDULE
:
13958 if (OMP_CLAUSE_SCHEDULE_KIND (c
) & OMP_CLAUSE_SCHEDULE_NONMONOTONIC
)
13960 const char *p
= NULL
;
13961 switch (OMP_CLAUSE_SCHEDULE_KIND (c
) & OMP_CLAUSE_SCHEDULE_MASK
)
13963 case OMP_CLAUSE_SCHEDULE_STATIC
: p
= "static"; break;
13964 case OMP_CLAUSE_SCHEDULE_DYNAMIC
: break;
13965 case OMP_CLAUSE_SCHEDULE_GUIDED
: break;
13966 case OMP_CLAUSE_SCHEDULE_AUTO
: p
= "auto"; break;
13967 case OMP_CLAUSE_SCHEDULE_RUNTIME
: p
= "runtime"; break;
13968 default: gcc_unreachable ();
13972 error_at (OMP_CLAUSE_LOCATION (c
),
13973 "%<nonmonotonic%> modifier specified for %qs "
13974 "schedule kind", p
);
13975 OMP_CLAUSE_SCHEDULE_KIND (c
)
13976 = (enum omp_clause_schedule_kind
)
13977 (OMP_CLAUSE_SCHEDULE_KIND (c
)
13978 & ~OMP_CLAUSE_SCHEDULE_NONMONOTONIC
);
13981 schedule_clause
= c
;
13982 pc
= &OMP_CLAUSE_CHAIN (c
);
13985 case OMP_CLAUSE_ORDERED
:
13986 ordered_seen
= true;
13987 pc
= &OMP_CLAUSE_CHAIN (c
);
13990 case OMP_CLAUSE_SAFELEN
:
13992 pc
= &OMP_CLAUSE_CHAIN (c
);
13994 case OMP_CLAUSE_SIMDLEN
:
13996 pc
= &OMP_CLAUSE_CHAIN (c
);
13999 case OMP_CLAUSE_INBRANCH
:
14000 case OMP_CLAUSE_NOTINBRANCH
:
14003 error_at (OMP_CLAUSE_LOCATION (c
),
14004 "%<inbranch%> clause is incompatible with "
14005 "%<notinbranch%>");
14009 branch_seen
= true;
14010 pc
= &OMP_CLAUSE_CHAIN (c
);
14014 gcc_unreachable ();
14019 t
= OMP_CLAUSE_DECL (c
);
14023 t
= require_complete_type (OMP_CLAUSE_LOCATION (c
), t
);
14024 if (t
== error_mark_node
)
14028 if (need_implicitly_determined
)
14030 const char *share_name
= NULL
;
14032 if (VAR_P (t
) && DECL_THREAD_LOCAL_P (t
))
14033 share_name
= "threadprivate";
14034 else switch (c_omp_predetermined_sharing (t
))
14036 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
14038 case OMP_CLAUSE_DEFAULT_SHARED
:
14039 /* const vars may be specified in firstprivate clause. */
14040 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
14041 && TREE_READONLY (t
))
14043 share_name
= "shared";
14045 case OMP_CLAUSE_DEFAULT_PRIVATE
:
14046 share_name
= "private";
14049 gcc_unreachable ();
14053 error_at (OMP_CLAUSE_LOCATION (c
),
14054 "%qE is predetermined %qs for %qs",
14056 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
14063 *pc
= OMP_CLAUSE_CHAIN (c
);
14065 pc
= &OMP_CLAUSE_CHAIN (c
);
14070 && tree_int_cst_lt (OMP_CLAUSE_SAFELEN_EXPR (safelen
),
14071 OMP_CLAUSE_SIMDLEN_EXPR (simdlen
)))
14073 error_at (OMP_CLAUSE_LOCATION (simdlen
),
14074 "%<simdlen%> clause value is bigger than "
14075 "%<safelen%> clause value");
14076 OMP_CLAUSE_SIMDLEN_EXPR (simdlen
)
14077 = OMP_CLAUSE_SAFELEN_EXPR (safelen
);
14082 && (OMP_CLAUSE_SCHEDULE_KIND (schedule_clause
)
14083 & OMP_CLAUSE_SCHEDULE_NONMONOTONIC
))
14085 error_at (OMP_CLAUSE_LOCATION (schedule_clause
),
14086 "%<nonmonotonic%> schedule modifier specified together "
14087 "with %<ordered%> clause");
14088 OMP_CLAUSE_SCHEDULE_KIND (schedule_clause
)
14089 = (enum omp_clause_schedule_kind
)
14090 (OMP_CLAUSE_SCHEDULE_KIND (schedule_clause
)
14091 & ~OMP_CLAUSE_SCHEDULE_NONMONOTONIC
);
14094 if (linear_variable_step_check
)
14095 for (pc
= &clauses
, c
= clauses
; c
; c
= *pc
)
14097 bool remove
= false;
14098 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_LINEAR
14099 && OMP_CLAUSE_LINEAR_VARIABLE_STRIDE (c
)
14100 && !bitmap_bit_p (&map_head
,
14101 DECL_UID (OMP_CLAUSE_LINEAR_STEP (c
))))
14103 error_at (OMP_CLAUSE_LOCATION (c
),
14104 "%<linear%> clause step is a parameter %qD not "
14105 "specified in %<uniform%> clause",
14106 OMP_CLAUSE_LINEAR_STEP (c
));
14111 *pc
= OMP_CLAUSE_CHAIN (c
);
14113 pc
= &OMP_CLAUSE_CHAIN (c
);
14116 bitmap_obstack_release (NULL
);
14120 /* Return code to initialize DST with a copy constructor from SRC.
14121 C doesn't have copy constructors nor assignment operators, only for
14122 _Atomic vars we need to perform __atomic_load from src into a temporary
14123 followed by __atomic_store of the temporary to dst. */
14126 c_omp_clause_copy_ctor (tree clause
, tree dst
, tree src
)
14128 if (!really_atomic_lvalue (dst
) && !really_atomic_lvalue (src
))
14129 return build2 (MODIFY_EXPR
, TREE_TYPE (dst
), dst
, src
);
14131 location_t loc
= OMP_CLAUSE_LOCATION (clause
);
14132 tree type
= TREE_TYPE (dst
);
14133 tree nonatomic_type
= build_qualified_type (type
, TYPE_UNQUALIFIED
);
14134 tree tmp
= create_tmp_var (nonatomic_type
);
14135 tree tmp_addr
= build_fold_addr_expr (tmp
);
14136 TREE_ADDRESSABLE (tmp
) = 1;
14137 TREE_NO_WARNING (tmp
) = 1;
14138 tree src_addr
= build_fold_addr_expr (src
);
14139 tree dst_addr
= build_fold_addr_expr (dst
);
14140 tree seq_cst
= build_int_cst (integer_type_node
, MEMMODEL_SEQ_CST
);
14141 vec
<tree
, va_gc
> *params
;
14142 /* Expansion of a generic atomic load may require an addition
14143 element, so allocate enough to prevent a resize. */
14144 vec_alloc (params
, 4);
14146 /* Build __atomic_load (&src, &tmp, SEQ_CST); */
14147 tree fndecl
= builtin_decl_explicit (BUILT_IN_ATOMIC_LOAD
);
14148 params
->quick_push (src_addr
);
14149 params
->quick_push (tmp_addr
);
14150 params
->quick_push (seq_cst
);
14151 tree load
= c_build_function_call_vec (loc
, vNULL
, fndecl
, params
, NULL
);
14153 vec_alloc (params
, 4);
14155 /* Build __atomic_store (&dst, &tmp, SEQ_CST); */
14156 fndecl
= builtin_decl_explicit (BUILT_IN_ATOMIC_STORE
);
14157 params
->quick_push (dst_addr
);
14158 params
->quick_push (tmp_addr
);
14159 params
->quick_push (seq_cst
);
14160 tree store
= c_build_function_call_vec (loc
, vNULL
, fndecl
, params
, NULL
);
14161 return build2 (COMPOUND_EXPR
, void_type_node
, load
, store
);
14164 /* Create a transaction node. */
14167 c_finish_transaction (location_t loc
, tree block
, int flags
)
14169 tree stmt
= build_stmt (loc
, TRANSACTION_EXPR
, block
);
14170 if (flags
& TM_STMT_ATTR_OUTER
)
14171 TRANSACTION_EXPR_OUTER (stmt
) = 1;
14172 if (flags
& TM_STMT_ATTR_RELAXED
)
14173 TRANSACTION_EXPR_RELAXED (stmt
) = 1;
14174 return add_stmt (stmt
);
14177 /* Make a variant type in the proper way for C/C++, propagating qualifiers
14178 down to the element type of an array. If ORIG_QUAL_TYPE is not
14179 NULL, then it should be used as the qualified type
14180 ORIG_QUAL_INDIRECT levels down in array type derivation (to
14181 preserve information about the typedef name from which an array
14182 type was derived). */
14185 c_build_qualified_type (tree type
, int type_quals
, tree orig_qual_type
,
14186 size_t orig_qual_indirect
)
14188 if (type
== error_mark_node
)
14191 if (TREE_CODE (type
) == ARRAY_TYPE
)
14194 tree element_type
= c_build_qualified_type (TREE_TYPE (type
),
14195 type_quals
, orig_qual_type
,
14196 orig_qual_indirect
- 1);
14198 /* See if we already have an identically qualified type. */
14199 if (orig_qual_type
&& orig_qual_indirect
== 0)
14200 t
= orig_qual_type
;
14202 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
14204 if (TYPE_QUALS (strip_array_types (t
)) == type_quals
14205 && TYPE_NAME (t
) == TYPE_NAME (type
)
14206 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
14207 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
14208 TYPE_ATTRIBUTES (type
)))
14213 tree domain
= TYPE_DOMAIN (type
);
14215 t
= build_variant_type_copy (type
);
14216 TREE_TYPE (t
) = element_type
;
14218 if (TYPE_STRUCTURAL_EQUALITY_P (element_type
)
14219 || (domain
&& TYPE_STRUCTURAL_EQUALITY_P (domain
)))
14220 SET_TYPE_STRUCTURAL_EQUALITY (t
);
14221 else if (TYPE_CANONICAL (element_type
) != element_type
14222 || (domain
&& TYPE_CANONICAL (domain
) != domain
))
14224 tree unqualified_canon
14225 = build_array_type (TYPE_CANONICAL (element_type
),
14226 domain
? TYPE_CANONICAL (domain
)
14228 if (TYPE_REVERSE_STORAGE_ORDER (type
))
14231 = build_distinct_type_copy (unqualified_canon
);
14232 TYPE_REVERSE_STORAGE_ORDER (unqualified_canon
) = 1;
14235 = c_build_qualified_type (unqualified_canon
, type_quals
);
14238 TYPE_CANONICAL (t
) = t
;
14243 /* A restrict-qualified pointer type must be a pointer to object or
14244 incomplete type. Note that the use of POINTER_TYPE_P also allows
14245 REFERENCE_TYPEs, which is appropriate for C++. */
14246 if ((type_quals
& TYPE_QUAL_RESTRICT
)
14247 && (!POINTER_TYPE_P (type
)
14248 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
))))
14250 error ("invalid use of %<restrict%>");
14251 type_quals
&= ~TYPE_QUAL_RESTRICT
;
14254 tree var_type
= (orig_qual_type
&& orig_qual_indirect
== 0
14256 : build_qualified_type (type
, type_quals
));
14257 /* A variant type does not inherit the list of incomplete vars from the
14258 type main variant. */
14259 if (RECORD_OR_UNION_TYPE_P (var_type
)
14260 && TYPE_MAIN_VARIANT (var_type
) != var_type
)
14261 C_TYPE_INCOMPLETE_VARS (var_type
) = 0;
14265 /* Build a VA_ARG_EXPR for the C parser. */
14268 c_build_va_arg (location_t loc1
, tree expr
, location_t loc2
, tree type
)
14270 if (error_operand_p (type
))
14271 return error_mark_node
;
14272 /* VA_ARG_EXPR cannot be used for a scalar va_list with reverse storage
14273 order because it takes the address of the expression. */
14274 else if (handled_component_p (expr
)
14275 && reverse_storage_order_for_component_p (expr
))
14277 error_at (loc1
, "cannot use %<va_arg%> with reverse storage order");
14278 return error_mark_node
;
14280 else if (!COMPLETE_TYPE_P (type
))
14282 error_at (loc2
, "second argument to %<va_arg%> is of incomplete "
14284 return error_mark_node
;
14286 else if (warn_cxx_compat
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
14287 warning_at (loc2
, OPT_Wc___compat
,
14288 "C++ requires promoted type, not enum type, in %<va_arg%>");
14289 return build_va_arg (loc2
, expr
, type
);
14292 /* Return truthvalue of whether T1 is the same tree structure as T2.
14293 Return 1 if they are the same. Return false if they are different. */
14296 c_tree_equal (tree t1
, tree t2
)
14298 enum tree_code code1
, code2
;
14305 for (code1
= TREE_CODE (t1
);
14306 CONVERT_EXPR_CODE_P (code1
)
14307 || code1
== NON_LVALUE_EXPR
;
14308 code1
= TREE_CODE (t1
))
14309 t1
= TREE_OPERAND (t1
, 0);
14310 for (code2
= TREE_CODE (t2
);
14311 CONVERT_EXPR_CODE_P (code2
)
14312 || code2
== NON_LVALUE_EXPR
;
14313 code2
= TREE_CODE (t2
))
14314 t2
= TREE_OPERAND (t2
, 0);
14316 /* They might have become equal now. */
14320 if (code1
!= code2
)
14326 return wi::to_wide (t1
) == wi::to_wide (t2
);
14329 return real_equal (&TREE_REAL_CST (t1
), &TREE_REAL_CST (t2
));
14332 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
14333 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
14334 TREE_STRING_LENGTH (t1
));
14337 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
),
14338 TREE_FIXED_CST (t2
));
14341 return c_tree_equal (TREE_REALPART (t1
), TREE_REALPART (t2
))
14342 && c_tree_equal (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
14345 return operand_equal_p (t1
, t2
, OEP_ONLY_CONST
);
14348 /* We need to do this when determining whether or not two
14349 non-type pointer to member function template arguments
14351 if (!comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
))
14352 || CONSTRUCTOR_NELTS (t1
) != CONSTRUCTOR_NELTS (t2
))
14357 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, field
, value
)
14359 constructor_elt
*elt2
= CONSTRUCTOR_ELT (t2
, i
);
14360 if (!c_tree_equal (field
, elt2
->index
)
14361 || !c_tree_equal (value
, elt2
->value
))
14368 if (!c_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)))
14370 if (!c_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
)))
14372 return c_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
14375 return c_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
14380 call_expr_arg_iterator iter1
, iter2
;
14381 if (!c_tree_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
)))
14383 for (arg1
= first_call_expr_arg (t1
, &iter1
),
14384 arg2
= first_call_expr_arg (t2
, &iter2
);
14386 arg1
= next_call_expr_arg (&iter1
),
14387 arg2
= next_call_expr_arg (&iter2
))
14388 if (!c_tree_equal (arg1
, arg2
))
14397 tree o1
= TREE_OPERAND (t1
, 0);
14398 tree o2
= TREE_OPERAND (t2
, 0);
14400 /* Special case: if either target is an unallocated VAR_DECL,
14401 it means that it's going to be unified with whatever the
14402 TARGET_EXPR is really supposed to initialize, so treat it
14403 as being equivalent to anything. */
14404 if (VAR_P (o1
) && DECL_NAME (o1
) == NULL_TREE
14405 && !DECL_RTL_SET_P (o1
))
14407 else if (VAR_P (o2
) && DECL_NAME (o2
) == NULL_TREE
14408 && !DECL_RTL_SET_P (o2
))
14410 else if (!c_tree_equal (o1
, o2
))
14413 return c_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
14416 case COMPONENT_REF
:
14417 if (TREE_OPERAND (t1
, 1) != TREE_OPERAND (t2
, 1))
14419 return c_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
14425 case FUNCTION_DECL
:
14426 case IDENTIFIER_NODE
:
14433 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
14435 for (ix
= TREE_VEC_LENGTH (t1
); ix
--;)
14436 if (!c_tree_equal (TREE_VEC_ELT (t1
, ix
),
14437 TREE_VEC_ELT (t2
, ix
)))
14446 switch (TREE_CODE_CLASS (code1
))
14450 case tcc_comparison
:
14451 case tcc_expression
:
14453 case tcc_reference
:
14454 case tcc_statement
:
14456 int i
, n
= TREE_OPERAND_LENGTH (t1
);
14460 case PREINCREMENT_EXPR
:
14461 case PREDECREMENT_EXPR
:
14462 case POSTINCREMENT_EXPR
:
14463 case POSTDECREMENT_EXPR
:
14473 if (TREE_CODE_CLASS (code1
) == tcc_vl_exp
14474 && n
!= TREE_OPERAND_LENGTH (t2
))
14477 for (i
= 0; i
< n
; ++i
)
14478 if (!c_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
)))
14485 return comptypes (t1
, t2
);
14487 gcc_unreachable ();
14489 /* We can get here with --disable-checking. */
14493 /* Returns true when the function declaration FNDECL is implicit,
14494 introduced as a result of a call to an otherwise undeclared
14495 function, and false otherwise. */
14498 c_decl_implicit (const_tree fndecl
)
14500 return C_DECL_IMPLICIT (fndecl
);