1 /* Build expressions with type checking for C compiler.
2 Copyright (C) 1987-2014 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"
31 #include "stor-layout.h"
32 #include "trans-mem.h"
35 #include "langhooks.h"
41 #include "tree-iterator.h"
43 #include "pointer-set.h"
44 #include "basic-block.h"
45 #include "gimple-expr.h"
47 #include "tree-inline.h"
49 #include "c-family/c-objc.h"
50 #include "c-family/c-common.h"
51 #include "c-family/c-ubsan.h"
55 /* Possible cases of implicit bad conversions. Used to select
56 diagnostic messages in convert_for_assignment. */
64 /* The level of nesting inside "__alignof__". */
67 /* The level of nesting inside "sizeof". */
70 /* The level of nesting inside "typeof". */
73 /* The argument of last parsed sizeof expression, only to be tested
74 if expr.original_code == SIZEOF_EXPR. */
75 tree c_last_sizeof_arg
;
77 /* Nonzero if we've already printed a "missing braces around initializer"
78 message within this initializer. */
79 static int missing_braces_mentioned
;
81 static int require_constant_value
;
82 static int require_constant_elements
;
84 static bool null_pointer_constant_p (const_tree
);
85 static tree
qualify_type (tree
, tree
);
86 static int tagged_types_tu_compatible_p (const_tree
, const_tree
, bool *,
88 static int comp_target_types (location_t
, tree
, tree
);
89 static int function_types_compatible_p (const_tree
, const_tree
, bool *,
91 static int type_lists_compatible_p (const_tree
, const_tree
, bool *, bool *);
92 static tree
lookup_field (tree
, tree
);
93 static int convert_arguments (location_t
, vec
<location_t
>, tree
,
94 vec
<tree
, va_gc
> *, vec
<tree
, va_gc
> *, tree
,
96 static tree
pointer_diff (location_t
, tree
, tree
);
97 static tree
convert_for_assignment (location_t
, location_t
, tree
, tree
, tree
,
98 enum impl_conv
, bool, tree
, tree
, int);
99 static tree
valid_compound_expr_initializer (tree
, tree
);
100 static void push_string (const char *);
101 static void push_member_name (tree
);
102 static int spelling_length (void);
103 static char *print_spelling (char *);
104 static void warning_init (location_t
, int, const char *);
105 static tree
digest_init (location_t
, tree
, tree
, tree
, bool, bool, int);
106 static void output_init_element (location_t
, tree
, tree
, bool, tree
, tree
, int,
107 bool, struct obstack
*);
108 static void output_pending_init_elements (int, struct obstack
*);
109 static int set_designator (location_t
, int, struct obstack
*);
110 static void push_range_stack (tree
, struct obstack
*);
111 static void add_pending_init (location_t
, tree
, tree
, tree
, bool,
113 static void set_nonincremental_init (struct obstack
*);
114 static void set_nonincremental_init_from_string (tree
, struct obstack
*);
115 static tree
find_init_member (tree
, struct obstack
*);
116 static void readonly_warning (tree
, enum lvalue_use
);
117 static int lvalue_or_else (location_t
, const_tree
, enum lvalue_use
);
118 static void record_maybe_used_decl (tree
);
119 static int comptypes_internal (const_tree
, const_tree
, bool *, bool *);
121 /* Return true if EXP is a null pointer constant, false otherwise. */
124 null_pointer_constant_p (const_tree expr
)
126 /* This should really operate on c_expr structures, but they aren't
127 yet available everywhere required. */
128 tree type
= TREE_TYPE (expr
);
129 return (TREE_CODE (expr
) == INTEGER_CST
130 && !TREE_OVERFLOW (expr
)
131 && integer_zerop (expr
)
132 && (INTEGRAL_TYPE_P (type
)
133 || (TREE_CODE (type
) == POINTER_TYPE
134 && VOID_TYPE_P (TREE_TYPE (type
))
135 && TYPE_QUALS (TREE_TYPE (type
)) == TYPE_UNQUALIFIED
)));
138 /* EXPR may appear in an unevaluated part of an integer constant
139 expression, but not in an evaluated part. Wrap it in a
140 C_MAYBE_CONST_EXPR, or mark it with TREE_OVERFLOW if it is just an
141 INTEGER_CST and we cannot create a C_MAYBE_CONST_EXPR. */
144 note_integer_operands (tree expr
)
147 if (TREE_CODE (expr
) == INTEGER_CST
&& in_late_binary_op
)
149 ret
= copy_node (expr
);
150 TREE_OVERFLOW (ret
) = 1;
154 ret
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (expr
), NULL_TREE
, expr
);
155 C_MAYBE_CONST_EXPR_INT_OPERANDS (ret
) = 1;
160 /* Having checked whether EXPR may appear in an unevaluated part of an
161 integer constant expression and found that it may, remove any
162 C_MAYBE_CONST_EXPR noting this fact and return the resulting
166 remove_c_maybe_const_expr (tree expr
)
168 if (TREE_CODE (expr
) == C_MAYBE_CONST_EXPR
)
169 return C_MAYBE_CONST_EXPR_EXPR (expr
);
174 \f/* This is a cache to hold if two types are compatible or not. */
176 struct tagged_tu_seen_cache
{
177 const struct tagged_tu_seen_cache
* next
;
180 /* The return value of tagged_types_tu_compatible_p if we had seen
181 these two types already. */
185 static const struct tagged_tu_seen_cache
* tagged_tu_seen_base
;
186 static void free_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache
*);
188 /* Do `exp = require_complete_type (exp);' to make sure exp
189 does not have an incomplete type. (That includes void types.) */
192 require_complete_type (tree value
)
194 tree type
= TREE_TYPE (value
);
196 if (value
== error_mark_node
|| type
== error_mark_node
)
197 return error_mark_node
;
199 /* First, detect a valid value with a complete type. */
200 if (COMPLETE_TYPE_P (type
))
203 c_incomplete_type_error (value
, type
);
204 return error_mark_node
;
207 /* Print an error message for invalid use of an incomplete type.
208 VALUE is the expression that was used (or 0 if that isn't known)
209 and TYPE is the type that was invalid. */
212 c_incomplete_type_error (const_tree value
, const_tree type
)
214 const char *type_code_string
;
216 /* Avoid duplicate error message. */
217 if (TREE_CODE (type
) == ERROR_MARK
)
220 if (value
!= 0 && (TREE_CODE (value
) == VAR_DECL
221 || TREE_CODE (value
) == PARM_DECL
))
222 error ("%qD has an incomplete type", value
);
226 /* We must print an error message. Be clever about what it says. */
228 switch (TREE_CODE (type
))
231 type_code_string
= "struct";
235 type_code_string
= "union";
239 type_code_string
= "enum";
243 error ("invalid use of void expression");
247 if (TYPE_DOMAIN (type
))
249 if (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) == NULL
)
251 error ("invalid use of flexible array member");
254 type
= TREE_TYPE (type
);
257 error ("invalid use of array with unspecified bounds");
264 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
265 error ("invalid use of undefined type %<%s %E%>",
266 type_code_string
, TYPE_NAME (type
));
268 /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
269 error ("invalid use of incomplete typedef %qD", TYPE_NAME (type
));
273 /* Given a type, apply default promotions wrt unnamed function
274 arguments and return the new type. */
277 c_type_promotes_to (tree type
)
279 tree ret
= NULL_TREE
;
281 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
282 ret
= double_type_node
;
283 else if (c_promoting_integer_type_p (type
))
285 /* Preserve unsignedness if not really getting any wider. */
286 if (TYPE_UNSIGNED (type
)
287 && (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
)))
288 ret
= unsigned_type_node
;
290 ret
= integer_type_node
;
293 if (ret
!= NULL_TREE
)
294 return (TYPE_ATOMIC (type
)
295 ? c_build_qualified_type (ret
, TYPE_QUAL_ATOMIC
)
301 /* Return true if between two named address spaces, whether there is a superset
302 named address space that encompasses both address spaces. If there is a
303 superset, return which address space is the superset. */
306 addr_space_superset (addr_space_t as1
, addr_space_t as2
, addr_space_t
*common
)
313 else if (targetm
.addr_space
.subset_p (as1
, as2
))
318 else if (targetm
.addr_space
.subset_p (as2
, as1
))
327 /* Return a variant of TYPE which has all the type qualifiers of LIKE
328 as well as those of TYPE. */
331 qualify_type (tree type
, tree like
)
333 addr_space_t as_type
= TYPE_ADDR_SPACE (type
);
334 addr_space_t as_like
= TYPE_ADDR_SPACE (like
);
335 addr_space_t as_common
;
337 /* If the two named address spaces are different, determine the common
338 superset address space. If there isn't one, raise an error. */
339 if (!addr_space_superset (as_type
, as_like
, &as_common
))
342 error ("%qT and %qT are in disjoint named address spaces",
346 return c_build_qualified_type (type
,
347 TYPE_QUALS_NO_ADDR_SPACE (type
)
348 | TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC (like
)
349 | ENCODE_QUAL_ADDR_SPACE (as_common
));
352 /* Return true iff the given tree T is a variable length array. */
355 c_vla_type_p (const_tree t
)
357 if (TREE_CODE (t
) == ARRAY_TYPE
358 && C_TYPE_VARIABLE_SIZE (t
))
363 /* Return the composite type of two compatible types.
365 We assume that comptypes has already been done and returned
366 nonzero; if that isn't so, this may crash. In particular, we
367 assume that qualifiers match. */
370 composite_type (tree t1
, tree t2
)
372 enum tree_code code1
;
373 enum tree_code code2
;
376 /* Save time if the two types are the same. */
378 if (t1
== t2
) return t1
;
380 /* If one type is nonsense, use the other. */
381 if (t1
== error_mark_node
)
383 if (t2
== error_mark_node
)
386 code1
= TREE_CODE (t1
);
387 code2
= TREE_CODE (t2
);
389 /* Merge the attributes. */
390 attributes
= targetm
.merge_type_attributes (t1
, t2
);
392 /* If one is an enumerated type and the other is the compatible
393 integer type, the composite type might be either of the two
394 (DR#013 question 3). For consistency, use the enumerated type as
395 the composite type. */
397 if (code1
== ENUMERAL_TYPE
&& code2
== INTEGER_TYPE
)
399 if (code2
== ENUMERAL_TYPE
&& code1
== INTEGER_TYPE
)
402 gcc_assert (code1
== code2
);
407 /* For two pointers, do this recursively on the target type. */
409 tree pointed_to_1
= TREE_TYPE (t1
);
410 tree pointed_to_2
= TREE_TYPE (t2
);
411 tree target
= composite_type (pointed_to_1
, pointed_to_2
);
412 t1
= build_pointer_type_for_mode (target
, TYPE_MODE (t1
), false);
413 t1
= build_type_attribute_variant (t1
, attributes
);
414 return qualify_type (t1
, t2
);
419 tree elt
= composite_type (TREE_TYPE (t1
), TREE_TYPE (t2
));
422 tree d1
= TYPE_DOMAIN (t1
);
423 tree d2
= TYPE_DOMAIN (t2
);
424 bool d1_variable
, d2_variable
;
425 bool d1_zero
, d2_zero
;
426 bool t1_complete
, t2_complete
;
428 /* We should not have any type quals on arrays at all. */
429 gcc_assert (!TYPE_QUALS_NO_ADDR_SPACE (t1
)
430 && !TYPE_QUALS_NO_ADDR_SPACE (t2
));
432 t1_complete
= COMPLETE_TYPE_P (t1
);
433 t2_complete
= COMPLETE_TYPE_P (t2
);
435 d1_zero
= d1
== 0 || !TYPE_MAX_VALUE (d1
);
436 d2_zero
= d2
== 0 || !TYPE_MAX_VALUE (d2
);
438 d1_variable
= (!d1_zero
439 && (TREE_CODE (TYPE_MIN_VALUE (d1
)) != INTEGER_CST
440 || TREE_CODE (TYPE_MAX_VALUE (d1
)) != INTEGER_CST
));
441 d2_variable
= (!d2_zero
442 && (TREE_CODE (TYPE_MIN_VALUE (d2
)) != INTEGER_CST
443 || TREE_CODE (TYPE_MAX_VALUE (d2
)) != INTEGER_CST
));
444 d1_variable
= d1_variable
|| (d1_zero
&& c_vla_type_p (t1
));
445 d2_variable
= d2_variable
|| (d2_zero
&& c_vla_type_p (t2
));
447 /* Save space: see if the result is identical to one of the args. */
448 if (elt
== TREE_TYPE (t1
) && TYPE_DOMAIN (t1
)
449 && (d2_variable
|| d2_zero
|| !d1_variable
))
450 return build_type_attribute_variant (t1
, attributes
);
451 if (elt
== TREE_TYPE (t2
) && TYPE_DOMAIN (t2
)
452 && (d1_variable
|| d1_zero
|| !d2_variable
))
453 return build_type_attribute_variant (t2
, attributes
);
455 if (elt
== TREE_TYPE (t1
) && !TYPE_DOMAIN (t2
) && !TYPE_DOMAIN (t1
))
456 return build_type_attribute_variant (t1
, attributes
);
457 if (elt
== TREE_TYPE (t2
) && !TYPE_DOMAIN (t2
) && !TYPE_DOMAIN (t1
))
458 return build_type_attribute_variant (t2
, attributes
);
460 /* Merge the element types, and have a size if either arg has
461 one. We may have qualifiers on the element types. To set
462 up TYPE_MAIN_VARIANT correctly, we need to form the
463 composite of the unqualified types and add the qualifiers
465 quals
= TYPE_QUALS (strip_array_types (elt
));
466 unqual_elt
= c_build_qualified_type (elt
, TYPE_UNQUALIFIED
);
467 t1
= build_array_type (unqual_elt
,
468 TYPE_DOMAIN ((TYPE_DOMAIN (t1
)
474 /* Ensure a composite type involving a zero-length array type
475 is a zero-length type not an incomplete type. */
476 if (d1_zero
&& d2_zero
477 && (t1_complete
|| t2_complete
)
478 && !COMPLETE_TYPE_P (t1
))
480 TYPE_SIZE (t1
) = bitsize_zero_node
;
481 TYPE_SIZE_UNIT (t1
) = size_zero_node
;
483 t1
= c_build_qualified_type (t1
, quals
);
484 return build_type_attribute_variant (t1
, attributes
);
490 if (attributes
!= NULL
)
492 /* Try harder not to create a new aggregate type. */
493 if (attribute_list_equal (TYPE_ATTRIBUTES (t1
), attributes
))
495 if (attribute_list_equal (TYPE_ATTRIBUTES (t2
), attributes
))
498 return build_type_attribute_variant (t1
, attributes
);
501 /* Function types: prefer the one that specified arg types.
502 If both do, merge the arg types. Also merge the return types. */
504 tree valtype
= composite_type (TREE_TYPE (t1
), TREE_TYPE (t2
));
505 tree p1
= TYPE_ARG_TYPES (t1
);
506 tree p2
= TYPE_ARG_TYPES (t2
);
511 /* Save space: see if the result is identical to one of the args. */
512 if (valtype
== TREE_TYPE (t1
) && !TYPE_ARG_TYPES (t2
))
513 return build_type_attribute_variant (t1
, attributes
);
514 if (valtype
== TREE_TYPE (t2
) && !TYPE_ARG_TYPES (t1
))
515 return build_type_attribute_variant (t2
, attributes
);
517 /* Simple way if one arg fails to specify argument types. */
518 if (TYPE_ARG_TYPES (t1
) == 0)
520 t1
= build_function_type (valtype
, TYPE_ARG_TYPES (t2
));
521 t1
= build_type_attribute_variant (t1
, attributes
);
522 return qualify_type (t1
, t2
);
524 if (TYPE_ARG_TYPES (t2
) == 0)
526 t1
= build_function_type (valtype
, TYPE_ARG_TYPES (t1
));
527 t1
= build_type_attribute_variant (t1
, attributes
);
528 return qualify_type (t1
, t2
);
531 /* If both args specify argument types, we must merge the two
532 lists, argument by argument. */
534 len
= list_length (p1
);
537 for (i
= 0; i
< len
; i
++)
538 newargs
= tree_cons (NULL_TREE
, NULL_TREE
, newargs
);
543 p1
= TREE_CHAIN (p1
), p2
= TREE_CHAIN (p2
), n
= TREE_CHAIN (n
))
545 /* A null type means arg type is not specified.
546 Take whatever the other function type has. */
547 if (TREE_VALUE (p1
) == 0)
549 TREE_VALUE (n
) = TREE_VALUE (p2
);
552 if (TREE_VALUE (p2
) == 0)
554 TREE_VALUE (n
) = TREE_VALUE (p1
);
558 /* Given wait (union {union wait *u; int *i} *)
559 and wait (union wait *),
560 prefer union wait * as type of parm. */
561 if (TREE_CODE (TREE_VALUE (p1
)) == UNION_TYPE
562 && TREE_VALUE (p1
) != TREE_VALUE (p2
))
565 tree mv2
= TREE_VALUE (p2
);
566 if (mv2
&& mv2
!= error_mark_node
567 && TREE_CODE (mv2
) != ARRAY_TYPE
)
568 mv2
= TYPE_MAIN_VARIANT (mv2
);
569 for (memb
= TYPE_FIELDS (TREE_VALUE (p1
));
570 memb
; memb
= DECL_CHAIN (memb
))
572 tree mv3
= TREE_TYPE (memb
);
573 if (mv3
&& mv3
!= error_mark_node
574 && TREE_CODE (mv3
) != ARRAY_TYPE
)
575 mv3
= TYPE_MAIN_VARIANT (mv3
);
576 if (comptypes (mv3
, mv2
))
578 TREE_VALUE (n
) = composite_type (TREE_TYPE (memb
),
580 pedwarn (input_location
, OPT_Wpedantic
,
581 "function types not truly compatible in ISO C");
586 if (TREE_CODE (TREE_VALUE (p2
)) == UNION_TYPE
587 && TREE_VALUE (p2
) != TREE_VALUE (p1
))
590 tree mv1
= TREE_VALUE (p1
);
591 if (mv1
&& mv1
!= error_mark_node
592 && TREE_CODE (mv1
) != ARRAY_TYPE
)
593 mv1
= TYPE_MAIN_VARIANT (mv1
);
594 for (memb
= TYPE_FIELDS (TREE_VALUE (p2
));
595 memb
; memb
= DECL_CHAIN (memb
))
597 tree mv3
= TREE_TYPE (memb
);
598 if (mv3
&& mv3
!= error_mark_node
599 && TREE_CODE (mv3
) != ARRAY_TYPE
)
600 mv3
= TYPE_MAIN_VARIANT (mv3
);
601 if (comptypes (mv3
, mv1
))
603 TREE_VALUE (n
) = composite_type (TREE_TYPE (memb
),
605 pedwarn (input_location
, OPT_Wpedantic
,
606 "function types not truly compatible in ISO C");
611 TREE_VALUE (n
) = composite_type (TREE_VALUE (p1
), TREE_VALUE (p2
));
615 t1
= build_function_type (valtype
, newargs
);
616 t1
= qualify_type (t1
, t2
);
617 /* ... falls through ... */
621 return build_type_attribute_variant (t1
, attributes
);
626 /* Return the type of a conditional expression between pointers to
627 possibly differently qualified versions of compatible types.
629 We assume that comp_target_types has already been done and returned
630 nonzero; if that isn't so, this may crash. */
633 common_pointer_type (tree t1
, tree t2
)
636 tree pointed_to_1
, mv1
;
637 tree pointed_to_2
, mv2
;
639 unsigned target_quals
;
640 addr_space_t as1
, as2
, as_common
;
643 /* Save time if the two types are the same. */
645 if (t1
== t2
) return t1
;
647 /* If one type is nonsense, use the other. */
648 if (t1
== error_mark_node
)
650 if (t2
== error_mark_node
)
653 gcc_assert (TREE_CODE (t1
) == POINTER_TYPE
654 && TREE_CODE (t2
) == POINTER_TYPE
);
656 /* Merge the attributes. */
657 attributes
= targetm
.merge_type_attributes (t1
, t2
);
659 /* Find the composite type of the target types, and combine the
660 qualifiers of the two types' targets. Do not lose qualifiers on
661 array element types by taking the TYPE_MAIN_VARIANT. */
662 mv1
= pointed_to_1
= TREE_TYPE (t1
);
663 mv2
= pointed_to_2
= TREE_TYPE (t2
);
664 if (TREE_CODE (mv1
) != ARRAY_TYPE
)
665 mv1
= TYPE_MAIN_VARIANT (pointed_to_1
);
666 if (TREE_CODE (mv2
) != ARRAY_TYPE
)
667 mv2
= TYPE_MAIN_VARIANT (pointed_to_2
);
668 target
= composite_type (mv1
, mv2
);
670 /* For function types do not merge const qualifiers, but drop them
671 if used inconsistently. The middle-end uses these to mark const
672 and noreturn functions. */
673 quals1
= TYPE_QUALS_NO_ADDR_SPACE (pointed_to_1
);
674 quals2
= TYPE_QUALS_NO_ADDR_SPACE (pointed_to_2
);
676 if (TREE_CODE (pointed_to_1
) == FUNCTION_TYPE
)
677 target_quals
= (quals1
& quals2
);
679 target_quals
= (quals1
| quals2
);
681 /* If the two named address spaces are different, determine the common
682 superset address space. This is guaranteed to exist due to the
683 assumption that comp_target_type returned non-zero. */
684 as1
= TYPE_ADDR_SPACE (pointed_to_1
);
685 as2
= TYPE_ADDR_SPACE (pointed_to_2
);
686 if (!addr_space_superset (as1
, as2
, &as_common
))
689 target_quals
|= ENCODE_QUAL_ADDR_SPACE (as_common
);
691 t1
= build_pointer_type (c_build_qualified_type (target
, target_quals
));
692 return build_type_attribute_variant (t1
, attributes
);
695 /* Return the common type for two arithmetic types under the usual
696 arithmetic conversions. The default conversions have already been
697 applied, and enumerated types converted to their compatible integer
698 types. The resulting type is unqualified and has no attributes.
700 This is the type for the result of most arithmetic operations
701 if the operands have the given two types. */
704 c_common_type (tree t1
, tree t2
)
706 enum tree_code code1
;
707 enum tree_code code2
;
709 /* If one type is nonsense, use the other. */
710 if (t1
== error_mark_node
)
712 if (t2
== error_mark_node
)
715 if (TYPE_QUALS (t1
) != TYPE_UNQUALIFIED
)
716 t1
= TYPE_MAIN_VARIANT (t1
);
718 if (TYPE_QUALS (t2
) != TYPE_UNQUALIFIED
)
719 t2
= TYPE_MAIN_VARIANT (t2
);
721 if (TYPE_ATTRIBUTES (t1
) != NULL_TREE
)
722 t1
= build_type_attribute_variant (t1
, NULL_TREE
);
724 if (TYPE_ATTRIBUTES (t2
) != NULL_TREE
)
725 t2
= build_type_attribute_variant (t2
, NULL_TREE
);
727 /* Save time if the two types are the same. */
729 if (t1
== t2
) return t1
;
731 code1
= TREE_CODE (t1
);
732 code2
= TREE_CODE (t2
);
734 gcc_assert (code1
== VECTOR_TYPE
|| code1
== COMPLEX_TYPE
735 || code1
== FIXED_POINT_TYPE
|| code1
== REAL_TYPE
736 || code1
== INTEGER_TYPE
);
737 gcc_assert (code2
== VECTOR_TYPE
|| code2
== COMPLEX_TYPE
738 || code2
== FIXED_POINT_TYPE
|| code2
== REAL_TYPE
739 || code2
== INTEGER_TYPE
);
741 /* When one operand is a decimal float type, the other operand cannot be
742 a generic float type or a complex type. We also disallow vector types
744 if ((DECIMAL_FLOAT_TYPE_P (t1
) || DECIMAL_FLOAT_TYPE_P (t2
))
745 && !(DECIMAL_FLOAT_TYPE_P (t1
) && DECIMAL_FLOAT_TYPE_P (t2
)))
747 if (code1
== VECTOR_TYPE
|| code2
== VECTOR_TYPE
)
749 error ("can%'t mix operands of decimal float and vector types");
750 return error_mark_node
;
752 if (code1
== COMPLEX_TYPE
|| code2
== COMPLEX_TYPE
)
754 error ("can%'t mix operands of decimal float and complex types");
755 return error_mark_node
;
757 if (code1
== REAL_TYPE
&& code2
== REAL_TYPE
)
759 error ("can%'t mix operands of decimal float and other float types");
760 return error_mark_node
;
764 /* If one type is a vector type, return that type. (How the usual
765 arithmetic conversions apply to the vector types extension is not
766 precisely specified.) */
767 if (code1
== VECTOR_TYPE
)
770 if (code2
== VECTOR_TYPE
)
773 /* If one type is complex, form the common type of the non-complex
774 components, then make that complex. Use T1 or T2 if it is the
776 if (code1
== COMPLEX_TYPE
|| code2
== COMPLEX_TYPE
)
778 tree subtype1
= code1
== COMPLEX_TYPE
? TREE_TYPE (t1
) : t1
;
779 tree subtype2
= code2
== COMPLEX_TYPE
? TREE_TYPE (t2
) : t2
;
780 tree subtype
= c_common_type (subtype1
, subtype2
);
782 if (code1
== COMPLEX_TYPE
&& TREE_TYPE (t1
) == subtype
)
784 else if (code2
== COMPLEX_TYPE
&& TREE_TYPE (t2
) == subtype
)
787 return build_complex_type (subtype
);
790 /* If only one is real, use it as the result. */
792 if (code1
== REAL_TYPE
&& code2
!= REAL_TYPE
)
795 if (code2
== REAL_TYPE
&& code1
!= REAL_TYPE
)
798 /* If both are real and either are decimal floating point types, use
799 the decimal floating point type with the greater precision. */
801 if (code1
== REAL_TYPE
&& code2
== REAL_TYPE
)
803 if (TYPE_MAIN_VARIANT (t1
) == dfloat128_type_node
804 || TYPE_MAIN_VARIANT (t2
) == dfloat128_type_node
)
805 return dfloat128_type_node
;
806 else if (TYPE_MAIN_VARIANT (t1
) == dfloat64_type_node
807 || TYPE_MAIN_VARIANT (t2
) == dfloat64_type_node
)
808 return dfloat64_type_node
;
809 else if (TYPE_MAIN_VARIANT (t1
) == dfloat32_type_node
810 || TYPE_MAIN_VARIANT (t2
) == dfloat32_type_node
)
811 return dfloat32_type_node
;
814 /* Deal with fixed-point types. */
815 if (code1
== FIXED_POINT_TYPE
|| code2
== FIXED_POINT_TYPE
)
817 unsigned int unsignedp
= 0, satp
= 0;
818 enum machine_mode m1
, m2
;
819 unsigned int fbit1
, ibit1
, fbit2
, ibit2
, max_fbit
, max_ibit
;
824 /* If one input type is saturating, the result type is saturating. */
825 if (TYPE_SATURATING (t1
) || TYPE_SATURATING (t2
))
828 /* If both fixed-point types are unsigned, the result type is unsigned.
829 When mixing fixed-point and integer types, follow the sign of the
831 Otherwise, the result type is signed. */
832 if ((TYPE_UNSIGNED (t1
) && TYPE_UNSIGNED (t2
)
833 && code1
== FIXED_POINT_TYPE
&& code2
== FIXED_POINT_TYPE
)
834 || (code1
== FIXED_POINT_TYPE
&& code2
!= FIXED_POINT_TYPE
835 && TYPE_UNSIGNED (t1
))
836 || (code1
!= FIXED_POINT_TYPE
&& code2
== FIXED_POINT_TYPE
837 && TYPE_UNSIGNED (t2
)))
840 /* The result type is signed. */
843 /* If the input type is unsigned, we need to convert to the
845 if (code1
== FIXED_POINT_TYPE
&& TYPE_UNSIGNED (t1
))
847 enum mode_class mclass
= (enum mode_class
) 0;
848 if (GET_MODE_CLASS (m1
) == MODE_UFRACT
)
850 else if (GET_MODE_CLASS (m1
) == MODE_UACCUM
)
854 m1
= mode_for_size (GET_MODE_PRECISION (m1
), mclass
, 0);
856 if (code2
== FIXED_POINT_TYPE
&& TYPE_UNSIGNED (t2
))
858 enum mode_class mclass
= (enum mode_class
) 0;
859 if (GET_MODE_CLASS (m2
) == MODE_UFRACT
)
861 else if (GET_MODE_CLASS (m2
) == MODE_UACCUM
)
865 m2
= mode_for_size (GET_MODE_PRECISION (m2
), mclass
, 0);
869 if (code1
== FIXED_POINT_TYPE
)
871 fbit1
= GET_MODE_FBIT (m1
);
872 ibit1
= GET_MODE_IBIT (m1
);
877 /* Signed integers need to subtract one sign bit. */
878 ibit1
= TYPE_PRECISION (t1
) - (!TYPE_UNSIGNED (t1
));
881 if (code2
== FIXED_POINT_TYPE
)
883 fbit2
= GET_MODE_FBIT (m2
);
884 ibit2
= GET_MODE_IBIT (m2
);
889 /* Signed integers need to subtract one sign bit. */
890 ibit2
= TYPE_PRECISION (t2
) - (!TYPE_UNSIGNED (t2
));
893 max_ibit
= ibit1
>= ibit2
? ibit1
: ibit2
;
894 max_fbit
= fbit1
>= fbit2
? fbit1
: fbit2
;
895 return c_common_fixed_point_type_for_size (max_ibit
, max_fbit
, unsignedp
,
899 /* Both real or both integers; use the one with greater precision. */
901 if (TYPE_PRECISION (t1
) > TYPE_PRECISION (t2
))
903 else if (TYPE_PRECISION (t2
) > TYPE_PRECISION (t1
))
906 /* Same precision. Prefer long longs to longs to ints when the
907 same precision, following the C99 rules on integer type rank
908 (which are equivalent to the C90 rules for C90 types). */
910 if (TYPE_MAIN_VARIANT (t1
) == long_long_unsigned_type_node
911 || TYPE_MAIN_VARIANT (t2
) == long_long_unsigned_type_node
)
912 return long_long_unsigned_type_node
;
914 if (TYPE_MAIN_VARIANT (t1
) == long_long_integer_type_node
915 || TYPE_MAIN_VARIANT (t2
) == long_long_integer_type_node
)
917 if (TYPE_UNSIGNED (t1
) || TYPE_UNSIGNED (t2
))
918 return long_long_unsigned_type_node
;
920 return long_long_integer_type_node
;
923 if (TYPE_MAIN_VARIANT (t1
) == long_unsigned_type_node
924 || TYPE_MAIN_VARIANT (t2
) == long_unsigned_type_node
)
925 return long_unsigned_type_node
;
927 if (TYPE_MAIN_VARIANT (t1
) == long_integer_type_node
928 || TYPE_MAIN_VARIANT (t2
) == long_integer_type_node
)
930 /* But preserve unsignedness from the other type,
931 since long cannot hold all the values of an unsigned int. */
932 if (TYPE_UNSIGNED (t1
) || TYPE_UNSIGNED (t2
))
933 return long_unsigned_type_node
;
935 return long_integer_type_node
;
938 /* Likewise, prefer long double to double even if same size. */
939 if (TYPE_MAIN_VARIANT (t1
) == long_double_type_node
940 || TYPE_MAIN_VARIANT (t2
) == long_double_type_node
)
941 return long_double_type_node
;
943 /* Likewise, prefer double to float even if same size.
944 We got a couple of embedded targets with 32 bit doubles, and the
945 pdp11 might have 64 bit floats. */
946 if (TYPE_MAIN_VARIANT (t1
) == double_type_node
947 || TYPE_MAIN_VARIANT (t2
) == double_type_node
)
948 return double_type_node
;
950 /* Otherwise prefer the unsigned one. */
952 if (TYPE_UNSIGNED (t1
))
958 /* Wrapper around c_common_type that is used by c-common.c and other
959 front end optimizations that remove promotions. ENUMERAL_TYPEs
960 are allowed here and are converted to their compatible integer types.
961 BOOLEAN_TYPEs are allowed here and return either boolean_type_node or
962 preferably a non-Boolean type as the common type. */
964 common_type (tree t1
, tree t2
)
966 if (TREE_CODE (t1
) == ENUMERAL_TYPE
)
967 t1
= c_common_type_for_size (TYPE_PRECISION (t1
), 1);
968 if (TREE_CODE (t2
) == ENUMERAL_TYPE
)
969 t2
= c_common_type_for_size (TYPE_PRECISION (t2
), 1);
971 /* If both types are BOOLEAN_TYPE, then return boolean_type_node. */
972 if (TREE_CODE (t1
) == BOOLEAN_TYPE
973 && TREE_CODE (t2
) == BOOLEAN_TYPE
)
974 return boolean_type_node
;
976 /* If either type is BOOLEAN_TYPE, then return the other. */
977 if (TREE_CODE (t1
) == BOOLEAN_TYPE
)
979 if (TREE_CODE (t2
) == BOOLEAN_TYPE
)
982 return c_common_type (t1
, t2
);
985 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
986 or various other operations. Return 2 if they are compatible
987 but a warning may be needed if you use them together. */
990 comptypes (tree type1
, tree type2
)
992 const struct tagged_tu_seen_cache
* tagged_tu_seen_base1
= tagged_tu_seen_base
;
995 val
= comptypes_internal (type1
, type2
, NULL
, NULL
);
996 free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1
);
1001 /* Like comptypes, but if it returns non-zero because enum and int are
1002 compatible, it sets *ENUM_AND_INT_P to true. */
1005 comptypes_check_enum_int (tree type1
, tree type2
, bool *enum_and_int_p
)
1007 const struct tagged_tu_seen_cache
* tagged_tu_seen_base1
= tagged_tu_seen_base
;
1010 val
= comptypes_internal (type1
, type2
, enum_and_int_p
, NULL
);
1011 free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1
);
1016 /* Like comptypes, but if it returns nonzero for different types, it
1017 sets *DIFFERENT_TYPES_P to true. */
1020 comptypes_check_different_types (tree type1
, tree type2
,
1021 bool *different_types_p
)
1023 const struct tagged_tu_seen_cache
* tagged_tu_seen_base1
= tagged_tu_seen_base
;
1026 val
= comptypes_internal (type1
, type2
, NULL
, different_types_p
);
1027 free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1
);
1032 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
1033 or various other operations. Return 2 if they are compatible
1034 but a warning may be needed if you use them together. If
1035 ENUM_AND_INT_P is not NULL, and one type is an enum and the other a
1036 compatible integer type, then this sets *ENUM_AND_INT_P to true;
1037 *ENUM_AND_INT_P is never set to false. If DIFFERENT_TYPES_P is not
1038 NULL, and the types are compatible but different enough not to be
1039 permitted in C11 typedef redeclarations, then this sets
1040 *DIFFERENT_TYPES_P to true; *DIFFERENT_TYPES_P is never set to
1041 false, but may or may not be set if the types are incompatible.
1042 This differs from comptypes, in that we don't free the seen
1046 comptypes_internal (const_tree type1
, const_tree type2
, bool *enum_and_int_p
,
1047 bool *different_types_p
)
1049 const_tree t1
= type1
;
1050 const_tree t2
= type2
;
1053 /* Suppress errors caused by previously reported errors. */
1055 if (t1
== t2
|| !t1
|| !t2
1056 || TREE_CODE (t1
) == ERROR_MARK
|| TREE_CODE (t2
) == ERROR_MARK
)
1059 /* Enumerated types are compatible with integer types, but this is
1060 not transitive: two enumerated types in the same translation unit
1061 are compatible with each other only if they are the same type. */
1063 if (TREE_CODE (t1
) == ENUMERAL_TYPE
&& TREE_CODE (t2
) != ENUMERAL_TYPE
)
1065 t1
= c_common_type_for_size (TYPE_PRECISION (t1
), TYPE_UNSIGNED (t1
));
1066 if (TREE_CODE (t2
) != VOID_TYPE
)
1068 if (enum_and_int_p
!= NULL
)
1069 *enum_and_int_p
= true;
1070 if (different_types_p
!= NULL
)
1071 *different_types_p
= true;
1074 else if (TREE_CODE (t2
) == ENUMERAL_TYPE
&& TREE_CODE (t1
) != ENUMERAL_TYPE
)
1076 t2
= c_common_type_for_size (TYPE_PRECISION (t2
), TYPE_UNSIGNED (t2
));
1077 if (TREE_CODE (t1
) != VOID_TYPE
)
1079 if (enum_and_int_p
!= NULL
)
1080 *enum_and_int_p
= true;
1081 if (different_types_p
!= NULL
)
1082 *different_types_p
= true;
1089 /* Different classes of types can't be compatible. */
1091 if (TREE_CODE (t1
) != TREE_CODE (t2
))
1094 /* Qualifiers must match. C99 6.7.3p9 */
1096 if (TYPE_QUALS (t1
) != TYPE_QUALS (t2
))
1099 /* Allow for two different type nodes which have essentially the same
1100 definition. Note that we already checked for equality of the type
1101 qualifiers (just above). */
1103 if (TREE_CODE (t1
) != ARRAY_TYPE
1104 && TYPE_MAIN_VARIANT (t1
) == TYPE_MAIN_VARIANT (t2
))
1107 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1108 if (!(attrval
= comp_type_attributes (t1
, t2
)))
1111 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1114 switch (TREE_CODE (t1
))
1117 /* Do not remove mode or aliasing information. */
1118 if (TYPE_MODE (t1
) != TYPE_MODE (t2
)
1119 || TYPE_REF_CAN_ALIAS_ALL (t1
) != TYPE_REF_CAN_ALIAS_ALL (t2
))
1121 val
= (TREE_TYPE (t1
) == TREE_TYPE (t2
)
1122 ? 1 : comptypes_internal (TREE_TYPE (t1
), TREE_TYPE (t2
),
1123 enum_and_int_p
, different_types_p
));
1127 val
= function_types_compatible_p (t1
, t2
, enum_and_int_p
,
1133 tree d1
= TYPE_DOMAIN (t1
);
1134 tree d2
= TYPE_DOMAIN (t2
);
1135 bool d1_variable
, d2_variable
;
1136 bool d1_zero
, d2_zero
;
1139 /* Target types must match incl. qualifiers. */
1140 if (TREE_TYPE (t1
) != TREE_TYPE (t2
)
1141 && 0 == (val
= comptypes_internal (TREE_TYPE (t1
), TREE_TYPE (t2
),
1143 different_types_p
)))
1146 if (different_types_p
!= NULL
1147 && (d1
== 0) != (d2
== 0))
1148 *different_types_p
= true;
1149 /* Sizes must match unless one is missing or variable. */
1150 if (d1
== 0 || d2
== 0 || d1
== d2
)
1153 d1_zero
= !TYPE_MAX_VALUE (d1
);
1154 d2_zero
= !TYPE_MAX_VALUE (d2
);
1156 d1_variable
= (!d1_zero
1157 && (TREE_CODE (TYPE_MIN_VALUE (d1
)) != INTEGER_CST
1158 || TREE_CODE (TYPE_MAX_VALUE (d1
)) != INTEGER_CST
));
1159 d2_variable
= (!d2_zero
1160 && (TREE_CODE (TYPE_MIN_VALUE (d2
)) != INTEGER_CST
1161 || TREE_CODE (TYPE_MAX_VALUE (d2
)) != INTEGER_CST
));
1162 d1_variable
= d1_variable
|| (d1_zero
&& c_vla_type_p (t1
));
1163 d2_variable
= d2_variable
|| (d2_zero
&& c_vla_type_p (t2
));
1165 if (different_types_p
!= NULL
1166 && d1_variable
!= d2_variable
)
1167 *different_types_p
= true;
1168 if (d1_variable
|| d2_variable
)
1170 if (d1_zero
&& d2_zero
)
1172 if (d1_zero
|| d2_zero
1173 || !tree_int_cst_equal (TYPE_MIN_VALUE (d1
), TYPE_MIN_VALUE (d2
))
1174 || !tree_int_cst_equal (TYPE_MAX_VALUE (d1
), TYPE_MAX_VALUE (d2
)))
1183 if (val
!= 1 && !same_translation_unit_p (t1
, t2
))
1185 tree a1
= TYPE_ATTRIBUTES (t1
);
1186 tree a2
= TYPE_ATTRIBUTES (t2
);
1188 if (! attribute_list_contained (a1
, a2
)
1189 && ! attribute_list_contained (a2
, a1
))
1193 return tagged_types_tu_compatible_p (t1
, t2
, enum_and_int_p
,
1195 val
= tagged_types_tu_compatible_p (t1
, t2
, enum_and_int_p
,
1201 val
= (TYPE_VECTOR_SUBPARTS (t1
) == TYPE_VECTOR_SUBPARTS (t2
)
1202 && comptypes_internal (TREE_TYPE (t1
), TREE_TYPE (t2
),
1203 enum_and_int_p
, different_types_p
));
1209 return attrval
== 2 && val
== 1 ? 2 : val
;
1212 /* Return 1 if TTL and TTR are pointers to types that are equivalent, ignoring
1213 their qualifiers, except for named address spaces. If the pointers point to
1214 different named addresses, then we must determine if one address space is a
1215 subset of the other. */
1218 comp_target_types (location_t location
, tree ttl
, tree ttr
)
1221 tree mvl
= TREE_TYPE (ttl
);
1222 tree mvr
= TREE_TYPE (ttr
);
1223 addr_space_t asl
= TYPE_ADDR_SPACE (mvl
);
1224 addr_space_t asr
= TYPE_ADDR_SPACE (mvr
);
1225 addr_space_t as_common
;
1226 bool enum_and_int_p
;
1228 /* Fail if pointers point to incompatible address spaces. */
1229 if (!addr_space_superset (asl
, asr
, &as_common
))
1232 /* Do not lose qualifiers on element types of array types that are
1233 pointer targets by taking their TYPE_MAIN_VARIANT. */
1234 if (TREE_CODE (mvl
) != ARRAY_TYPE
)
1235 mvl
= (TYPE_ATOMIC (mvl
)
1236 ? c_build_qualified_type (TYPE_MAIN_VARIANT (mvl
), TYPE_QUAL_ATOMIC
)
1237 : TYPE_MAIN_VARIANT (mvl
));
1238 if (TREE_CODE (mvr
) != ARRAY_TYPE
)
1239 mvr
= (TYPE_ATOMIC (mvr
)
1240 ? c_build_qualified_type (TYPE_MAIN_VARIANT (mvr
), TYPE_QUAL_ATOMIC
)
1241 : TYPE_MAIN_VARIANT (mvr
));
1242 enum_and_int_p
= false;
1243 val
= comptypes_check_enum_int (mvl
, mvr
, &enum_and_int_p
);
1246 pedwarn (location
, OPT_Wpedantic
, "types are not quite compatible");
1248 if (val
== 1 && enum_and_int_p
&& warn_cxx_compat
)
1249 warning_at (location
, OPT_Wc___compat
,
1250 "pointer target types incompatible in C++");
1255 /* Subroutines of `comptypes'. */
1257 /* Determine whether two trees derive from the same translation unit.
1258 If the CONTEXT chain ends in a null, that tree's context is still
1259 being parsed, so if two trees have context chains ending in null,
1260 they're in the same translation unit. */
1262 same_translation_unit_p (const_tree t1
, const_tree t2
)
1264 while (t1
&& TREE_CODE (t1
) != TRANSLATION_UNIT_DECL
)
1265 switch (TREE_CODE_CLASS (TREE_CODE (t1
)))
1267 case tcc_declaration
:
1268 t1
= DECL_CONTEXT (t1
); break;
1270 t1
= TYPE_CONTEXT (t1
); break;
1271 case tcc_exceptional
:
1272 t1
= BLOCK_SUPERCONTEXT (t1
); break; /* assume block */
1273 default: gcc_unreachable ();
1276 while (t2
&& TREE_CODE (t2
) != TRANSLATION_UNIT_DECL
)
1277 switch (TREE_CODE_CLASS (TREE_CODE (t2
)))
1279 case tcc_declaration
:
1280 t2
= DECL_CONTEXT (t2
); break;
1282 t2
= TYPE_CONTEXT (t2
); break;
1283 case tcc_exceptional
:
1284 t2
= BLOCK_SUPERCONTEXT (t2
); break; /* assume block */
1285 default: gcc_unreachable ();
1291 /* Allocate the seen two types, assuming that they are compatible. */
1293 static struct tagged_tu_seen_cache
*
1294 alloc_tagged_tu_seen_cache (const_tree t1
, const_tree t2
)
1296 struct tagged_tu_seen_cache
*tu
= XNEW (struct tagged_tu_seen_cache
);
1297 tu
->next
= tagged_tu_seen_base
;
1301 tagged_tu_seen_base
= tu
;
1303 /* The C standard says that two structures in different translation
1304 units are compatible with each other only if the types of their
1305 fields are compatible (among other things). We assume that they
1306 are compatible until proven otherwise when building the cache.
1307 An example where this can occur is:
1312 If we are comparing this against a similar struct in another TU,
1313 and did not assume they were compatible, we end up with an infinite
1319 /* Free the seen types until we get to TU_TIL. */
1322 free_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache
*tu_til
)
1324 const struct tagged_tu_seen_cache
*tu
= tagged_tu_seen_base
;
1325 while (tu
!= tu_til
)
1327 const struct tagged_tu_seen_cache
*const tu1
1328 = (const struct tagged_tu_seen_cache
*) tu
;
1330 free (CONST_CAST (struct tagged_tu_seen_cache
*, tu1
));
1332 tagged_tu_seen_base
= tu_til
;
1335 /* Return 1 if two 'struct', 'union', or 'enum' types T1 and T2 are
1336 compatible. If the two types are not the same (which has been
1337 checked earlier), this can only happen when multiple translation
1338 units are being compiled. See C99 6.2.7 paragraph 1 for the exact
1339 rules. ENUM_AND_INT_P and DIFFERENT_TYPES_P are as in
1340 comptypes_internal. */
1343 tagged_types_tu_compatible_p (const_tree t1
, const_tree t2
,
1344 bool *enum_and_int_p
, bool *different_types_p
)
1347 bool needs_warning
= false;
1349 /* We have to verify that the tags of the types are the same. This
1350 is harder than it looks because this may be a typedef, so we have
1351 to go look at the original type. It may even be a typedef of a
1353 In the case of compiler-created builtin structs the TYPE_DECL
1354 may be a dummy, with no DECL_ORIGINAL_TYPE. Don't fault. */
1355 while (TYPE_NAME (t1
)
1356 && TREE_CODE (TYPE_NAME (t1
)) == TYPE_DECL
1357 && DECL_ORIGINAL_TYPE (TYPE_NAME (t1
)))
1358 t1
= DECL_ORIGINAL_TYPE (TYPE_NAME (t1
));
1360 while (TYPE_NAME (t2
)
1361 && TREE_CODE (TYPE_NAME (t2
)) == TYPE_DECL
1362 && DECL_ORIGINAL_TYPE (TYPE_NAME (t2
)))
1363 t2
= DECL_ORIGINAL_TYPE (TYPE_NAME (t2
));
1365 /* C90 didn't have the requirement that the two tags be the same. */
1366 if (flag_isoc99
&& TYPE_NAME (t1
) != TYPE_NAME (t2
))
1369 /* C90 didn't say what happened if one or both of the types were
1370 incomplete; we choose to follow C99 rules here, which is that they
1372 if (TYPE_SIZE (t1
) == NULL
1373 || TYPE_SIZE (t2
) == NULL
)
1377 const struct tagged_tu_seen_cache
* tts_i
;
1378 for (tts_i
= tagged_tu_seen_base
; tts_i
!= NULL
; tts_i
= tts_i
->next
)
1379 if (tts_i
->t1
== t1
&& tts_i
->t2
== t2
)
1383 switch (TREE_CODE (t1
))
1387 struct tagged_tu_seen_cache
*tu
= alloc_tagged_tu_seen_cache (t1
, t2
);
1388 /* Speed up the case where the type values are in the same order. */
1389 tree tv1
= TYPE_VALUES (t1
);
1390 tree tv2
= TYPE_VALUES (t2
);
1397 for (;tv1
&& tv2
; tv1
= TREE_CHAIN (tv1
), tv2
= TREE_CHAIN (tv2
))
1399 if (TREE_PURPOSE (tv1
) != TREE_PURPOSE (tv2
))
1401 if (simple_cst_equal (TREE_VALUE (tv1
), TREE_VALUE (tv2
)) != 1)
1408 if (tv1
== NULL_TREE
&& tv2
== NULL_TREE
)
1412 if (tv1
== NULL_TREE
|| tv2
== NULL_TREE
)
1418 if (list_length (TYPE_VALUES (t1
)) != list_length (TYPE_VALUES (t2
)))
1424 for (s1
= TYPE_VALUES (t1
); s1
; s1
= TREE_CHAIN (s1
))
1426 s2
= purpose_member (TREE_PURPOSE (s1
), TYPE_VALUES (t2
));
1428 || simple_cst_equal (TREE_VALUE (s1
), TREE_VALUE (s2
)) != 1)
1439 struct tagged_tu_seen_cache
*tu
= alloc_tagged_tu_seen_cache (t1
, t2
);
1440 if (list_length (TYPE_FIELDS (t1
)) != list_length (TYPE_FIELDS (t2
)))
1446 /* Speed up the common case where the fields are in the same order. */
1447 for (s1
= TYPE_FIELDS (t1
), s2
= TYPE_FIELDS (t2
); s1
&& s2
;
1448 s1
= DECL_CHAIN (s1
), s2
= DECL_CHAIN (s2
))
1452 if (DECL_NAME (s1
) != DECL_NAME (s2
))
1454 result
= comptypes_internal (TREE_TYPE (s1
), TREE_TYPE (s2
),
1455 enum_and_int_p
, different_types_p
);
1457 if (result
!= 1 && !DECL_NAME (s1
))
1465 needs_warning
= true;
1467 if (TREE_CODE (s1
) == FIELD_DECL
1468 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1
),
1469 DECL_FIELD_BIT_OFFSET (s2
)) != 1)
1477 tu
->val
= needs_warning
? 2 : 1;
1481 for (s1
= TYPE_FIELDS (t1
); s1
; s1
= DECL_CHAIN (s1
))
1485 for (s2
= TYPE_FIELDS (t2
); s2
; s2
= DECL_CHAIN (s2
))
1486 if (DECL_NAME (s1
) == DECL_NAME (s2
))
1490 result
= comptypes_internal (TREE_TYPE (s1
), TREE_TYPE (s2
),
1494 if (result
!= 1 && !DECL_NAME (s1
))
1502 needs_warning
= true;
1504 if (TREE_CODE (s1
) == FIELD_DECL
1505 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1
),
1506 DECL_FIELD_BIT_OFFSET (s2
)) != 1)
1518 tu
->val
= needs_warning
? 2 : 10;
1524 struct tagged_tu_seen_cache
*tu
= alloc_tagged_tu_seen_cache (t1
, t2
);
1526 for (s1
= TYPE_FIELDS (t1
), s2
= TYPE_FIELDS (t2
);
1528 s1
= DECL_CHAIN (s1
), s2
= DECL_CHAIN (s2
))
1531 if (TREE_CODE (s1
) != TREE_CODE (s2
)
1532 || DECL_NAME (s1
) != DECL_NAME (s2
))
1534 result
= comptypes_internal (TREE_TYPE (s1
), TREE_TYPE (s2
),
1535 enum_and_int_p
, different_types_p
);
1539 needs_warning
= true;
1541 if (TREE_CODE (s1
) == FIELD_DECL
1542 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1
),
1543 DECL_FIELD_BIT_OFFSET (s2
)) != 1)
1549 tu
->val
= needs_warning
? 2 : 1;
1558 /* Return 1 if two function types F1 and F2 are compatible.
1559 If either type specifies no argument types,
1560 the other must specify a fixed number of self-promoting arg types.
1561 Otherwise, if one type specifies only the number of arguments,
1562 the other must specify that number of self-promoting arg types.
1563 Otherwise, the argument types must match.
1564 ENUM_AND_INT_P and DIFFERENT_TYPES_P are as in comptypes_internal. */
1567 function_types_compatible_p (const_tree f1
, const_tree f2
,
1568 bool *enum_and_int_p
, bool *different_types_p
)
1571 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1576 ret1
= TREE_TYPE (f1
);
1577 ret2
= TREE_TYPE (f2
);
1579 /* 'volatile' qualifiers on a function's return type used to mean
1580 the function is noreturn. */
1581 if (TYPE_VOLATILE (ret1
) != TYPE_VOLATILE (ret2
))
1582 pedwarn (input_location
, 0, "function return types not compatible due to %<volatile%>");
1583 if (TYPE_VOLATILE (ret1
))
1584 ret1
= build_qualified_type (TYPE_MAIN_VARIANT (ret1
),
1585 TYPE_QUALS (ret1
) & ~TYPE_QUAL_VOLATILE
);
1586 if (TYPE_VOLATILE (ret2
))
1587 ret2
= build_qualified_type (TYPE_MAIN_VARIANT (ret2
),
1588 TYPE_QUALS (ret2
) & ~TYPE_QUAL_VOLATILE
);
1589 val
= comptypes_internal (ret1
, ret2
, enum_and_int_p
, different_types_p
);
1593 args1
= TYPE_ARG_TYPES (f1
);
1594 args2
= TYPE_ARG_TYPES (f2
);
1596 if (different_types_p
!= NULL
1597 && (args1
== 0) != (args2
== 0))
1598 *different_types_p
= true;
1600 /* An unspecified parmlist matches any specified parmlist
1601 whose argument types don't need default promotions. */
1605 if (!self_promoting_args_p (args2
))
1607 /* If one of these types comes from a non-prototype fn definition,
1608 compare that with the other type's arglist.
1609 If they don't match, ask for a warning (but no error). */
1610 if (TYPE_ACTUAL_ARG_TYPES (f1
)
1611 && 1 != type_lists_compatible_p (args2
, TYPE_ACTUAL_ARG_TYPES (f1
),
1612 enum_and_int_p
, different_types_p
))
1618 if (!self_promoting_args_p (args1
))
1620 if (TYPE_ACTUAL_ARG_TYPES (f2
)
1621 && 1 != type_lists_compatible_p (args1
, TYPE_ACTUAL_ARG_TYPES (f2
),
1622 enum_and_int_p
, different_types_p
))
1627 /* Both types have argument lists: compare them and propagate results. */
1628 val1
= type_lists_compatible_p (args1
, args2
, enum_and_int_p
,
1630 return val1
!= 1 ? val1
: val
;
1633 /* Check two lists of types for compatibility, returning 0 for
1634 incompatible, 1 for compatible, or 2 for compatible with
1635 warning. ENUM_AND_INT_P and DIFFERENT_TYPES_P are as in
1636 comptypes_internal. */
1639 type_lists_compatible_p (const_tree args1
, const_tree args2
,
1640 bool *enum_and_int_p
, bool *different_types_p
)
1642 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1648 tree a1
, mv1
, a2
, mv2
;
1649 if (args1
== 0 && args2
== 0)
1651 /* If one list is shorter than the other,
1652 they fail to match. */
1653 if (args1
== 0 || args2
== 0)
1655 mv1
= a1
= TREE_VALUE (args1
);
1656 mv2
= a2
= TREE_VALUE (args2
);
1657 if (mv1
&& mv1
!= error_mark_node
&& TREE_CODE (mv1
) != ARRAY_TYPE
)
1658 mv1
= (TYPE_ATOMIC (mv1
)
1659 ? c_build_qualified_type (TYPE_MAIN_VARIANT (mv1
),
1661 : TYPE_MAIN_VARIANT (mv1
));
1662 if (mv2
&& mv2
!= error_mark_node
&& TREE_CODE (mv2
) != ARRAY_TYPE
)
1663 mv2
= (TYPE_ATOMIC (mv2
)
1664 ? c_build_qualified_type (TYPE_MAIN_VARIANT (mv2
),
1666 : TYPE_MAIN_VARIANT (mv2
));
1667 /* A null pointer instead of a type
1668 means there is supposed to be an argument
1669 but nothing is specified about what type it has.
1670 So match anything that self-promotes. */
1671 if (different_types_p
!= NULL
1672 && (a1
== 0) != (a2
== 0))
1673 *different_types_p
= true;
1676 if (c_type_promotes_to (a2
) != a2
)
1681 if (c_type_promotes_to (a1
) != a1
)
1684 /* If one of the lists has an error marker, ignore this arg. */
1685 else if (TREE_CODE (a1
) == ERROR_MARK
1686 || TREE_CODE (a2
) == ERROR_MARK
)
1688 else if (!(newval
= comptypes_internal (mv1
, mv2
, enum_and_int_p
,
1689 different_types_p
)))
1691 if (different_types_p
!= NULL
)
1692 *different_types_p
= true;
1693 /* Allow wait (union {union wait *u; int *i} *)
1694 and wait (union wait *) to be compatible. */
1695 if (TREE_CODE (a1
) == UNION_TYPE
1696 && (TYPE_NAME (a1
) == 0
1697 || TYPE_TRANSPARENT_AGGR (a1
))
1698 && TREE_CODE (TYPE_SIZE (a1
)) == INTEGER_CST
1699 && tree_int_cst_equal (TYPE_SIZE (a1
),
1703 for (memb
= TYPE_FIELDS (a1
);
1704 memb
; memb
= DECL_CHAIN (memb
))
1706 tree mv3
= TREE_TYPE (memb
);
1707 if (mv3
&& mv3
!= error_mark_node
1708 && TREE_CODE (mv3
) != ARRAY_TYPE
)
1709 mv3
= (TYPE_ATOMIC (mv3
)
1710 ? c_build_qualified_type (TYPE_MAIN_VARIANT (mv3
),
1712 : TYPE_MAIN_VARIANT (mv3
));
1713 if (comptypes_internal (mv3
, mv2
, enum_and_int_p
,
1720 else if (TREE_CODE (a2
) == UNION_TYPE
1721 && (TYPE_NAME (a2
) == 0
1722 || TYPE_TRANSPARENT_AGGR (a2
))
1723 && TREE_CODE (TYPE_SIZE (a2
)) == INTEGER_CST
1724 && tree_int_cst_equal (TYPE_SIZE (a2
),
1728 for (memb
= TYPE_FIELDS (a2
);
1729 memb
; memb
= DECL_CHAIN (memb
))
1731 tree mv3
= TREE_TYPE (memb
);
1732 if (mv3
&& mv3
!= error_mark_node
1733 && TREE_CODE (mv3
) != ARRAY_TYPE
)
1734 mv3
= (TYPE_ATOMIC (mv3
)
1735 ? c_build_qualified_type (TYPE_MAIN_VARIANT (mv3
),
1737 : TYPE_MAIN_VARIANT (mv3
));
1738 if (comptypes_internal (mv3
, mv1
, enum_and_int_p
,
1749 /* comptypes said ok, but record if it said to warn. */
1753 args1
= TREE_CHAIN (args1
);
1754 args2
= TREE_CHAIN (args2
);
1758 /* Compute the size to increment a pointer by. When a function type or void
1759 type or incomplete type is passed, size_one_node is returned.
1760 This function does not emit any diagnostics; the caller is responsible
1764 c_size_in_bytes (const_tree type
)
1766 enum tree_code code
= TREE_CODE (type
);
1768 if (code
== FUNCTION_TYPE
|| code
== VOID_TYPE
|| code
== ERROR_MARK
1769 || !COMPLETE_TYPE_P (type
))
1770 return size_one_node
;
1772 /* Convert in case a char is more than one unit. */
1773 return size_binop_loc (input_location
, CEIL_DIV_EXPR
, TYPE_SIZE_UNIT (type
),
1774 size_int (TYPE_PRECISION (char_type_node
)
1778 /* Return either DECL or its known constant value (if it has one). */
1781 decl_constant_value (tree decl
)
1783 if (/* Don't change a variable array bound or initial value to a constant
1784 in a place where a variable is invalid. Note that DECL_INITIAL
1785 isn't valid for a PARM_DECL. */
1786 current_function_decl
!= 0
1787 && TREE_CODE (decl
) != PARM_DECL
1788 && !TREE_THIS_VOLATILE (decl
)
1789 && TREE_READONLY (decl
)
1790 && DECL_INITIAL (decl
) != 0
1791 && TREE_CODE (DECL_INITIAL (decl
)) != ERROR_MARK
1792 /* This is invalid if initial value is not constant.
1793 If it has either a function call, a memory reference,
1794 or a variable, then re-evaluating it could give different results. */
1795 && TREE_CONSTANT (DECL_INITIAL (decl
))
1796 /* Check for cases where this is sub-optimal, even though valid. */
1797 && TREE_CODE (DECL_INITIAL (decl
)) != CONSTRUCTOR
)
1798 return DECL_INITIAL (decl
);
1802 /* Convert the array expression EXP to a pointer. */
1804 array_to_pointer_conversion (location_t loc
, tree exp
)
1806 tree orig_exp
= exp
;
1807 tree type
= TREE_TYPE (exp
);
1809 tree restype
= TREE_TYPE (type
);
1812 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
1814 STRIP_TYPE_NOPS (exp
);
1816 if (TREE_NO_WARNING (orig_exp
))
1817 TREE_NO_WARNING (exp
) = 1;
1819 ptrtype
= build_pointer_type (restype
);
1821 if (TREE_CODE (exp
) == INDIRECT_REF
)
1822 return convert (ptrtype
, TREE_OPERAND (exp
, 0));
1824 /* In C++ array compound literals are temporary objects unless they are
1825 const or appear in namespace scope, so they are destroyed too soon
1826 to use them for much of anything (c++/53220). */
1827 if (warn_cxx_compat
&& TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
)
1829 tree decl
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
1830 if (!TREE_READONLY (decl
) && !TREE_STATIC (decl
))
1831 warning_at (DECL_SOURCE_LOCATION (decl
), OPT_Wc___compat
,
1832 "converting an array compound literal to a pointer "
1833 "is ill-formed in C++");
1836 adr
= build_unary_op (loc
, ADDR_EXPR
, exp
, 1);
1837 return convert (ptrtype
, adr
);
1840 /* Convert the function expression EXP to a pointer. */
1842 function_to_pointer_conversion (location_t loc
, tree exp
)
1844 tree orig_exp
= exp
;
1846 gcc_assert (TREE_CODE (TREE_TYPE (exp
)) == FUNCTION_TYPE
);
1848 STRIP_TYPE_NOPS (exp
);
1850 if (TREE_NO_WARNING (orig_exp
))
1851 TREE_NO_WARNING (exp
) = 1;
1853 return build_unary_op (loc
, ADDR_EXPR
, exp
, 0);
1856 /* Mark EXP as read, not just set, for set but not used -Wunused
1857 warning purposes. */
1860 mark_exp_read (tree exp
)
1862 switch (TREE_CODE (exp
))
1866 DECL_READ_P (exp
) = 1;
1875 mark_exp_read (TREE_OPERAND (exp
, 0));
1878 case C_MAYBE_CONST_EXPR
:
1879 mark_exp_read (TREE_OPERAND (exp
, 1));
1886 /* Perform the default conversion of arrays and functions to pointers.
1887 Return the result of converting EXP. For any other expression, just
1890 LOC is the location of the expression. */
1893 default_function_array_conversion (location_t loc
, struct c_expr exp
)
1895 tree orig_exp
= exp
.value
;
1896 tree type
= TREE_TYPE (exp
.value
);
1897 enum tree_code code
= TREE_CODE (type
);
1903 bool not_lvalue
= false;
1904 bool lvalue_array_p
;
1906 while ((TREE_CODE (exp
.value
) == NON_LVALUE_EXPR
1907 || CONVERT_EXPR_P (exp
.value
))
1908 && TREE_TYPE (TREE_OPERAND (exp
.value
, 0)) == type
)
1910 if (TREE_CODE (exp
.value
) == NON_LVALUE_EXPR
)
1912 exp
.value
= TREE_OPERAND (exp
.value
, 0);
1915 if (TREE_NO_WARNING (orig_exp
))
1916 TREE_NO_WARNING (exp
.value
) = 1;
1918 lvalue_array_p
= !not_lvalue
&& lvalue_p (exp
.value
);
1919 if (!flag_isoc99
&& !lvalue_array_p
)
1921 /* Before C99, non-lvalue arrays do not decay to pointers.
1922 Normally, using such an array would be invalid; but it can
1923 be used correctly inside sizeof or as a statement expression.
1924 Thus, do not give an error here; an error will result later. */
1928 exp
.value
= array_to_pointer_conversion (loc
, exp
.value
);
1932 exp
.value
= function_to_pointer_conversion (loc
, exp
.value
);
1942 default_function_array_read_conversion (location_t loc
, struct c_expr exp
)
1944 mark_exp_read (exp
.value
);
1945 return default_function_array_conversion (loc
, exp
);
1948 /* Return whether EXPR should be treated as an atomic lvalue for the
1949 purposes of load and store handling. */
1952 really_atomic_lvalue (tree expr
)
1954 if (expr
== error_mark_node
|| TREE_TYPE (expr
) == error_mark_node
)
1956 if (!TYPE_ATOMIC (TREE_TYPE (expr
)))
1958 if (!lvalue_p (expr
))
1961 /* Ignore _Atomic on register variables, since their addresses can't
1962 be taken so (a) atomicity is irrelevant and (b) the normal atomic
1963 sequences wouldn't work. Ignore _Atomic on structures containing
1964 bit-fields, since accessing elements of atomic structures or
1965 unions is undefined behavior (C11 6.5.2.3#5), but it's unclear if
1966 it's undefined at translation time or execution time, and the
1967 normal atomic sequences again wouldn't work. */
1968 while (handled_component_p (expr
))
1970 if (TREE_CODE (expr
) == COMPONENT_REF
1971 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
1973 expr
= TREE_OPERAND (expr
, 0);
1975 if (DECL_P (expr
) && C_DECL_REGISTER (expr
))
1980 /* Convert expression EXP (location LOC) from lvalue to rvalue,
1981 including converting functions and arrays to pointers if CONVERT_P.
1982 If READ_P, also mark the expression as having been read. */
1985 convert_lvalue_to_rvalue (location_t loc
, struct c_expr exp
,
1986 bool convert_p
, bool read_p
)
1989 mark_exp_read (exp
.value
);
1991 exp
= default_function_array_conversion (loc
, exp
);
1992 if (really_atomic_lvalue (exp
.value
))
1994 vec
<tree
, va_gc
> *params
;
1995 tree nonatomic_type
, tmp
, tmp_addr
, fndecl
, func_call
;
1996 tree expr_type
= TREE_TYPE (exp
.value
);
1997 tree expr_addr
= build_unary_op (loc
, ADDR_EXPR
, exp
.value
, 0);
1998 tree seq_cst
= build_int_cst (integer_type_node
, MEMMODEL_SEQ_CST
);
2000 gcc_assert (TYPE_ATOMIC (expr_type
));
2002 /* Expansion of a generic atomic load may require an addition
2003 element, so allocate enough to prevent a resize. */
2004 vec_alloc (params
, 4);
2006 /* Remove the qualifiers for the rest of the expressions and
2007 create the VAL temp variable to hold the RHS. */
2008 nonatomic_type
= build_qualified_type (expr_type
, TYPE_UNQUALIFIED
);
2009 tmp
= create_tmp_var (nonatomic_type
, NULL
);
2010 tmp_addr
= build_unary_op (loc
, ADDR_EXPR
, tmp
, 0);
2011 TREE_ADDRESSABLE (tmp
) = 1;
2012 TREE_NO_WARNING (tmp
) = 1;
2014 /* Issue __atomic_load (&expr, &tmp, SEQ_CST); */
2015 fndecl
= builtin_decl_explicit (BUILT_IN_ATOMIC_LOAD
);
2016 params
->quick_push (expr_addr
);
2017 params
->quick_push (tmp_addr
);
2018 params
->quick_push (seq_cst
);
2019 func_call
= c_build_function_call_vec (loc
, vNULL
, fndecl
, params
, NULL
);
2021 /* EXPR is always read. */
2022 mark_exp_read (exp
.value
);
2024 /* Return tmp which contains the value loaded. */
2025 exp
.value
= build2 (COMPOUND_EXPR
, nonatomic_type
, func_call
, tmp
);
2030 /* EXP is an expression of integer type. Apply the integer promotions
2031 to it and return the promoted value. */
2034 perform_integral_promotions (tree exp
)
2036 tree type
= TREE_TYPE (exp
);
2037 enum tree_code code
= TREE_CODE (type
);
2039 gcc_assert (INTEGRAL_TYPE_P (type
));
2041 /* Normally convert enums to int,
2042 but convert wide enums to something wider. */
2043 if (code
== ENUMERAL_TYPE
)
2045 type
= c_common_type_for_size (MAX (TYPE_PRECISION (type
),
2046 TYPE_PRECISION (integer_type_node
)),
2047 ((TYPE_PRECISION (type
)
2048 >= TYPE_PRECISION (integer_type_node
))
2049 && TYPE_UNSIGNED (type
)));
2051 return convert (type
, exp
);
2054 /* ??? This should no longer be needed now bit-fields have their
2056 if (TREE_CODE (exp
) == COMPONENT_REF
2057 && DECL_C_BIT_FIELD (TREE_OPERAND (exp
, 1))
2058 /* If it's thinner than an int, promote it like a
2059 c_promoting_integer_type_p, otherwise leave it alone. */
2060 && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp
, 1)),
2061 TYPE_PRECISION (integer_type_node
)))
2062 return convert (integer_type_node
, exp
);
2064 if (c_promoting_integer_type_p (type
))
2066 /* Preserve unsignedness if not really getting any wider. */
2067 if (TYPE_UNSIGNED (type
)
2068 && TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
2069 return convert (unsigned_type_node
, exp
);
2071 return convert (integer_type_node
, exp
);
2078 /* Perform default promotions for C data used in expressions.
2079 Enumeral types or short or char are converted to int.
2080 In addition, manifest constants symbols are replaced by their values. */
2083 default_conversion (tree exp
)
2086 tree type
= TREE_TYPE (exp
);
2087 enum tree_code code
= TREE_CODE (type
);
2090 mark_exp_read (exp
);
2092 /* Functions and arrays have been converted during parsing. */
2093 gcc_assert (code
!= FUNCTION_TYPE
);
2094 if (code
== ARRAY_TYPE
)
2097 /* Constants can be used directly unless they're not loadable. */
2098 if (TREE_CODE (exp
) == CONST_DECL
)
2099 exp
= DECL_INITIAL (exp
);
2101 /* Strip no-op conversions. */
2103 STRIP_TYPE_NOPS (exp
);
2105 if (TREE_NO_WARNING (orig_exp
))
2106 TREE_NO_WARNING (exp
) = 1;
2108 if (code
== VOID_TYPE
)
2110 error_at (EXPR_LOC_OR_LOC (exp
, input_location
),
2111 "void value not ignored as it ought to be");
2112 return error_mark_node
;
2115 exp
= require_complete_type (exp
);
2116 if (exp
== error_mark_node
)
2117 return error_mark_node
;
2119 promoted_type
= targetm
.promoted_type (type
);
2121 return convert (promoted_type
, exp
);
2123 if (INTEGRAL_TYPE_P (type
))
2124 return perform_integral_promotions (exp
);
2129 /* Look up COMPONENT in a structure or union TYPE.
2131 If the component name is not found, returns NULL_TREE. Otherwise,
2132 the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL
2133 stepping down the chain to the component, which is in the last
2134 TREE_VALUE of the list. Normally the list is of length one, but if
2135 the component is embedded within (nested) anonymous structures or
2136 unions, the list steps down the chain to the component. */
2139 lookup_field (tree type
, tree component
)
2143 /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
2144 to the field elements. Use a binary search on this array to quickly
2145 find the element. Otherwise, do a linear search. TYPE_LANG_SPECIFIC
2146 will always be set for structures which have many elements. */
2148 if (TYPE_LANG_SPECIFIC (type
) && TYPE_LANG_SPECIFIC (type
)->s
)
2151 tree
*field_array
= &TYPE_LANG_SPECIFIC (type
)->s
->elts
[0];
2153 field
= TYPE_FIELDS (type
);
2155 top
= TYPE_LANG_SPECIFIC (type
)->s
->len
;
2156 while (top
- bot
> 1)
2158 half
= (top
- bot
+ 1) >> 1;
2159 field
= field_array
[bot
+half
];
2161 if (DECL_NAME (field
) == NULL_TREE
)
2163 /* Step through all anon unions in linear fashion. */
2164 while (DECL_NAME (field_array
[bot
]) == NULL_TREE
)
2166 field
= field_array
[bot
++];
2167 if (TREE_CODE (TREE_TYPE (field
)) == RECORD_TYPE
2168 || TREE_CODE (TREE_TYPE (field
)) == UNION_TYPE
)
2170 tree anon
= lookup_field (TREE_TYPE (field
), component
);
2173 return tree_cons (NULL_TREE
, field
, anon
);
2175 /* The Plan 9 compiler permits referring
2176 directly to an anonymous struct/union field
2177 using a typedef name. */
2178 if (flag_plan9_extensions
2179 && TYPE_NAME (TREE_TYPE (field
)) != NULL_TREE
2180 && (TREE_CODE (TYPE_NAME (TREE_TYPE (field
)))
2182 && (DECL_NAME (TYPE_NAME (TREE_TYPE (field
)))
2188 /* Entire record is only anon unions. */
2192 /* Restart the binary search, with new lower bound. */
2196 if (DECL_NAME (field
) == component
)
2198 if (DECL_NAME (field
) < component
)
2204 if (DECL_NAME (field_array
[bot
]) == component
)
2205 field
= field_array
[bot
];
2206 else if (DECL_NAME (field
) != component
)
2211 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
2213 if (DECL_NAME (field
) == NULL_TREE
2214 && (TREE_CODE (TREE_TYPE (field
)) == RECORD_TYPE
2215 || TREE_CODE (TREE_TYPE (field
)) == UNION_TYPE
))
2217 tree anon
= lookup_field (TREE_TYPE (field
), component
);
2220 return tree_cons (NULL_TREE
, field
, anon
);
2222 /* The Plan 9 compiler permits referring directly to an
2223 anonymous struct/union field using a typedef
2225 if (flag_plan9_extensions
2226 && TYPE_NAME (TREE_TYPE (field
)) != NULL_TREE
2227 && TREE_CODE (TYPE_NAME (TREE_TYPE (field
))) == TYPE_DECL
2228 && (DECL_NAME (TYPE_NAME (TREE_TYPE (field
)))
2233 if (DECL_NAME (field
) == component
)
2237 if (field
== NULL_TREE
)
2241 return tree_cons (NULL_TREE
, field
, NULL_TREE
);
2244 /* Make an expression to refer to the COMPONENT field of structure or
2245 union value DATUM. COMPONENT is an IDENTIFIER_NODE. LOC is the
2246 location of the COMPONENT_REF. */
2249 build_component_ref (location_t loc
, tree datum
, tree component
)
2251 tree type
= TREE_TYPE (datum
);
2252 enum tree_code code
= TREE_CODE (type
);
2255 bool datum_lvalue
= lvalue_p (datum
);
2257 if (!objc_is_public (datum
, component
))
2258 return error_mark_node
;
2260 /* Detect Objective-C property syntax object.property. */
2261 if (c_dialect_objc ()
2262 && (ref
= objc_maybe_build_component_ref (datum
, component
)))
2265 /* See if there is a field or component with name COMPONENT. */
2267 if (code
== RECORD_TYPE
|| code
== UNION_TYPE
)
2269 if (!COMPLETE_TYPE_P (type
))
2271 c_incomplete_type_error (NULL_TREE
, type
);
2272 return error_mark_node
;
2275 field
= lookup_field (type
, component
);
2279 error_at (loc
, "%qT has no member named %qE", type
, component
);
2280 return error_mark_node
;
2283 /* Chain the COMPONENT_REFs if necessary down to the FIELD.
2284 This might be better solved in future the way the C++ front
2285 end does it - by giving the anonymous entities each a
2286 separate name and type, and then have build_component_ref
2287 recursively call itself. We can't do that here. */
2290 tree subdatum
= TREE_VALUE (field
);
2293 bool use_datum_quals
;
2295 if (TREE_TYPE (subdatum
) == error_mark_node
)
2296 return error_mark_node
;
2298 /* If this is an rvalue, it does not have qualifiers in C
2299 standard terms and we must avoid propagating such
2300 qualifiers down to a non-lvalue array that is then
2301 converted to a pointer. */
2302 use_datum_quals
= (datum_lvalue
2303 || TREE_CODE (TREE_TYPE (subdatum
)) != ARRAY_TYPE
);
2305 quals
= TYPE_QUALS (strip_array_types (TREE_TYPE (subdatum
)));
2306 if (use_datum_quals
)
2307 quals
|= TYPE_QUALS (TREE_TYPE (datum
));
2308 subtype
= c_build_qualified_type (TREE_TYPE (subdatum
), quals
);
2310 ref
= build3 (COMPONENT_REF
, subtype
, datum
, subdatum
,
2312 SET_EXPR_LOCATION (ref
, loc
);
2313 if (TREE_READONLY (subdatum
)
2314 || (use_datum_quals
&& TREE_READONLY (datum
)))
2315 TREE_READONLY (ref
) = 1;
2316 if (TREE_THIS_VOLATILE (subdatum
)
2317 || (use_datum_quals
&& TREE_THIS_VOLATILE (datum
)))
2318 TREE_THIS_VOLATILE (ref
) = 1;
2320 if (TREE_DEPRECATED (subdatum
))
2321 warn_deprecated_use (subdatum
, NULL_TREE
);
2325 field
= TREE_CHAIN (field
);
2331 else if (code
!= ERROR_MARK
)
2333 "request for member %qE in something not a structure or union",
2336 return error_mark_node
;
2339 /* Given an expression PTR for a pointer, return an expression
2340 for the value pointed to.
2341 ERRORSTRING is the name of the operator to appear in error messages.
2343 LOC is the location to use for the generated tree. */
2346 build_indirect_ref (location_t loc
, tree ptr
, ref_operator errstring
)
2348 tree pointer
= default_conversion (ptr
);
2349 tree type
= TREE_TYPE (pointer
);
2352 if (TREE_CODE (type
) == POINTER_TYPE
)
2354 if (CONVERT_EXPR_P (pointer
)
2355 || TREE_CODE (pointer
) == VIEW_CONVERT_EXPR
)
2357 /* If a warning is issued, mark it to avoid duplicates from
2358 the backend. This only needs to be done at
2359 warn_strict_aliasing > 2. */
2360 if (warn_strict_aliasing
> 2)
2361 if (strict_aliasing_warning (TREE_TYPE (TREE_OPERAND (pointer
, 0)),
2362 type
, TREE_OPERAND (pointer
, 0)))
2363 TREE_NO_WARNING (pointer
) = 1;
2366 if (TREE_CODE (pointer
) == ADDR_EXPR
2367 && (TREE_TYPE (TREE_OPERAND (pointer
, 0))
2368 == TREE_TYPE (type
)))
2370 ref
= TREE_OPERAND (pointer
, 0);
2371 protected_set_expr_location (ref
, loc
);
2376 tree t
= TREE_TYPE (type
);
2378 ref
= build1 (INDIRECT_REF
, t
, pointer
);
2380 if (!COMPLETE_OR_VOID_TYPE_P (t
) && TREE_CODE (t
) != ARRAY_TYPE
)
2382 error_at (loc
, "dereferencing pointer to incomplete type");
2383 return error_mark_node
;
2385 if (VOID_TYPE_P (t
) && c_inhibit_evaluation_warnings
== 0)
2386 warning_at (loc
, 0, "dereferencing %<void *%> pointer");
2388 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2389 so that we get the proper error message if the result is used
2390 to assign to. Also, &* is supposed to be a no-op.
2391 And ANSI C seems to specify that the type of the result
2392 should be the const type. */
2393 /* A de-reference of a pointer to const is not a const. It is valid
2394 to change it via some other pointer. */
2395 TREE_READONLY (ref
) = TYPE_READONLY (t
);
2396 TREE_SIDE_EFFECTS (ref
)
2397 = TYPE_VOLATILE (t
) || TREE_SIDE_EFFECTS (pointer
);
2398 TREE_THIS_VOLATILE (ref
) = TYPE_VOLATILE (t
);
2399 protected_set_expr_location (ref
, loc
);
2403 else if (TREE_CODE (pointer
) != ERROR_MARK
)
2404 invalid_indirection_error (loc
, type
, errstring
);
2406 return error_mark_node
;
2409 /* This handles expressions of the form "a[i]", which denotes
2412 This is logically equivalent in C to *(a+i), but we may do it differently.
2413 If A is a variable or a member, we generate a primitive ARRAY_REF.
2414 This avoids forcing the array out of registers, and can work on
2415 arrays that are not lvalues (for example, members of structures returned
2418 For vector types, allow vector[i] but not i[vector], and create
2419 *(((type*)&vectortype) + i) for the expression.
2421 LOC is the location to use for the returned expression. */
2424 build_array_ref (location_t loc
, tree array
, tree index
)
2427 bool swapped
= false;
2428 if (TREE_TYPE (array
) == error_mark_node
2429 || TREE_TYPE (index
) == error_mark_node
)
2430 return error_mark_node
;
2432 if (flag_cilkplus
&& contains_array_notation_expr (index
))
2435 if (!find_rank (loc
, index
, index
, true, &rank
))
2436 return error_mark_node
;
2439 error_at (loc
, "rank of the array's index is greater than 1");
2440 return error_mark_node
;
2443 if (TREE_CODE (TREE_TYPE (array
)) != ARRAY_TYPE
2444 && TREE_CODE (TREE_TYPE (array
)) != POINTER_TYPE
2445 /* Allow vector[index] but not index[vector]. */
2446 && TREE_CODE (TREE_TYPE (array
)) != VECTOR_TYPE
)
2449 if (TREE_CODE (TREE_TYPE (index
)) != ARRAY_TYPE
2450 && TREE_CODE (TREE_TYPE (index
)) != POINTER_TYPE
)
2453 "subscripted value is neither array nor pointer nor vector");
2455 return error_mark_node
;
2463 if (!INTEGRAL_TYPE_P (TREE_TYPE (index
)))
2465 error_at (loc
, "array subscript is not an integer");
2466 return error_mark_node
;
2469 if (TREE_CODE (TREE_TYPE (TREE_TYPE (array
))) == FUNCTION_TYPE
)
2471 error_at (loc
, "subscripted value is pointer to function");
2472 return error_mark_node
;
2475 /* ??? Existing practice has been to warn only when the char
2476 index is syntactically the index, not for char[array]. */
2478 warn_array_subscript_with_type_char (index
);
2480 /* Apply default promotions *after* noticing character types. */
2481 index
= default_conversion (index
);
2483 gcc_assert (TREE_CODE (TREE_TYPE (index
)) == INTEGER_TYPE
);
2485 convert_vector_to_pointer_for_subscript (loc
, &array
, index
);
2487 if (TREE_CODE (TREE_TYPE (array
)) == ARRAY_TYPE
)
2491 /* An array that is indexed by a non-constant
2492 cannot be stored in a register; we must be able to do
2493 address arithmetic on its address.
2494 Likewise an array of elements of variable size. */
2495 if (TREE_CODE (index
) != INTEGER_CST
2496 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array
)))
2497 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array
)))) != INTEGER_CST
))
2499 if (!c_mark_addressable (array
))
2500 return error_mark_node
;
2502 /* An array that is indexed by a constant value which is not within
2503 the array bounds cannot be stored in a register either; because we
2504 would get a crash in store_bit_field/extract_bit_field when trying
2505 to access a non-existent part of the register. */
2506 if (TREE_CODE (index
) == INTEGER_CST
2507 && TYPE_DOMAIN (TREE_TYPE (array
))
2508 && !int_fits_type_p (index
, TYPE_DOMAIN (TREE_TYPE (array
))))
2510 if (!c_mark_addressable (array
))
2511 return error_mark_node
;
2517 while (TREE_CODE (foo
) == COMPONENT_REF
)
2518 foo
= TREE_OPERAND (foo
, 0);
2519 if (TREE_CODE (foo
) == VAR_DECL
&& C_DECL_REGISTER (foo
))
2520 pedwarn (loc
, OPT_Wpedantic
,
2521 "ISO C forbids subscripting %<register%> array");
2522 else if (!flag_isoc99
&& !lvalue_p (foo
))
2523 pedwarn (loc
, OPT_Wpedantic
,
2524 "ISO C90 forbids subscripting non-lvalue array");
2527 type
= TREE_TYPE (TREE_TYPE (array
));
2528 rval
= build4 (ARRAY_REF
, type
, array
, index
, NULL_TREE
, NULL_TREE
);
2529 /* Array ref is const/volatile if the array elements are
2530 or if the array is. */
2531 TREE_READONLY (rval
)
2532 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array
)))
2533 | TREE_READONLY (array
));
2534 TREE_SIDE_EFFECTS (rval
)
2535 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array
)))
2536 | TREE_SIDE_EFFECTS (array
));
2537 TREE_THIS_VOLATILE (rval
)
2538 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array
)))
2539 /* This was added by rms on 16 Nov 91.
2540 It fixes vol struct foo *a; a->elts[1]
2541 in an inline function.
2542 Hope it doesn't break something else. */
2543 | TREE_THIS_VOLATILE (array
));
2544 ret
= require_complete_type (rval
);
2545 protected_set_expr_location (ret
, loc
);
2550 tree ar
= default_conversion (array
);
2552 if (ar
== error_mark_node
)
2555 gcc_assert (TREE_CODE (TREE_TYPE (ar
)) == POINTER_TYPE
);
2556 gcc_assert (TREE_CODE (TREE_TYPE (TREE_TYPE (ar
))) != FUNCTION_TYPE
);
2558 return build_indirect_ref
2559 (loc
, build_binary_op (loc
, PLUS_EXPR
, ar
, index
, 0),
2564 /* Build an external reference to identifier ID. FUN indicates
2565 whether this will be used for a function call. LOC is the source
2566 location of the identifier. This sets *TYPE to the type of the
2567 identifier, which is not the same as the type of the returned value
2568 for CONST_DECLs defined as enum constants. If the type of the
2569 identifier is not available, *TYPE is set to NULL. */
2571 build_external_ref (location_t loc
, tree id
, int fun
, tree
*type
)
2574 tree decl
= lookup_name (id
);
2576 /* In Objective-C, an instance variable (ivar) may be preferred to
2577 whatever lookup_name() found. */
2578 decl
= objc_lookup_ivar (decl
, id
);
2581 if (decl
&& decl
!= error_mark_node
)
2584 *type
= TREE_TYPE (ref
);
2587 /* Implicit function declaration. */
2588 ref
= implicitly_declare (loc
, id
);
2589 else if (decl
== error_mark_node
)
2590 /* Don't complain about something that's already been
2591 complained about. */
2592 return error_mark_node
;
2595 undeclared_variable (loc
, id
);
2596 return error_mark_node
;
2599 if (TREE_TYPE (ref
) == error_mark_node
)
2600 return error_mark_node
;
2602 if (TREE_DEPRECATED (ref
))
2603 warn_deprecated_use (ref
, NULL_TREE
);
2605 /* Recursive call does not count as usage. */
2606 if (ref
!= current_function_decl
)
2608 TREE_USED (ref
) = 1;
2611 if (TREE_CODE (ref
) == FUNCTION_DECL
&& !in_alignof
)
2613 if (!in_sizeof
&& !in_typeof
)
2614 C_DECL_USED (ref
) = 1;
2615 else if (DECL_INITIAL (ref
) == 0
2616 && DECL_EXTERNAL (ref
)
2617 && !TREE_PUBLIC (ref
))
2618 record_maybe_used_decl (ref
);
2621 if (TREE_CODE (ref
) == CONST_DECL
)
2623 used_types_insert (TREE_TYPE (ref
));
2626 && TREE_CODE (TREE_TYPE (ref
)) == ENUMERAL_TYPE
2627 && C_TYPE_DEFINED_IN_STRUCT (TREE_TYPE (ref
)))
2629 warning_at (loc
, OPT_Wc___compat
,
2630 ("enum constant defined in struct or union "
2631 "is not visible in C++"));
2632 inform (DECL_SOURCE_LOCATION (ref
), "enum constant defined here");
2635 ref
= DECL_INITIAL (ref
);
2636 TREE_CONSTANT (ref
) = 1;
2638 else if (current_function_decl
!= 0
2639 && !DECL_FILE_SCOPE_P (current_function_decl
)
2640 && (TREE_CODE (ref
) == VAR_DECL
2641 || TREE_CODE (ref
) == PARM_DECL
2642 || TREE_CODE (ref
) == FUNCTION_DECL
))
2644 tree context
= decl_function_context (ref
);
2646 if (context
!= 0 && context
!= current_function_decl
)
2647 DECL_NONLOCAL (ref
) = 1;
2649 /* C99 6.7.4p3: An inline definition of a function with external
2650 linkage ... shall not contain a reference to an identifier with
2651 internal linkage. */
2652 else if (current_function_decl
!= 0
2653 && DECL_DECLARED_INLINE_P (current_function_decl
)
2654 && DECL_EXTERNAL (current_function_decl
)
2655 && VAR_OR_FUNCTION_DECL_P (ref
)
2656 && (TREE_CODE (ref
) != VAR_DECL
|| TREE_STATIC (ref
))
2657 && ! TREE_PUBLIC (ref
)
2658 && DECL_CONTEXT (ref
) != current_function_decl
)
2659 record_inline_static (loc
, current_function_decl
, ref
,
2665 /* Record details of decls possibly used inside sizeof or typeof. */
2666 struct maybe_used_decl
2670 /* The level seen at (in_sizeof + in_typeof). */
2672 /* The next one at this level or above, or NULL. */
2673 struct maybe_used_decl
*next
;
2676 static struct maybe_used_decl
*maybe_used_decls
;
2678 /* Record that DECL, an undefined static function reference seen
2679 inside sizeof or typeof, might be used if the operand of sizeof is
2680 a VLA type or the operand of typeof is a variably modified
2684 record_maybe_used_decl (tree decl
)
2686 struct maybe_used_decl
*t
= XOBNEW (&parser_obstack
, struct maybe_used_decl
);
2688 t
->level
= in_sizeof
+ in_typeof
;
2689 t
->next
= maybe_used_decls
;
2690 maybe_used_decls
= t
;
2693 /* Pop the stack of decls possibly used inside sizeof or typeof. If
2694 USED is false, just discard them. If it is true, mark them used
2695 (if no longer inside sizeof or typeof) or move them to the next
2696 level up (if still inside sizeof or typeof). */
2699 pop_maybe_used (bool used
)
2701 struct maybe_used_decl
*p
= maybe_used_decls
;
2702 int cur_level
= in_sizeof
+ in_typeof
;
2703 while (p
&& p
->level
> cur_level
)
2708 C_DECL_USED (p
->decl
) = 1;
2710 p
->level
= cur_level
;
2714 if (!used
|| cur_level
== 0)
2715 maybe_used_decls
= p
;
2718 /* Return the result of sizeof applied to EXPR. */
2721 c_expr_sizeof_expr (location_t loc
, struct c_expr expr
)
2724 if (expr
.value
== error_mark_node
)
2726 ret
.value
= error_mark_node
;
2727 ret
.original_code
= ERROR_MARK
;
2728 ret
.original_type
= NULL
;
2729 pop_maybe_used (false);
2733 bool expr_const_operands
= true;
2734 tree folded_expr
= c_fully_fold (expr
.value
, require_constant_value
,
2735 &expr_const_operands
);
2736 ret
.value
= c_sizeof (loc
, TREE_TYPE (folded_expr
));
2737 c_last_sizeof_arg
= expr
.value
;
2738 ret
.original_code
= SIZEOF_EXPR
;
2739 ret
.original_type
= NULL
;
2740 if (c_vla_type_p (TREE_TYPE (folded_expr
)))
2742 /* sizeof is evaluated when given a vla (C99 6.5.3.4p2). */
2743 ret
.value
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (ret
.value
),
2744 folded_expr
, ret
.value
);
2745 C_MAYBE_CONST_EXPR_NON_CONST (ret
.value
) = !expr_const_operands
;
2746 SET_EXPR_LOCATION (ret
.value
, loc
);
2748 pop_maybe_used (C_TYPE_VARIABLE_SIZE (TREE_TYPE (folded_expr
)));
2753 /* Return the result of sizeof applied to T, a structure for the type
2754 name passed to sizeof (rather than the type itself). LOC is the
2755 location of the original expression. */
2758 c_expr_sizeof_type (location_t loc
, struct c_type_name
*t
)
2762 tree type_expr
= NULL_TREE
;
2763 bool type_expr_const
= true;
2764 type
= groktypename (t
, &type_expr
, &type_expr_const
);
2765 ret
.value
= c_sizeof (loc
, type
);
2766 c_last_sizeof_arg
= type
;
2767 ret
.original_code
= SIZEOF_EXPR
;
2768 ret
.original_type
= NULL
;
2769 if ((type_expr
|| TREE_CODE (ret
.value
) == INTEGER_CST
)
2770 && c_vla_type_p (type
))
2772 /* If the type is a [*] array, it is a VLA but is represented as
2773 having a size of zero. In such a case we must ensure that
2774 the result of sizeof does not get folded to a constant by
2775 c_fully_fold, because if the size is evaluated the result is
2776 not constant and so constraints on zero or negative size
2777 arrays must not be applied when this sizeof call is inside
2778 another array declarator. */
2780 type_expr
= integer_zero_node
;
2781 ret
.value
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (ret
.value
),
2782 type_expr
, ret
.value
);
2783 C_MAYBE_CONST_EXPR_NON_CONST (ret
.value
) = !type_expr_const
;
2785 pop_maybe_used (type
!= error_mark_node
2786 ? C_TYPE_VARIABLE_SIZE (type
) : false);
2790 /* Build a function call to function FUNCTION with parameters PARAMS.
2791 The function call is at LOC.
2792 PARAMS is a list--a chain of TREE_LIST nodes--in which the
2793 TREE_VALUE of each node is a parameter-expression.
2794 FUNCTION's data type may be a function type or a pointer-to-function. */
2797 build_function_call (location_t loc
, tree function
, tree params
)
2799 vec
<tree
, va_gc
> *v
;
2802 vec_alloc (v
, list_length (params
));
2803 for (; params
; params
= TREE_CHAIN (params
))
2804 v
->quick_push (TREE_VALUE (params
));
2805 ret
= c_build_function_call_vec (loc
, vNULL
, function
, v
, NULL
);
2810 /* Give a note about the location of the declaration of DECL. */
2812 static void inform_declaration (tree decl
)
2814 if (decl
&& (TREE_CODE (decl
) != FUNCTION_DECL
|| !DECL_BUILT_IN (decl
)))
2815 inform (DECL_SOURCE_LOCATION (decl
), "declared here");
2818 /* Build a function call to function FUNCTION with parameters PARAMS.
2819 ORIGTYPES, if not NULL, is a vector of types; each element is
2820 either NULL or the original type of the corresponding element in
2821 PARAMS. The original type may differ from TREE_TYPE of the
2822 parameter for enums. FUNCTION's data type may be a function type
2823 or pointer-to-function. This function changes the elements of
2827 build_function_call_vec (location_t loc
, vec
<location_t
> arg_loc
,
2828 tree function
, vec
<tree
, va_gc
> *params
,
2829 vec
<tree
, va_gc
> *origtypes
)
2831 tree fntype
, fundecl
= 0;
2832 tree name
= NULL_TREE
, result
;
2838 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
2839 STRIP_TYPE_NOPS (function
);
2841 /* Convert anything with function type to a pointer-to-function. */
2842 if (TREE_CODE (function
) == FUNCTION_DECL
)
2844 name
= DECL_NAME (function
);
2847 tm_malloc_replacement (function
);
2849 /* Atomic functions have type checking/casting already done. They are
2850 often rewritten and don't match the original parameter list. */
2851 if (name
&& !strncmp (IDENTIFIER_POINTER (name
), "__atomic_", 9))
2855 && is_cilkplus_reduce_builtin (function
))
2858 if (TREE_CODE (TREE_TYPE (function
)) == FUNCTION_TYPE
)
2859 function
= function_to_pointer_conversion (loc
, function
);
2861 /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
2862 expressions, like those used for ObjC messenger dispatches. */
2863 if (params
&& !params
->is_empty ())
2864 function
= objc_rewrite_function_call (function
, (*params
)[0]);
2866 function
= c_fully_fold (function
, false, NULL
);
2868 fntype
= TREE_TYPE (function
);
2870 if (TREE_CODE (fntype
) == ERROR_MARK
)
2871 return error_mark_node
;
2873 if (!(TREE_CODE (fntype
) == POINTER_TYPE
2874 && TREE_CODE (TREE_TYPE (fntype
)) == FUNCTION_TYPE
))
2876 if (!flag_diagnostics_show_caret
)
2878 "called object %qE is not a function or function pointer",
2880 else if (DECL_P (function
))
2883 "called object %qD is not a function or function pointer",
2885 inform_declaration (function
);
2889 "called object is not a function or function pointer");
2890 return error_mark_node
;
2893 if (fundecl
&& TREE_THIS_VOLATILE (fundecl
))
2894 current_function_returns_abnormally
= 1;
2896 /* fntype now gets the type of function pointed to. */
2897 fntype
= TREE_TYPE (fntype
);
2899 /* Convert the parameters to the types declared in the
2900 function prototype, or apply default promotions. */
2902 nargs
= convert_arguments (loc
, arg_loc
, TYPE_ARG_TYPES (fntype
), params
,
2903 origtypes
, function
, fundecl
);
2905 return error_mark_node
;
2907 /* Check that the function is called through a compatible prototype.
2908 If it is not, warn. */
2909 if (CONVERT_EXPR_P (function
)
2910 && TREE_CODE (tem
= TREE_OPERAND (function
, 0)) == ADDR_EXPR
2911 && TREE_CODE (tem
= TREE_OPERAND (tem
, 0)) == FUNCTION_DECL
2912 && !comptypes (fntype
, TREE_TYPE (tem
)))
2914 tree return_type
= TREE_TYPE (fntype
);
2916 /* This situation leads to run-time undefined behavior. We can't,
2917 therefore, simply error unless we can prove that all possible
2918 executions of the program must execute the code. */
2919 warning_at (loc
, 0, "function called through a non-compatible type");
2921 if (VOID_TYPE_P (return_type
)
2922 && TYPE_QUALS (return_type
) != TYPE_UNQUALIFIED
)
2924 "function with qualified void return type called");
2927 argarray
= vec_safe_address (params
);
2929 /* Check that arguments to builtin functions match the expectations. */
2931 && DECL_BUILT_IN (fundecl
)
2932 && DECL_BUILT_IN_CLASS (fundecl
) == BUILT_IN_NORMAL
2933 && !check_builtin_function_arguments (fundecl
, nargs
, argarray
))
2934 return error_mark_node
;
2936 /* Check that the arguments to the function are valid. */
2937 check_function_arguments (fntype
, nargs
, argarray
);
2939 if (name
!= NULL_TREE
2940 && !strncmp (IDENTIFIER_POINTER (name
), "__builtin_", 10))
2942 if (require_constant_value
)
2944 fold_build_call_array_initializer_loc (loc
, TREE_TYPE (fntype
),
2945 function
, nargs
, argarray
);
2947 result
= fold_build_call_array_loc (loc
, TREE_TYPE (fntype
),
2948 function
, nargs
, argarray
);
2949 if (TREE_CODE (result
) == NOP_EXPR
2950 && TREE_CODE (TREE_OPERAND (result
, 0)) == INTEGER_CST
)
2951 STRIP_TYPE_NOPS (result
);
2954 result
= build_call_array_loc (loc
, TREE_TYPE (fntype
),
2955 function
, nargs
, argarray
);
2957 if (VOID_TYPE_P (TREE_TYPE (result
)))
2959 if (TYPE_QUALS (TREE_TYPE (result
)) != TYPE_UNQUALIFIED
)
2961 "function with qualified void return type called");
2964 return require_complete_type (result
);
2967 /* Like build_function_call_vec, but call also resolve_overloaded_builtin. */
2970 c_build_function_call_vec (location_t loc
, vec
<location_t
> arg_loc
,
2971 tree function
, vec
<tree
, va_gc
> *params
,
2972 vec
<tree
, va_gc
> *origtypes
)
2974 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
2975 STRIP_TYPE_NOPS (function
);
2977 /* Convert anything with function type to a pointer-to-function. */
2978 if (TREE_CODE (function
) == FUNCTION_DECL
)
2980 /* Implement type-directed function overloading for builtins.
2981 resolve_overloaded_builtin and targetm.resolve_overloaded_builtin
2982 handle all the type checking. The result is a complete expression
2983 that implements this function call. */
2984 tree tem
= resolve_overloaded_builtin (loc
, function
, params
);
2988 return build_function_call_vec (loc
, arg_loc
, function
, params
, origtypes
);
2991 /* Convert the argument expressions in the vector VALUES
2992 to the types in the list TYPELIST.
2994 If TYPELIST is exhausted, or when an element has NULL as its type,
2995 perform the default conversions.
2997 ORIGTYPES is the original types of the expressions in VALUES. This
2998 holds the type of enum values which have been converted to integral
2999 types. It may be NULL.
3001 FUNCTION is a tree for the called function. It is used only for
3002 error messages, where it is formatted with %qE.
3004 This is also where warnings about wrong number of args are generated.
3006 ARG_LOC are locations of function arguments (if any).
3008 Returns the actual number of arguments processed (which may be less
3009 than the length of VALUES in some error situations), or -1 on
3013 convert_arguments (location_t loc
, vec
<location_t
> arg_loc
, tree typelist
,
3014 vec
<tree
, va_gc
> *values
, vec
<tree
, va_gc
> *origtypes
,
3015 tree function
, tree fundecl
)
3018 unsigned int parmnum
;
3019 bool error_args
= false;
3020 const bool type_generic
= fundecl
3021 && lookup_attribute ("type generic", TYPE_ATTRIBUTES (TREE_TYPE (fundecl
)));
3022 bool type_generic_remove_excess_precision
= false;
3025 /* Change pointer to function to the function itself for
3027 if (TREE_CODE (function
) == ADDR_EXPR
3028 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
3029 function
= TREE_OPERAND (function
, 0);
3031 /* Handle an ObjC selector specially for diagnostics. */
3032 selector
= objc_message_selector ();
3034 /* For type-generic built-in functions, determine whether excess
3035 precision should be removed (classification) or not
3038 && DECL_BUILT_IN (fundecl
)
3039 && DECL_BUILT_IN_CLASS (fundecl
) == BUILT_IN_NORMAL
)
3041 switch (DECL_FUNCTION_CODE (fundecl
))
3043 case BUILT_IN_ISFINITE
:
3044 case BUILT_IN_ISINF
:
3045 case BUILT_IN_ISINF_SIGN
:
3046 case BUILT_IN_ISNAN
:
3047 case BUILT_IN_ISNORMAL
:
3048 case BUILT_IN_FPCLASSIFY
:
3049 type_generic_remove_excess_precision
= true;
3053 type_generic_remove_excess_precision
= false;
3057 if (flag_cilkplus
&& fundecl
&& is_cilkplus_reduce_builtin (fundecl
))
3058 return vec_safe_length (values
);
3060 /* Scan the given expressions and types, producing individual
3061 converted arguments. */
3063 for (typetail
= typelist
, parmnum
= 0;
3064 values
&& values
->iterate (parmnum
, &val
);
3067 tree type
= typetail
? TREE_VALUE (typetail
) : 0;
3068 tree valtype
= TREE_TYPE (val
);
3069 tree rname
= function
;
3070 int argnum
= parmnum
+ 1;
3071 const char *invalid_func_diag
;
3072 bool excess_precision
= false;
3075 /* Some __atomic_* builtins have additional hidden argument at
3078 = !arg_loc
.is_empty () && values
->length () == arg_loc
.length ()
3079 ? expansion_point_location_if_in_system_header (arg_loc
[parmnum
])
3082 if (type
== void_type_node
)
3085 error_at (loc
, "too many arguments to method %qE", selector
);
3087 error_at (loc
, "too many arguments to function %qE", function
);
3088 inform_declaration (fundecl
);
3092 if (selector
&& argnum
> 2)
3098 npc
= null_pointer_constant_p (val
);
3100 /* If there is excess precision and a prototype, convert once to
3101 the required type rather than converting via the semantic
3102 type. Likewise without a prototype a float value represented
3103 as long double should be converted once to double. But for
3104 type-generic classification functions excess precision must
3106 if (TREE_CODE (val
) == EXCESS_PRECISION_EXPR
3107 && (type
|| !type_generic
|| !type_generic_remove_excess_precision
))
3109 val
= TREE_OPERAND (val
, 0);
3110 excess_precision
= true;
3112 val
= c_fully_fold (val
, false, NULL
);
3113 STRIP_TYPE_NOPS (val
);
3115 val
= require_complete_type (val
);
3119 /* Formal parm type is specified by a function prototype. */
3121 if (type
== error_mark_node
|| !COMPLETE_TYPE_P (type
))
3123 error_at (ploc
, "type of formal parameter %d is incomplete",
3131 /* Optionally warn about conversions that
3132 differ from the default conversions. */
3133 if (warn_traditional_conversion
|| warn_traditional
)
3135 unsigned int formal_prec
= TYPE_PRECISION (type
);
3137 if (INTEGRAL_TYPE_P (type
)
3138 && TREE_CODE (valtype
) == REAL_TYPE
)
3139 warning_at (ploc
, OPT_Wtraditional_conversion
,
3140 "passing argument %d of %qE as integer rather "
3141 "than floating due to prototype",
3143 if (INTEGRAL_TYPE_P (type
)
3144 && TREE_CODE (valtype
) == COMPLEX_TYPE
)
3145 warning_at (ploc
, OPT_Wtraditional_conversion
,
3146 "passing argument %d of %qE as integer rather "
3147 "than complex due to prototype",
3149 else if (TREE_CODE (type
) == COMPLEX_TYPE
3150 && TREE_CODE (valtype
) == REAL_TYPE
)
3151 warning_at (ploc
, OPT_Wtraditional_conversion
,
3152 "passing argument %d of %qE as complex rather "
3153 "than floating due to prototype",
3155 else if (TREE_CODE (type
) == REAL_TYPE
3156 && INTEGRAL_TYPE_P (valtype
))
3157 warning_at (ploc
, OPT_Wtraditional_conversion
,
3158 "passing argument %d of %qE as floating rather "
3159 "than integer due to prototype",
3161 else if (TREE_CODE (type
) == COMPLEX_TYPE
3162 && INTEGRAL_TYPE_P (valtype
))
3163 warning_at (ploc
, OPT_Wtraditional_conversion
,
3164 "passing argument %d of %qE as complex rather "
3165 "than integer due to prototype",
3167 else if (TREE_CODE (type
) == REAL_TYPE
3168 && TREE_CODE (valtype
) == COMPLEX_TYPE
)
3169 warning_at (ploc
, OPT_Wtraditional_conversion
,
3170 "passing argument %d of %qE as floating rather "
3171 "than complex due to prototype",
3173 /* ??? At some point, messages should be written about
3174 conversions between complex types, but that's too messy
3176 else if (TREE_CODE (type
) == REAL_TYPE
3177 && TREE_CODE (valtype
) == REAL_TYPE
)
3179 /* Warn if any argument is passed as `float',
3180 since without a prototype it would be `double'. */
3181 if (formal_prec
== TYPE_PRECISION (float_type_node
)
3182 && type
!= dfloat32_type_node
)
3183 warning_at (ploc
, 0,
3184 "passing argument %d of %qE as %<float%> "
3185 "rather than %<double%> due to prototype",
3188 /* Warn if mismatch between argument and prototype
3189 for decimal float types. Warn of conversions with
3190 binary float types and of precision narrowing due to
3192 else if (type
!= valtype
3193 && (type
== dfloat32_type_node
3194 || type
== dfloat64_type_node
3195 || type
== dfloat128_type_node
3196 || valtype
== dfloat32_type_node
3197 || valtype
== dfloat64_type_node
3198 || valtype
== dfloat128_type_node
)
3200 <= TYPE_PRECISION (valtype
)
3201 || (type
== dfloat128_type_node
3203 != dfloat64_type_node
3205 != dfloat32_type_node
)))
3206 || (type
== dfloat64_type_node
3208 != dfloat32_type_node
))))
3209 warning_at (ploc
, 0,
3210 "passing argument %d of %qE as %qT "
3211 "rather than %qT due to prototype",
3212 argnum
, rname
, type
, valtype
);
3215 /* Detect integer changing in width or signedness.
3216 These warnings are only activated with
3217 -Wtraditional-conversion, not with -Wtraditional. */
3218 else if (warn_traditional_conversion
&& INTEGRAL_TYPE_P (type
)
3219 && INTEGRAL_TYPE_P (valtype
))
3221 tree would_have_been
= default_conversion (val
);
3222 tree type1
= TREE_TYPE (would_have_been
);
3224 if (TREE_CODE (type
) == ENUMERAL_TYPE
3225 && (TYPE_MAIN_VARIANT (type
)
3226 == TYPE_MAIN_VARIANT (valtype
)))
3227 /* No warning if function asks for enum
3228 and the actual arg is that enum type. */
3230 else if (formal_prec
!= TYPE_PRECISION (type1
))
3231 warning_at (ploc
, OPT_Wtraditional_conversion
,
3232 "passing argument %d of %qE "
3233 "with different width due to prototype",
3235 else if (TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (type1
))
3237 /* Don't complain if the formal parameter type
3238 is an enum, because we can't tell now whether
3239 the value was an enum--even the same enum. */
3240 else if (TREE_CODE (type
) == ENUMERAL_TYPE
)
3242 else if (TREE_CODE (val
) == INTEGER_CST
3243 && int_fits_type_p (val
, type
))
3244 /* Change in signedness doesn't matter
3245 if a constant value is unaffected. */
3247 /* If the value is extended from a narrower
3248 unsigned type, it doesn't matter whether we
3249 pass it as signed or unsigned; the value
3250 certainly is the same either way. */
3251 else if (TYPE_PRECISION (valtype
) < TYPE_PRECISION (type
)
3252 && TYPE_UNSIGNED (valtype
))
3254 else if (TYPE_UNSIGNED (type
))
3255 warning_at (ploc
, OPT_Wtraditional_conversion
,
3256 "passing argument %d of %qE "
3257 "as unsigned due to prototype",
3260 warning_at (ploc
, OPT_Wtraditional_conversion
,
3261 "passing argument %d of %qE "
3262 "as signed due to prototype",
3267 /* Possibly restore an EXCESS_PRECISION_EXPR for the
3268 sake of better warnings from convert_and_check. */
3269 if (excess_precision
)
3270 val
= build1 (EXCESS_PRECISION_EXPR
, valtype
, val
);
3271 origtype
= (!origtypes
) ? NULL_TREE
: (*origtypes
)[parmnum
];
3272 parmval
= convert_for_assignment (loc
, ploc
, type
,
3273 val
, origtype
, ic_argpass
,
3274 npc
, fundecl
, function
,
3277 if (targetm
.calls
.promote_prototypes (fundecl
? TREE_TYPE (fundecl
) : 0)
3278 && INTEGRAL_TYPE_P (type
)
3279 && (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
)))
3280 parmval
= default_conversion (parmval
);
3283 else if (TREE_CODE (valtype
) == REAL_TYPE
3284 && (TYPE_PRECISION (valtype
)
3285 <= TYPE_PRECISION (double_type_node
))
3286 && TYPE_MAIN_VARIANT (valtype
) != double_type_node
3287 && TYPE_MAIN_VARIANT (valtype
) != long_double_type_node
3288 && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (valtype
)))
3294 /* Convert `float' to `double'. */
3295 if (warn_double_promotion
&& !c_inhibit_evaluation_warnings
)
3296 warning_at (ploc
, OPT_Wdouble_promotion
,
3297 "implicit conversion from %qT to %qT when passing "
3298 "argument to function",
3299 valtype
, double_type_node
);
3300 parmval
= convert (double_type_node
, val
);
3303 else if (excess_precision
&& !type_generic
)
3304 /* A "double" argument with excess precision being passed
3305 without a prototype or in variable arguments. */
3306 parmval
= convert (valtype
, val
);
3307 else if ((invalid_func_diag
=
3308 targetm
.calls
.invalid_arg_for_unprototyped_fn (typelist
, fundecl
, val
)))
3310 error (invalid_func_diag
);
3314 /* Convert `short' and `char' to full-size `int'. */
3315 parmval
= default_conversion (val
);
3317 (*values
)[parmnum
] = parmval
;
3318 if (parmval
== error_mark_node
)
3322 typetail
= TREE_CHAIN (typetail
);
3325 gcc_assert (parmnum
== vec_safe_length (values
));
3327 if (typetail
!= 0 && TREE_VALUE (typetail
) != void_type_node
)
3329 error_at (loc
, "too few arguments to function %qE", function
);
3330 inform_declaration (fundecl
);
3334 return error_args
? -1 : (int) parmnum
;
3337 /* This is the entry point used by the parser to build unary operators
3338 in the input. CODE, a tree_code, specifies the unary operator, and
3339 ARG is the operand. For unary plus, the C parser currently uses
3340 CONVERT_EXPR for code.
3342 LOC is the location to use for the tree generated.
3346 parser_build_unary_op (location_t loc
, enum tree_code code
, struct c_expr arg
)
3348 struct c_expr result
;
3350 result
.value
= build_unary_op (loc
, code
, arg
.value
, 0);
3351 result
.original_code
= code
;
3352 result
.original_type
= NULL
;
3354 if (TREE_OVERFLOW_P (result
.value
) && !TREE_OVERFLOW_P (arg
.value
))
3355 overflow_warning (loc
, result
.value
);
3360 /* This is the entry point used by the parser to build binary operators
3361 in the input. CODE, a tree_code, specifies the binary operator, and
3362 ARG1 and ARG2 are the operands. In addition to constructing the
3363 expression, we check for operands that were written with other binary
3364 operators in a way that is likely to confuse the user.
3366 LOCATION is the location of the binary operator. */
3369 parser_build_binary_op (location_t location
, enum tree_code code
,
3370 struct c_expr arg1
, struct c_expr arg2
)
3372 struct c_expr result
;
3374 enum tree_code code1
= arg1
.original_code
;
3375 enum tree_code code2
= arg2
.original_code
;
3376 tree type1
= (arg1
.original_type
3377 ? arg1
.original_type
3378 : TREE_TYPE (arg1
.value
));
3379 tree type2
= (arg2
.original_type
3380 ? arg2
.original_type
3381 : TREE_TYPE (arg2
.value
));
3383 result
.value
= build_binary_op (location
, code
,
3384 arg1
.value
, arg2
.value
, 1);
3385 result
.original_code
= code
;
3386 result
.original_type
= NULL
;
3388 if (TREE_CODE (result
.value
) == ERROR_MARK
)
3391 if (location
!= UNKNOWN_LOCATION
)
3392 protected_set_expr_location (result
.value
, location
);
3394 /* Check for cases such as x+y<<z which users are likely
3396 if (warn_parentheses
)
3397 warn_about_parentheses (location
, code
, code1
, arg1
.value
, code2
,
3400 if (warn_logical_op
)
3401 warn_logical_operator (location
, code
, TREE_TYPE (result
.value
),
3402 code1
, arg1
.value
, code2
, arg2
.value
);
3404 if (warn_logical_not_paren
3405 && code1
== TRUTH_NOT_EXPR
)
3406 warn_logical_not_parentheses (location
, code
, arg1
.value
, arg2
.value
);
3408 /* Warn about comparisons against string literals, with the exception
3409 of testing for equality or inequality of a string literal with NULL. */
3410 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
3412 if ((code1
== STRING_CST
&& !integer_zerop (arg2
.value
))
3413 || (code2
== STRING_CST
&& !integer_zerop (arg1
.value
)))
3414 warning_at (location
, OPT_Waddress
,
3415 "comparison with string literal results in unspecified behavior");
3417 else if (TREE_CODE_CLASS (code
) == tcc_comparison
3418 && (code1
== STRING_CST
|| code2
== STRING_CST
))
3419 warning_at (location
, OPT_Waddress
,
3420 "comparison with string literal results in unspecified behavior");
3422 if (TREE_OVERFLOW_P (result
.value
)
3423 && !TREE_OVERFLOW_P (arg1
.value
)
3424 && !TREE_OVERFLOW_P (arg2
.value
))
3425 overflow_warning (location
, result
.value
);
3427 /* Warn about comparisons of different enum types. */
3428 if (warn_enum_compare
3429 && TREE_CODE_CLASS (code
) == tcc_comparison
3430 && TREE_CODE (type1
) == ENUMERAL_TYPE
3431 && TREE_CODE (type2
) == ENUMERAL_TYPE
3432 && TYPE_MAIN_VARIANT (type1
) != TYPE_MAIN_VARIANT (type2
))
3433 warning_at (location
, OPT_Wenum_compare
,
3434 "comparison between %qT and %qT",
3440 /* Return a tree for the difference of pointers OP0 and OP1.
3441 The resulting tree has type int. */
3444 pointer_diff (location_t loc
, tree op0
, tree op1
)
3446 tree restype
= ptrdiff_type_node
;
3447 tree result
, inttype
;
3449 addr_space_t as0
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op0
)));
3450 addr_space_t as1
= TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op1
)));
3451 tree target_type
= TREE_TYPE (TREE_TYPE (op0
));
3452 tree con0
, con1
, lit0
, lit1
;
3453 tree orig_op1
= op1
;
3455 /* If the operands point into different address spaces, we need to
3456 explicitly convert them to pointers into the common address space
3457 before we can subtract the numerical address values. */
3460 addr_space_t as_common
;
3463 /* Determine the common superset address space. This is guaranteed
3464 to exist because the caller verified that comp_target_types
3465 returned non-zero. */
3466 if (!addr_space_superset (as0
, as1
, &as_common
))
3469 common_type
= common_pointer_type (TREE_TYPE (op0
), TREE_TYPE (op1
));
3470 op0
= convert (common_type
, op0
);
3471 op1
= convert (common_type
, op1
);
3474 /* Determine integer type to perform computations in. This will usually
3475 be the same as the result type (ptrdiff_t), but may need to be a wider
3476 type if pointers for the address space are wider than ptrdiff_t. */
3477 if (TYPE_PRECISION (restype
) < TYPE_PRECISION (TREE_TYPE (op0
)))
3478 inttype
= c_common_type_for_size (TYPE_PRECISION (TREE_TYPE (op0
)), 0);
3483 if (TREE_CODE (target_type
) == VOID_TYPE
)
3484 pedwarn (loc
, OPT_Wpointer_arith
,
3485 "pointer of type %<void *%> used in subtraction");
3486 if (TREE_CODE (target_type
) == FUNCTION_TYPE
)
3487 pedwarn (loc
, OPT_Wpointer_arith
,
3488 "pointer to a function used in subtraction");
3490 /* If the conversion to ptrdiff_type does anything like widening or
3491 converting a partial to an integral mode, we get a convert_expression
3492 that is in the way to do any simplifications.
3493 (fold-const.c doesn't know that the extra bits won't be needed.
3494 split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a
3495 different mode in place.)
3496 So first try to find a common term here 'by hand'; we want to cover
3497 at least the cases that occur in legal static initializers. */
3498 if (CONVERT_EXPR_P (op0
)
3499 && (TYPE_PRECISION (TREE_TYPE (op0
))
3500 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0
, 0)))))
3501 con0
= TREE_OPERAND (op0
, 0);
3504 if (CONVERT_EXPR_P (op1
)
3505 && (TYPE_PRECISION (TREE_TYPE (op1
))
3506 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1
, 0)))))
3507 con1
= TREE_OPERAND (op1
, 0);
3511 if (TREE_CODE (con0
) == POINTER_PLUS_EXPR
)
3513 lit0
= TREE_OPERAND (con0
, 1);
3514 con0
= TREE_OPERAND (con0
, 0);
3517 lit0
= integer_zero_node
;
3519 if (TREE_CODE (con1
) == POINTER_PLUS_EXPR
)
3521 lit1
= TREE_OPERAND (con1
, 1);
3522 con1
= TREE_OPERAND (con1
, 0);
3525 lit1
= integer_zero_node
;
3527 if (operand_equal_p (con0
, con1
, 0))
3534 /* First do the subtraction as integers;
3535 then drop through to build the divide operator.
3536 Do not do default conversions on the minus operator
3537 in case restype is a short type. */
3539 op0
= build_binary_op (loc
,
3540 MINUS_EXPR
, convert (inttype
, op0
),
3541 convert (inttype
, op1
), 0);
3542 /* This generates an error if op1 is pointer to incomplete type. */
3543 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1
))))
3544 error_at (loc
, "arithmetic on pointer to an incomplete type");
3546 op1
= c_size_in_bytes (target_type
);
3548 if (pointer_to_zero_sized_aggr_p (TREE_TYPE (orig_op1
)))
3549 error_at (loc
, "arithmetic on pointer to an empty aggregate");
3551 /* Divide by the size, in easiest possible way. */
3552 result
= fold_build2_loc (loc
, EXACT_DIV_EXPR
, inttype
,
3553 op0
, convert (inttype
, op1
));
3555 /* Convert to final result type if necessary. */
3556 return convert (restype
, result
);
3559 /* Expand atomic compound assignments into an approriate sequence as
3560 specified by the C11 standard section 6.5.16.2.
3566 This sequence is used for all types for which these operations are
3569 In addition, built-in versions of the 'fe' prefixed routines may
3570 need to be invoked for floating point (real, complex or vector) when
3571 floating-point exceptions are supported. See 6.5.16.2 footnote 113.
3581 __atomic_load (addr, &old, SEQ_CST);
3582 feholdexcept (&fenv);
3584 newval = old op val;
3585 if (__atomic_compare_exchange_strong (addr, &old, &newval, SEQ_CST,
3588 feclearexcept (FE_ALL_EXCEPT);
3591 feupdateenv (&fenv);
3593 Also note that the compiler is simply issuing the generic form of
3594 the atomic operations. This requires temp(s) and has their address
3595 taken. The atomic processing is smart enough to figure out when the
3596 size of an object can utilize a lock-free version, and convert the
3597 built-in call to the appropriate lock-free routine. The optimizers
3598 will then dispose of any temps that are no longer required, and
3599 lock-free implementations are utilized as long as there is target
3600 support for the required size.
3602 If the operator is NOP_EXPR, then this is a simple assignment, and
3603 an __atomic_store is issued to perform the assignment rather than
3608 /* Build an atomic assignment at LOC, expanding into the proper
3609 sequence to store LHS MODIFYCODE= RHS. Return a value representing
3610 the result of the operation, unless RETURN_OLD_P in which case
3611 return the old value of LHS (this is only for postincrement and
3614 build_atomic_assign (location_t loc
, tree lhs
, enum tree_code modifycode
,
3615 tree rhs
, bool return_old_p
)
3617 tree fndecl
, func_call
;
3618 vec
<tree
, va_gc
> *params
;
3619 tree val
, nonatomic_lhs_type
, nonatomic_rhs_type
, newval
, newval_addr
;
3622 tree stmt
, goto_stmt
;
3623 tree loop_label
, loop_decl
, done_label
, done_decl
;
3625 tree lhs_type
= TREE_TYPE (lhs
);
3626 tree lhs_addr
= build_unary_op (loc
, ADDR_EXPR
, lhs
, 0);
3627 tree seq_cst
= build_int_cst (integer_type_node
, MEMMODEL_SEQ_CST
);
3628 tree rhs_type
= TREE_TYPE (rhs
);
3630 gcc_assert (TYPE_ATOMIC (lhs_type
));
3633 gcc_assert (modifycode
== PLUS_EXPR
|| modifycode
== MINUS_EXPR
);
3635 /* Allocate enough vector items for a compare_exchange. */
3636 vec_alloc (params
, 6);
3638 /* Create a compound statement to hold the sequence of statements
3640 compound_stmt
= c_begin_compound_stmt (false);
3642 /* Fold the RHS if it hasn't already been folded. */
3643 if (modifycode
!= NOP_EXPR
)
3644 rhs
= c_fully_fold (rhs
, false, NULL
);
3646 /* Remove the qualifiers for the rest of the expressions and create
3647 the VAL temp variable to hold the RHS. */
3648 nonatomic_lhs_type
= build_qualified_type (lhs_type
, TYPE_UNQUALIFIED
);
3649 nonatomic_rhs_type
= build_qualified_type (rhs_type
, TYPE_UNQUALIFIED
);
3650 val
= create_tmp_var (nonatomic_rhs_type
, NULL
);
3651 TREE_ADDRESSABLE (val
) = 1;
3652 TREE_NO_WARNING (val
) = 1;
3653 rhs
= build2 (MODIFY_EXPR
, nonatomic_rhs_type
, val
, rhs
);
3654 SET_EXPR_LOCATION (rhs
, loc
);
3657 /* NOP_EXPR indicates it's a straight store of the RHS. Simply issue
3659 if (modifycode
== NOP_EXPR
)
3661 /* Build __atomic_store (&lhs, &val, SEQ_CST) */
3662 rhs
= build_unary_op (loc
, ADDR_EXPR
, val
, 0);
3663 fndecl
= builtin_decl_explicit (BUILT_IN_ATOMIC_STORE
);
3664 params
->quick_push (lhs_addr
);
3665 params
->quick_push (rhs
);
3666 params
->quick_push (seq_cst
);
3667 func_call
= c_build_function_call_vec (loc
, vNULL
, fndecl
, params
, NULL
);
3668 add_stmt (func_call
);
3670 /* Finish the compound statement. */
3671 compound_stmt
= c_end_compound_stmt (loc
, compound_stmt
, false);
3673 /* VAL is the value which was stored, return a COMPOUND_STMT of
3674 the statement and that value. */
3675 return build2 (COMPOUND_EXPR
, nonatomic_lhs_type
, compound_stmt
, val
);
3678 /* Create the variables and labels required for the op= form. */
3679 old
= create_tmp_var (nonatomic_lhs_type
, NULL
);
3680 old_addr
= build_unary_op (loc
, ADDR_EXPR
, old
, 0);
3681 TREE_ADDRESSABLE (old
) = 1;
3682 TREE_NO_WARNING (old
) = 1;
3684 newval
= create_tmp_var (nonatomic_lhs_type
, NULL
);
3685 newval_addr
= build_unary_op (loc
, ADDR_EXPR
, newval
, 0);
3686 TREE_ADDRESSABLE (newval
) = 1;
3688 loop_decl
= create_artificial_label (loc
);
3689 loop_label
= build1 (LABEL_EXPR
, void_type_node
, loop_decl
);
3691 done_decl
= create_artificial_label (loc
);
3692 done_label
= build1 (LABEL_EXPR
, void_type_node
, done_decl
);
3694 /* __atomic_load (addr, &old, SEQ_CST). */
3695 fndecl
= builtin_decl_explicit (BUILT_IN_ATOMIC_LOAD
);
3696 params
->quick_push (lhs_addr
);
3697 params
->quick_push (old_addr
);
3698 params
->quick_push (seq_cst
);
3699 func_call
= c_build_function_call_vec (loc
, vNULL
, fndecl
, params
, NULL
);
3700 add_stmt (func_call
);
3701 params
->truncate (0);
3703 /* Create the expressions for floating-point environment
3704 manipulation, if required. */
3705 bool need_fenv
= (flag_trapping_math
3706 && (FLOAT_TYPE_P (lhs_type
) || FLOAT_TYPE_P (rhs_type
)));
3707 tree hold_call
= NULL_TREE
, clear_call
= NULL_TREE
, update_call
= NULL_TREE
;
3709 targetm
.atomic_assign_expand_fenv (&hold_call
, &clear_call
, &update_call
);
3712 add_stmt (hold_call
);
3715 add_stmt (loop_label
);
3717 /* newval = old + val; */
3718 rhs
= build_binary_op (loc
, modifycode
, old
, val
, 1);
3719 rhs
= convert_for_assignment (loc
, UNKNOWN_LOCATION
, nonatomic_lhs_type
,
3720 rhs
, NULL_TREE
, ic_assign
, false, NULL_TREE
,
3722 if (rhs
!= error_mark_node
)
3724 rhs
= build2 (MODIFY_EXPR
, nonatomic_lhs_type
, newval
, rhs
);
3725 SET_EXPR_LOCATION (rhs
, loc
);
3729 /* if (__atomic_compare_exchange (addr, &old, &new, false, SEQ_CST, SEQ_CST))
3731 fndecl
= builtin_decl_explicit (BUILT_IN_ATOMIC_COMPARE_EXCHANGE
);
3732 params
->quick_push (lhs_addr
);
3733 params
->quick_push (old_addr
);
3734 params
->quick_push (newval_addr
);
3735 params
->quick_push (integer_zero_node
);
3736 params
->quick_push (seq_cst
);
3737 params
->quick_push (seq_cst
);
3738 func_call
= c_build_function_call_vec (loc
, vNULL
, fndecl
, params
, NULL
);
3740 goto_stmt
= build1 (GOTO_EXPR
, void_type_node
, done_decl
);
3741 SET_EXPR_LOCATION (goto_stmt
, loc
);
3743 stmt
= build3 (COND_EXPR
, void_type_node
, func_call
, goto_stmt
, NULL_TREE
);
3744 SET_EXPR_LOCATION (stmt
, loc
);
3748 add_stmt (clear_call
);
3751 goto_stmt
= build1 (GOTO_EXPR
, void_type_node
, loop_decl
);
3752 SET_EXPR_LOCATION (goto_stmt
, loc
);
3753 add_stmt (goto_stmt
);
3756 add_stmt (done_label
);
3759 add_stmt (update_call
);
3761 /* Finish the compound statement. */
3762 compound_stmt
= c_end_compound_stmt (loc
, compound_stmt
, false);
3764 /* NEWVAL is the value that was successfully stored, return a
3765 COMPOUND_EXPR of the statement and the appropriate value. */
3766 return build2 (COMPOUND_EXPR
, nonatomic_lhs_type
, compound_stmt
,
3767 return_old_p
? old
: newval
);
3770 /* Construct and perhaps optimize a tree representation
3771 for a unary operation. CODE, a tree_code, specifies the operation
3772 and XARG is the operand.
3773 For any CODE other than ADDR_EXPR, FLAG nonzero suppresses
3774 the default promotions (such as from short to int).
3775 For ADDR_EXPR, the default promotions are not applied; FLAG nonzero
3776 allows non-lvalues; this is only used to handle conversion of non-lvalue
3777 arrays to pointers in C99.
3779 LOCATION is the location of the operator. */
3782 build_unary_op (location_t location
,
3783 enum tree_code code
, tree xarg
, int flag
)
3785 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
3788 enum tree_code typecode
;
3790 tree ret
= error_mark_node
;
3791 tree eptype
= NULL_TREE
;
3792 int noconvert
= flag
;
3793 const char *invalid_op_diag
;
3796 int_operands
= EXPR_INT_CONST_OPERANDS (xarg
);
3798 arg
= remove_c_maybe_const_expr (arg
);
3800 if (code
!= ADDR_EXPR
)
3801 arg
= require_complete_type (arg
);
3803 typecode
= TREE_CODE (TREE_TYPE (arg
));
3804 if (typecode
== ERROR_MARK
)
3805 return error_mark_node
;
3806 if (typecode
== ENUMERAL_TYPE
|| typecode
== BOOLEAN_TYPE
)
3807 typecode
= INTEGER_TYPE
;
3809 if ((invalid_op_diag
3810 = targetm
.invalid_unary_op (code
, TREE_TYPE (xarg
))))
3812 error_at (location
, invalid_op_diag
);
3813 return error_mark_node
;
3816 if (TREE_CODE (arg
) == EXCESS_PRECISION_EXPR
)
3818 eptype
= TREE_TYPE (arg
);
3819 arg
= TREE_OPERAND (arg
, 0);
3825 /* This is used for unary plus, because a CONVERT_EXPR
3826 is enough to prevent anybody from looking inside for
3827 associativity, but won't generate any code. */
3828 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
3829 || typecode
== FIXED_POINT_TYPE
|| typecode
== COMPLEX_TYPE
3830 || typecode
== VECTOR_TYPE
))
3832 error_at (location
, "wrong type argument to unary plus");
3833 return error_mark_node
;
3835 else if (!noconvert
)
3836 arg
= default_conversion (arg
);
3837 arg
= non_lvalue_loc (location
, arg
);
3841 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
3842 || typecode
== FIXED_POINT_TYPE
|| typecode
== COMPLEX_TYPE
3843 || typecode
== VECTOR_TYPE
))
3845 error_at (location
, "wrong type argument to unary minus");
3846 return error_mark_node
;
3848 else if (!noconvert
)
3849 arg
= default_conversion (arg
);
3853 /* ~ works on integer types and non float vectors. */
3854 if (typecode
== INTEGER_TYPE
3855 || (typecode
== VECTOR_TYPE
3856 && !VECTOR_FLOAT_TYPE_P (TREE_TYPE (arg
))))
3859 arg
= default_conversion (arg
);
3861 else if (typecode
== COMPLEX_TYPE
)
3864 pedwarn (location
, OPT_Wpedantic
,
3865 "ISO C does not support %<~%> for complex conjugation");
3867 arg
= default_conversion (arg
);
3871 error_at (location
, "wrong type argument to bit-complement");
3872 return error_mark_node
;
3877 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
))
3879 error_at (location
, "wrong type argument to abs");
3880 return error_mark_node
;
3882 else if (!noconvert
)
3883 arg
= default_conversion (arg
);
3887 /* Conjugating a real value is a no-op, but allow it anyway. */
3888 if (!(typecode
== INTEGER_TYPE
|| typecode
== REAL_TYPE
3889 || typecode
== COMPLEX_TYPE
))
3891 error_at (location
, "wrong type argument to conjugation");
3892 return error_mark_node
;
3894 else if (!noconvert
)
3895 arg
= default_conversion (arg
);
3898 case TRUTH_NOT_EXPR
:
3899 if (typecode
!= INTEGER_TYPE
&& typecode
!= FIXED_POINT_TYPE
3900 && typecode
!= REAL_TYPE
&& typecode
!= POINTER_TYPE
3901 && typecode
!= COMPLEX_TYPE
)
3904 "wrong type argument to unary exclamation mark");
3905 return error_mark_node
;
3909 arg
= c_objc_common_truthvalue_conversion (location
, xarg
);
3910 arg
= remove_c_maybe_const_expr (arg
);
3913 arg
= c_objc_common_truthvalue_conversion (location
, arg
);
3914 ret
= invert_truthvalue_loc (location
, arg
);
3915 /* If the TRUTH_NOT_EXPR has been folded, reset the location. */
3916 if (EXPR_P (ret
) && EXPR_HAS_LOCATION (ret
))
3917 location
= EXPR_LOCATION (ret
);
3918 goto return_build_unary_op
;
3922 ret
= build_real_imag_expr (location
, code
, arg
);
3923 if (ret
== error_mark_node
)
3924 return error_mark_node
;
3925 if (eptype
&& TREE_CODE (eptype
) == COMPLEX_TYPE
)
3926 eptype
= TREE_TYPE (eptype
);
3927 goto return_build_unary_op
;
3929 case PREINCREMENT_EXPR
:
3930 case POSTINCREMENT_EXPR
:
3931 case PREDECREMENT_EXPR
:
3932 case POSTDECREMENT_EXPR
:
3934 if (TREE_CODE (arg
) == C_MAYBE_CONST_EXPR
)
3936 tree inner
= build_unary_op (location
, code
,
3937 C_MAYBE_CONST_EXPR_EXPR (arg
), flag
);
3938 if (inner
== error_mark_node
)
3939 return error_mark_node
;
3940 ret
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (inner
),
3941 C_MAYBE_CONST_EXPR_PRE (arg
), inner
);
3942 gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (arg
));
3943 C_MAYBE_CONST_EXPR_NON_CONST (ret
) = 1;
3944 goto return_build_unary_op
;
3947 /* Complain about anything that is not a true lvalue. In
3948 Objective-C, skip this check for property_refs. */
3949 if (!objc_is_property_ref (arg
)
3950 && !lvalue_or_else (location
,
3951 arg
, ((code
== PREINCREMENT_EXPR
3952 || code
== POSTINCREMENT_EXPR
)
3955 return error_mark_node
;
3957 if (warn_cxx_compat
&& TREE_CODE (TREE_TYPE (arg
)) == ENUMERAL_TYPE
)
3959 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
3960 warning_at (location
, OPT_Wc___compat
,
3961 "increment of enumeration value is invalid in C++");
3963 warning_at (location
, OPT_Wc___compat
,
3964 "decrement of enumeration value is invalid in C++");
3967 /* Ensure the argument is fully folded inside any SAVE_EXPR. */
3968 arg
= c_fully_fold (arg
, false, NULL
);
3971 atomic_op
= really_atomic_lvalue (arg
);
3973 /* Increment or decrement the real part of the value,
3974 and don't change the imaginary part. */
3975 if (typecode
== COMPLEX_TYPE
)
3979 pedwarn (location
, OPT_Wpedantic
,
3980 "ISO C does not support %<++%> and %<--%> on complex types");
3984 arg
= stabilize_reference (arg
);
3985 real
= build_unary_op (EXPR_LOCATION (arg
), REALPART_EXPR
, arg
, 1);
3986 imag
= build_unary_op (EXPR_LOCATION (arg
), IMAGPART_EXPR
, arg
, 1);
3987 real
= build_unary_op (EXPR_LOCATION (arg
), code
, real
, 1);
3988 if (real
== error_mark_node
|| imag
== error_mark_node
)
3989 return error_mark_node
;
3990 ret
= build2 (COMPLEX_EXPR
, TREE_TYPE (arg
),
3992 goto return_build_unary_op
;
3996 /* Report invalid types. */
3998 if (typecode
!= POINTER_TYPE
&& typecode
!= FIXED_POINT_TYPE
3999 && typecode
!= INTEGER_TYPE
&& typecode
!= REAL_TYPE
4000 && typecode
!= COMPLEX_TYPE
&& typecode
!= VECTOR_TYPE
)
4002 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
4003 error_at (location
, "wrong type argument to increment");
4005 error_at (location
, "wrong type argument to decrement");
4007 return error_mark_node
;
4013 argtype
= TREE_TYPE (arg
);
4015 /* Compute the increment. */
4017 if (typecode
== POINTER_TYPE
)
4019 /* If pointer target is an incomplete type,
4020 we just cannot know how to do the arithmetic. */
4021 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (argtype
)))
4023 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
4025 "increment of pointer to an incomplete type %qT",
4026 TREE_TYPE (argtype
));
4029 "decrement of pointer to an incomplete type %qT",
4030 TREE_TYPE (argtype
));
4032 else if (TREE_CODE (TREE_TYPE (argtype
)) == FUNCTION_TYPE
4033 || TREE_CODE (TREE_TYPE (argtype
)) == VOID_TYPE
)
4035 if (code
== PREINCREMENT_EXPR
|| code
== POSTINCREMENT_EXPR
)
4036 pedwarn (location
, OPT_Wpointer_arith
,
4037 "wrong type argument to increment");
4039 pedwarn (location
, OPT_Wpointer_arith
,
4040 "wrong type argument to decrement");
4043 inc
= c_size_in_bytes (TREE_TYPE (argtype
));
4044 inc
= convert_to_ptrofftype_loc (location
, inc
);
4046 else if (FRACT_MODE_P (TYPE_MODE (argtype
)))
4048 /* For signed fract types, we invert ++ to -- or
4049 -- to ++, and change inc from 1 to -1, because
4050 it is not possible to represent 1 in signed fract constants.
4051 For unsigned fract types, the result always overflows and
4052 we get an undefined (original) or the maximum value. */
4053 if (code
== PREINCREMENT_EXPR
)
4054 code
= PREDECREMENT_EXPR
;
4055 else if (code
== PREDECREMENT_EXPR
)
4056 code
= PREINCREMENT_EXPR
;
4057 else if (code
== POSTINCREMENT_EXPR
)
4058 code
= POSTDECREMENT_EXPR
;
4059 else /* code == POSTDECREMENT_EXPR */
4060 code
= POSTINCREMENT_EXPR
;
4062 inc
= integer_minus_one_node
;
4063 inc
= convert (argtype
, inc
);
4067 inc
= VECTOR_TYPE_P (argtype
)
4068 ? build_one_cst (argtype
)
4070 inc
= convert (argtype
, inc
);
4073 /* If 'arg' is an Objective-C PROPERTY_REF expression, then we
4074 need to ask Objective-C to build the increment or decrement
4075 expression for it. */
4076 if (objc_is_property_ref (arg
))
4077 return objc_build_incr_expr_for_property_ref (location
, code
,
4080 /* Report a read-only lvalue. */
4081 if (TYPE_READONLY (argtype
))
4083 readonly_error (location
, arg
,
4084 ((code
== PREINCREMENT_EXPR
4085 || code
== POSTINCREMENT_EXPR
)
4086 ? lv_increment
: lv_decrement
));
4087 return error_mark_node
;
4089 else if (TREE_READONLY (arg
))
4090 readonly_warning (arg
,
4091 ((code
== PREINCREMENT_EXPR
4092 || code
== POSTINCREMENT_EXPR
)
4093 ? lv_increment
: lv_decrement
));
4095 /* If the argument is atomic, use the special code sequences for
4096 atomic compound assignment. */
4099 arg
= stabilize_reference (arg
);
4100 ret
= build_atomic_assign (location
, arg
,
4101 ((code
== PREINCREMENT_EXPR
4102 || code
== POSTINCREMENT_EXPR
)
4105 (FRACT_MODE_P (TYPE_MODE (argtype
))
4107 : integer_one_node
),
4108 (code
== POSTINCREMENT_EXPR
4109 || code
== POSTDECREMENT_EXPR
));
4110 goto return_build_unary_op
;
4113 if (TREE_CODE (TREE_TYPE (arg
)) == BOOLEAN_TYPE
)
4114 val
= boolean_increment (code
, arg
);
4116 val
= build2 (code
, TREE_TYPE (arg
), arg
, inc
);
4117 TREE_SIDE_EFFECTS (val
) = 1;
4118 if (TREE_CODE (val
) != code
)
4119 TREE_NO_WARNING (val
) = 1;
4121 goto return_build_unary_op
;
4125 /* Note that this operation never does default_conversion. */
4127 /* The operand of unary '&' must be an lvalue (which excludes
4128 expressions of type void), or, in C99, the result of a [] or
4129 unary '*' operator. */
4130 if (VOID_TYPE_P (TREE_TYPE (arg
))
4131 && TYPE_QUALS (TREE_TYPE (arg
)) == TYPE_UNQUALIFIED
4132 && (TREE_CODE (arg
) != INDIRECT_REF
4134 pedwarn (location
, 0, "taking address of expression of type %<void%>");
4136 /* Let &* cancel out to simplify resulting code. */
4137 if (TREE_CODE (arg
) == INDIRECT_REF
)
4139 /* Don't let this be an lvalue. */
4140 if (lvalue_p (TREE_OPERAND (arg
, 0)))
4141 return non_lvalue_loc (location
, TREE_OPERAND (arg
, 0));
4142 ret
= TREE_OPERAND (arg
, 0);
4143 goto return_build_unary_op
;
4146 /* For &x[y], return x+y */
4147 if (TREE_CODE (arg
) == ARRAY_REF
)
4149 tree op0
= TREE_OPERAND (arg
, 0);
4150 if (!c_mark_addressable (op0
))
4151 return error_mark_node
;
4154 /* Anything not already handled and not a true memory reference
4155 or a non-lvalue array is an error. */
4156 else if (typecode
!= FUNCTION_TYPE
&& !flag
4157 && !lvalue_or_else (location
, arg
, lv_addressof
))
4158 return error_mark_node
;
4160 /* Move address operations inside C_MAYBE_CONST_EXPR to simplify
4162 if (TREE_CODE (arg
) == C_MAYBE_CONST_EXPR
)
4164 tree inner
= build_unary_op (location
, code
,
4165 C_MAYBE_CONST_EXPR_EXPR (arg
), flag
);
4166 ret
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (inner
),
4167 C_MAYBE_CONST_EXPR_PRE (arg
), inner
);
4168 gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (arg
));
4169 C_MAYBE_CONST_EXPR_NON_CONST (ret
)
4170 = C_MAYBE_CONST_EXPR_NON_CONST (arg
);
4171 goto return_build_unary_op
;
4174 /* Ordinary case; arg is a COMPONENT_REF or a decl. */
4175 argtype
= TREE_TYPE (arg
);
4177 /* If the lvalue is const or volatile, merge that into the type
4178 to which the address will point. This is only needed
4179 for function types. */
4180 if ((DECL_P (arg
) || REFERENCE_CLASS_P (arg
))
4181 && (TREE_READONLY (arg
) || TREE_THIS_VOLATILE (arg
))
4182 && TREE_CODE (argtype
) == FUNCTION_TYPE
)
4184 int orig_quals
= TYPE_QUALS (strip_array_types (argtype
));
4185 int quals
= orig_quals
;
4187 if (TREE_READONLY (arg
))
4188 quals
|= TYPE_QUAL_CONST
;
4189 if (TREE_THIS_VOLATILE (arg
))
4190 quals
|= TYPE_QUAL_VOLATILE
;
4192 argtype
= c_build_qualified_type (argtype
, quals
);
4195 if (!c_mark_addressable (arg
))
4196 return error_mark_node
;
4198 gcc_assert (TREE_CODE (arg
) != COMPONENT_REF
4199 || !DECL_C_BIT_FIELD (TREE_OPERAND (arg
, 1)));
4201 argtype
= build_pointer_type (argtype
);
4203 /* ??? Cope with user tricks that amount to offsetof. Delete this
4204 when we have proper support for integer constant expressions. */
4205 val
= get_base_address (arg
);
4206 if (val
&& TREE_CODE (val
) == INDIRECT_REF
4207 && TREE_CONSTANT (TREE_OPERAND (val
, 0)))
4209 ret
= fold_convert_loc (location
, argtype
, fold_offsetof_1 (arg
));
4210 goto return_build_unary_op
;
4213 val
= build1 (ADDR_EXPR
, argtype
, arg
);
4216 goto return_build_unary_op
;
4223 argtype
= TREE_TYPE (arg
);
4224 if (TREE_CODE (arg
) == INTEGER_CST
)
4225 ret
= (require_constant_value
4226 ? fold_build1_initializer_loc (location
, code
, argtype
, arg
)
4227 : fold_build1_loc (location
, code
, argtype
, arg
));
4229 ret
= build1 (code
, argtype
, arg
);
4230 return_build_unary_op
:
4231 gcc_assert (ret
!= error_mark_node
);
4232 if (TREE_CODE (ret
) == INTEGER_CST
&& !TREE_OVERFLOW (ret
)
4233 && !(TREE_CODE (xarg
) == INTEGER_CST
&& !TREE_OVERFLOW (xarg
)))
4234 ret
= build1 (NOP_EXPR
, TREE_TYPE (ret
), ret
);
4235 else if (TREE_CODE (ret
) != INTEGER_CST
&& int_operands
)
4236 ret
= note_integer_operands (ret
);
4238 ret
= build1 (EXCESS_PRECISION_EXPR
, eptype
, ret
);
4239 protected_set_expr_location (ret
, location
);
4243 /* Return nonzero if REF is an lvalue valid for this language.
4244 Lvalues can be assigned, unless their type has TYPE_READONLY.
4245 Lvalues can have their address taken, unless they have C_DECL_REGISTER. */
4248 lvalue_p (const_tree ref
)
4250 const enum tree_code code
= TREE_CODE (ref
);
4257 return lvalue_p (TREE_OPERAND (ref
, 0));
4259 case C_MAYBE_CONST_EXPR
:
4260 return lvalue_p (TREE_OPERAND (ref
, 1));
4262 case COMPOUND_LITERAL_EXPR
:
4268 case ARRAY_NOTATION_REF
:
4273 return (TREE_CODE (TREE_TYPE (ref
)) != FUNCTION_TYPE
4274 && TREE_CODE (TREE_TYPE (ref
)) != METHOD_TYPE
);
4277 return TREE_CODE (TREE_TYPE (ref
)) == ARRAY_TYPE
;
4284 /* Give a warning for storing in something that is read-only in GCC
4285 terms but not const in ISO C terms. */
4288 readonly_warning (tree arg
, enum lvalue_use use
)
4293 warning (0, "assignment of read-only location %qE", arg
);
4296 warning (0, "increment of read-only location %qE", arg
);
4299 warning (0, "decrement of read-only location %qE", arg
);
4308 /* Return nonzero if REF is an lvalue valid for this language;
4309 otherwise, print an error message and return zero. USE says
4310 how the lvalue is being used and so selects the error message.
4311 LOCATION is the location at which any error should be reported. */
4314 lvalue_or_else (location_t loc
, const_tree ref
, enum lvalue_use use
)
4316 int win
= lvalue_p (ref
);
4319 lvalue_error (loc
, use
);
4324 /* Mark EXP saying that we need to be able to take the
4325 address of it; it should not be allocated in a register.
4326 Returns true if successful. */
4329 c_mark_addressable (tree exp
)
4334 switch (TREE_CODE (x
))
4337 if (DECL_C_BIT_FIELD (TREE_OPERAND (x
, 1)))
4340 ("cannot take address of bit-field %qD", TREE_OPERAND (x
, 1));
4344 /* ... fall through ... */
4350 x
= TREE_OPERAND (x
, 0);
4353 case COMPOUND_LITERAL_EXPR
:
4355 TREE_ADDRESSABLE (x
) = 1;
4362 if (C_DECL_REGISTER (x
)
4363 && DECL_NONLOCAL (x
))
4365 if (TREE_PUBLIC (x
) || TREE_STATIC (x
) || DECL_EXTERNAL (x
))
4368 ("global register variable %qD used in nested function", x
);
4371 pedwarn (input_location
, 0, "register variable %qD used in nested function", x
);
4373 else if (C_DECL_REGISTER (x
))
4375 if (TREE_PUBLIC (x
) || TREE_STATIC (x
) || DECL_EXTERNAL (x
))
4376 error ("address of global register variable %qD requested", x
);
4378 error ("address of register variable %qD requested", x
);
4384 TREE_ADDRESSABLE (x
) = 1;
4391 /* Convert EXPR to TYPE, warning about conversion problems with
4392 constants. SEMANTIC_TYPE is the type this conversion would use
4393 without excess precision. If SEMANTIC_TYPE is NULL, this function
4394 is equivalent to convert_and_check. This function is a wrapper that
4395 handles conversions that may be different than
4396 the usual ones because of excess precision. */
4399 ep_convert_and_check (location_t loc
, tree type
, tree expr
,
4402 if (TREE_TYPE (expr
) == type
)
4406 return convert_and_check (loc
, type
, expr
);
4408 if (TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
4409 && TREE_TYPE (expr
) != semantic_type
)
4411 /* For integers, we need to check the real conversion, not
4412 the conversion to the excess precision type. */
4413 expr
= convert_and_check (loc
, semantic_type
, expr
);
4415 /* Result type is the excess precision type, which should be
4416 large enough, so do not check. */
4417 return convert (type
, expr
);
4420 /* Build and return a conditional expression IFEXP ? OP1 : OP2. If
4421 IFEXP_BCP then the condition is a call to __builtin_constant_p, and
4422 if folded to an integer constant then the unselected half may
4423 contain arbitrary operations not normally permitted in constant
4424 expressions. Set the location of the expression to LOC. */
4427 build_conditional_expr (location_t colon_loc
, tree ifexp
, bool ifexp_bcp
,
4428 tree op1
, tree op1_original_type
, tree op2
,
4429 tree op2_original_type
)
4433 enum tree_code code1
;
4434 enum tree_code code2
;
4435 tree result_type
= NULL
;
4436 tree semantic_result_type
= NULL
;
4437 tree orig_op1
= op1
, orig_op2
= op2
;
4438 bool int_const
, op1_int_operands
, op2_int_operands
, int_operands
;
4439 bool ifexp_int_operands
;
4442 op1_int_operands
= EXPR_INT_CONST_OPERANDS (orig_op1
);
4443 if (op1_int_operands
)
4444 op1
= remove_c_maybe_const_expr (op1
);
4445 op2_int_operands
= EXPR_INT_CONST_OPERANDS (orig_op2
);
4446 if (op2_int_operands
)
4447 op2
= remove_c_maybe_const_expr (op2
);
4448 ifexp_int_operands
= EXPR_INT_CONST_OPERANDS (ifexp
);
4449 if (ifexp_int_operands
)
4450 ifexp
= remove_c_maybe_const_expr (ifexp
);
4452 /* Promote both alternatives. */
4454 if (TREE_CODE (TREE_TYPE (op1
)) != VOID_TYPE
)
4455 op1
= default_conversion (op1
);
4456 if (TREE_CODE (TREE_TYPE (op2
)) != VOID_TYPE
)
4457 op2
= default_conversion (op2
);
4459 if (TREE_CODE (ifexp
) == ERROR_MARK
4460 || TREE_CODE (TREE_TYPE (op1
)) == ERROR_MARK
4461 || TREE_CODE (TREE_TYPE (op2
)) == ERROR_MARK
)
4462 return error_mark_node
;
4464 type1
= TREE_TYPE (op1
);
4465 code1
= TREE_CODE (type1
);
4466 type2
= TREE_TYPE (op2
);
4467 code2
= TREE_CODE (type2
);
4469 /* C90 does not permit non-lvalue arrays in conditional expressions.
4470 In C99 they will be pointers by now. */
4471 if (code1
== ARRAY_TYPE
|| code2
== ARRAY_TYPE
)
4473 error_at (colon_loc
, "non-lvalue array in conditional expression");
4474 return error_mark_node
;
4477 if ((TREE_CODE (op1
) == EXCESS_PRECISION_EXPR
4478 || TREE_CODE (op2
) == EXCESS_PRECISION_EXPR
)
4479 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
4480 || code1
== COMPLEX_TYPE
)
4481 && (code2
== INTEGER_TYPE
|| code2
== REAL_TYPE
4482 || code2
== COMPLEX_TYPE
))
4484 semantic_result_type
= c_common_type (type1
, type2
);
4485 if (TREE_CODE (op1
) == EXCESS_PRECISION_EXPR
)
4487 op1
= TREE_OPERAND (op1
, 0);
4488 type1
= TREE_TYPE (op1
);
4489 gcc_assert (TREE_CODE (type1
) == code1
);
4491 if (TREE_CODE (op2
) == EXCESS_PRECISION_EXPR
)
4493 op2
= TREE_OPERAND (op2
, 0);
4494 type2
= TREE_TYPE (op2
);
4495 gcc_assert (TREE_CODE (type2
) == code2
);
4499 if (warn_cxx_compat
)
4501 tree t1
= op1_original_type
? op1_original_type
: TREE_TYPE (orig_op1
);
4502 tree t2
= op2_original_type
? op2_original_type
: TREE_TYPE (orig_op2
);
4504 if (TREE_CODE (t1
) == ENUMERAL_TYPE
4505 && TREE_CODE (t2
) == ENUMERAL_TYPE
4506 && TYPE_MAIN_VARIANT (t1
) != TYPE_MAIN_VARIANT (t2
))
4507 warning_at (colon_loc
, OPT_Wc___compat
,
4508 ("different enum types in conditional is "
4509 "invalid in C++: %qT vs %qT"),
4513 /* Quickly detect the usual case where op1 and op2 have the same type
4515 if (TYPE_MAIN_VARIANT (type1
) == TYPE_MAIN_VARIANT (type2
))
4518 result_type
= type1
;
4520 result_type
= TYPE_MAIN_VARIANT (type1
);
4522 else if ((code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
4523 || code1
== COMPLEX_TYPE
)
4524 && (code2
== INTEGER_TYPE
|| code2
== REAL_TYPE
4525 || code2
== COMPLEX_TYPE
))
4527 result_type
= c_common_type (type1
, type2
);
4528 do_warn_double_promotion (result_type
, type1
, type2
,
4529 "implicit conversion from %qT to %qT to "
4530 "match other result of conditional",
4533 /* If -Wsign-compare, warn here if type1 and type2 have
4534 different signedness. We'll promote the signed to unsigned
4535 and later code won't know it used to be different.
4536 Do this check on the original types, so that explicit casts
4537 will be considered, but default promotions won't. */
4538 if (c_inhibit_evaluation_warnings
== 0)
4540 int unsigned_op1
= TYPE_UNSIGNED (TREE_TYPE (orig_op1
));
4541 int unsigned_op2
= TYPE_UNSIGNED (TREE_TYPE (orig_op2
));
4543 if (unsigned_op1
^ unsigned_op2
)
4547 /* Do not warn if the result type is signed, since the
4548 signed type will only be chosen if it can represent
4549 all the values of the unsigned type. */
4550 if (!TYPE_UNSIGNED (result_type
))
4554 bool op1_maybe_const
= true;
4555 bool op2_maybe_const
= true;
4557 /* Do not warn if the signed quantity is an
4558 unsuffixed integer literal (or some static
4559 constant expression involving such literals) and
4560 it is non-negative. This warning requires the
4561 operands to be folded for best results, so do
4562 that folding in this case even without
4563 warn_sign_compare to avoid warning options
4564 possibly affecting code generation. */
4565 c_inhibit_evaluation_warnings
4566 += (ifexp
== truthvalue_false_node
);
4567 op1
= c_fully_fold (op1
, require_constant_value
,
4569 c_inhibit_evaluation_warnings
4570 -= (ifexp
== truthvalue_false_node
);
4572 c_inhibit_evaluation_warnings
4573 += (ifexp
== truthvalue_true_node
);
4574 op2
= c_fully_fold (op2
, require_constant_value
,
4576 c_inhibit_evaluation_warnings
4577 -= (ifexp
== truthvalue_true_node
);
4579 if (warn_sign_compare
)
4582 && tree_expr_nonnegative_warnv_p (op1
, &ovf
))
4584 && tree_expr_nonnegative_warnv_p (op2
, &ovf
)))
4587 warning_at (colon_loc
, OPT_Wsign_compare
,
4588 ("signed and unsigned type in "
4589 "conditional expression"));
4591 if (!op1_maybe_const
|| TREE_CODE (op1
) != INTEGER_CST
)
4592 op1
= c_wrap_maybe_const (op1
, !op1_maybe_const
);
4593 if (!op2_maybe_const
|| TREE_CODE (op2
) != INTEGER_CST
)
4594 op2
= c_wrap_maybe_const (op2
, !op2_maybe_const
);
4599 else if (code1
== VOID_TYPE
|| code2
== VOID_TYPE
)
4601 if (code1
!= VOID_TYPE
|| code2
!= VOID_TYPE
)
4602 pedwarn (colon_loc
, OPT_Wpedantic
,
4603 "ISO C forbids conditional expr with only one void side");
4604 result_type
= void_type_node
;
4606 else if (code1
== POINTER_TYPE
&& code2
== POINTER_TYPE
)
4608 addr_space_t as1
= TYPE_ADDR_SPACE (TREE_TYPE (type1
));
4609 addr_space_t as2
= TYPE_ADDR_SPACE (TREE_TYPE (type2
));
4610 addr_space_t as_common
;
4612 if (comp_target_types (colon_loc
, type1
, type2
))
4613 result_type
= common_pointer_type (type1
, type2
);
4614 else if (null_pointer_constant_p (orig_op1
))
4615 result_type
= type2
;
4616 else if (null_pointer_constant_p (orig_op2
))
4617 result_type
= type1
;
4618 else if (!addr_space_superset (as1
, as2
, &as_common
))
4620 error_at (colon_loc
, "pointers to disjoint address spaces "
4621 "used in conditional expression");
4622 return error_mark_node
;
4624 else if (VOID_TYPE_P (TREE_TYPE (type1
))
4625 && !TYPE_ATOMIC (TREE_TYPE (type1
)))
4627 if (TREE_CODE (TREE_TYPE (type2
)) == FUNCTION_TYPE
)
4628 pedwarn (colon_loc
, OPT_Wpedantic
,
4629 "ISO C forbids conditional expr between "
4630 "%<void *%> and function pointer");
4631 result_type
= build_pointer_type (qualify_type (TREE_TYPE (type1
),
4632 TREE_TYPE (type2
)));
4634 else if (VOID_TYPE_P (TREE_TYPE (type2
))
4635 && !TYPE_ATOMIC (TREE_TYPE (type2
)))
4637 if (TREE_CODE (TREE_TYPE (type1
)) == FUNCTION_TYPE
)
4638 pedwarn (colon_loc
, OPT_Wpedantic
,
4639 "ISO C forbids conditional expr between "
4640 "%<void *%> and function pointer");
4641 result_type
= build_pointer_type (qualify_type (TREE_TYPE (type2
),
4642 TREE_TYPE (type1
)));
4644 /* Objective-C pointer comparisons are a bit more lenient. */
4645 else if (objc_have_common_type (type1
, type2
, -3, NULL_TREE
))
4646 result_type
= objc_common_type (type1
, type2
);
4649 int qual
= ENCODE_QUAL_ADDR_SPACE (as_common
);
4651 pedwarn (colon_loc
, 0,
4652 "pointer type mismatch in conditional expression");
4653 result_type
= build_pointer_type
4654 (build_qualified_type (void_type_node
, qual
));
4657 else if (code1
== POINTER_TYPE
&& code2
== INTEGER_TYPE
)
4659 if (!null_pointer_constant_p (orig_op2
))
4660 pedwarn (colon_loc
, 0,
4661 "pointer/integer type mismatch in conditional expression");
4664 op2
= null_pointer_node
;
4666 result_type
= type1
;
4668 else if (code2
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
4670 if (!null_pointer_constant_p (orig_op1
))
4671 pedwarn (colon_loc
, 0,
4672 "pointer/integer type mismatch in conditional expression");
4675 op1
= null_pointer_node
;
4677 result_type
= type2
;
4682 if (flag_cond_mismatch
)
4683 result_type
= void_type_node
;
4686 error_at (colon_loc
, "type mismatch in conditional expression");
4687 return error_mark_node
;
4691 /* Merge const and volatile flags of the incoming types. */
4693 = build_type_variant (result_type
,
4694 TYPE_READONLY (type1
) || TYPE_READONLY (type2
),
4695 TYPE_VOLATILE (type1
) || TYPE_VOLATILE (type2
));
4697 op1
= ep_convert_and_check (colon_loc
, result_type
, op1
,
4698 semantic_result_type
);
4699 op2
= ep_convert_and_check (colon_loc
, result_type
, op2
,
4700 semantic_result_type
);
4702 if (ifexp_bcp
&& ifexp
== truthvalue_true_node
)
4704 op2_int_operands
= true;
4705 op1
= c_fully_fold (op1
, require_constant_value
, NULL
);
4707 if (ifexp_bcp
&& ifexp
== truthvalue_false_node
)
4709 op1_int_operands
= true;
4710 op2
= c_fully_fold (op2
, require_constant_value
, NULL
);
4712 int_const
= int_operands
= (ifexp_int_operands
4714 && op2_int_operands
);
4717 int_const
= ((ifexp
== truthvalue_true_node
4718 && TREE_CODE (orig_op1
) == INTEGER_CST
4719 && !TREE_OVERFLOW (orig_op1
))
4720 || (ifexp
== truthvalue_false_node
4721 && TREE_CODE (orig_op2
) == INTEGER_CST
4722 && !TREE_OVERFLOW (orig_op2
)));
4724 if (int_const
|| (ifexp_bcp
&& TREE_CODE (ifexp
) == INTEGER_CST
))
4725 ret
= fold_build3_loc (colon_loc
, COND_EXPR
, result_type
, ifexp
, op1
, op2
);
4730 /* Use c_fully_fold here, since C_MAYBE_CONST_EXPR might be
4731 nested inside of the expression. */
4732 op1
= c_fully_fold (op1
, false, NULL
);
4733 op2
= c_fully_fold (op2
, false, NULL
);
4735 ret
= build3 (COND_EXPR
, result_type
, ifexp
, op1
, op2
);
4737 ret
= note_integer_operands (ret
);
4739 if (semantic_result_type
)
4740 ret
= build1 (EXCESS_PRECISION_EXPR
, semantic_result_type
, ret
);
4742 protected_set_expr_location (ret
, colon_loc
);
4746 /* Return a compound expression that performs two expressions and
4747 returns the value of the second of them.
4749 LOC is the location of the COMPOUND_EXPR. */
4752 build_compound_expr (location_t loc
, tree expr1
, tree expr2
)
4754 bool expr1_int_operands
, expr2_int_operands
;
4755 tree eptype
= NULL_TREE
;
4759 && (TREE_CODE (expr1
) == CILK_SPAWN_STMT
4760 || TREE_CODE (expr2
) == CILK_SPAWN_STMT
))
4763 "spawned function call cannot be part of a comma expression");
4764 return error_mark_node
;
4766 expr1_int_operands
= EXPR_INT_CONST_OPERANDS (expr1
);
4767 if (expr1_int_operands
)
4768 expr1
= remove_c_maybe_const_expr (expr1
);
4769 expr2_int_operands
= EXPR_INT_CONST_OPERANDS (expr2
);
4770 if (expr2_int_operands
)
4771 expr2
= remove_c_maybe_const_expr (expr2
);
4773 if (TREE_CODE (expr1
) == EXCESS_PRECISION_EXPR
)
4774 expr1
= TREE_OPERAND (expr1
, 0);
4775 if (TREE_CODE (expr2
) == EXCESS_PRECISION_EXPR
)
4777 eptype
= TREE_TYPE (expr2
);
4778 expr2
= TREE_OPERAND (expr2
, 0);
4781 if (!TREE_SIDE_EFFECTS (expr1
))
4783 /* The left-hand operand of a comma expression is like an expression
4784 statement: with -Wunused, we should warn if it doesn't have
4785 any side-effects, unless it was explicitly cast to (void). */
4786 if (warn_unused_value
)
4788 if (VOID_TYPE_P (TREE_TYPE (expr1
))
4789 && CONVERT_EXPR_P (expr1
))
4791 else if (VOID_TYPE_P (TREE_TYPE (expr1
))
4792 && TREE_CODE (expr1
) == COMPOUND_EXPR
4793 && CONVERT_EXPR_P (TREE_OPERAND (expr1
, 1)))
4794 ; /* (void) a, (void) b, c */
4796 warning_at (loc
, OPT_Wunused_value
,
4797 "left-hand operand of comma expression has no effect");
4800 else if (TREE_CODE (expr1
) == COMPOUND_EXPR
4801 && warn_unused_value
)
4804 location_t cloc
= loc
;
4805 while (TREE_CODE (r
) == COMPOUND_EXPR
)
4807 if (EXPR_HAS_LOCATION (r
))
4808 cloc
= EXPR_LOCATION (r
);
4809 r
= TREE_OPERAND (r
, 1);
4811 if (!TREE_SIDE_EFFECTS (r
)
4812 && !VOID_TYPE_P (TREE_TYPE (r
))
4813 && !CONVERT_EXPR_P (r
))
4814 warning_at (cloc
, OPT_Wunused_value
,
4815 "right-hand operand of comma expression has no effect");
4818 /* With -Wunused, we should also warn if the left-hand operand does have
4819 side-effects, but computes a value which is not used. For example, in
4820 `foo() + bar(), baz()' the result of the `+' operator is not used,
4821 so we should issue a warning. */
4822 else if (warn_unused_value
)
4823 warn_if_unused_value (expr1
, loc
);
4825 if (expr2
== error_mark_node
)
4826 return error_mark_node
;
4828 ret
= build2 (COMPOUND_EXPR
, TREE_TYPE (expr2
), expr1
, expr2
);
4831 && expr1_int_operands
4832 && expr2_int_operands
)
4833 ret
= note_integer_operands (ret
);
4836 ret
= build1 (EXCESS_PRECISION_EXPR
, eptype
, ret
);
4838 protected_set_expr_location (ret
, loc
);
4842 /* Issue -Wcast-qual warnings when appropriate. TYPE is the type to
4843 which we are casting. OTYPE is the type of the expression being
4844 cast. Both TYPE and OTYPE are pointer types. LOC is the location
4845 of the cast. -Wcast-qual appeared on the command line. Named
4846 address space qualifiers are not handled here, because they result
4847 in different warnings. */
4850 handle_warn_cast_qual (location_t loc
, tree type
, tree otype
)
4852 tree in_type
= type
;
4853 tree in_otype
= otype
;
4858 /* Check that the qualifiers on IN_TYPE are a superset of the
4859 qualifiers of IN_OTYPE. The outermost level of POINTER_TYPE
4860 nodes is uninteresting and we stop as soon as we hit a
4861 non-POINTER_TYPE node on either type. */
4864 in_otype
= TREE_TYPE (in_otype
);
4865 in_type
= TREE_TYPE (in_type
);
4867 /* GNU C allows cv-qualified function types. 'const' means the
4868 function is very pure, 'volatile' means it can't return. We
4869 need to warn when such qualifiers are added, not when they're
4871 if (TREE_CODE (in_otype
) == FUNCTION_TYPE
4872 && TREE_CODE (in_type
) == FUNCTION_TYPE
)
4873 added
|= (TYPE_QUALS_NO_ADDR_SPACE (in_type
)
4874 & ~TYPE_QUALS_NO_ADDR_SPACE (in_otype
));
4876 discarded
|= (TYPE_QUALS_NO_ADDR_SPACE (in_otype
)
4877 & ~TYPE_QUALS_NO_ADDR_SPACE (in_type
));
4879 while (TREE_CODE (in_type
) == POINTER_TYPE
4880 && TREE_CODE (in_otype
) == POINTER_TYPE
);
4883 warning_at (loc
, OPT_Wcast_qual
,
4884 "cast adds %q#v qualifier to function type", added
);
4887 /* There are qualifiers present in IN_OTYPE that are not present
4889 warning_at (loc
, OPT_Wcast_qual
,
4890 "cast discards %qv qualifier from pointer target type",
4893 if (added
|| discarded
)
4896 /* A cast from **T to const **T is unsafe, because it can cause a
4897 const value to be changed with no additional warning. We only
4898 issue this warning if T is the same on both sides, and we only
4899 issue the warning if there are the same number of pointers on
4900 both sides, as otherwise the cast is clearly unsafe anyhow. A
4901 cast is unsafe when a qualifier is added at one level and const
4902 is not present at all outer levels.
4904 To issue this warning, we check at each level whether the cast
4905 adds new qualifiers not already seen. We don't need to special
4906 case function types, as they won't have the same
4907 TYPE_MAIN_VARIANT. */
4909 if (TYPE_MAIN_VARIANT (in_type
) != TYPE_MAIN_VARIANT (in_otype
))
4911 if (TREE_CODE (TREE_TYPE (type
)) != POINTER_TYPE
)
4916 is_const
= TYPE_READONLY (TREE_TYPE (in_type
));
4919 in_type
= TREE_TYPE (in_type
);
4920 in_otype
= TREE_TYPE (in_otype
);
4921 if ((TYPE_QUALS (in_type
) &~ TYPE_QUALS (in_otype
)) != 0
4924 warning_at (loc
, OPT_Wcast_qual
,
4925 "to be safe all intermediate pointers in cast from "
4926 "%qT to %qT must be %<const%> qualified",
4931 is_const
= TYPE_READONLY (in_type
);
4933 while (TREE_CODE (in_type
) == POINTER_TYPE
);
4936 /* Build an expression representing a cast to type TYPE of expression EXPR.
4937 LOC is the location of the cast-- typically the open paren of the cast. */
4940 build_c_cast (location_t loc
, tree type
, tree expr
)
4944 if (TREE_CODE (expr
) == EXCESS_PRECISION_EXPR
)
4945 expr
= TREE_OPERAND (expr
, 0);
4949 if (type
== error_mark_node
|| expr
== error_mark_node
)
4950 return error_mark_node
;
4952 /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
4953 only in <protocol> qualifications. But when constructing cast expressions,
4954 the protocols do matter and must be kept around. */
4955 if (objc_is_object_ptr (type
) && objc_is_object_ptr (TREE_TYPE (expr
)))
4956 return build1 (NOP_EXPR
, type
, expr
);
4958 type
= TYPE_MAIN_VARIANT (type
);
4960 if (TREE_CODE (type
) == ARRAY_TYPE
)
4962 error_at (loc
, "cast specifies array type");
4963 return error_mark_node
;
4966 if (TREE_CODE (type
) == FUNCTION_TYPE
)
4968 error_at (loc
, "cast specifies function type");
4969 return error_mark_node
;
4972 if (!VOID_TYPE_P (type
))
4974 value
= require_complete_type (value
);
4975 if (value
== error_mark_node
)
4976 return error_mark_node
;
4979 if (type
== TYPE_MAIN_VARIANT (TREE_TYPE (value
)))
4981 if (TREE_CODE (type
) == RECORD_TYPE
4982 || TREE_CODE (type
) == UNION_TYPE
)
4983 pedwarn (loc
, OPT_Wpedantic
,
4984 "ISO C forbids casting nonscalar to the same type");
4986 else if (TREE_CODE (type
) == UNION_TYPE
)
4990 for (field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
4991 if (TREE_TYPE (field
) != error_mark_node
4992 && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field
)),
4993 TYPE_MAIN_VARIANT (TREE_TYPE (value
))))
4999 bool maybe_const
= true;
5001 pedwarn (loc
, OPT_Wpedantic
, "ISO C forbids casts to union type");
5002 t
= c_fully_fold (value
, false, &maybe_const
);
5003 t
= build_constructor_single (type
, field
, t
);
5005 t
= c_wrap_maybe_const (t
, true);
5006 t
= digest_init (loc
, type
, t
,
5007 NULL_TREE
, false, true, 0);
5008 TREE_CONSTANT (t
) = TREE_CONSTANT (value
);
5011 error_at (loc
, "cast to union type from type not present in union");
5012 return error_mark_node
;
5018 if (type
== void_type_node
)
5020 tree t
= build1 (CONVERT_EXPR
, type
, value
);
5021 SET_EXPR_LOCATION (t
, loc
);
5025 otype
= TREE_TYPE (value
);
5027 /* Optionally warn about potentially worrisome casts. */
5029 && TREE_CODE (type
) == POINTER_TYPE
5030 && TREE_CODE (otype
) == POINTER_TYPE
)
5031 handle_warn_cast_qual (loc
, type
, otype
);
5033 /* Warn about conversions between pointers to disjoint
5035 if (TREE_CODE (type
) == POINTER_TYPE
5036 && TREE_CODE (otype
) == POINTER_TYPE
5037 && !null_pointer_constant_p (value
))
5039 addr_space_t as_to
= TYPE_ADDR_SPACE (TREE_TYPE (type
));
5040 addr_space_t as_from
= TYPE_ADDR_SPACE (TREE_TYPE (otype
));
5041 addr_space_t as_common
;
5043 if (!addr_space_superset (as_to
, as_from
, &as_common
))
5045 if (ADDR_SPACE_GENERIC_P (as_from
))
5046 warning_at (loc
, 0, "cast to %s address space pointer "
5047 "from disjoint generic address space pointer",
5048 c_addr_space_name (as_to
));
5050 else if (ADDR_SPACE_GENERIC_P (as_to
))
5051 warning_at (loc
, 0, "cast to generic address space pointer "
5052 "from disjoint %s address space pointer",
5053 c_addr_space_name (as_from
));
5056 warning_at (loc
, 0, "cast to %s address space pointer "
5057 "from disjoint %s address space pointer",
5058 c_addr_space_name (as_to
),
5059 c_addr_space_name (as_from
));
5063 /* Warn about possible alignment problems. */
5064 if (STRICT_ALIGNMENT
5065 && TREE_CODE (type
) == POINTER_TYPE
5066 && TREE_CODE (otype
) == POINTER_TYPE
5067 && TREE_CODE (TREE_TYPE (otype
)) != VOID_TYPE
5068 && TREE_CODE (TREE_TYPE (otype
)) != FUNCTION_TYPE
5069 /* Don't warn about opaque types, where the actual alignment
5070 restriction is unknown. */
5071 && !((TREE_CODE (TREE_TYPE (otype
)) == UNION_TYPE
5072 || TREE_CODE (TREE_TYPE (otype
)) == RECORD_TYPE
)
5073 && TYPE_MODE (TREE_TYPE (otype
)) == VOIDmode
)
5074 && TYPE_ALIGN (TREE_TYPE (type
)) > TYPE_ALIGN (TREE_TYPE (otype
)))
5075 warning_at (loc
, OPT_Wcast_align
,
5076 "cast increases required alignment of target type");
5078 if (TREE_CODE (type
) == INTEGER_TYPE
5079 && TREE_CODE (otype
) == POINTER_TYPE
5080 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
))
5081 /* Unlike conversion of integers to pointers, where the
5082 warning is disabled for converting constants because
5083 of cases such as SIG_*, warn about converting constant
5084 pointers to integers. In some cases it may cause unwanted
5085 sign extension, and a warning is appropriate. */
5086 warning_at (loc
, OPT_Wpointer_to_int_cast
,
5087 "cast from pointer to integer of different size");
5089 if (TREE_CODE (value
) == CALL_EXPR
5090 && TREE_CODE (type
) != TREE_CODE (otype
))
5091 warning_at (loc
, OPT_Wbad_function_cast
,
5092 "cast from function call of type %qT "
5093 "to non-matching type %qT", otype
, type
);
5095 if (TREE_CODE (type
) == POINTER_TYPE
5096 && TREE_CODE (otype
) == INTEGER_TYPE
5097 && TYPE_PRECISION (type
) != TYPE_PRECISION (otype
)
5098 /* Don't warn about converting any constant. */
5099 && !TREE_CONSTANT (value
))
5101 OPT_Wint_to_pointer_cast
, "cast to pointer from integer "
5102 "of different size");
5104 if (warn_strict_aliasing
<= 2)
5105 strict_aliasing_warning (otype
, type
, expr
);
5107 /* If pedantic, warn for conversions between function and object
5108 pointer types, except for converting a null pointer constant
5109 to function pointer type. */
5111 && TREE_CODE (type
) == POINTER_TYPE
5112 && TREE_CODE (otype
) == POINTER_TYPE
5113 && TREE_CODE (TREE_TYPE (otype
)) == FUNCTION_TYPE
5114 && TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
)
5115 pedwarn (loc
, OPT_Wpedantic
, "ISO C forbids "
5116 "conversion of function pointer to object pointer type");
5119 && TREE_CODE (type
) == POINTER_TYPE
5120 && TREE_CODE (otype
) == POINTER_TYPE
5121 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
5122 && TREE_CODE (TREE_TYPE (otype
)) != FUNCTION_TYPE
5123 && !null_pointer_constant_p (value
))
5124 pedwarn (loc
, OPT_Wpedantic
, "ISO C forbids "
5125 "conversion of object pointer to function pointer type");
5128 value
= convert (type
, value
);
5130 /* Ignore any integer overflow caused by the cast. */
5131 if (TREE_CODE (value
) == INTEGER_CST
&& !FLOAT_TYPE_P (otype
))
5133 if (CONSTANT_CLASS_P (ovalue
) && TREE_OVERFLOW (ovalue
))
5135 if (!TREE_OVERFLOW (value
))
5137 /* Avoid clobbering a shared constant. */
5138 value
= copy_node (value
);
5139 TREE_OVERFLOW (value
) = TREE_OVERFLOW (ovalue
);
5142 else if (TREE_OVERFLOW (value
))
5143 /* Reset VALUE's overflow flags, ensuring constant sharing. */
5144 value
= wide_int_to_tree (TREE_TYPE (value
), value
);
5148 /* Don't let a cast be an lvalue. */
5150 value
= non_lvalue_loc (loc
, value
);
5152 /* Don't allow the results of casting to floating-point or complex
5153 types be confused with actual constants, or casts involving
5154 integer and pointer types other than direct integer-to-integer
5155 and integer-to-pointer be confused with integer constant
5156 expressions and null pointer constants. */
5157 if (TREE_CODE (value
) == REAL_CST
5158 || TREE_CODE (value
) == COMPLEX_CST
5159 || (TREE_CODE (value
) == INTEGER_CST
5160 && !((TREE_CODE (expr
) == INTEGER_CST
5161 && INTEGRAL_TYPE_P (TREE_TYPE (expr
)))
5162 || TREE_CODE (expr
) == REAL_CST
5163 || TREE_CODE (expr
) == COMPLEX_CST
)))
5164 value
= build1 (NOP_EXPR
, type
, value
);
5166 if (CAN_HAVE_LOCATION_P (value
))
5167 SET_EXPR_LOCATION (value
, loc
);
5171 /* Interpret a cast of expression EXPR to type TYPE. LOC is the
5172 location of the open paren of the cast, or the position of the cast
5175 c_cast_expr (location_t loc
, struct c_type_name
*type_name
, tree expr
)
5178 tree type_expr
= NULL_TREE
;
5179 bool type_expr_const
= true;
5181 int saved_wsp
= warn_strict_prototypes
;
5183 /* This avoids warnings about unprototyped casts on
5184 integers. E.g. "#define SIG_DFL (void(*)())0". */
5185 if (TREE_CODE (expr
) == INTEGER_CST
)
5186 warn_strict_prototypes
= 0;
5187 type
= groktypename (type_name
, &type_expr
, &type_expr_const
);
5188 warn_strict_prototypes
= saved_wsp
;
5190 ret
= build_c_cast (loc
, type
, expr
);
5193 bool inner_expr_const
= true;
5194 ret
= c_fully_fold (ret
, require_constant_value
, &inner_expr_const
);
5195 ret
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (ret
), type_expr
, ret
);
5196 C_MAYBE_CONST_EXPR_NON_CONST (ret
) = !(type_expr_const
5197 && inner_expr_const
);
5198 SET_EXPR_LOCATION (ret
, loc
);
5201 if (CAN_HAVE_LOCATION_P (ret
) && !EXPR_HAS_LOCATION (ret
))
5202 SET_EXPR_LOCATION (ret
, loc
);
5204 /* C++ does not permits types to be defined in a cast, but it
5205 allows references to incomplete types. */
5206 if (warn_cxx_compat
&& type_name
->specs
->typespec_kind
== ctsk_tagdef
)
5207 warning_at (loc
, OPT_Wc___compat
,
5208 "defining a type in a cast is invalid in C++");
5213 /* Build an assignment expression of lvalue LHS from value RHS.
5214 If LHS_ORIGTYPE is not NULL, it is the original type of LHS, which
5215 may differ from TREE_TYPE (LHS) for an enum bitfield.
5216 MODIFYCODE is the code for a binary operator that we use
5217 to combine the old value of LHS with RHS to get the new value.
5218 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
5219 If RHS_ORIGTYPE is not NULL_TREE, it is the original type of RHS,
5220 which may differ from TREE_TYPE (RHS) for an enum value.
5222 LOCATION is the location of the MODIFYCODE operator.
5223 RHS_LOC is the location of the RHS. */
5226 build_modify_expr (location_t location
, tree lhs
, tree lhs_origtype
,
5227 enum tree_code modifycode
,
5228 location_t rhs_loc
, tree rhs
, tree rhs_origtype
)
5232 tree rhseval
= NULL_TREE
;
5233 tree rhs_semantic_type
= NULL_TREE
;
5234 tree lhstype
= TREE_TYPE (lhs
);
5235 tree olhstype
= lhstype
;
5239 /* Types that aren't fully specified cannot be used in assignments. */
5240 lhs
= require_complete_type (lhs
);
5242 /* Avoid duplicate error messages from operands that had errors. */
5243 if (TREE_CODE (lhs
) == ERROR_MARK
|| TREE_CODE (rhs
) == ERROR_MARK
)
5244 return error_mark_node
;
5246 /* Ensure an error for assigning a non-lvalue array to an array in
5248 if (TREE_CODE (lhstype
) == ARRAY_TYPE
)
5250 error_at (location
, "assignment to expression with array type");
5251 return error_mark_node
;
5254 /* For ObjC properties, defer this check. */
5255 if (!objc_is_property_ref (lhs
) && !lvalue_or_else (location
, lhs
, lv_assign
))
5256 return error_mark_node
;
5258 is_atomic_op
= really_atomic_lvalue (lhs
);
5260 if (TREE_CODE (rhs
) == EXCESS_PRECISION_EXPR
)
5262 rhs_semantic_type
= TREE_TYPE (rhs
);
5263 rhs
= TREE_OPERAND (rhs
, 0);
5268 if (TREE_CODE (lhs
) == C_MAYBE_CONST_EXPR
)
5270 tree inner
= build_modify_expr (location
, C_MAYBE_CONST_EXPR_EXPR (lhs
),
5271 lhs_origtype
, modifycode
, rhs_loc
, rhs
,
5273 if (inner
== error_mark_node
)
5274 return error_mark_node
;
5275 result
= build2 (C_MAYBE_CONST_EXPR
, TREE_TYPE (inner
),
5276 C_MAYBE_CONST_EXPR_PRE (lhs
), inner
);
5277 gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (lhs
));
5278 C_MAYBE_CONST_EXPR_NON_CONST (result
) = 1;
5279 protected_set_expr_location (result
, location
);
5283 /* If a binary op has been requested, combine the old LHS value with the RHS
5284 producing the value we should actually store into the LHS. */
5286 if (modifycode
!= NOP_EXPR
)
5288 lhs
= c_fully_fold (lhs
, false, NULL
);
5289 lhs
= stabilize_reference (lhs
);
5291 /* Construct the RHS for any non-atomic compound assignemnt. */
5294 /* If in LHS op= RHS the RHS has side-effects, ensure they
5295 are preevaluated before the rest of the assignment expression's
5296 side-effects, because RHS could contain e.g. function calls
5298 if (TREE_SIDE_EFFECTS (rhs
))
5300 newrhs
= in_late_binary_op
? save_expr (rhs
) : c_save_expr (rhs
);
5303 newrhs
= build_binary_op (location
,
5304 modifycode
, lhs
, newrhs
, 1);
5306 /* The original type of the right hand side is no longer
5308 rhs_origtype
= NULL_TREE
;
5312 if (c_dialect_objc ())
5314 /* Check if we are modifying an Objective-C property reference;
5315 if so, we need to generate setter calls. */
5316 result
= objc_maybe_build_modify_expr (lhs
, newrhs
);
5320 /* Else, do the check that we postponed for Objective-C. */
5321 if (!lvalue_or_else (location
, lhs
, lv_assign
))
5322 return error_mark_node
;
5325 /* Give an error for storing in something that is 'const'. */
5327 if (TYPE_READONLY (lhstype
)
5328 || ((TREE_CODE (lhstype
) == RECORD_TYPE
5329 || TREE_CODE (lhstype
) == UNION_TYPE
)
5330 && C_TYPE_FIELDS_READONLY (lhstype
)))
5332 readonly_error (location
, lhs
, lv_assign
);
5333 return error_mark_node
;
5335 else if (TREE_READONLY (lhs
))
5336 readonly_warning (lhs
, lv_assign
);
5338 /* If storing into a structure or union member,
5339 it has probably been given type `int'.
5340 Compute the type that would go with
5341 the actual amount of storage the member occupies. */
5343 if (TREE_CODE (lhs
) == COMPONENT_REF
5344 && (TREE_CODE (lhstype
) == INTEGER_TYPE
5345 || TREE_CODE (lhstype
) == BOOLEAN_TYPE
5346 || TREE_CODE (lhstype
) == REAL_TYPE
5347 || TREE_CODE (lhstype
) == ENUMERAL_TYPE
))
5348 lhstype
= TREE_TYPE (get_unwidened (lhs
, 0));
5350 /* If storing in a field that is in actuality a short or narrower than one,
5351 we must store in the field in its actual type. */
5353 if (lhstype
!= TREE_TYPE (lhs
))
5355 lhs
= copy_node (lhs
);
5356 TREE_TYPE (lhs
) = lhstype
;
5359 /* Issue -Wc++-compat warnings about an assignment to an enum type
5360 when LHS does not have its original type. This happens for,
5361 e.g., an enum bitfield in a struct. */
5363 && lhs_origtype
!= NULL_TREE
5364 && lhs_origtype
!= lhstype
5365 && TREE_CODE (lhs_origtype
) == ENUMERAL_TYPE
)
5367 tree checktype
= (rhs_origtype
!= NULL_TREE
5370 if (checktype
!= error_mark_node
5371 && (TYPE_MAIN_VARIANT (checktype
) != TYPE_MAIN_VARIANT (lhs_origtype
)
5372 || (is_atomic_op
&& modifycode
!= NOP_EXPR
)))
5373 warning_at (location
, OPT_Wc___compat
,
5374 "enum conversion in assignment is invalid in C++");
5377 /* If the lhs is atomic, remove that qualifier. */
5380 lhstype
= build_qualified_type (lhstype
,
5381 (TYPE_QUALS (lhstype
)
5382 & ~TYPE_QUAL_ATOMIC
));
5383 olhstype
= build_qualified_type (olhstype
,
5384 (TYPE_QUALS (lhstype
)
5385 & ~TYPE_QUAL_ATOMIC
));
5388 /* Convert new value to destination type. Fold it first, then
5389 restore any excess precision information, for the sake of
5390 conversion warnings. */
5392 if (!(is_atomic_op
&& modifycode
!= NOP_EXPR
))
5394 npc
= null_pointer_constant_p (newrhs
);
5395 newrhs
= c_fully_fold (newrhs
, false, NULL
);
5396 if (rhs_semantic_type
)
5397 newrhs
= build1 (EXCESS_PRECISION_EXPR
, rhs_semantic_type
, newrhs
);
5398 newrhs
= convert_for_assignment (location
, rhs_loc
, lhstype
, newrhs
,
5399 rhs_origtype
, ic_assign
, npc
,
5400 NULL_TREE
, NULL_TREE
, 0);
5401 if (TREE_CODE (newrhs
) == ERROR_MARK
)
5402 return error_mark_node
;
5405 /* Emit ObjC write barrier, if necessary. */
5406 if (c_dialect_objc () && flag_objc_gc
)
5408 result
= objc_generate_write_barrier (lhs
, modifycode
, newrhs
);
5411 protected_set_expr_location (result
, location
);
5416 /* Scan operands. */
5419 result
= build_atomic_assign (location
, lhs
, modifycode
, newrhs
, false);
5422 result
= build2 (MODIFY_EXPR
, lhstype
, lhs
, newrhs
);
5423 TREE_SIDE_EFFECTS (result
) = 1;
5424 protected_set_expr_location (result
, location
);
5427 /* If we got the LHS in a different type for storing in,
5428 convert the result back to the nominal type of LHS
5429 so that the value we return always has the same type
5430 as the LHS argument. */
5432 if (olhstype
== TREE_TYPE (result
))
5435 result
= convert_for_assignment (location
, rhs_loc
, olhstype
, result
,
5436 rhs_origtype
, ic_assign
, false, NULL_TREE
,
5438 protected_set_expr_location (result
, location
);
5442 result
= build2 (COMPOUND_EXPR
, TREE_TYPE (result
), rhseval
, result
);
5446 /* Return whether STRUCT_TYPE has an anonymous field with type TYPE.
5447 This is used to implement -fplan9-extensions. */
5450 find_anonymous_field_with_type (tree struct_type
, tree type
)
5455 gcc_assert (TREE_CODE (struct_type
) == RECORD_TYPE
5456 || TREE_CODE (struct_type
) == UNION_TYPE
);
5458 for (field
= TYPE_FIELDS (struct_type
);
5460 field
= TREE_CHAIN (field
))
5462 tree fieldtype
= (TYPE_ATOMIC (TREE_TYPE (field
))
5463 ? c_build_qualified_type (TREE_TYPE (field
),
5465 : TYPE_MAIN_VARIANT (TREE_TYPE (field
)));
5466 if (DECL_NAME (field
) == NULL
5467 && comptypes (type
, fieldtype
))
5473 else if (DECL_NAME (field
) == NULL
5474 && (TREE_CODE (TREE_TYPE (field
)) == RECORD_TYPE
5475 || TREE_CODE (TREE_TYPE (field
)) == UNION_TYPE
)
5476 && find_anonymous_field_with_type (TREE_TYPE (field
), type
))
5486 /* RHS is an expression whose type is pointer to struct. If there is
5487 an anonymous field in RHS with type TYPE, then return a pointer to
5488 that field in RHS. This is used with -fplan9-extensions. This
5489 returns NULL if no conversion could be found. */
5492 convert_to_anonymous_field (location_t location
, tree type
, tree rhs
)
5494 tree rhs_struct_type
, lhs_main_type
;
5495 tree field
, found_field
;
5496 bool found_sub_field
;
5499 gcc_assert (POINTER_TYPE_P (TREE_TYPE (rhs
)));
5500 rhs_struct_type
= TREE_TYPE (TREE_TYPE (rhs
));
5501 gcc_assert (TREE_CODE (rhs_struct_type
) == RECORD_TYPE
5502 || TREE_CODE (rhs_struct_type
) == UNION_TYPE
);
5504 gcc_assert (POINTER_TYPE_P (type
));
5505 lhs_main_type
= (TYPE_ATOMIC (TREE_TYPE (type
))
5506 ? c_build_qualified_type (TREE_TYPE (type
),
5508 : TYPE_MAIN_VARIANT (TREE_TYPE (type
)));
5510 found_field
= NULL_TREE
;
5511 found_sub_field
= false;
5512 for (field
= TYPE_FIELDS (rhs_struct_type
);
5514 field
= TREE_CHAIN (field
))
5516 if (DECL_NAME (field
) != NULL_TREE
5517 || (TREE_CODE (TREE_TYPE (field
)) != RECORD_TYPE
5518 && TREE_CODE (TREE_TYPE (field
)) != UNION_TYPE
))
5520 tree fieldtype
= (TYPE_ATOMIC (TREE_TYPE (field
))
5521 ? c_build_qualified_type (TREE_TYPE (field
),
5523 : TYPE_MAIN_VARIANT (TREE_TYPE (field
)));
5524 if (comptypes (lhs_main_type
, fieldtype
))
5526 if (found_field
!= NULL_TREE
)
5528 found_field
= field
;
5530 else if (find_anonymous_field_with_type (TREE_TYPE (field
),
5533 if (found_field
!= NULL_TREE
)
5535 found_field
= field
;
5536 found_sub_field
= true;
5540 if (found_field
== NULL_TREE
)
5543 ret
= fold_build3_loc (location
, COMPONENT_REF
, TREE_TYPE (found_field
),
5544 build_fold_indirect_ref (rhs
), found_field
,
5546 ret
= build_fold_addr_expr_loc (location
, ret
);
5548 if (found_sub_field
)
5550 ret
= convert_to_anonymous_field (location
, type
, ret
);
5551 gcc_assert (ret
!= NULL_TREE
);
5557 /* Issue an error message for a bad initializer component.
5558 GMSGID identifies the message.
5559 The component name is taken from the spelling stack. */
5562 error_init (location_t loc
, const char *gmsgid
)
5566 /* The gmsgid may be a format string with %< and %>. */
5567 error_at (loc
, gmsgid
);
5568 ofwhat
= print_spelling ((char *) alloca (spelling_length () + 1));
5570 error_at (loc
, "(near initialization for %qs)", ofwhat
);
5573 /* Issue a pedantic warning for a bad initializer component. OPT is
5574 the option OPT_* (from options.h) controlling this warning or 0 if
5575 it is unconditionally given. GMSGID identifies the message. The
5576 component name is taken from the spelling stack. */
5579 pedwarn_init (location_t location
, int opt
, const char *gmsgid
)
5583 /* The gmsgid may be a format string with %< and %>. */
5584 pedwarn (location
, opt
, gmsgid
);
5585 ofwhat
= print_spelling ((char *) alloca (spelling_length () + 1));
5587 pedwarn (location
, opt
, "(near initialization for %qs)", ofwhat
);
5590 /* Issue a warning for a bad initializer component.
5592 OPT is the OPT_W* value corresponding to the warning option that
5593 controls this warning. GMSGID identifies the message. The
5594 component name is taken from the spelling stack. */
5597 warning_init (location_t loc
, int opt
, const char *gmsgid
)
5601 /* The gmsgid may be a format string with %< and %>. */
5602 warning_at (loc
, opt
, gmsgid
);
5603 ofwhat
= print_spelling ((char *) alloca (spelling_length () + 1));
5605 warning_at (loc
, opt
, "(near initialization for %qs)", ofwhat
);
5608 /* If TYPE is an array type and EXPR is a parenthesized string
5609 constant, warn if pedantic that EXPR is being used to initialize an
5610 object of type TYPE. */
5613 maybe_warn_string_init (location_t loc
, tree type
, struct c_expr expr
)
5616 && TREE_CODE (type
) == ARRAY_TYPE
5617 && TREE_CODE (expr
.value
) == STRING_CST
5618 && expr
.original_code
!= STRING_CST
)
5619 pedwarn_init (loc
, OPT_Wpedantic
,
5620 "array initialized from parenthesized string constant");
5623 /* Convert value RHS to type TYPE as preparation for an assignment to
5624 an lvalue of type TYPE. If ORIGTYPE is not NULL_TREE, it is the
5625 original type of RHS; this differs from TREE_TYPE (RHS) for enum
5626 types. NULL_POINTER_CONSTANT says whether RHS was a null pointer
5627 constant before any folding.
5628 The real work of conversion is done by `convert'.
5629 The purpose of this function is to generate error messages
5630 for assignments that are not allowed in C.
5631 ERRTYPE says whether it is argument passing, assignment,
5632 initialization or return.
5634 LOCATION is the location of the assignment, EXPR_LOC is the location of
5635 the RHS or, for a function, location of an argument.
5636 FUNCTION is a tree for the function being called.
5637 PARMNUM is the number of the argument, for printing in error messages. */
5640 convert_for_assignment (location_t location
, location_t expr_loc
, tree type
,
5641 tree rhs
, tree origtype
, enum impl_conv errtype
,
5642 bool null_pointer_constant
, tree fundecl
,
5643 tree function
, int parmnum
)
5645 enum tree_code codel
= TREE_CODE (type
);
5646 tree orig_rhs
= rhs
;
5648 enum tree_code coder
;
5649 tree rname
= NULL_TREE
;
5650 bool objc_ok
= false;
5652 if (errtype
== ic_argpass
)
5655 /* Change pointer to function to the function itself for
5657 if (TREE_CODE (function
) == ADDR_EXPR
5658 && TREE_CODE (TREE_OPERAND (function
, 0)) == FUNCTION_DECL
)
5659 function
= TREE_OPERAND (function
, 0);
5661 /* Handle an ObjC selector specially for diagnostics. */
5662 selector
= objc_message_selector ();
5664 if (selector
&& parmnum
> 2)
5671 /* This macro is used to emit diagnostics to ensure that all format
5672 strings are complete sentences, visible to gettext and checked at
5674 #define WARN_FOR_ASSIGNMENT(LOCATION, PLOC, OPT, AR, AS, IN, RE) \
5679 if (pedwarn (PLOC, OPT, AR, parmnum, rname)) \
5680 inform ((fundecl && !DECL_IS_BUILTIN (fundecl)) \
5681 ? DECL_SOURCE_LOCATION (fundecl) : PLOC, \
5682 "expected %qT but argument is of type %qT", \
5686 pedwarn (LOCATION, OPT, AS); \
5689 pedwarn_init (LOCATION, OPT, IN); \
5692 pedwarn (LOCATION, OPT, RE); \
5695 gcc_unreachable (); \
5699 /* This macro is used to emit diagnostics to ensure that all format
5700 strings are complete sentences, visible to gettext and checked at
5701 compile time. It is the same as WARN_FOR_ASSIGNMENT but with an
5702 extra parameter to enumerate qualifiers. */
5704 #define WARN_FOR_QUALIFIERS(LOCATION, PLOC, OPT, AR, AS, IN, RE, QUALS) \
5709 if (pedwarn (PLOC, OPT, AR, parmnum, rname, QUALS)) \
5710 inform ((fundecl && !DECL_IS_BUILTIN (fundecl)) \
5711 ? DECL_SOURCE_LOCATION (fundecl) : PLOC, \
5712 "expected %qT but argument is of type %qT", \
5716 pedwarn (LOCATION, OPT, AS, QUALS); \
5719 pedwarn (LOCATION, OPT, IN, QUALS); \
5722 pedwarn (LOCATION, OPT, RE, QUALS); \
5725 gcc_unreachable (); \
5729 if (TREE_CODE (rhs
) == EXCESS_PRECISION_EXPR
)
5730 rhs
= TREE_OPERAND (rhs
, 0);
5732 rhstype
= TREE_TYPE (rhs
);
5733 coder
= TREE_CODE (rhstype
);
5735 if (coder
== ERROR_MARK
)
5736 return error_mark_node
;
5738 if (c_dialect_objc ())
5761 objc_ok
= objc_compare_types (type
, rhstype
, parmno
, rname
);
5764 if (warn_cxx_compat
)
5766 tree checktype
= origtype
!= NULL_TREE
? origtype
: rhstype
;
5767 if (checktype
!= error_mark_node
5768 && TREE_CODE (type
) == ENUMERAL_TYPE
5769 && TYPE_MAIN_VARIANT (checktype
) != TYPE_MAIN_VARIANT (type
))
5771 WARN_FOR_ASSIGNMENT (location
, expr_loc
, OPT_Wc___compat
,
5772 G_("enum conversion when passing argument "
5773 "%d of %qE is invalid in C++"),
5774 G_("enum conversion in assignment is "
5776 G_("enum conversion in initialization is "
5778 G_("enum conversion in return is "
5783 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (rhstype
))
5786 if (coder
== VOID_TYPE
)
5788 /* Except for passing an argument to an unprototyped function,
5789 this is a constraint violation. When passing an argument to
5790 an unprototyped function, it is compile-time undefined;
5791 making it a constraint in that case was rejected in
5793 error_at (location
, "void value not ignored as it ought to be");
5794 return error_mark_node
;
5796 rhs
= require_complete_type (rhs
);
5797 if (rhs
== error_mark_node
)
5798 return error_mark_node
;
5799 /* A non-reference type can convert to a reference. This handles
5800 va_start, va_copy and possibly port built-ins. */
5801 if (codel
== REFERENCE_TYPE
&& coder
!= REFERENCE_TYPE
)
5803 if (!lvalue_p (rhs
))
5805 error_at (location
, "cannot pass rvalue to reference parameter");
5806 return error_mark_node
;
5808 if (!c_mark_addressable (rhs
))
5809 return error_mark_node
;
5810 rhs
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (rhs
)), rhs
);
5811 SET_EXPR_LOCATION (rhs
, location
);
5813 rhs
= convert_for_assignment (location
, expr_loc
,
5814 build_pointer_type (TREE_TYPE (type
)),
5815 rhs
, origtype
, errtype
,
5816 null_pointer_constant
, fundecl
, function
,
5818 if (rhs
== error_mark_node
)
5819 return error_mark_node
;
5821 rhs
= build1 (NOP_EXPR
, type
, rhs
);
5822 SET_EXPR_LOCATION (rhs
, location
);
5825 /* Some types can interconvert without explicit casts. */
5826 else if (codel
== VECTOR_TYPE
&& coder
== VECTOR_TYPE
5827 && vector_types_convertible_p (type
, TREE_TYPE (rhs
), true))
5828 return convert (type
, rhs
);
5829 /* Arithmetic types all interconvert, and enum is treated like int. */
5830 else if ((codel
== INTEGER_TYPE
|| codel
== REAL_TYPE
5831 || codel
== FIXED_POINT_TYPE
5832 || codel
== ENUMERAL_TYPE
|| codel
== COMPLEX_TYPE
5833 || codel
== BOOLEAN_TYPE
)
5834 && (coder
== INTEGER_TYPE
|| coder
== REAL_TYPE
5835 || coder
== FIXED_POINT_TYPE
5836 || coder
== ENUMERAL_TYPE
|| coder
== COMPLEX_TYPE
5837 || coder
== BOOLEAN_TYPE
))
5840 bool save
= in_late_binary_op
;
5841 if (codel
== BOOLEAN_TYPE
|| codel
== COMPLEX_TYPE
)
5842 in_late_binary_op
= true;
5843 ret
= convert_and_check (expr_loc
!= UNKNOWN_LOCATION
5844 ? expr_loc
: location
, type
, orig_rhs
);
5845 if (codel
== BOOLEAN_TYPE
|| codel
== COMPLEX_TYPE
)
5846 in_late_binary_op
= save
;
5850 /* Aggregates in different TUs might need conversion. */
5851 if ((codel
== RECORD_TYPE
|| codel
== UNION_TYPE
)
5853 && comptypes (type
, rhstype
))
5854 return convert_and_check (expr_loc
!= UNKNOWN_LOCATION
5855 ? expr_loc
: location
, type
, rhs
);
5857 /* Conversion to a transparent union or record from its member types.
5858 This applies only to function arguments. */
5859 if (((codel
== UNION_TYPE
|| codel
== RECORD_TYPE
)
5860 && TYPE_TRANSPARENT_AGGR (type
))
5861 && errtype
== ic_argpass
)
5863 tree memb
, marginal_memb
= NULL_TREE
;
5865 for (memb
= TYPE_FIELDS (type
); memb
; memb
= DECL_CHAIN (memb
))
5867 tree memb_type
= TREE_TYPE (memb
);
5869 if (comptypes (TYPE_MAIN_VARIANT (memb_type
),
5870 TYPE_MAIN_VARIANT (rhstype
)))
5873 if (TREE_CODE (memb_type
) != POINTER_TYPE
)
5876 if (coder
== POINTER_TYPE
)
5878 tree ttl
= TREE_TYPE (memb_type
);
5879 tree ttr
= TREE_TYPE (rhstype
);
5881 /* Any non-function converts to a [const][volatile] void *
5882 and vice versa; otherwise, targets must be the same.
5883 Meanwhile, the lhs target must have all the qualifiers of
5885 if ((VOID_TYPE_P (ttl
) && !TYPE_ATOMIC (ttl
))
5886 || (VOID_TYPE_P (ttr
) && !TYPE_ATOMIC (ttr
))
5887 || comp_target_types (location
, memb_type
, rhstype
))
5889 int lquals
= TYPE_QUALS (ttl
) & ~TYPE_QUAL_ATOMIC
;
5890 int rquals
= TYPE_QUALS (ttr
) & ~TYPE_QUAL_ATOMIC
;
5891 /* If this type won't generate any warnings, use it. */
5892 if (lquals
== rquals
5893 || ((TREE_CODE (ttr
) == FUNCTION_TYPE
5894 && TREE_CODE (ttl
) == FUNCTION_TYPE
)
5895 ? ((lquals
| rquals
) == rquals
)
5896 : ((lquals
| rquals
) == lquals
)))
5899 /* Keep looking for a better type, but remember this one. */
5901 marginal_memb
= memb
;
5905 /* Can convert integer zero to any pointer type. */
5906 if (null_pointer_constant
)
5908 rhs
= null_pointer_node
;
5913 if (memb
|| marginal_memb
)
5917 /* We have only a marginally acceptable member type;
5918 it needs a warning. */
5919 tree ttl
= TREE_TYPE (TREE_TYPE (marginal_memb
));
5920 tree ttr
= TREE_TYPE (rhstype
);
5922 /* Const and volatile mean something different for function
5923 types, so the usual warnings are not appropriate. */
5924 if (TREE_CODE (ttr
) == FUNCTION_TYPE
5925 && TREE_CODE (ttl
) == FUNCTION_TYPE
)
5927 /* Because const and volatile on functions are
5928 restrictions that say the function will not do
5929 certain things, it is okay to use a const or volatile
5930 function where an ordinary one is wanted, but not
5932 if (TYPE_QUALS_NO_ADDR_SPACE (ttl
)
5933 & ~TYPE_QUALS_NO_ADDR_SPACE (ttr
))
5934 WARN_FOR_QUALIFIERS (location
, expr_loc
,
5935 OPT_Wdiscarded_qualifiers
,
5936 G_("passing argument %d of %qE "
5937 "makes %q#v qualified function "
5938 "pointer from unqualified"),
5939 G_("assignment makes %q#v qualified "
5940 "function pointer from "
5942 G_("initialization makes %q#v qualified "
5943 "function pointer from "
5945 G_("return makes %q#v qualified function "
5946 "pointer from unqualified"),
5947 TYPE_QUALS (ttl
) & ~TYPE_QUALS (ttr
));
5949 else if (TYPE_QUALS_NO_ADDR_SPACE (ttr
)
5950 & ~TYPE_QUALS_NO_ADDR_SPACE (ttl
))
5951 WARN_FOR_QUALIFIERS (location
, expr_loc
,
5952 OPT_Wdiscarded_qualifiers
,
5953 G_("passing argument %d of %qE discards "
5954 "%qv qualifier from pointer target type"),
5955 G_("assignment discards %qv qualifier "
5956 "from pointer target type"),
5957 G_("initialization discards %qv qualifier "
5958 "from pointer target type"),
5959 G_("return discards %qv qualifier from "
5960 "pointer target type"),
5961 TYPE_QUALS (ttr
) & ~TYPE_QUALS (ttl
));
5963 memb
= marginal_memb
;
5966 if (!fundecl
|| !DECL_IN_SYSTEM_HEADER (fundecl
))
5967 pedwarn (location
, OPT_Wpedantic
,
5968 "ISO C prohibits argument conversion to union type");
5970 rhs
= fold_convert_loc (location
, TREE_TYPE (memb
), rhs
);
5971 return build_constructor_single (type
, memb
, rhs
);
5975 /* Conversions among pointers */
5976 else if ((codel
== POINTER_TYPE
|| codel
== REFERENCE_TYPE
)
5977 && (coder
== codel
))
5979 tree ttl
= TREE_TYPE (type
);
5980 tree ttr
= TREE_TYPE (rhstype
);
5983 bool is_opaque_pointer
;
5984 int target_cmp
= 0; /* Cache comp_target_types () result. */
5988 if (TREE_CODE (mvl
) != ARRAY_TYPE
)
5989 mvl
= (TYPE_ATOMIC (mvl
)
5990 ? c_build_qualified_type (TYPE_MAIN_VARIANT (mvl
),
5992 : TYPE_MAIN_VARIANT (mvl
));
5993 if (TREE_CODE (mvr
) != ARRAY_TYPE
)
5994 mvr
= (TYPE_ATOMIC (mvr
)
5995 ? c_build_qualified_type (TYPE_MAIN_VARIANT (mvr
),
5997 : TYPE_MAIN_VARIANT (mvr
));
5998 /* Opaque pointers are treated like void pointers. */
5999 is_opaque_pointer
= vector_targets_convertible_p (ttl
, ttr
);
6001 /* The Plan 9 compiler permits a pointer to a struct to be
6002 automatically converted into a pointer to an anonymous field
6003 within the struct. */
6004 if (flag_plan9_extensions
6005 && (TREE_CODE (mvl
) == RECORD_TYPE
|| TREE_CODE(mvl
) == UNION_TYPE
)
6006 && (TREE_CODE (mvr
) == RECORD_TYPE
|| TREE_CODE(mvr
) == UNION_TYPE
)
6009 tree new_rhs
= convert_to_anonymous_field (location
, type
, rhs
);
6010 if (new_rhs
!= NULL_TREE
)
6013 rhstype
= TREE_TYPE (rhs
);
6014 coder
= TREE_CODE (rhstype
);
6015 ttr
= TREE_TYPE (rhstype
);
6016 mvr
= TYPE_MAIN_VARIANT (ttr
);
6020 /* C++ does not allow the implicit conversion void* -> T*. However,
6021 for the purpose of reducing the number of false positives, we
6022 tolerate the special case of
6026 where NULL is typically defined in C to be '(void *) 0'. */
6027 if (VOID_TYPE_P (ttr
) && rhs
!= null_pointer_node
&& !VOID_TYPE_P (ttl
))
6028 warning_at (location
, OPT_Wc___compat
,
6029 "request for implicit conversion "
6030 "from %qT to %qT not permitted in C++", rhstype
, type
);
6032 /* See if the pointers point to incompatible address spaces. */
6033 asl
= TYPE_ADDR_SPACE (ttl
);
6034 asr
= TYPE_ADDR_SPACE (ttr
);
6035 if (!null_pointer_constant_p (rhs
)
6036 && asr
!= asl
&& !targetm
.addr_space
.subset_p (asr
, asl
))
6041 error_at (location
, "passing argument %d of %qE from pointer to "
6042 "non-enclosed address space", parmnum
, rname
);
6045 error_at (location
, "assignment from pointer to "
6046 "non-enclosed address space");
6049 error_at (location
, "initialization from pointer to "
6050 "non-enclosed address space");
6053 error_at (location
, "return from pointer to "
6054 "non-enclosed address space");
6059 return error_mark_node
;
6062 /* Check if the right-hand side has a format attribute but the
6063 left-hand side doesn't. */
6064 if (warn_suggest_attribute_format
6065 && check_missing_format_attribute (type
, rhstype
))
6070 warning_at (location
, OPT_Wsuggest_attribute_format
,
6071 "argument %d of %qE might be "
6072 "a candidate for a format attribute",
6076 warning_at (location
, OPT_Wsuggest_attribute_format
,
6077 "assignment left-hand side might be "
6078 "a candidate for a format attribute");
6081 warning_at (location
, OPT_Wsuggest_attribute_format
,
6082 "initialization left-hand side might be "
6083 "a candidate for a format attribute");
6086 warning_at (location
, OPT_Wsuggest_attribute_format
,
6087 "return type might be "
6088 "a candidate for a format attribute");
6095 /* Any non-function converts to a [const][volatile] void *
6096 and vice versa; otherwise, targets must be the same.
6097 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
6098 if ((VOID_TYPE_P (ttl
) && !TYPE_ATOMIC (ttl
))
6099 || (VOID_TYPE_P (ttr
) && !TYPE_ATOMIC (ttr
))
6100 || (target_cmp
= comp_target_types (location
, type
, rhstype
))
6101 || is_opaque_pointer
6102 || ((c_common_unsigned_type (mvl
)
6103 == c_common_unsigned_type (mvr
))
6104 && (c_common_signed_type (mvl
)
6105 == c_common_signed_type (mvr
))
6106 && TYPE_ATOMIC (mvl
) == TYPE_ATOMIC (mvr
)))
6109 && ((VOID_TYPE_P (ttl
) && TREE_CODE (ttr
) == FUNCTION_TYPE
)
6112 && !null_pointer_constant
6113 && TREE_CODE (ttl
) == FUNCTION_TYPE
)))
6114 WARN_FOR_ASSIGNMENT (location
, expr_loc
, OPT_Wpedantic
,
6115 G_("ISO C forbids passing argument %d of "
6116 "%qE between function pointer "
6118 G_("ISO C forbids assignment between "
6119 "function pointer and %<void *%>"),
6120 G_("ISO C forbids initialization between "
6121 "function pointer and %<void *%>"),
6122 G_("ISO C forbids return between function "
6123 "pointer and %<void *%>"));
6124 /* Const and volatile mean something different for function types,
6125 so the usual warnings are not appropriate. */
6126 else if (TREE_CODE (ttr
) != FUNCTION_TYPE
6127 && TREE_CODE (ttl
) != FUNCTION_TYPE
)
6129 /* Assignments between atomic and non-atomic objects are OK. */
6130 if (TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC (ttr
)
6131 & ~TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC (ttl
))
6133 WARN_FOR_QUALIFIERS (location
, expr_loc
,
6134 OPT_Wdiscarded_qualifiers
,
6135 G_("passing argument %d of %qE discards "
6136 "%qv qualifier from pointer target type"),
6137 G_("assignment discards %qv qualifier "
6138 "from pointer target type"),
6139 G_("initialization discards %qv qualifier "
6140 "from pointer target type"),
6141 G_("return discards %qv qualifier from "
6142 "pointer target type"),
6143 TYPE_QUALS (ttr
) & ~TYPE_QUALS (ttl
));
6145 /* If this is not a case of ignoring a mismatch in signedness,
6147 else if (VOID_TYPE_P (ttl
) || VOID_TYPE_P (ttr
)
6150 /* If there is a mismatch, do warn. */
6151 else if (warn_pointer_sign
)
6152 WARN_FOR_ASSIGNMENT (location
, expr_loc
, OPT_Wpointer_sign
,
6153 G_("pointer targets in passing argument "
6154 "%d of %qE differ in signedness"),
6155 G_("pointer targets in assignment "
6156 "differ in signedness"),
6157 G_("pointer targets in initialization "
6158 "differ in signedness"),
6159 G_("pointer targets in return differ "
6162 else if (TREE_CODE (ttl
) == FUNCTION_TYPE
6163 && TREE_CODE (ttr
) == FUNCTION_TYPE
)
6165 /* Because const and volatile on functions are restrictions
6166 that say the function will not do certain things,
6167 it is okay to use a const or volatile function
6168 where an ordinary one is wanted, but not vice-versa. */
6169 if (TYPE_QUALS_NO_ADDR_SPACE (ttl
)
6170 & ~TYPE_QUALS_NO_ADDR_SPACE (ttr
))
6171 WARN_FOR_QUALIFIERS (location
, expr_loc
,
6172 OPT_Wdiscarded_qualifiers
,
6173 G_("passing argument %d of %qE makes "
6174 "%q#v qualified function pointer "
6175 "from unqualified"),
6176 G_("assignment makes %q#v qualified function "
6177 "pointer from unqualified"),
6178 G_("initialization makes %q#v qualified "
6179 "function pointer from unqualified"),
6180 G_("return makes %q#v qualified function "
6181 "pointer from unqualified"),
6182 TYPE_QUALS (ttl
) & ~TYPE_QUALS (ttr
));
6186 /* Avoid warning about the volatile ObjC EH puts on decls. */
6188 WARN_FOR_ASSIGNMENT (location
, expr_loc
, 0,
6189 G_("passing argument %d of %qE from "
6190 "incompatible pointer type"),
6191 G_("assignment from incompatible pointer type"),
6192 G_("initialization from incompatible "
6194 G_("return from incompatible pointer type"));
6196 return convert (type
, rhs
);
6198 else if (codel
== POINTER_TYPE
&& coder
== ARRAY_TYPE
)
6200 /* ??? This should not be an error when inlining calls to
6201 unprototyped functions. */
6202 error_at (location
, "invalid use of non-lvalue array");
6203 return error_mark_node
;
6205 else if (codel
== POINTER_TYPE
&& coder
== INTEGER_TYPE
)
6207 /* An explicit constant 0 can convert to a pointer,
6208 or one that results from arithmetic, even including
6209 a cast to integer type. */
6210 if (!null_pointer_constant
)
6211 WARN_FOR_ASSIGNMENT (location
, expr_loc
, 0,
6212 G_("passing argument %d of %qE makes "
6213 "pointer from integer without a cast"),
6214 G_("assignment makes pointer from integer "
6216 G_("initialization makes pointer from "
6217 "integer without a cast"),
6218 G_("return makes pointer from integer "
6221 return convert (type
, rhs
);
6223 else if (codel
== INTEGER_TYPE
&& coder
== POINTER_TYPE
)
6225 WARN_FOR_ASSIGNMENT (location
, expr_loc
, 0,
6226 G_("passing argument %d of %qE makes integer "
6227 "from pointer without a cast"),
6228 G_("assignment makes integer from pointer "
6230 G_("initialization makes integer from pointer "
6232 G_("return makes integer from pointer "
6234 return convert (type
, rhs
);
6236 else if (codel
== BOOLEAN_TYPE
&& coder
== POINTER_TYPE
)
6239 bool save
= in_late_binary_op
;
6240 in_late_binary_op
= true;
6241 ret
= convert (type
, rhs
);
6242 in_late_binary_op
= save
;
6249 error_at (location
, "incompatible type for argument %d of %qE", parmnum
, rname
);
6250 inform ((fundecl
&& !DECL_IS_BUILTIN (fundecl
))
6251 ? DECL_SOURCE_LOCATION (fundecl
) : input_location
,
6252 "expected %qT but argument is of type %qT", type
, rhstype
);
6255 error_at (location
, "incompatible types when assigning to type %qT from "
6256 "type %qT", type
, rhstype
);
6260 "incompatible types when initializing type %qT using type %qT",
6265 "incompatible types when returning type %qT but %qT was "
6266 "expected", rhstype
, type
);
6272 return error_mark_node
;
6275 /* If VALUE is a compound expr all of whose expressions are constant, then
6276 return its value. Otherwise, return error_mark_node.
6278 This is for handling COMPOUND_EXPRs as initializer elements
6279 which is allowed with a warning when -pedantic is specified. */
6282 valid_compound_expr_initializer (tree value
, tree endtype
)
6284 if (TREE_CODE (value
) == COMPOUND_EXPR
)
6286 if (valid_compound_expr_initializer (TREE_OPERAND (value
, 0), endtype
)
6288 return error_mark_node
;
6289 return valid_compound_expr_initializer (TREE_OPERAND (value
, 1),
6292 else if (!initializer_constant_valid_p (value
, endtype
))
6293 return error_mark_node
;
6298 /* Perform appropriate conversions on the initial value of a variable,
6299 store it in the declaration DECL,
6300 and print any error messages that are appropriate.
6301 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
6302 If the init is invalid, store an ERROR_MARK.
6304 INIT_LOC is the location of the initial value. */
6307 store_init_value (location_t init_loc
, tree decl
, tree init
, tree origtype
)
6312 /* If variable's type was invalidly declared, just ignore it. */
6314 type
= TREE_TYPE (decl
);
6315 if (TREE_CODE (type
) == ERROR_MARK
)
6318 /* Digest the specified initializer into an expression. */
6321 npc
= null_pointer_constant_p (init
);
6322 value
= digest_init (init_loc
, type
, init
, origtype
, npc
,
6323 true, TREE_STATIC (decl
));
6325 /* Store the expression if valid; else report error. */
6327 if (!in_system_header_at (input_location
)
6328 && AGGREGATE_TYPE_P (TREE_TYPE (decl
)) && !TREE_STATIC (decl
))
6329 warning (OPT_Wtraditional
, "traditional C rejects automatic "
6330 "aggregate initialization");
6332 DECL_INITIAL (decl
) = value
;
6334 /* ANSI wants warnings about out-of-range constant initializers. */
6335 STRIP_TYPE_NOPS (value
);
6336 if (TREE_STATIC (decl
))
6337 constant_expression_warning (value
);
6339 /* Check if we need to set array size from compound literal size. */
6340 if (TREE_CODE (type
) == ARRAY_TYPE
6341 && TYPE_DOMAIN (type
) == 0
6342 && value
!= error_mark_node
)
6344 tree inside_init
= init
;
6346 STRIP_TYPE_NOPS (inside_init
);
6347 inside_init
= fold (inside_init
);
6349 if (TREE_CODE (inside_init
) == COMPOUND_LITERAL_EXPR
)
6351 tree cldecl
= COMPOUND_LITERAL_EXPR_DECL (inside_init
);
6353 if (TYPE_DOMAIN (TREE_TYPE (cldecl
)))
6355 /* For int foo[] = (int [3]){1}; we need to set array size
6356 now since later on array initializer will be just the
6357 brace enclosed list of the compound literal. */
6358 tree etype
= strip_array_types (TREE_TYPE (decl
));
6359 type
= build_distinct_type_copy (TYPE_MAIN_VARIANT (type
));
6360 TYPE_DOMAIN (type
) = TYPE_DOMAIN (TREE_TYPE (cldecl
));
6362 layout_decl (cldecl
, 0);
6364 = c_build_qualified_type (type
, TYPE_QUALS (etype
));
6370 /* Methods for storing and printing names for error messages. */
6372 /* Implement a spelling stack that allows components of a name to be pushed
6373 and popped. Each element on the stack is this structure. */
6380 unsigned HOST_WIDE_INT i
;
6385 #define SPELLING_STRING 1
6386 #define SPELLING_MEMBER 2
6387 #define SPELLING_BOUNDS 3
6389 static struct spelling
*spelling
; /* Next stack element (unused). */
6390 static struct spelling
*spelling_base
; /* Spelling stack base. */
6391 static int spelling_size
; /* Size of the spelling stack. */
6393 /* Macros to save and restore the spelling stack around push_... functions.
6394 Alternative to SAVE_SPELLING_STACK. */
6396 #define SPELLING_DEPTH() (spelling - spelling_base)
6397 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
6399 /* Push an element on the spelling stack with type KIND and assign VALUE
6402 #define PUSH_SPELLING(KIND, VALUE, MEMBER) \
6404 int depth = SPELLING_DEPTH (); \
6406 if (depth >= spelling_size) \
6408 spelling_size += 10; \
6409 spelling_base = XRESIZEVEC (struct spelling, spelling_base, \
6411 RESTORE_SPELLING_DEPTH (depth); \
6414 spelling->kind = (KIND); \
6415 spelling->MEMBER = (VALUE); \
6419 /* Push STRING on the stack. Printed literally. */
6422 push_string (const char *string
)
6424 PUSH_SPELLING (SPELLING_STRING
, string
, u
.s
);
6427 /* Push a member name on the stack. Printed as '.' STRING. */
6430 push_member_name (tree decl
)
6432 const char *const string
6434 ? identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl
)))
6435 : _("<anonymous>"));
6436 PUSH_SPELLING (SPELLING_MEMBER
, string
, u
.s
);
6439 /* Push an array bounds on the stack. Printed as [BOUNDS]. */
6442 push_array_bounds (unsigned HOST_WIDE_INT bounds
)
6444 PUSH_SPELLING (SPELLING_BOUNDS
, bounds
, u
.i
);
6447 /* Compute the maximum size in bytes of the printed spelling. */
6450 spelling_length (void)
6455 for (p
= spelling_base
; p
< spelling
; p
++)
6457 if (p
->kind
== SPELLING_BOUNDS
)
6460 size
+= strlen (p
->u
.s
) + 1;
6466 /* Print the spelling to BUFFER and return it. */
6469 print_spelling (char *buffer
)
6474 for (p
= spelling_base
; p
< spelling
; p
++)
6475 if (p
->kind
== SPELLING_BOUNDS
)
6477 sprintf (d
, "[" HOST_WIDE_INT_PRINT_UNSIGNED
"]", p
->u
.i
);
6483 if (p
->kind
== SPELLING_MEMBER
)
6485 for (s
= p
->u
.s
; (*d
= *s
++); d
++)
6492 /* Digest the parser output INIT as an initializer for type TYPE.
6493 Return a C expression of type TYPE to represent the initial value.
6495 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
6497 NULL_POINTER_CONSTANT is true if INIT is a null pointer constant.
6499 If INIT is a string constant, STRICT_STRING is true if it is
6500 unparenthesized or we should not warn here for it being parenthesized.
6501 For other types of INIT, STRICT_STRING is not used.
6503 INIT_LOC is the location of the INIT.
6505 REQUIRE_CONSTANT requests an error if non-constant initializers or
6506 elements are seen. */
6509 digest_init (location_t init_loc
, tree type
, tree init
, tree origtype
,
6510 bool null_pointer_constant
, bool strict_string
,
6511 int require_constant
)
6513 enum tree_code code
= TREE_CODE (type
);
6514 tree inside_init
= init
;
6515 tree semantic_type
= NULL_TREE
;
6516 bool maybe_const
= true;
6518 if (type
== error_mark_node
6520 || init
== error_mark_node
6521 || TREE_TYPE (init
) == error_mark_node
)
6522 return error_mark_node
;
6524 STRIP_TYPE_NOPS (inside_init
);
6526 if (TREE_CODE (inside_init
) == EXCESS_PRECISION_EXPR
)
6528 semantic_type
= TREE_TYPE (inside_init
);
6529 inside_init
= TREE_OPERAND (inside_init
, 0);
6531 inside_init
= c_fully_fold (inside_init
, require_constant
, &maybe_const
);
6532 inside_init
= decl_constant_value_for_optimization (inside_init
);
6534 /* Initialization of an array of chars from a string constant
6535 optionally enclosed in braces. */
6537 if (code
== ARRAY_TYPE
&& inside_init
6538 && TREE_CODE (inside_init
) == STRING_CST
)
6541 = (TYPE_ATOMIC (TREE_TYPE (type
))
6542 ? c_build_qualified_type (TYPE_MAIN_VARIANT (TREE_TYPE (type
)),
6544 : TYPE_MAIN_VARIANT (TREE_TYPE (type
)));
6545 /* Note that an array could be both an array of character type
6546 and an array of wchar_t if wchar_t is signed char or unsigned
6548 bool char_array
= (typ1
== char_type_node
6549 || typ1
== signed_char_type_node
6550 || typ1
== unsigned_char_type_node
);
6551 bool wchar_array
= !!comptypes (typ1
, wchar_type_node
);
6552 bool char16_array
= !!comptypes (typ1
, char16_type_node
);
6553 bool char32_array
= !!comptypes (typ1
, char32_type_node
);
6555 if (char_array
|| wchar_array
|| char16_array
|| char32_array
)
6558 tree typ2
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init
)));
6559 expr
.value
= inside_init
;
6560 expr
.original_code
= (strict_string
? STRING_CST
: ERROR_MARK
);
6561 expr
.original_type
= NULL
;
6562 maybe_warn_string_init (init_loc
, type
, expr
);
6564 if (TYPE_DOMAIN (type
) && !TYPE_MAX_VALUE (TYPE_DOMAIN (type
)))
6565 pedwarn_init (init_loc
, OPT_Wpedantic
,
6566 "initialization of a flexible array member");
6568 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init
)),
6569 TYPE_MAIN_VARIANT (type
)))
6574 if (typ2
!= char_type_node
)
6576 error_init (init_loc
, "char-array initialized from wide "
6578 return error_mark_node
;
6583 if (typ2
== char_type_node
)
6585 error_init (init_loc
, "wide character array initialized "
6586 "from non-wide string");
6587 return error_mark_node
;
6589 else if (!comptypes(typ1
, typ2
))
6591 error_init (init_loc
, "wide character array initialized "
6592 "from incompatible wide string");
6593 return error_mark_node
;
6597 TREE_TYPE (inside_init
) = type
;
6598 if (TYPE_DOMAIN (type
) != 0
6599 && TYPE_SIZE (type
) != 0
6600 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
6602 unsigned HOST_WIDE_INT len
= TREE_STRING_LENGTH (inside_init
);
6604 /* Subtract the size of a single (possibly wide) character
6605 because it's ok to ignore the terminating null char
6606 that is counted in the length of the constant. */
6607 if (0 > compare_tree_int (TYPE_SIZE_UNIT (type
),
6609 - (TYPE_PRECISION (typ1
)
6611 pedwarn_init (init_loc
, 0,
6612 ("initializer-string for array of chars "
6614 else if (warn_cxx_compat
6615 && 0 > compare_tree_int (TYPE_SIZE_UNIT (type
), len
))
6616 warning_at (init_loc
, OPT_Wc___compat
,
6617 ("initializer-string for array chars "
6618 "is too long for C++"));
6623 else if (INTEGRAL_TYPE_P (typ1
))
6625 error_init (init_loc
, "array of inappropriate type initialized "
6626 "from string constant");
6627 return error_mark_node
;
6631 /* Build a VECTOR_CST from a *constant* vector constructor. If the
6632 vector constructor is not constant (e.g. {1,2,3,foo()}) then punt
6633 below and handle as a constructor. */
6634 if (code
== VECTOR_TYPE
6635 && TREE_CODE (TREE_TYPE (inside_init
)) == VECTOR_TYPE
6636 && vector_types_convertible_p (TREE_TYPE (inside_init
), type
, true)
6637 && TREE_CONSTANT (inside_init
))
6639 if (TREE_CODE (inside_init
) == VECTOR_CST
6640 && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init
)),
6641 TYPE_MAIN_VARIANT (type
)))
6644 if (TREE_CODE (inside_init
) == CONSTRUCTOR
)
6646 unsigned HOST_WIDE_INT ix
;
6648 bool constant_p
= true;
6650 /* Iterate through elements and check if all constructor
6651 elements are *_CSTs. */
6652 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (inside_init
), ix
, value
)
6653 if (!CONSTANT_CLASS_P (value
))
6660 return build_vector_from_ctor (type
,
6661 CONSTRUCTOR_ELTS (inside_init
));
6665 if (warn_sequence_point
)
6666 verify_sequence_points (inside_init
);
6668 /* Any type can be initialized
6669 from an expression of the same type, optionally with braces. */
6671 if (inside_init
&& TREE_TYPE (inside_init
) != 0
6672 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init
)),
6673 TYPE_MAIN_VARIANT (type
))
6674 || (code
== ARRAY_TYPE
6675 && comptypes (TREE_TYPE (inside_init
), type
))
6676 || (code
== VECTOR_TYPE
6677 && comptypes (TREE_TYPE (inside_init
), type
))
6678 || (code
== POINTER_TYPE
6679 && TREE_CODE (TREE_TYPE (inside_init
)) == ARRAY_TYPE
6680 && comptypes (TREE_TYPE (TREE_TYPE (inside_init
)),
6681 TREE_TYPE (type
)))))
6683 if (code
== POINTER_TYPE
)
6685 if (TREE_CODE (TREE_TYPE (inside_init
)) == ARRAY_TYPE
)
6687 if (TREE_CODE (inside_init
) == STRING_CST
6688 || TREE_CODE (inside_init
) == COMPOUND_LITERAL_EXPR
)
6689 inside_init
= array_to_pointer_conversion
6690 (init_loc
, inside_init
);
6693 error_init (init_loc
, "invalid use of non-lvalue array");
6694 return error_mark_node
;
6699 if (code
== VECTOR_TYPE
)
6700 /* Although the types are compatible, we may require a
6702 inside_init
= convert (type
, inside_init
);
6704 if (require_constant
6705 && (code
== VECTOR_TYPE
|| !flag_isoc99
)
6706 && TREE_CODE (inside_init
) == COMPOUND_LITERAL_EXPR
)
6708 /* As an extension, allow initializing objects with static storage
6709 duration with compound literals (which are then treated just as
6710 the brace enclosed list they contain). Also allow this for
6711 vectors, as we can only assign them with compound literals. */
6712 tree decl
= COMPOUND_LITERAL_EXPR_DECL (inside_init
);
6713 inside_init
= DECL_INITIAL (decl
);
6716 if (code
== ARRAY_TYPE
&& TREE_CODE (inside_init
) != STRING_CST
6717 && TREE_CODE (inside_init
) != CONSTRUCTOR
)
6719 error_init (init_loc
, "array initialized from non-constant array "
6721 return error_mark_node
;
6724 /* Compound expressions can only occur here if -Wpedantic or
6725 -pedantic-errors is specified. In the later case, we always want
6726 an error. In the former case, we simply want a warning. */
6727 if (require_constant
&& pedantic
6728 && TREE_CODE (inside_init
) == COMPOUND_EXPR
)
6731 = valid_compound_expr_initializer (inside_init
,
6732 TREE_TYPE (inside_init
));
6733 if (inside_init
== error_mark_node
)
6734 error_init (init_loc
, "initializer element is not constant");
6736 pedwarn_init (init_loc
, OPT_Wpedantic
,
6737 "initializer element is not constant");
6738 if (flag_pedantic_errors
)
6739 inside_init
= error_mark_node
;
6741 else if (require_constant
6742 && !initializer_constant_valid_p (inside_init
,
6743 TREE_TYPE (inside_init
)))
6745 error_init (init_loc
, "initializer element is not constant");
6746 inside_init
= error_mark_node
;
6748 else if (require_constant
&& !maybe_const
)
6749 pedwarn_init (init_loc
, 0,
6750 "initializer element is not a constant expression");
6752 /* Added to enable additional -Wsuggest-attribute=format warnings. */
6753 if (TREE_CODE (TREE_TYPE (inside_init
)) == POINTER_TYPE
)
6754 inside_init
= convert_for_assignment (init_loc
, UNKNOWN_LOCATION
,
6755 type
, inside_init
, origtype
,
6756 ic_init
, null_pointer_constant
,
6757 NULL_TREE
, NULL_TREE
, 0);
6761 /* Handle scalar types, including conversions. */
6763 if (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== FIXED_POINT_TYPE
6764 || code
== POINTER_TYPE
|| code
== ENUMERAL_TYPE
|| code
== BOOLEAN_TYPE
6765 || code
== COMPLEX_TYPE
|| code
== VECTOR_TYPE
)
6767 if (TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
6768 && (TREE_CODE (init
) == STRING_CST
6769 || TREE_CODE (init
) == COMPOUND_LITERAL_EXPR
))
6770 inside_init
= init
= array_to_pointer_conversion (init_loc
, init
);
6772 inside_init
= build1 (EXCESS_PRECISION_EXPR
, semantic_type
,
6775 = convert_for_assignment (init_loc
, UNKNOWN_LOCATION
, type
,
6776 inside_init
, origtype
, ic_init
,
6777 null_pointer_constant
, NULL_TREE
, NULL_TREE
,
6780 /* Check to see if we have already given an error message. */
6781 if (inside_init
== error_mark_node
)
6783 else if (require_constant
&& !TREE_CONSTANT (inside_init
))
6785 error_init (init_loc
, "initializer element is not constant");
6786 inside_init
= error_mark_node
;
6788 else if (require_constant
6789 && !initializer_constant_valid_p (inside_init
,
6790 TREE_TYPE (inside_init
)))
6792 error_init (init_loc
, "initializer element is not computable at "
6794 inside_init
= error_mark_node
;
6796 else if (require_constant
&& !maybe_const
)
6797 pedwarn_init (init_loc
, 0,
6798 "initializer element is not a constant expression");
6803 /* Come here only for records and arrays. */
6805 if (COMPLETE_TYPE_P (type
) && TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
6807 error_init (init_loc
, "variable-sized object may not be initialized");
6808 return error_mark_node
;
6811 error_init (init_loc
, "invalid initializer");
6812 return error_mark_node
;
6815 /* Handle initializers that use braces. */
6817 /* Type of object we are accumulating a constructor for.
6818 This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */
6819 static tree constructor_type
;
6821 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
6823 static tree constructor_fields
;
6825 /* For an ARRAY_TYPE, this is the specified index
6826 at which to store the next element we get. */
6827 static tree constructor_index
;
6829 /* For an ARRAY_TYPE, this is the maximum index. */
6830 static tree constructor_max_index
;
6832 /* For a RECORD_TYPE, this is the first field not yet written out. */
6833 static tree constructor_unfilled_fields
;
6835 /* For an ARRAY_TYPE, this is the index of the first element
6836 not yet written out. */
6837 static tree constructor_unfilled_index
;
6839 /* In a RECORD_TYPE, the byte index of the next consecutive field.
6840 This is so we can generate gaps between fields, when appropriate. */
6841 static tree constructor_bit_index
;
6843 /* If we are saving up the elements rather than allocating them,
6844 this is the list of elements so far (in reverse order,
6845 most recent first). */
6846 static vec
<constructor_elt
, va_gc
> *constructor_elements
;
6848 /* 1 if constructor should be incrementally stored into a constructor chain,
6849 0 if all the elements should be kept in AVL tree. */
6850 static int constructor_incremental
;
6852 /* 1 if so far this constructor's elements are all compile-time constants. */
6853 static int constructor_constant
;
6855 /* 1 if so far this constructor's elements are all valid address constants. */
6856 static int constructor_simple
;
6858 /* 1 if this constructor has an element that cannot be part of a
6859 constant expression. */
6860 static int constructor_nonconst
;
6862 /* 1 if this constructor is erroneous so far. */
6863 static int constructor_erroneous
;
6865 /* Structure for managing pending initializer elements, organized as an
6870 struct init_node
*left
, *right
;
6871 struct init_node
*parent
;
6878 /* Tree of pending elements at this constructor level.
6879 These are elements encountered out of order
6880 which belong at places we haven't reached yet in actually
6882 Will never hold tree nodes across GC runs. */
6883 static struct init_node
*constructor_pending_elts
;
6885 /* The SPELLING_DEPTH of this constructor. */
6886 static int constructor_depth
;
6888 /* DECL node for which an initializer is being read.
6889 0 means we are reading a constructor expression
6890 such as (struct foo) {...}. */
6891 static tree constructor_decl
;
6893 /* Nonzero if this is an initializer for a top-level decl. */
6894 static int constructor_top_level
;
6896 /* Nonzero if there were any member designators in this initializer. */
6897 static int constructor_designated
;
6899 /* Nesting depth of designator list. */
6900 static int designator_depth
;
6902 /* Nonzero if there were diagnosed errors in this designator list. */
6903 static int designator_erroneous
;
6906 /* This stack has a level for each implicit or explicit level of
6907 structuring in the initializer, including the outermost one. It
6908 saves the values of most of the variables above. */
6910 struct constructor_range_stack
;
6912 struct constructor_stack
6914 struct constructor_stack
*next
;
6919 tree unfilled_index
;
6920 tree unfilled_fields
;
6922 vec
<constructor_elt
, va_gc
> *elements
;
6923 struct init_node
*pending_elts
;
6926 /* If value nonzero, this value should replace the entire
6927 constructor at this level. */
6928 struct c_expr replacement_value
;
6929 struct constructor_range_stack
*range_stack
;
6940 static struct constructor_stack
*constructor_stack
;
6942 /* This stack represents designators from some range designator up to
6943 the last designator in the list. */
6945 struct constructor_range_stack
6947 struct constructor_range_stack
*next
, *prev
;
6948 struct constructor_stack
*stack
;
6955 static struct constructor_range_stack
*constructor_range_stack
;
6957 /* This stack records separate initializers that are nested.
6958 Nested initializers can't happen in ANSI C, but GNU C allows them
6959 in cases like { ... (struct foo) { ... } ... }. */
6961 struct initializer_stack
6963 struct initializer_stack
*next
;
6965 struct constructor_stack
*constructor_stack
;
6966 struct constructor_range_stack
*constructor_range_stack
;
6967 vec
<constructor_elt
, va_gc
> *elements
;
6968 struct spelling
*spelling
;
6969 struct spelling
*spelling_base
;
6972 char require_constant_value
;
6973 char require_constant_elements
;
6976 static struct initializer_stack
*initializer_stack
;
6978 /* Prepare to parse and output the initializer for variable DECL. */
6981 start_init (tree decl
, tree asmspec_tree ATTRIBUTE_UNUSED
, int top_level
)
6984 struct initializer_stack
*p
= XNEW (struct initializer_stack
);
6986 p
->decl
= constructor_decl
;
6987 p
->require_constant_value
= require_constant_value
;
6988 p
->require_constant_elements
= require_constant_elements
;
6989 p
->constructor_stack
= constructor_stack
;
6990 p
->constructor_range_stack
= constructor_range_stack
;
6991 p
->elements
= constructor_elements
;
6992 p
->spelling
= spelling
;
6993 p
->spelling_base
= spelling_base
;
6994 p
->spelling_size
= spelling_size
;
6995 p
->top_level
= constructor_top_level
;
6996 p
->next
= initializer_stack
;
6997 initializer_stack
= p
;
6999 constructor_decl
= decl
;
7000 constructor_designated
= 0;
7001 constructor_top_level
= top_level
;
7003 if (decl
!= 0 && decl
!= error_mark_node
)
7005 require_constant_value
= TREE_STATIC (decl
);
7006 require_constant_elements
7007 = ((TREE_STATIC (decl
) || (pedantic
&& !flag_isoc99
))
7008 /* For a scalar, you can always use any value to initialize,
7009 even within braces. */
7010 && (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
7011 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
7012 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
7013 || TREE_CODE (TREE_TYPE (decl
)) == QUAL_UNION_TYPE
));
7014 locus
= identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl
)));
7018 require_constant_value
= 0;
7019 require_constant_elements
= 0;
7020 locus
= _("(anonymous)");
7023 constructor_stack
= 0;
7024 constructor_range_stack
= 0;
7026 missing_braces_mentioned
= 0;
7030 RESTORE_SPELLING_DEPTH (0);
7033 push_string (locus
);
7039 struct initializer_stack
*p
= initializer_stack
;
7041 /* Free the whole constructor stack of this initializer. */
7042 while (constructor_stack
)
7044 struct constructor_stack
*q
= constructor_stack
;
7045 constructor_stack
= q
->next
;
7049 gcc_assert (!constructor_range_stack
);
7051 /* Pop back to the data of the outer initializer (if any). */
7052 free (spelling_base
);
7054 constructor_decl
= p
->decl
;
7055 require_constant_value
= p
->require_constant_value
;
7056 require_constant_elements
= p
->require_constant_elements
;
7057 constructor_stack
= p
->constructor_stack
;
7058 constructor_range_stack
= p
->constructor_range_stack
;
7059 constructor_elements
= p
->elements
;
7060 spelling
= p
->spelling
;
7061 spelling_base
= p
->spelling_base
;
7062 spelling_size
= p
->spelling_size
;
7063 constructor_top_level
= p
->top_level
;
7064 initializer_stack
= p
->next
;
7068 /* Call here when we see the initializer is surrounded by braces.
7069 This is instead of a call to push_init_level;
7070 it is matched by a call to pop_init_level.
7072 TYPE is the type to initialize, for a constructor expression.
7073 For an initializer for a decl, TYPE is zero. */
7076 really_start_incremental_init (tree type
)
7078 struct constructor_stack
*p
= XNEW (struct constructor_stack
);
7081 type
= TREE_TYPE (constructor_decl
);
7083 if (TREE_CODE (type
) == VECTOR_TYPE
7084 && TYPE_VECTOR_OPAQUE (type
))
7085 error ("opaque vector types cannot be initialized");
7087 p
->type
= constructor_type
;
7088 p
->fields
= constructor_fields
;
7089 p
->index
= constructor_index
;
7090 p
->max_index
= constructor_max_index
;
7091 p
->unfilled_index
= constructor_unfilled_index
;
7092 p
->unfilled_fields
= constructor_unfilled_fields
;
7093 p
->bit_index
= constructor_bit_index
;
7094 p
->elements
= constructor_elements
;
7095 p
->constant
= constructor_constant
;
7096 p
->simple
= constructor_simple
;
7097 p
->nonconst
= constructor_nonconst
;
7098 p
->erroneous
= constructor_erroneous
;
7099 p
->pending_elts
= constructor_pending_elts
;
7100 p
->depth
= constructor_depth
;
7101 p
->replacement_value
.value
= 0;
7102 p
->replacement_value
.original_code
= ERROR_MARK
;
7103 p
->replacement_value
.original_type
= NULL
;
7107 p
->incremental
= constructor_incremental
;
7108 p
->designated
= constructor_designated
;
7110 constructor_stack
= p
;
7112 constructor_constant
= 1;
7113 constructor_simple
= 1;
7114 constructor_nonconst
= 0;
7115 constructor_depth
= SPELLING_DEPTH ();
7116 constructor_elements
= NULL
;
7117 constructor_pending_elts
= 0;
7118 constructor_type
= type
;
7119 constructor_incremental
= 1;
7120 constructor_designated
= 0;
7121 designator_depth
= 0;
7122 designator_erroneous
= 0;
7124 if (TREE_CODE (constructor_type
) == RECORD_TYPE
7125 || TREE_CODE (constructor_type
) == UNION_TYPE
)
7127 constructor_fields
= TYPE_FIELDS (constructor_type
);
7128 /* Skip any nameless bit fields at the beginning. */
7129 while (constructor_fields
!= 0 && DECL_C_BIT_FIELD (constructor_fields
)
7130 && DECL_NAME (constructor_fields
) == 0)
7131 constructor_fields
= DECL_CHAIN (constructor_fields
);
7133 constructor_unfilled_fields
= constructor_fields
;
7134 constructor_bit_index
= bitsize_zero_node
;
7136 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
7138 if (TYPE_DOMAIN (constructor_type
))
7140 constructor_max_index
7141 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type
));
7143 /* Detect non-empty initializations of zero-length arrays. */
7144 if (constructor_max_index
== NULL_TREE
7145 && TYPE_SIZE (constructor_type
))
7146 constructor_max_index
= integer_minus_one_node
;
7148 /* constructor_max_index needs to be an INTEGER_CST. Attempts
7149 to initialize VLAs will cause a proper error; avoid tree
7150 checking errors as well by setting a safe value. */
7151 if (constructor_max_index
7152 && TREE_CODE (constructor_max_index
) != INTEGER_CST
)
7153 constructor_max_index
= integer_minus_one_node
;
7156 = convert (bitsizetype
,
7157 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type
)));
7161 constructor_index
= bitsize_zero_node
;
7162 constructor_max_index
= NULL_TREE
;
7165 constructor_unfilled_index
= constructor_index
;
7167 else if (TREE_CODE (constructor_type
) == VECTOR_TYPE
)
7169 /* Vectors are like simple fixed-size arrays. */
7170 constructor_max_index
=
7171 bitsize_int (TYPE_VECTOR_SUBPARTS (constructor_type
) - 1);
7172 constructor_index
= bitsize_zero_node
;
7173 constructor_unfilled_index
= constructor_index
;
7177 /* Handle the case of int x = {5}; */
7178 constructor_fields
= constructor_type
;
7179 constructor_unfilled_fields
= constructor_type
;
7183 /* Push down into a subobject, for initialization.
7184 If this is for an explicit set of braces, IMPLICIT is 0.
7185 If it is because the next element belongs at a lower level,
7186 IMPLICIT is 1 (or 2 if the push is because of designator list). */
7189 push_init_level (location_t loc
, int implicit
,
7190 struct obstack
*braced_init_obstack
)
7192 struct constructor_stack
*p
;
7193 tree value
= NULL_TREE
;
7195 /* If we've exhausted any levels that didn't have braces,
7196 pop them now. If implicit == 1, this will have been done in
7197 process_init_element; do not repeat it here because in the case
7198 of excess initializers for an empty aggregate this leads to an
7199 infinite cycle of popping a level and immediately recreating
7203 while (constructor_stack
->implicit
)
7205 if ((TREE_CODE (constructor_type
) == RECORD_TYPE
7206 || TREE_CODE (constructor_type
) == UNION_TYPE
)
7207 && constructor_fields
== 0)
7208 process_init_element (input_location
,
7209 pop_init_level (loc
, 1, braced_init_obstack
),
7210 true, braced_init_obstack
);
7211 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
7212 && constructor_max_index
7213 && tree_int_cst_lt (constructor_max_index
,
7215 process_init_element (input_location
,
7216 pop_init_level (loc
, 1, braced_init_obstack
),
7217 true, braced_init_obstack
);
7223 /* Unless this is an explicit brace, we need to preserve previous
7227 if ((TREE_CODE (constructor_type
) == RECORD_TYPE
7228 || TREE_CODE (constructor_type
) == UNION_TYPE
)
7229 && constructor_fields
)
7230 value
= find_init_member (constructor_fields
, braced_init_obstack
);
7231 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
7232 value
= find_init_member (constructor_index
, braced_init_obstack
);
7235 p
= XNEW (struct constructor_stack
);
7236 p
->type
= constructor_type
;
7237 p
->fields
= constructor_fields
;
7238 p
->index
= constructor_index
;
7239 p
->max_index
= constructor_max_index
;
7240 p
->unfilled_index
= constructor_unfilled_index
;
7241 p
->unfilled_fields
= constructor_unfilled_fields
;
7242 p
->bit_index
= constructor_bit_index
;
7243 p
->elements
= constructor_elements
;
7244 p
->constant
= constructor_constant
;
7245 p
->simple
= constructor_simple
;
7246 p
->nonconst
= constructor_nonconst
;
7247 p
->erroneous
= constructor_erroneous
;
7248 p
->pending_elts
= constructor_pending_elts
;
7249 p
->depth
= constructor_depth
;
7250 p
->replacement_value
.value
= 0;
7251 p
->replacement_value
.original_code
= ERROR_MARK
;
7252 p
->replacement_value
.original_type
= NULL
;
7253 p
->implicit
= implicit
;
7255 p
->incremental
= constructor_incremental
;
7256 p
->designated
= constructor_designated
;
7257 p
->next
= constructor_stack
;
7259 constructor_stack
= p
;
7261 constructor_constant
= 1;
7262 constructor_simple
= 1;
7263 constructor_nonconst
= 0;
7264 constructor_depth
= SPELLING_DEPTH ();
7265 constructor_elements
= NULL
;
7266 constructor_incremental
= 1;
7267 constructor_designated
= 0;
7268 constructor_pending_elts
= 0;
7271 p
->range_stack
= constructor_range_stack
;
7272 constructor_range_stack
= 0;
7273 designator_depth
= 0;
7274 designator_erroneous
= 0;
7277 /* Don't die if an entire brace-pair level is superfluous
7278 in the containing level. */
7279 if (constructor_type
== 0)
7281 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
7282 || TREE_CODE (constructor_type
) == UNION_TYPE
)
7284 /* Don't die if there are extra init elts at the end. */
7285 if (constructor_fields
== 0)
7286 constructor_type
= 0;
7289 constructor_type
= TREE_TYPE (constructor_fields
);
7290 push_member_name (constructor_fields
);
7291 constructor_depth
++;
7293 /* If upper initializer is designated, then mark this as
7294 designated too to prevent bogus warnings. */
7295 constructor_designated
= p
->designated
;
7297 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
7299 constructor_type
= TREE_TYPE (constructor_type
);
7300 push_array_bounds (tree_to_uhwi (constructor_index
));
7301 constructor_depth
++;
7304 if (constructor_type
== 0)
7306 error_init (loc
, "extra brace group at end of initializer");
7307 constructor_fields
= 0;
7308 constructor_unfilled_fields
= 0;
7312 if (value
&& TREE_CODE (value
) == CONSTRUCTOR
)
7314 constructor_constant
= TREE_CONSTANT (value
);
7315 constructor_simple
= TREE_STATIC (value
);
7316 constructor_nonconst
= CONSTRUCTOR_NON_CONST (value
);
7317 constructor_elements
= CONSTRUCTOR_ELTS (value
);
7318 if (!vec_safe_is_empty (constructor_elements
)
7319 && (TREE_CODE (constructor_type
) == RECORD_TYPE
7320 || TREE_CODE (constructor_type
) == ARRAY_TYPE
))
7321 set_nonincremental_init (braced_init_obstack
);
7324 if (implicit
== 1 && warn_missing_braces
&& !missing_braces_mentioned
)
7326 missing_braces_mentioned
= 1;
7327 warning_init (input_location
, OPT_Wmissing_braces
,
7328 "missing braces around initializer");
7331 if (TREE_CODE (constructor_type
) == RECORD_TYPE
7332 || TREE_CODE (constructor_type
) == UNION_TYPE
)
7334 constructor_fields
= TYPE_FIELDS (constructor_type
);
7335 /* Skip any nameless bit fields at the beginning. */
7336 while (constructor_fields
!= 0 && DECL_C_BIT_FIELD (constructor_fields
)
7337 && DECL_NAME (constructor_fields
) == 0)
7338 constructor_fields
= DECL_CHAIN (constructor_fields
);
7340 constructor_unfilled_fields
= constructor_fields
;
7341 constructor_bit_index
= bitsize_zero_node
;
7343 else if (TREE_CODE (constructor_type
) == VECTOR_TYPE
)
7345 /* Vectors are like simple fixed-size arrays. */
7346 constructor_max_index
=
7347 bitsize_int (TYPE_VECTOR_SUBPARTS (constructor_type
) - 1);
7348 constructor_index
= bitsize_int (0);
7349 constructor_unfilled_index
= constructor_index
;
7351 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
7353 if (TYPE_DOMAIN (constructor_type
))
7355 constructor_max_index
7356 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type
));
7358 /* Detect non-empty initializations of zero-length arrays. */
7359 if (constructor_max_index
== NULL_TREE
7360 && TYPE_SIZE (constructor_type
))
7361 constructor_max_index
= integer_minus_one_node
;
7363 /* constructor_max_index needs to be an INTEGER_CST. Attempts
7364 to initialize VLAs will cause a proper error; avoid tree
7365 checking errors as well by setting a safe value. */
7366 if (constructor_max_index
7367 && TREE_CODE (constructor_max_index
) != INTEGER_CST
)
7368 constructor_max_index
= integer_minus_one_node
;
7371 = convert (bitsizetype
,
7372 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type
)));
7375 constructor_index
= bitsize_zero_node
;
7377 constructor_unfilled_index
= constructor_index
;
7378 if (value
&& TREE_CODE (value
) == STRING_CST
)
7380 /* We need to split the char/wchar array into individual
7381 characters, so that we don't have to special case it
7383 set_nonincremental_init_from_string (value
, braced_init_obstack
);
7388 if (constructor_type
!= error_mark_node
)
7389 warning_init (input_location
, 0, "braces around scalar initializer");
7390 constructor_fields
= constructor_type
;
7391 constructor_unfilled_fields
= constructor_type
;
7395 /* At the end of an implicit or explicit brace level,
7396 finish up that level of constructor. If a single expression
7397 with redundant braces initialized that level, return the
7398 c_expr structure for that expression. Otherwise, the original_code
7399 element is set to ERROR_MARK.
7400 If we were outputting the elements as they are read, return 0 as the value
7401 from inner levels (process_init_element ignores that),
7402 but return error_mark_node as the value from the outermost level
7403 (that's what we want to put in DECL_INITIAL).
7404 Otherwise, return a CONSTRUCTOR expression as the value. */
7407 pop_init_level (location_t loc
, int implicit
,
7408 struct obstack
*braced_init_obstack
)
7410 struct constructor_stack
*p
;
7413 ret
.original_code
= ERROR_MARK
;
7414 ret
.original_type
= NULL
;
7418 /* When we come to an explicit close brace,
7419 pop any inner levels that didn't have explicit braces. */
7420 while (constructor_stack
->implicit
)
7421 process_init_element (input_location
,
7422 pop_init_level (loc
, 1, braced_init_obstack
),
7423 true, braced_init_obstack
);
7424 gcc_assert (!constructor_range_stack
);
7427 /* Now output all pending elements. */
7428 constructor_incremental
= 1;
7429 output_pending_init_elements (1, braced_init_obstack
);
7431 p
= constructor_stack
;
7433 /* Error for initializing a flexible array member, or a zero-length
7434 array member in an inappropriate context. */
7435 if (constructor_type
&& constructor_fields
7436 && TREE_CODE (constructor_type
) == ARRAY_TYPE
7437 && TYPE_DOMAIN (constructor_type
)
7438 && !TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type
)))
7440 /* Silently discard empty initializations. The parser will
7441 already have pedwarned for empty brackets. */
7442 if (integer_zerop (constructor_unfilled_index
))
7443 constructor_type
= NULL_TREE
;
7446 gcc_assert (!TYPE_SIZE (constructor_type
));
7448 if (constructor_depth
> 2)
7449 error_init (loc
, "initialization of flexible array member in a nested context");
7451 pedwarn_init (loc
, OPT_Wpedantic
,
7452 "initialization of a flexible array member");
7454 /* We have already issued an error message for the existence
7455 of a flexible array member not at the end of the structure.
7456 Discard the initializer so that we do not die later. */
7457 if (DECL_CHAIN (constructor_fields
) != NULL_TREE
)
7458 constructor_type
= NULL_TREE
;
7462 /* Warn when some struct elements are implicitly initialized to zero. */
7463 if (warn_missing_field_initializers
7465 && TREE_CODE (constructor_type
) == RECORD_TYPE
7466 && constructor_unfilled_fields
)
7468 bool constructor_zeroinit
=
7469 (vec_safe_length (constructor_elements
) == 1
7470 && integer_zerop ((*constructor_elements
)[0].value
));
7472 /* Do not warn for flexible array members or zero-length arrays. */
7473 while (constructor_unfilled_fields
7474 && (!DECL_SIZE (constructor_unfilled_fields
)
7475 || integer_zerop (DECL_SIZE (constructor_unfilled_fields
))))
7476 constructor_unfilled_fields
= DECL_CHAIN (constructor_unfilled_fields
);
7478 if (constructor_unfilled_fields
7479 /* Do not warn if this level of the initializer uses member
7480 designators; it is likely to be deliberate. */
7481 && !constructor_designated
7482 /* Do not warn about initializing with ` = {0}'. */
7483 && !constructor_zeroinit
)
7485 if (warning_at (input_location
, OPT_Wmissing_field_initializers
,
7486 "missing initializer for field %qD of %qT",
7487 constructor_unfilled_fields
,
7489 inform (DECL_SOURCE_LOCATION (constructor_unfilled_fields
),
7490 "%qD declared here", constructor_unfilled_fields
);
7494 /* Pad out the end of the structure. */
7495 if (p
->replacement_value
.value
)
7496 /* If this closes a superfluous brace pair,
7497 just pass out the element between them. */
7498 ret
= p
->replacement_value
;
7499 else if (constructor_type
== 0)
7501 else if (TREE_CODE (constructor_type
) != RECORD_TYPE
7502 && TREE_CODE (constructor_type
) != UNION_TYPE
7503 && TREE_CODE (constructor_type
) != ARRAY_TYPE
7504 && TREE_CODE (constructor_type
) != VECTOR_TYPE
)
7506 /* A nonincremental scalar initializer--just return
7507 the element, after verifying there is just one. */
7508 if (vec_safe_is_empty (constructor_elements
))
7510 if (!constructor_erroneous
)
7511 error_init (loc
, "empty scalar initializer");
7512 ret
.value
= error_mark_node
;
7514 else if (vec_safe_length (constructor_elements
) != 1)
7516 error_init (loc
, "extra elements in scalar initializer");
7517 ret
.value
= (*constructor_elements
)[0].value
;
7520 ret
.value
= (*constructor_elements
)[0].value
;
7524 if (constructor_erroneous
)
7525 ret
.value
= error_mark_node
;
7528 ret
.value
= build_constructor (constructor_type
,
7529 constructor_elements
);
7530 if (constructor_constant
)
7531 TREE_CONSTANT (ret
.value
) = 1;
7532 if (constructor_constant
&& constructor_simple
)
7533 TREE_STATIC (ret
.value
) = 1;
7534 if (constructor_nonconst
)
7535 CONSTRUCTOR_NON_CONST (ret
.value
) = 1;
7539 if (ret
.value
&& TREE_CODE (ret
.value
) != CONSTRUCTOR
)
7541 if (constructor_nonconst
)
7542 ret
.original_code
= C_MAYBE_CONST_EXPR
;
7543 else if (ret
.original_code
== C_MAYBE_CONST_EXPR
)
7544 ret
.original_code
= ERROR_MARK
;
7547 constructor_type
= p
->type
;
7548 constructor_fields
= p
->fields
;
7549 constructor_index
= p
->index
;
7550 constructor_max_index
= p
->max_index
;
7551 constructor_unfilled_index
= p
->unfilled_index
;
7552 constructor_unfilled_fields
= p
->unfilled_fields
;
7553 constructor_bit_index
= p
->bit_index
;
7554 constructor_elements
= p
->elements
;
7555 constructor_constant
= p
->constant
;
7556 constructor_simple
= p
->simple
;
7557 constructor_nonconst
= p
->nonconst
;
7558 constructor_erroneous
= p
->erroneous
;
7559 constructor_incremental
= p
->incremental
;
7560 constructor_designated
= p
->designated
;
7561 constructor_pending_elts
= p
->pending_elts
;
7562 constructor_depth
= p
->depth
;
7564 constructor_range_stack
= p
->range_stack
;
7565 RESTORE_SPELLING_DEPTH (constructor_depth
);
7567 constructor_stack
= p
->next
;
7570 if (ret
.value
== 0 && constructor_stack
== 0)
7571 ret
.value
= error_mark_node
;
7575 /* Common handling for both array range and field name designators.
7576 ARRAY argument is nonzero for array ranges. Returns zero for success. */
7579 set_designator (location_t loc
, int array
,
7580 struct obstack
*braced_init_obstack
)
7583 enum tree_code subcode
;
7585 /* Don't die if an entire brace-pair level is superfluous
7586 in the containing level. */
7587 if (constructor_type
== 0)
7590 /* If there were errors in this designator list already, bail out
7592 if (designator_erroneous
)
7595 if (!designator_depth
)
7597 gcc_assert (!constructor_range_stack
);
7599 /* Designator list starts at the level of closest explicit
7601 while (constructor_stack
->implicit
)
7602 process_init_element (input_location
,
7603 pop_init_level (loc
, 1, braced_init_obstack
),
7604 true, braced_init_obstack
);
7605 constructor_designated
= 1;
7609 switch (TREE_CODE (constructor_type
))
7613 subtype
= TREE_TYPE (constructor_fields
);
7614 if (subtype
!= error_mark_node
)
7615 subtype
= TYPE_MAIN_VARIANT (subtype
);
7618 subtype
= TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type
));
7624 subcode
= TREE_CODE (subtype
);
7625 if (array
&& subcode
!= ARRAY_TYPE
)
7627 error_init (loc
, "array index in non-array initializer");
7630 else if (!array
&& subcode
!= RECORD_TYPE
&& subcode
!= UNION_TYPE
)
7632 error_init (loc
, "field name not in record or union initializer");
7636 constructor_designated
= 1;
7637 push_init_level (loc
, 2, braced_init_obstack
);
7641 /* If there are range designators in designator list, push a new designator
7642 to constructor_range_stack. RANGE_END is end of such stack range or
7643 NULL_TREE if there is no range designator at this level. */
7646 push_range_stack (tree range_end
, struct obstack
* braced_init_obstack
)
7648 struct constructor_range_stack
*p
;
7650 p
= (struct constructor_range_stack
*)
7651 obstack_alloc (braced_init_obstack
,
7652 sizeof (struct constructor_range_stack
));
7653 p
->prev
= constructor_range_stack
;
7655 p
->fields
= constructor_fields
;
7656 p
->range_start
= constructor_index
;
7657 p
->index
= constructor_index
;
7658 p
->stack
= constructor_stack
;
7659 p
->range_end
= range_end
;
7660 if (constructor_range_stack
)
7661 constructor_range_stack
->next
= p
;
7662 constructor_range_stack
= p
;
7665 /* Within an array initializer, specify the next index to be initialized.
7666 FIRST is that index. If LAST is nonzero, then initialize a range
7667 of indices, running from FIRST through LAST. */
7670 set_init_index (location_t loc
, tree first
, tree last
,
7671 struct obstack
*braced_init_obstack
)
7673 if (set_designator (loc
, 1, braced_init_obstack
))
7676 designator_erroneous
= 1;
7678 if (!INTEGRAL_TYPE_P (TREE_TYPE (first
))
7679 || (last
&& !INTEGRAL_TYPE_P (TREE_TYPE (last
))))
7681 error_init (loc
, "array index in initializer not of integer type");
7685 if (TREE_CODE (first
) != INTEGER_CST
)
7687 first
= c_fully_fold (first
, false, NULL
);
7688 if (TREE_CODE (first
) == INTEGER_CST
)
7689 pedwarn_init (loc
, OPT_Wpedantic
,
7690 "array index in initializer is not "
7691 "an integer constant expression");
7694 if (last
&& TREE_CODE (last
) != INTEGER_CST
)
7696 last
= c_fully_fold (last
, false, NULL
);
7697 if (TREE_CODE (last
) == INTEGER_CST
)
7698 pedwarn_init (loc
, OPT_Wpedantic
,
7699 "array index in initializer is not "
7700 "an integer constant expression");
7703 if (TREE_CODE (first
) != INTEGER_CST
)
7704 error_init (loc
, "nonconstant array index in initializer");
7705 else if (last
!= 0 && TREE_CODE (last
) != INTEGER_CST
)
7706 error_init (loc
, "nonconstant array index in initializer");
7707 else if (TREE_CODE (constructor_type
) != ARRAY_TYPE
)
7708 error_init (loc
, "array index in non-array initializer");
7709 else if (tree_int_cst_sgn (first
) == -1)
7710 error_init (loc
, "array index in initializer exceeds array bounds");
7711 else if (constructor_max_index
7712 && tree_int_cst_lt (constructor_max_index
, first
))
7713 error_init (loc
, "array index in initializer exceeds array bounds");
7716 constant_expression_warning (first
);
7718 constant_expression_warning (last
);
7719 constructor_index
= convert (bitsizetype
, first
);
7720 if (tree_int_cst_lt (constructor_index
, first
))
7722 constructor_index
= copy_node (constructor_index
);
7723 TREE_OVERFLOW (constructor_index
) = 1;
7728 if (tree_int_cst_equal (first
, last
))
7730 else if (tree_int_cst_lt (last
, first
))
7732 error_init (loc
, "empty index range in initializer");
7737 last
= convert (bitsizetype
, last
);
7738 if (constructor_max_index
!= 0
7739 && tree_int_cst_lt (constructor_max_index
, last
))
7741 error_init (loc
, "array index range in initializer exceeds "
7749 designator_erroneous
= 0;
7750 if (constructor_range_stack
|| last
)
7751 push_range_stack (last
, braced_init_obstack
);
7755 /* Within a struct initializer, specify the next field to be initialized. */
7758 set_init_label (location_t loc
, tree fieldname
,
7759 struct obstack
*braced_init_obstack
)
7763 if (set_designator (loc
, 0, braced_init_obstack
))
7766 designator_erroneous
= 1;
7768 if (TREE_CODE (constructor_type
) != RECORD_TYPE
7769 && TREE_CODE (constructor_type
) != UNION_TYPE
)
7771 error_init (loc
, "field name not in record or union initializer");
7775 field
= lookup_field (constructor_type
, fieldname
);
7778 error ("unknown field %qE specified in initializer", fieldname
);
7782 constructor_fields
= TREE_VALUE (field
);
7784 designator_erroneous
= 0;
7785 if (constructor_range_stack
)
7786 push_range_stack (NULL_TREE
, braced_init_obstack
);
7787 field
= TREE_CHAIN (field
);
7790 if (set_designator (loc
, 0, braced_init_obstack
))
7794 while (field
!= NULL_TREE
);
7797 /* Add a new initializer to the tree of pending initializers. PURPOSE
7798 identifies the initializer, either array index or field in a structure.
7799 VALUE is the value of that index or field. If ORIGTYPE is not
7800 NULL_TREE, it is the original type of VALUE.
7802 IMPLICIT is true if value comes from pop_init_level (1),
7803 the new initializer has been merged with the existing one
7804 and thus no warnings should be emitted about overriding an
7805 existing initializer. */
7808 add_pending_init (location_t loc
, tree purpose
, tree value
, tree origtype
,
7809 bool implicit
, struct obstack
*braced_init_obstack
)
7811 struct init_node
*p
, **q
, *r
;
7813 q
= &constructor_pending_elts
;
7816 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
7821 if (tree_int_cst_lt (purpose
, p
->purpose
))
7823 else if (tree_int_cst_lt (p
->purpose
, purpose
))
7829 if (TREE_SIDE_EFFECTS (p
->value
))
7830 warning_init (loc
, 0,
7831 "initialized field with side-effects "
7833 else if (warn_override_init
)
7834 warning_init (loc
, OPT_Woverride_init
,
7835 "initialized field overwritten");
7838 p
->origtype
= origtype
;
7847 bitpos
= bit_position (purpose
);
7851 if (tree_int_cst_lt (bitpos
, bit_position (p
->purpose
)))
7853 else if (p
->purpose
!= purpose
)
7859 if (TREE_SIDE_EFFECTS (p
->value
))
7860 warning_init (loc
, 0,
7861 "initialized field with side-effects "
7863 else if (warn_override_init
)
7864 warning_init (loc
, OPT_Woverride_init
,
7865 "initialized field overwritten");
7868 p
->origtype
= origtype
;
7874 r
= (struct init_node
*) obstack_alloc (braced_init_obstack
,
7875 sizeof (struct init_node
));
7876 r
->purpose
= purpose
;
7878 r
->origtype
= origtype
;
7888 struct init_node
*s
;
7892 if (p
->balance
== 0)
7894 else if (p
->balance
< 0)
7901 p
->left
->parent
= p
;
7918 constructor_pending_elts
= r
;
7923 struct init_node
*t
= r
->right
;
7927 r
->right
->parent
= r
;
7932 p
->left
->parent
= p
;
7935 p
->balance
= t
->balance
< 0;
7936 r
->balance
= -(t
->balance
> 0);
7951 constructor_pending_elts
= t
;
7957 /* p->balance == +1; growth of left side balances the node. */
7962 else /* r == p->right */
7964 if (p
->balance
== 0)
7965 /* Growth propagation from right side. */
7967 else if (p
->balance
> 0)
7974 p
->right
->parent
= p
;
7991 constructor_pending_elts
= r
;
7993 else /* r->balance == -1 */
7996 struct init_node
*t
= r
->left
;
8000 r
->left
->parent
= r
;
8005 p
->right
->parent
= p
;
8008 r
->balance
= (t
->balance
< 0);
8009 p
->balance
= -(t
->balance
> 0);
8024 constructor_pending_elts
= t
;
8030 /* p->balance == -1; growth of right side balances the node. */
8041 /* Build AVL tree from a sorted chain. */
8044 set_nonincremental_init (struct obstack
* braced_init_obstack
)
8046 unsigned HOST_WIDE_INT ix
;
8049 if (TREE_CODE (constructor_type
) != RECORD_TYPE
8050 && TREE_CODE (constructor_type
) != ARRAY_TYPE
)
8053 FOR_EACH_CONSTRUCTOR_ELT (constructor_elements
, ix
, index
, value
)
8054 add_pending_init (input_location
, index
, value
, NULL_TREE
, true,
8055 braced_init_obstack
);
8056 constructor_elements
= NULL
;
8057 if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
8059 constructor_unfilled_fields
= TYPE_FIELDS (constructor_type
);
8060 /* Skip any nameless bit fields at the beginning. */
8061 while (constructor_unfilled_fields
!= 0
8062 && DECL_C_BIT_FIELD (constructor_unfilled_fields
)
8063 && DECL_NAME (constructor_unfilled_fields
) == 0)
8064 constructor_unfilled_fields
= TREE_CHAIN (constructor_unfilled_fields
);
8067 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
8069 if (TYPE_DOMAIN (constructor_type
))
8070 constructor_unfilled_index
8071 = convert (bitsizetype
,
8072 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type
)));
8074 constructor_unfilled_index
= bitsize_zero_node
;
8076 constructor_incremental
= 0;
8079 /* Build AVL tree from a string constant. */
8082 set_nonincremental_init_from_string (tree str
,
8083 struct obstack
* braced_init_obstack
)
8085 tree value
, purpose
, type
;
8086 HOST_WIDE_INT val
[2];
8087 const char *p
, *end
;
8088 int byte
, wchar_bytes
, charwidth
, bitpos
;
8090 gcc_assert (TREE_CODE (constructor_type
) == ARRAY_TYPE
);
8092 wchar_bytes
= TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str
))) / BITS_PER_UNIT
;
8093 charwidth
= TYPE_PRECISION (char_type_node
);
8094 type
= TREE_TYPE (constructor_type
);
8095 p
= TREE_STRING_POINTER (str
);
8096 end
= p
+ TREE_STRING_LENGTH (str
);
8098 for (purpose
= bitsize_zero_node
;
8100 && !(constructor_max_index
8101 && tree_int_cst_lt (constructor_max_index
, purpose
));
8102 purpose
= size_binop (PLUS_EXPR
, purpose
, bitsize_one_node
))
8104 if (wchar_bytes
== 1)
8106 val
[0] = (unsigned char) *p
++;
8113 for (byte
= 0; byte
< wchar_bytes
; byte
++)
8115 if (BYTES_BIG_ENDIAN
)
8116 bitpos
= (wchar_bytes
- byte
- 1) * charwidth
;
8118 bitpos
= byte
* charwidth
;
8119 val
[bitpos
% HOST_BITS_PER_WIDE_INT
]
8120 |= ((unsigned HOST_WIDE_INT
) ((unsigned char) *p
++))
8121 << (bitpos
% HOST_BITS_PER_WIDE_INT
);
8125 if (!TYPE_UNSIGNED (type
))
8127 bitpos
= ((wchar_bytes
- 1) * charwidth
) + HOST_BITS_PER_CHAR
;
8128 if (bitpos
< HOST_BITS_PER_WIDE_INT
)
8130 if (val
[0] & (((HOST_WIDE_INT
) 1) << (bitpos
- 1)))
8132 val
[0] |= ((HOST_WIDE_INT
) -1) << bitpos
;
8136 else if (bitpos
== HOST_BITS_PER_WIDE_INT
)
8141 else if (val
[1] & (((HOST_WIDE_INT
) 1)
8142 << (bitpos
- 1 - HOST_BITS_PER_WIDE_INT
)))
8143 val
[1] |= ((HOST_WIDE_INT
) -1)
8144 << (bitpos
- HOST_BITS_PER_WIDE_INT
);
8147 value
= wide_int_to_tree (type
,
8148 wide_int::from_array (val
, 2,
8149 HOST_BITS_PER_WIDE_INT
* 2));
8150 add_pending_init (input_location
, purpose
, value
, NULL_TREE
, true,
8151 braced_init_obstack
);
8154 constructor_incremental
= 0;
8157 /* Return value of FIELD in pending initializer or zero if the field was
8158 not initialized yet. */
8161 find_init_member (tree field
, struct obstack
* braced_init_obstack
)
8163 struct init_node
*p
;
8165 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
8167 if (constructor_incremental
8168 && tree_int_cst_lt (field
, constructor_unfilled_index
))
8169 set_nonincremental_init (braced_init_obstack
);
8171 p
= constructor_pending_elts
;
8174 if (tree_int_cst_lt (field
, p
->purpose
))
8176 else if (tree_int_cst_lt (p
->purpose
, field
))
8182 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
8184 tree bitpos
= bit_position (field
);
8186 if (constructor_incremental
8187 && (!constructor_unfilled_fields
8188 || tree_int_cst_lt (bitpos
,
8189 bit_position (constructor_unfilled_fields
))))
8190 set_nonincremental_init (braced_init_obstack
);
8192 p
= constructor_pending_elts
;
8195 if (field
== p
->purpose
)
8197 else if (tree_int_cst_lt (bitpos
, bit_position (p
->purpose
)))
8203 else if (TREE_CODE (constructor_type
) == UNION_TYPE
)
8205 if (!vec_safe_is_empty (constructor_elements
)
8206 && (constructor_elements
->last ().index
== field
))
8207 return constructor_elements
->last ().value
;
8212 /* "Output" the next constructor element.
8213 At top level, really output it to assembler code now.
8214 Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
8215 If ORIGTYPE is not NULL_TREE, it is the original type of VALUE.
8216 TYPE is the data type that the containing data type wants here.
8217 FIELD is the field (a FIELD_DECL) or the index that this element fills.
8218 If VALUE is a string constant, STRICT_STRING is true if it is
8219 unparenthesized or we should not warn here for it being parenthesized.
8220 For other types of VALUE, STRICT_STRING is not used.
8222 PENDING if non-nil means output pending elements that belong
8223 right after this element. (PENDING is normally 1;
8224 it is 0 while outputting pending elements, to avoid recursion.)
8226 IMPLICIT is true if value comes from pop_init_level (1),
8227 the new initializer has been merged with the existing one
8228 and thus no warnings should be emitted about overriding an
8229 existing initializer. */
8232 output_init_element (location_t loc
, tree value
, tree origtype
,
8233 bool strict_string
, tree type
, tree field
, int pending
,
8234 bool implicit
, struct obstack
* braced_init_obstack
)
8236 tree semantic_type
= NULL_TREE
;
8237 bool maybe_const
= true;
8240 if (type
== error_mark_node
|| value
== error_mark_node
)
8242 constructor_erroneous
= 1;
8245 if (TREE_CODE (TREE_TYPE (value
)) == ARRAY_TYPE
8246 && (TREE_CODE (value
) == STRING_CST
8247 || TREE_CODE (value
) == COMPOUND_LITERAL_EXPR
)
8248 && !(TREE_CODE (value
) == STRING_CST
8249 && TREE_CODE (type
) == ARRAY_TYPE
8250 && INTEGRAL_TYPE_P (TREE_TYPE (type
)))
8251 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value
)),
8252 TYPE_MAIN_VARIANT (type
)))
8253 value
= array_to_pointer_conversion (input_location
, value
);
8255 if (TREE_CODE (value
) == COMPOUND_LITERAL_EXPR
8256 && require_constant_value
&& !flag_isoc99
&& pending
)
8258 /* As an extension, allow initializing objects with static storage
8259 duration with compound literals (which are then treated just as
8260 the brace enclosed list they contain). */
8261 tree decl
= COMPOUND_LITERAL_EXPR_DECL (value
);
8262 value
= DECL_INITIAL (decl
);
8265 npc
= null_pointer_constant_p (value
);
8266 if (TREE_CODE (value
) == EXCESS_PRECISION_EXPR
)
8268 semantic_type
= TREE_TYPE (value
);
8269 value
= TREE_OPERAND (value
, 0);
8271 value
= c_fully_fold (value
, require_constant_value
, &maybe_const
);
8273 if (value
== error_mark_node
)
8274 constructor_erroneous
= 1;
8275 else if (!TREE_CONSTANT (value
))
8276 constructor_constant
= 0;
8277 else if (!initializer_constant_valid_p (value
, TREE_TYPE (value
))
8278 || ((TREE_CODE (constructor_type
) == RECORD_TYPE
8279 || TREE_CODE (constructor_type
) == UNION_TYPE
)
8280 && DECL_C_BIT_FIELD (field
)
8281 && TREE_CODE (value
) != INTEGER_CST
))
8282 constructor_simple
= 0;
8284 constructor_nonconst
= 1;
8286 if (!initializer_constant_valid_p (value
, TREE_TYPE (value
)))
8288 if (require_constant_value
)
8290 error_init (loc
, "initializer element is not constant");
8291 value
= error_mark_node
;
8293 else if (require_constant_elements
)
8294 pedwarn (loc
, OPT_Wpedantic
,
8295 "initializer element is not computable at load time");
8297 else if (!maybe_const
8298 && (require_constant_value
|| require_constant_elements
))
8299 pedwarn_init (loc
, OPT_Wpedantic
,
8300 "initializer element is not a constant expression");
8302 /* Issue -Wc++-compat warnings about initializing a bitfield with
8305 && field
!= NULL_TREE
8306 && TREE_CODE (field
) == FIELD_DECL
8307 && DECL_BIT_FIELD_TYPE (field
) != NULL_TREE
8308 && (TYPE_MAIN_VARIANT (DECL_BIT_FIELD_TYPE (field
))
8309 != TYPE_MAIN_VARIANT (type
))
8310 && TREE_CODE (DECL_BIT_FIELD_TYPE (field
)) == ENUMERAL_TYPE
)
8312 tree checktype
= origtype
!= NULL_TREE
? origtype
: TREE_TYPE (value
);
8313 if (checktype
!= error_mark_node
8314 && (TYPE_MAIN_VARIANT (checktype
)
8315 != TYPE_MAIN_VARIANT (DECL_BIT_FIELD_TYPE (field
))))
8316 warning_init (loc
, OPT_Wc___compat
,
8317 "enum conversion in initialization is invalid in C++");
8320 /* If this field is empty (and not at the end of structure),
8321 don't do anything other than checking the initializer. */
8323 && (TREE_TYPE (field
) == error_mark_node
8324 || (COMPLETE_TYPE_P (TREE_TYPE (field
))
8325 && integer_zerop (TYPE_SIZE (TREE_TYPE (field
)))
8326 && (TREE_CODE (constructor_type
) == ARRAY_TYPE
8327 || DECL_CHAIN (field
)))))
8331 value
= build1 (EXCESS_PRECISION_EXPR
, semantic_type
, value
);
8332 value
= digest_init (loc
, type
, value
, origtype
, npc
, strict_string
,
8333 require_constant_value
);
8334 if (value
== error_mark_node
)
8336 constructor_erroneous
= 1;
8339 if (require_constant_value
|| require_constant_elements
)
8340 constant_expression_warning (value
);
8342 /* If this element doesn't come next in sequence,
8343 put it on constructor_pending_elts. */
8344 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
8345 && (!constructor_incremental
8346 || !tree_int_cst_equal (field
, constructor_unfilled_index
)))
8348 if (constructor_incremental
8349 && tree_int_cst_lt (field
, constructor_unfilled_index
))
8350 set_nonincremental_init (braced_init_obstack
);
8352 add_pending_init (loc
, field
, value
, origtype
, implicit
,
8353 braced_init_obstack
);
8356 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
8357 && (!constructor_incremental
8358 || field
!= constructor_unfilled_fields
))
8360 /* We do this for records but not for unions. In a union,
8361 no matter which field is specified, it can be initialized
8362 right away since it starts at the beginning of the union. */
8363 if (constructor_incremental
)
8365 if (!constructor_unfilled_fields
)
8366 set_nonincremental_init (braced_init_obstack
);
8369 tree bitpos
, unfillpos
;
8371 bitpos
= bit_position (field
);
8372 unfillpos
= bit_position (constructor_unfilled_fields
);
8374 if (tree_int_cst_lt (bitpos
, unfillpos
))
8375 set_nonincremental_init (braced_init_obstack
);
8379 add_pending_init (loc
, field
, value
, origtype
, implicit
,
8380 braced_init_obstack
);
8383 else if (TREE_CODE (constructor_type
) == UNION_TYPE
8384 && !vec_safe_is_empty (constructor_elements
))
8388 if (TREE_SIDE_EFFECTS (constructor_elements
->last ().value
))
8389 warning_init (loc
, 0,
8390 "initialized field with side-effects overwritten");
8391 else if (warn_override_init
)
8392 warning_init (loc
, OPT_Woverride_init
,
8393 "initialized field overwritten");
8396 /* We can have just one union field set. */
8397 constructor_elements
= NULL
;
8400 /* Otherwise, output this element either to
8401 constructor_elements or to the assembler file. */
8403 constructor_elt celt
= {field
, value
};
8404 vec_safe_push (constructor_elements
, celt
);
8406 /* Advance the variable that indicates sequential elements output. */
8407 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
8408 constructor_unfilled_index
8409 = size_binop_loc (input_location
, PLUS_EXPR
, constructor_unfilled_index
,
8411 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
8413 constructor_unfilled_fields
8414 = DECL_CHAIN (constructor_unfilled_fields
);
8416 /* Skip any nameless bit fields. */
8417 while (constructor_unfilled_fields
!= 0
8418 && DECL_C_BIT_FIELD (constructor_unfilled_fields
)
8419 && DECL_NAME (constructor_unfilled_fields
) == 0)
8420 constructor_unfilled_fields
=
8421 DECL_CHAIN (constructor_unfilled_fields
);
8423 else if (TREE_CODE (constructor_type
) == UNION_TYPE
)
8424 constructor_unfilled_fields
= 0;
8426 /* Now output any pending elements which have become next. */
8428 output_pending_init_elements (0, braced_init_obstack
);
8431 /* Output any pending elements which have become next.
8432 As we output elements, constructor_unfilled_{fields,index}
8433 advances, which may cause other elements to become next;
8434 if so, they too are output.
8436 If ALL is 0, we return when there are
8437 no more pending elements to output now.
8439 If ALL is 1, we output space as necessary so that
8440 we can output all the pending elements. */
8442 output_pending_init_elements (int all
, struct obstack
* braced_init_obstack
)
8444 struct init_node
*elt
= constructor_pending_elts
;
8449 /* Look through the whole pending tree.
8450 If we find an element that should be output now,
8451 output it. Otherwise, set NEXT to the element
8452 that comes first among those still pending. */
8457 if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
8459 if (tree_int_cst_equal (elt
->purpose
,
8460 constructor_unfilled_index
))
8461 output_init_element (input_location
, elt
->value
, elt
->origtype
,
8462 true, TREE_TYPE (constructor_type
),
8463 constructor_unfilled_index
, 0, false,
8464 braced_init_obstack
);
8465 else if (tree_int_cst_lt (constructor_unfilled_index
,
8468 /* Advance to the next smaller node. */
8473 /* We have reached the smallest node bigger than the
8474 current unfilled index. Fill the space first. */
8475 next
= elt
->purpose
;
8481 /* Advance to the next bigger node. */
8486 /* We have reached the biggest node in a subtree. Find
8487 the parent of it, which is the next bigger node. */
8488 while (elt
->parent
&& elt
->parent
->right
== elt
)
8491 if (elt
&& tree_int_cst_lt (constructor_unfilled_index
,
8494 next
= elt
->purpose
;
8500 else if (TREE_CODE (constructor_type
) == RECORD_TYPE
8501 || TREE_CODE (constructor_type
) == UNION_TYPE
)
8503 tree ctor_unfilled_bitpos
, elt_bitpos
;
8505 /* If the current record is complete we are done. */
8506 if (constructor_unfilled_fields
== 0)
8509 ctor_unfilled_bitpos
= bit_position (constructor_unfilled_fields
);
8510 elt_bitpos
= bit_position (elt
->purpose
);
8511 /* We can't compare fields here because there might be empty
8512 fields in between. */
8513 if (tree_int_cst_equal (elt_bitpos
, ctor_unfilled_bitpos
))
8515 constructor_unfilled_fields
= elt
->purpose
;
8516 output_init_element (input_location
, elt
->value
, elt
->origtype
,
8517 true, TREE_TYPE (elt
->purpose
),
8518 elt
->purpose
, 0, false,
8519 braced_init_obstack
);
8521 else if (tree_int_cst_lt (ctor_unfilled_bitpos
, elt_bitpos
))
8523 /* Advance to the next smaller node. */
8528 /* We have reached the smallest node bigger than the
8529 current unfilled field. Fill the space first. */
8530 next
= elt
->purpose
;
8536 /* Advance to the next bigger node. */
8541 /* We have reached the biggest node in a subtree. Find
8542 the parent of it, which is the next bigger node. */
8543 while (elt
->parent
&& elt
->parent
->right
== elt
)
8547 && (tree_int_cst_lt (ctor_unfilled_bitpos
,
8548 bit_position (elt
->purpose
))))
8550 next
= elt
->purpose
;
8558 /* Ordinarily return, but not if we want to output all
8559 and there are elements left. */
8560 if (!(all
&& next
!= 0))
8563 /* If it's not incremental, just skip over the gap, so that after
8564 jumping to retry we will output the next successive element. */
8565 if (TREE_CODE (constructor_type
) == RECORD_TYPE
8566 || TREE_CODE (constructor_type
) == UNION_TYPE
)
8567 constructor_unfilled_fields
= next
;
8568 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
8569 constructor_unfilled_index
= next
;
8571 /* ELT now points to the node in the pending tree with the next
8572 initializer to output. */
8576 /* Add one non-braced element to the current constructor level.
8577 This adjusts the current position within the constructor's type.
8578 This may also start or terminate implicit levels
8579 to handle a partly-braced initializer.
8581 Once this has found the correct level for the new element,
8582 it calls output_init_element.
8584 IMPLICIT is true if value comes from pop_init_level (1),
8585 the new initializer has been merged with the existing one
8586 and thus no warnings should be emitted about overriding an
8587 existing initializer. */
8590 process_init_element (location_t loc
, struct c_expr value
, bool implicit
,
8591 struct obstack
* braced_init_obstack
)
8593 tree orig_value
= value
.value
;
8594 int string_flag
= orig_value
!= 0 && TREE_CODE (orig_value
) == STRING_CST
;
8595 bool strict_string
= value
.original_code
== STRING_CST
;
8596 bool was_designated
= designator_depth
!= 0;
8598 designator_depth
= 0;
8599 designator_erroneous
= 0;
8601 /* Handle superfluous braces around string cst as in
8602 char x[] = {"foo"}; */
8606 && TREE_CODE (constructor_type
) == ARRAY_TYPE
8607 && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type
))
8608 && integer_zerop (constructor_unfilled_index
))
8610 if (constructor_stack
->replacement_value
.value
)
8611 error_init (loc
, "excess elements in char array initializer");
8612 constructor_stack
->replacement_value
= value
;
8616 if (constructor_stack
->replacement_value
.value
!= 0)
8618 error_init (loc
, "excess elements in struct initializer");
8622 /* Ignore elements of a brace group if it is entirely superfluous
8623 and has already been diagnosed. */
8624 if (constructor_type
== 0)
8627 /* If we've exhausted any levels that didn't have braces,
8629 while (constructor_stack
->implicit
)
8631 if ((TREE_CODE (constructor_type
) == RECORD_TYPE
8632 || TREE_CODE (constructor_type
) == UNION_TYPE
)
8633 && constructor_fields
== 0)
8634 process_init_element (loc
,
8635 pop_init_level (loc
, 1, braced_init_obstack
),
8636 true, braced_init_obstack
);
8637 else if ((TREE_CODE (constructor_type
) == ARRAY_TYPE
8638 || TREE_CODE (constructor_type
) == VECTOR_TYPE
)
8639 && constructor_max_index
8640 && tree_int_cst_lt (constructor_max_index
,
8642 process_init_element (loc
,
8643 pop_init_level (loc
, 1, braced_init_obstack
),
8644 true, braced_init_obstack
);
8649 /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */
8650 if (constructor_range_stack
)
8652 /* If value is a compound literal and we'll be just using its
8653 content, don't put it into a SAVE_EXPR. */
8654 if (TREE_CODE (value
.value
) != COMPOUND_LITERAL_EXPR
8655 || !require_constant_value
8658 tree semantic_type
= NULL_TREE
;
8659 if (TREE_CODE (value
.value
) == EXCESS_PRECISION_EXPR
)
8661 semantic_type
= TREE_TYPE (value
.value
);
8662 value
.value
= TREE_OPERAND (value
.value
, 0);
8664 value
.value
= c_save_expr (value
.value
);
8666 value
.value
= build1 (EXCESS_PRECISION_EXPR
, semantic_type
,
8673 if (TREE_CODE (constructor_type
) == RECORD_TYPE
)
8676 enum tree_code fieldcode
;
8678 if (constructor_fields
== 0)
8680 pedwarn_init (loc
, 0, "excess elements in struct initializer");
8684 fieldtype
= TREE_TYPE (constructor_fields
);
8685 if (fieldtype
!= error_mark_node
)
8686 fieldtype
= TYPE_MAIN_VARIANT (fieldtype
);
8687 fieldcode
= TREE_CODE (fieldtype
);
8689 /* Error for non-static initialization of a flexible array member. */
8690 if (fieldcode
== ARRAY_TYPE
8691 && !require_constant_value
8692 && TYPE_SIZE (fieldtype
) == NULL_TREE
8693 && DECL_CHAIN (constructor_fields
) == NULL_TREE
)
8695 error_init (loc
, "non-static initialization of a flexible "
8700 /* Accept a string constant to initialize a subarray. */
8701 if (value
.value
!= 0
8702 && fieldcode
== ARRAY_TYPE
8703 && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype
))
8705 value
.value
= orig_value
;
8706 /* Otherwise, if we have come to a subaggregate,
8707 and we don't have an element of its type, push into it. */
8708 else if (value
.value
!= 0
8709 && value
.value
!= error_mark_node
8710 && TYPE_MAIN_VARIANT (TREE_TYPE (value
.value
)) != fieldtype
8711 && (fieldcode
== RECORD_TYPE
|| fieldcode
== ARRAY_TYPE
8712 || fieldcode
== UNION_TYPE
|| fieldcode
== VECTOR_TYPE
))
8714 push_init_level (loc
, 1, braced_init_obstack
);
8720 push_member_name (constructor_fields
);
8721 output_init_element (loc
, value
.value
, value
.original_type
,
8722 strict_string
, fieldtype
,
8723 constructor_fields
, 1, implicit
,
8724 braced_init_obstack
);
8725 RESTORE_SPELLING_DEPTH (constructor_depth
);
8728 /* Do the bookkeeping for an element that was
8729 directly output as a constructor. */
8731 /* For a record, keep track of end position of last field. */
8732 if (DECL_SIZE (constructor_fields
))
8733 constructor_bit_index
8734 = size_binop_loc (input_location
, PLUS_EXPR
,
8735 bit_position (constructor_fields
),
8736 DECL_SIZE (constructor_fields
));
8738 /* If the current field was the first one not yet written out,
8739 it isn't now, so update. */
8740 if (constructor_unfilled_fields
== constructor_fields
)
8742 constructor_unfilled_fields
= DECL_CHAIN (constructor_fields
);
8743 /* Skip any nameless bit fields. */
8744 while (constructor_unfilled_fields
!= 0
8745 && DECL_C_BIT_FIELD (constructor_unfilled_fields
)
8746 && DECL_NAME (constructor_unfilled_fields
) == 0)
8747 constructor_unfilled_fields
=
8748 DECL_CHAIN (constructor_unfilled_fields
);
8752 constructor_fields
= DECL_CHAIN (constructor_fields
);
8753 /* Skip any nameless bit fields at the beginning. */
8754 while (constructor_fields
!= 0
8755 && DECL_C_BIT_FIELD (constructor_fields
)
8756 && DECL_NAME (constructor_fields
) == 0)
8757 constructor_fields
= DECL_CHAIN (constructor_fields
);
8759 else if (TREE_CODE (constructor_type
) == UNION_TYPE
)
8762 enum tree_code fieldcode
;
8764 if (constructor_fields
== 0)
8766 pedwarn_init (loc
, 0,
8767 "excess elements in union initializer");
8771 fieldtype
= TREE_TYPE (constructor_fields
);
8772 if (fieldtype
!= error_mark_node
)
8773 fieldtype
= TYPE_MAIN_VARIANT (fieldtype
);
8774 fieldcode
= TREE_CODE (fieldtype
);
8776 /* Warn that traditional C rejects initialization of unions.
8777 We skip the warning if the value is zero. This is done
8778 under the assumption that the zero initializer in user
8779 code appears conditioned on e.g. __STDC__ to avoid
8780 "missing initializer" warnings and relies on default
8781 initialization to zero in the traditional C case.
8782 We also skip the warning if the initializer is designated,
8783 again on the assumption that this must be conditional on
8784 __STDC__ anyway (and we've already complained about the
8785 member-designator already). */
8786 if (!in_system_header_at (input_location
) && !constructor_designated
8787 && !(value
.value
&& (integer_zerop (value
.value
)
8788 || real_zerop (value
.value
))))
8789 warning (OPT_Wtraditional
, "traditional C rejects initialization "
8792 /* Accept a string constant to initialize a subarray. */
8793 if (value
.value
!= 0
8794 && fieldcode
== ARRAY_TYPE
8795 && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype
))
8797 value
.value
= orig_value
;
8798 /* Otherwise, if we have come to a subaggregate,
8799 and we don't have an element of its type, push into it. */
8800 else if (value
.value
!= 0
8801 && value
.value
!= error_mark_node
8802 && TYPE_MAIN_VARIANT (TREE_TYPE (value
.value
)) != fieldtype
8803 && (fieldcode
== RECORD_TYPE
|| fieldcode
== ARRAY_TYPE
8804 || fieldcode
== UNION_TYPE
|| fieldcode
== VECTOR_TYPE
))
8806 push_init_level (loc
, 1, braced_init_obstack
);
8812 push_member_name (constructor_fields
);
8813 output_init_element (loc
, value
.value
, value
.original_type
,
8814 strict_string
, fieldtype
,
8815 constructor_fields
, 1, implicit
,
8816 braced_init_obstack
);
8817 RESTORE_SPELLING_DEPTH (constructor_depth
);
8820 /* Do the bookkeeping for an element that was
8821 directly output as a constructor. */
8823 constructor_bit_index
= DECL_SIZE (constructor_fields
);
8824 constructor_unfilled_fields
= DECL_CHAIN (constructor_fields
);
8827 constructor_fields
= 0;
8829 else if (TREE_CODE (constructor_type
) == ARRAY_TYPE
)
8831 tree elttype
= TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type
));
8832 enum tree_code eltcode
= TREE_CODE (elttype
);
8834 /* Accept a string constant to initialize a subarray. */
8835 if (value
.value
!= 0
8836 && eltcode
== ARRAY_TYPE
8837 && INTEGRAL_TYPE_P (TREE_TYPE (elttype
))
8839 value
.value
= orig_value
;
8840 /* Otherwise, if we have come to a subaggregate,
8841 and we don't have an element of its type, push into it. */
8842 else if (value
.value
!= 0
8843 && value
.value
!= error_mark_node
8844 && TYPE_MAIN_VARIANT (TREE_TYPE (value
.value
)) != elttype
8845 && (eltcode
== RECORD_TYPE
|| eltcode
== ARRAY_TYPE
8846 || eltcode
== UNION_TYPE
|| eltcode
== VECTOR_TYPE
))
8848 push_init_level (loc
, 1, braced_init_obstack
);
8852 if (constructor_max_index
!= 0
8853 && (tree_int_cst_lt (constructor_max_index
, constructor_index
)
8854 || integer_all_onesp (constructor_max_index
)))
8856 pedwarn_init (loc
, 0,
8857 "excess elements in array initializer");
8861 /* Now output the actual element. */
8864 push_array_bounds (tree_to_uhwi (constructor_index
));
8865 output_init_element (loc
, value
.value
, value
.original_type
,
8866 strict_string
, elttype
,
8867 constructor_index
, 1, implicit
,
8868 braced_init_obstack
);
8869 RESTORE_SPELLING_DEPTH (constructor_depth
);
8873 = size_binop_loc (input_location
, PLUS_EXPR
,
8874 constructor_index
, bitsize_one_node
);
8877 /* If we are doing the bookkeeping for an element that was
8878 directly output as a constructor, we must update
8879 constructor_unfilled_index. */
8880 constructor_unfilled_index
= constructor_index
;
8882 else if (TREE_CODE (constructor_type
) == VECTOR_TYPE
)
8884 tree elttype
= TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type
));
8886 /* Do a basic check of initializer size. Note that vectors
8887 always have a fixed size derived from their type. */
8888 if (tree_int_cst_lt (constructor_max_index
, constructor_index
))
8890 pedwarn_init (loc
, 0,
8891 "excess elements in vector initializer");
8895 /* Now output the actual element. */
8898 if (TREE_CODE (value
.value
) == VECTOR_CST
)
8899 elttype
= TYPE_MAIN_VARIANT (constructor_type
);
8900 output_init_element (loc
, value
.value
, value
.original_type
,
8901 strict_string
, elttype
,
8902 constructor_index
, 1, implicit
,
8903 braced_init_obstack
);
8907 = size_binop_loc (input_location
,
8908 PLUS_EXPR
, constructor_index
, bitsize_one_node
);
8911 /* If we are doing the bookkeeping for an element that was
8912 directly output as a constructor, we must update
8913 constructor_unfilled_index. */
8914 constructor_unfilled_index
= constructor_index
;
8917 /* Handle the sole element allowed in a braced initializer
8918 for a scalar variable. */
8919 else if (constructor_type
!= error_mark_node
8920 && constructor_fields
== 0)
8922 pedwarn_init (loc
, 0,
8923 "excess elements in scalar initializer");
8929 output_init_element (loc
, value
.value
, value
.original_type
,
8930 strict_string
, constructor_type
,
8931 NULL_TREE
, 1, implicit
,
8932 braced_init_obstack
);
8933 constructor_fields
= 0;
8936 /* Handle range initializers either at this level or anywhere higher
8937 in the designator stack. */
8938 if (constructor_range_stack
)
8940 struct constructor_range_stack
*p
, *range_stack
;
8943 range_stack
= constructor_range_stack
;
8944 constructor_range_stack
= 0;
8945 while (constructor_stack
!= range_stack
->stack
)
8947 gcc_assert (constructor_stack
->implicit
);
8948 process_init_element (loc
,
8949 pop_init_level (loc
, 1,
8950 braced_init_obstack
),
8951 true, braced_init_obstack
);
8953 for (p
= range_stack
;
8954 !p
->range_end
|| tree_int_cst_equal (p
->index
, p
->range_end
);
8957 gcc_assert (constructor_stack
->implicit
);
8958 process_init_element (loc
,
8959 pop_init_level (loc
, 1,
8960 braced_init_obstack
),
8961 true, braced_init_obstack
);
8964 p
->index
= size_binop_loc (input_location
,
8965 PLUS_EXPR
, p
->index
, bitsize_one_node
);
8966 if (tree_int_cst_equal (p
->index
, p
->range_end
) && !p
->prev
)
8971 constructor_index
= p
->index
;
8972 constructor_fields
= p
->fields
;
8973 if (finish
&& p
->range_end
&& p
->index
== p
->range_start
)
8981 push_init_level (loc
, 2, braced_init_obstack
);
8982 p
->stack
= constructor_stack
;
8983 if (p
->range_end
&& tree_int_cst_equal (p
->index
, p
->range_end
))
8984 p
->index
= p
->range_start
;
8988 constructor_range_stack
= range_stack
;
8995 constructor_range_stack
= 0;
8998 /* Build a complete asm-statement, whose components are a CV_QUALIFIER
8999 (guaranteed to be 'volatile' or null) and ARGS (represented using
9000 an ASM_EXPR node). */
9002 build_asm_stmt (tree cv_qualifier
, tree args
)
9004 if (!ASM_VOLATILE_P (args
) && cv_qualifier
)
9005 ASM_VOLATILE_P (args
) = 1;
9006 return add_stmt (args
);
9009 /* Build an asm-expr, whose components are a STRING, some OUTPUTS,
9010 some INPUTS, and some CLOBBERS. The latter three may be NULL.
9011 SIMPLE indicates whether there was anything at all after the
9012 string in the asm expression -- asm("blah") and asm("blah" : )
9013 are subtly different. We use a ASM_EXPR node to represent this. */
9015 build_asm_expr (location_t loc
, tree string
, tree outputs
, tree inputs
,
9016 tree clobbers
, tree labels
, bool simple
)
9021 const char *constraint
;
9022 const char **oconstraints
;
9023 bool allows_mem
, allows_reg
, is_inout
;
9024 int ninputs
, noutputs
;
9026 ninputs
= list_length (inputs
);
9027 noutputs
= list_length (outputs
);
9028 oconstraints
= (const char **) alloca (noutputs
* sizeof (const char *));
9030 string
= resolve_asm_operand_names (string
, outputs
, inputs
, labels
);
9032 /* Remove output conversions that change the type but not the mode. */
9033 for (i
= 0, tail
= outputs
; tail
; ++i
, tail
= TREE_CHAIN (tail
))
9035 tree output
= TREE_VALUE (tail
);
9037 output
= c_fully_fold (output
, false, NULL
);
9039 /* ??? Really, this should not be here. Users should be using a
9040 proper lvalue, dammit. But there's a long history of using casts
9041 in the output operands. In cases like longlong.h, this becomes a
9042 primitive form of typechecking -- if the cast can be removed, then
9043 the output operand had a type of the proper width; otherwise we'll
9044 get an error. Gross, but ... */
9045 STRIP_NOPS (output
);
9047 if (!lvalue_or_else (loc
, output
, lv_asm
))
9048 output
= error_mark_node
;
9050 if (output
!= error_mark_node
9051 && (TREE_READONLY (output
)
9052 || TYPE_READONLY (TREE_TYPE (output
))
9053 || ((TREE_CODE (TREE_TYPE (output
)) == RECORD_TYPE
9054 || TREE_CODE (TREE_TYPE (output
)) == UNION_TYPE
)
9055 && C_TYPE_FIELDS_READONLY (TREE_TYPE (output
)))))
9056 readonly_error (loc
, output
, lv_asm
);
9058 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail
)));
9059 oconstraints
[i
] = constraint
;
9061 if (parse_output_constraint (&constraint
, i
, ninputs
, noutputs
,
9062 &allows_mem
, &allows_reg
, &is_inout
))
9064 /* If the operand is going to end up in memory,
9065 mark it addressable. */
9066 if (!allows_reg
&& !c_mark_addressable (output
))
9067 output
= error_mark_node
;
9068 if (!(!allows_reg
&& allows_mem
)
9069 && output
!= error_mark_node
9070 && VOID_TYPE_P (TREE_TYPE (output
)))
9072 error_at (loc
, "invalid use of void expression");
9073 output
= error_mark_node
;
9077 output
= error_mark_node
;
9079 TREE_VALUE (tail
) = output
;
9082 for (i
= 0, tail
= inputs
; tail
; ++i
, tail
= TREE_CHAIN (tail
))
9086 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail
)));
9087 input
= TREE_VALUE (tail
);
9089 if (parse_input_constraint (&constraint
, i
, ninputs
, noutputs
, 0,
9090 oconstraints
, &allows_mem
, &allows_reg
))
9092 /* If the operand is going to end up in memory,
9093 mark it addressable. */
9094 if (!allows_reg
&& allows_mem
)
9096 input
= c_fully_fold (input
, false, NULL
);
9098 /* Strip the nops as we allow this case. FIXME, this really
9099 should be rejected or made deprecated. */
9101 if (!c_mark_addressable (input
))
9102 input
= error_mark_node
;
9107 memset (&expr
, 0, sizeof (expr
));
9109 expr
= convert_lvalue_to_rvalue (loc
, expr
, true, false);
9110 input
= c_fully_fold (expr
.value
, false, NULL
);
9112 if (input
!= error_mark_node
&& VOID_TYPE_P (TREE_TYPE (input
)))
9114 error_at (loc
, "invalid use of void expression");
9115 input
= error_mark_node
;
9120 input
= error_mark_node
;
9122 TREE_VALUE (tail
) = input
;
9125 /* ASMs with labels cannot have outputs. This should have been
9126 enforced by the parser. */
9127 gcc_assert (outputs
== NULL
|| labels
== NULL
);
9129 args
= build_stmt (loc
, ASM_EXPR
, string
, outputs
, inputs
, clobbers
, labels
);
9131 /* asm statements without outputs, including simple ones, are treated
9133 ASM_INPUT_P (args
) = simple
;
9134 ASM_VOLATILE_P (args
) = (noutputs
== 0);
9139 /* Generate a goto statement to LABEL. LOC is the location of the
9143 c_finish_goto_label (location_t loc
, tree label
)
9145 tree decl
= lookup_label_for_goto (loc
, label
);
9148 TREE_USED (decl
) = 1;
9150 tree t
= build1 (GOTO_EXPR
, void_type_node
, decl
);
9151 SET_EXPR_LOCATION (t
, loc
);
9152 return add_stmt (t
);
9156 /* Generate a computed goto statement to EXPR. LOC is the location of
9160 c_finish_goto_ptr (location_t loc
, tree expr
)
9163 pedwarn (loc
, OPT_Wpedantic
, "ISO C forbids %<goto *expr;%>");
9164 expr
= c_fully_fold (expr
, false, NULL
);
9165 expr
= convert (ptr_type_node
, expr
);
9166 t
= build1 (GOTO_EXPR
, void_type_node
, expr
);
9167 SET_EXPR_LOCATION (t
, loc
);
9168 return add_stmt (t
);
9171 /* Generate a C `return' statement. RETVAL is the expression for what
9172 to return, or a null pointer for `return;' with no value. LOC is
9173 the location of the return statement. If ORIGTYPE is not NULL_TREE, it
9174 is the original type of RETVAL. */
9177 c_finish_return (location_t loc
, tree retval
, tree origtype
)
9179 tree valtype
= TREE_TYPE (TREE_TYPE (current_function_decl
)), ret_stmt
;
9180 bool no_warning
= false;
9184 if (TREE_THIS_VOLATILE (current_function_decl
))
9186 "function declared %<noreturn%> has a %<return%> statement");
9188 if (flag_cilkplus
&& contains_array_notation_expr (retval
))
9190 /* Array notations are allowed in a return statement if it is inside a
9191 built-in array notation reduction function. */
9192 if (!find_rank (loc
, retval
, retval
, false, &rank
))
9193 return error_mark_node
;
9196 error_at (loc
, "array notation expression cannot be used as a "
9198 return error_mark_node
;
9201 if (flag_cilkplus
&& retval
&& contains_cilk_spawn_stmt (retval
))
9203 error_at (loc
, "use of %<_Cilk_spawn%> in a return statement is not "
9205 return error_mark_node
;
9209 tree semantic_type
= NULL_TREE
;
9210 npc
= null_pointer_constant_p (retval
);
9211 if (TREE_CODE (retval
) == EXCESS_PRECISION_EXPR
)
9213 semantic_type
= TREE_TYPE (retval
);
9214 retval
= TREE_OPERAND (retval
, 0);
9216 retval
= c_fully_fold (retval
, false, NULL
);
9218 retval
= build1 (EXCESS_PRECISION_EXPR
, semantic_type
, retval
);
9223 current_function_returns_null
= 1;
9224 if ((warn_return_type
|| flag_isoc99
)
9225 && valtype
!= 0 && TREE_CODE (valtype
) != VOID_TYPE
)
9227 pedwarn_c99 (loc
, flag_isoc99
? 0 : OPT_Wreturn_type
,
9228 "%<return%> with no value, in "
9229 "function returning non-void");
9233 else if (valtype
== 0 || TREE_CODE (valtype
) == VOID_TYPE
)
9235 current_function_returns_null
= 1;
9236 if (TREE_CODE (TREE_TYPE (retval
)) != VOID_TYPE
)
9238 "%<return%> with a value, in function returning void");
9240 pedwarn (loc
, OPT_Wpedantic
, "ISO C forbids "
9241 "%<return%> with expression, in function returning void");
9245 tree t
= convert_for_assignment (loc
, UNKNOWN_LOCATION
, valtype
,
9246 retval
, origtype
, ic_return
,
9247 npc
, NULL_TREE
, NULL_TREE
, 0);
9248 tree res
= DECL_RESULT (current_function_decl
);
9252 current_function_returns_value
= 1;
9253 if (t
== error_mark_node
)
9256 save
= in_late_binary_op
;
9257 if (TREE_CODE (TREE_TYPE (res
)) == BOOLEAN_TYPE
9258 || TREE_CODE (TREE_TYPE (res
)) == COMPLEX_TYPE
)
9259 in_late_binary_op
= true;
9260 inner
= t
= convert (TREE_TYPE (res
), t
);
9261 in_late_binary_op
= save
;
9263 /* Strip any conversions, additions, and subtractions, and see if
9264 we are returning the address of a local variable. Warn if so. */
9267 switch (TREE_CODE (inner
))
9270 case NON_LVALUE_EXPR
:
9272 case POINTER_PLUS_EXPR
:
9273 inner
= TREE_OPERAND (inner
, 0);
9277 /* If the second operand of the MINUS_EXPR has a pointer
9278 type (or is converted from it), this may be valid, so
9279 don't give a warning. */
9281 tree op1
= TREE_OPERAND (inner
, 1);
9283 while (!POINTER_TYPE_P (TREE_TYPE (op1
))
9284 && (CONVERT_EXPR_P (op1
)
9285 || TREE_CODE (op1
) == NON_LVALUE_EXPR
))
9286 op1
= TREE_OPERAND (op1
, 0);
9288 if (POINTER_TYPE_P (TREE_TYPE (op1
)))
9291 inner
= TREE_OPERAND (inner
, 0);
9296 inner
= TREE_OPERAND (inner
, 0);
9298 while (REFERENCE_CLASS_P (inner
)
9299 && TREE_CODE (inner
) != INDIRECT_REF
)
9300 inner
= TREE_OPERAND (inner
, 0);
9303 && !DECL_EXTERNAL (inner
)
9304 && !TREE_STATIC (inner
)
9305 && DECL_CONTEXT (inner
) == current_function_decl
)
9307 if (TREE_CODE (inner
) == LABEL_DECL
)
9308 warning_at (loc
, OPT_Wreturn_local_addr
,
9309 "function returns address of label");
9311 warning_at (loc
, OPT_Wreturn_local_addr
,
9312 "function returns address of local variable");
9323 retval
= build2 (MODIFY_EXPR
, TREE_TYPE (res
), res
, t
);
9324 SET_EXPR_LOCATION (retval
, loc
);
9326 if (warn_sequence_point
)
9327 verify_sequence_points (retval
);
9330 ret_stmt
= build_stmt (loc
, RETURN_EXPR
, retval
);
9331 TREE_NO_WARNING (ret_stmt
) |= no_warning
;
9332 return add_stmt (ret_stmt
);
9336 /* The SWITCH_EXPR being built. */
9339 /* The original type of the testing expression, i.e. before the
9340 default conversion is applied. */
9343 /* A splay-tree mapping the low element of a case range to the high
9344 element, or NULL_TREE if there is no high element. Used to
9345 determine whether or not a new case label duplicates an old case
9346 label. We need a tree, rather than simply a hash table, because
9347 of the GNU case range extension. */
9350 /* The bindings at the point of the switch. This is used for
9351 warnings crossing decls when branching to a case label. */
9352 struct c_spot_bindings
*bindings
;
9354 /* The next node on the stack. */
9355 struct c_switch
*next
;
9358 /* A stack of the currently active switch statements. The innermost
9359 switch statement is on the top of the stack. There is no need to
9360 mark the stack for garbage collection because it is only active
9361 during the processing of the body of a function, and we never
9362 collect at that point. */
9364 struct c_switch
*c_switch_stack
;
9366 /* Start a C switch statement, testing expression EXP. Return the new
9367 SWITCH_EXPR. SWITCH_LOC is the location of the `switch'.
9368 SWITCH_COND_LOC is the location of the switch's condition.
9369 EXPLICIT_CAST_P is true if the expression EXP has explicit cast. */
9372 c_start_case (location_t switch_loc
,
9373 location_t switch_cond_loc
,
9374 tree exp
, bool explicit_cast_p
)
9376 tree orig_type
= error_mark_node
;
9377 struct c_switch
*cs
;
9379 if (exp
!= error_mark_node
)
9381 orig_type
= TREE_TYPE (exp
);
9383 if (!INTEGRAL_TYPE_P (orig_type
))
9385 if (orig_type
!= error_mark_node
)
9387 error_at (switch_cond_loc
, "switch quantity not an integer");
9388 orig_type
= error_mark_node
;
9390 exp
= integer_zero_node
;
9394 tree type
= TYPE_MAIN_VARIANT (orig_type
);
9397 /* Warn if the condition has boolean value. */
9398 while (TREE_CODE (e
) == COMPOUND_EXPR
)
9399 e
= TREE_OPERAND (e
, 1);
9401 if ((TREE_CODE (type
) == BOOLEAN_TYPE
9402 || truth_value_p (TREE_CODE (e
)))
9403 /* Explicit cast to int suppresses this warning. */
9404 && !(TREE_CODE (type
) == INTEGER_TYPE
9405 && explicit_cast_p
))
9406 warning_at (switch_cond_loc
, OPT_Wswitch_bool
,
9407 "switch condition has boolean value");
9409 if (!in_system_header_at (input_location
)
9410 && (type
== long_integer_type_node
9411 || type
== long_unsigned_type_node
))
9412 warning_at (switch_cond_loc
,
9413 OPT_Wtraditional
, "%<long%> switch expression not "
9414 "converted to %<int%> in ISO C");
9416 exp
= c_fully_fold (exp
, false, NULL
);
9417 exp
= default_conversion (exp
);
9419 if (warn_sequence_point
)
9420 verify_sequence_points (exp
);
9424 /* Add this new SWITCH_EXPR to the stack. */
9425 cs
= XNEW (struct c_switch
);
9426 cs
->switch_expr
= build3 (SWITCH_EXPR
, orig_type
, exp
, NULL_TREE
, NULL_TREE
);
9427 SET_EXPR_LOCATION (cs
->switch_expr
, switch_loc
);
9428 cs
->orig_type
= orig_type
;
9429 cs
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
9430 cs
->bindings
= c_get_switch_bindings ();
9431 cs
->next
= c_switch_stack
;
9432 c_switch_stack
= cs
;
9434 return add_stmt (cs
->switch_expr
);
9437 /* Process a case label at location LOC. */
9440 do_case (location_t loc
, tree low_value
, tree high_value
)
9442 tree label
= NULL_TREE
;
9444 if (low_value
&& TREE_CODE (low_value
) != INTEGER_CST
)
9446 low_value
= c_fully_fold (low_value
, false, NULL
);
9447 if (TREE_CODE (low_value
) == INTEGER_CST
)
9448 pedwarn (loc
, OPT_Wpedantic
,
9449 "case label is not an integer constant expression");
9452 if (high_value
&& TREE_CODE (high_value
) != INTEGER_CST
)
9454 high_value
= c_fully_fold (high_value
, false, NULL
);
9455 if (TREE_CODE (high_value
) == INTEGER_CST
)
9456 pedwarn (input_location
, OPT_Wpedantic
,
9457 "case label is not an integer constant expression");
9460 if (c_switch_stack
== NULL
)
9463 error_at (loc
, "case label not within a switch statement");
9465 error_at (loc
, "%<default%> label not within a switch statement");
9469 if (c_check_switch_jump_warnings (c_switch_stack
->bindings
,
9470 EXPR_LOCATION (c_switch_stack
->switch_expr
),
9474 label
= c_add_case_label (loc
, c_switch_stack
->cases
,
9475 SWITCH_COND (c_switch_stack
->switch_expr
),
9476 c_switch_stack
->orig_type
,
9477 low_value
, high_value
);
9478 if (label
== error_mark_node
)
9483 /* Finish the switch statement. */
9486 c_finish_case (tree body
)
9488 struct c_switch
*cs
= c_switch_stack
;
9489 location_t switch_location
;
9491 SWITCH_BODY (cs
->switch_expr
) = body
;
9493 /* Emit warnings as needed. */
9494 switch_location
= EXPR_LOCATION (cs
->switch_expr
);
9495 c_do_switch_warnings (cs
->cases
, switch_location
,
9496 TREE_TYPE (cs
->switch_expr
),
9497 SWITCH_COND (cs
->switch_expr
));
9499 /* Pop the stack. */
9500 c_switch_stack
= cs
->next
;
9501 splay_tree_delete (cs
->cases
);
9502 c_release_switch_bindings (cs
->bindings
);
9506 /* Emit an if statement. IF_LOCUS is the location of the 'if'. COND,
9507 THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK
9508 may be null. NESTED_IF is true if THEN_BLOCK contains another IF
9509 statement, and was not surrounded with parenthesis. */
9512 c_finish_if_stmt (location_t if_locus
, tree cond
, tree then_block
,
9513 tree else_block
, bool nested_if
)
9517 /* If the condition has array notations, then the rank of the then_block and
9518 else_block must be either 0 or be equal to the rank of the condition. If
9519 the condition does not have array notations then break them up as it is
9520 broken up in a normal expression. */
9521 if (flag_cilkplus
&& contains_array_notation_expr (cond
))
9523 size_t then_rank
= 0, cond_rank
= 0, else_rank
= 0;
9524 if (!find_rank (if_locus
, cond
, cond
, true, &cond_rank
))
9527 && !find_rank (if_locus
, then_block
, then_block
, true, &then_rank
))
9530 && !find_rank (if_locus
, else_block
, else_block
, true, &else_rank
))
9532 if (cond_rank
!= then_rank
&& then_rank
!= 0)
9534 error_at (if_locus
, "rank-mismatch between if-statement%'s condition"
9535 " and the then-block");
9538 else if (cond_rank
!= else_rank
&& else_rank
!= 0)
9540 error_at (if_locus
, "rank-mismatch between if-statement%'s condition"
9541 " and the else-block");
9545 /* Diagnose an ambiguous else if if-then-else is nested inside if-then. */
9546 if (warn_parentheses
&& nested_if
&& else_block
== NULL
)
9548 tree inner_if
= then_block
;
9550 /* We know from the grammar productions that there is an IF nested
9551 within THEN_BLOCK. Due to labels and c99 conditional declarations,
9552 it might not be exactly THEN_BLOCK, but should be the last
9553 non-container statement within. */
9555 switch (TREE_CODE (inner_if
))
9560 inner_if
= BIND_EXPR_BODY (inner_if
);
9562 case STATEMENT_LIST
:
9563 inner_if
= expr_last (then_block
);
9565 case TRY_FINALLY_EXPR
:
9566 case TRY_CATCH_EXPR
:
9567 inner_if
= TREE_OPERAND (inner_if
, 0);
9574 if (COND_EXPR_ELSE (inner_if
))
9575 warning_at (if_locus
, OPT_Wparentheses
,
9576 "suggest explicit braces to avoid ambiguous %<else%>");
9579 stmt
= build3 (COND_EXPR
, void_type_node
, cond
, then_block
, else_block
);
9580 SET_EXPR_LOCATION (stmt
, if_locus
);
9584 /* Emit a general-purpose loop construct. START_LOCUS is the location of
9585 the beginning of the loop. COND is the loop condition. COND_IS_FIRST
9586 is false for DO loops. INCR is the FOR increment expression. BODY is
9587 the statement controlled by the loop. BLAB is the break label. CLAB is
9588 the continue label. Everything is allowed to be NULL. */
9591 c_finish_loop (location_t start_locus
, tree cond
, tree incr
, tree body
,
9592 tree blab
, tree clab
, bool cond_is_first
)
9594 tree entry
= NULL
, exit
= NULL
, t
;
9596 if (flag_cilkplus
&& contains_array_notation_expr (cond
))
9598 error_at (start_locus
, "array notation expression cannot be used in a "
9599 "loop%'s condition");
9603 /* If the condition is zero don't generate a loop construct. */
9604 if (cond
&& integer_zerop (cond
))
9608 t
= build_and_jump (&blab
);
9609 SET_EXPR_LOCATION (t
, start_locus
);
9615 tree top
= build1 (LABEL_EXPR
, void_type_node
, NULL_TREE
);
9617 /* If we have an exit condition, then we build an IF with gotos either
9618 out of the loop, or to the top of it. If there's no exit condition,
9619 then we just build a jump back to the top. */
9620 exit
= build_and_jump (&LABEL_EXPR_LABEL (top
));
9622 if (cond
&& !integer_nonzerop (cond
))
9624 /* Canonicalize the loop condition to the end. This means
9625 generating a branch to the loop condition. Reuse the
9626 continue label, if possible. */
9631 entry
= build1 (LABEL_EXPR
, void_type_node
, NULL_TREE
);
9632 t
= build_and_jump (&LABEL_EXPR_LABEL (entry
));
9635 t
= build1 (GOTO_EXPR
, void_type_node
, clab
);
9636 SET_EXPR_LOCATION (t
, start_locus
);
9640 t
= build_and_jump (&blab
);
9642 exit
= fold_build3_loc (start_locus
,
9643 COND_EXPR
, void_type_node
, cond
, exit
, t
);
9645 exit
= fold_build3_loc (input_location
,
9646 COND_EXPR
, void_type_node
, cond
, exit
, t
);
9655 add_stmt (build1 (LABEL_EXPR
, void_type_node
, clab
));
9663 add_stmt (build1 (LABEL_EXPR
, void_type_node
, blab
));
9667 c_finish_bc_stmt (location_t loc
, tree
*label_p
, bool is_break
)
9670 tree label
= *label_p
;
9672 /* In switch statements break is sometimes stylistically used after
9673 a return statement. This can lead to spurious warnings about
9674 control reaching the end of a non-void function when it is
9675 inlined. Note that we are calling block_may_fallthru with
9676 language specific tree nodes; this works because
9677 block_may_fallthru returns true when given something it does not
9679 skip
= !block_may_fallthru (cur_stmt_list
);
9684 *label_p
= label
= create_artificial_label (loc
);
9686 else if (TREE_CODE (label
) == LABEL_DECL
)
9688 else switch (TREE_INT_CST_LOW (label
))
9692 error_at (loc
, "break statement not within loop or switch");
9694 error_at (loc
, "continue statement not within a loop");
9698 gcc_assert (is_break
);
9699 error_at (loc
, "break statement used with OpenMP for loop");
9704 error ("break statement within %<#pragma simd%> loop body");
9706 error ("continue statement within %<#pragma simd%> loop body");
9717 add_stmt (build_predict_expr (PRED_CONTINUE
, NOT_TAKEN
));
9719 return add_stmt (build1 (GOTO_EXPR
, void_type_node
, label
));
9722 /* A helper routine for c_process_expr_stmt and c_finish_stmt_expr. */
9725 emit_side_effect_warnings (location_t loc
, tree expr
)
9727 if (expr
== error_mark_node
)
9729 else if (!TREE_SIDE_EFFECTS (expr
))
9731 if (!VOID_TYPE_P (TREE_TYPE (expr
)) && !TREE_NO_WARNING (expr
))
9732 warning_at (loc
, OPT_Wunused_value
, "statement with no effect");
9734 else if (TREE_CODE (expr
) == COMPOUND_EXPR
)
9737 location_t cloc
= loc
;
9738 while (TREE_CODE (r
) == COMPOUND_EXPR
)
9740 if (EXPR_HAS_LOCATION (r
))
9741 cloc
= EXPR_LOCATION (r
);
9742 r
= TREE_OPERAND (r
, 1);
9744 if (!TREE_SIDE_EFFECTS (r
)
9745 && !VOID_TYPE_P (TREE_TYPE (r
))
9746 && !CONVERT_EXPR_P (r
)
9747 && !TREE_NO_WARNING (r
)
9748 && !TREE_NO_WARNING (expr
))
9749 warning_at (cloc
, OPT_Wunused_value
,
9750 "right-hand operand of comma expression has no effect");
9753 warn_if_unused_value (expr
, loc
);
9756 /* Process an expression as if it were a complete statement. Emit
9757 diagnostics, but do not call ADD_STMT. LOC is the location of the
9761 c_process_expr_stmt (location_t loc
, tree expr
)
9768 expr
= c_fully_fold (expr
, false, NULL
);
9770 if (warn_sequence_point
)
9771 verify_sequence_points (expr
);
9773 if (TREE_TYPE (expr
) != error_mark_node
9774 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr
))
9775 && TREE_CODE (TREE_TYPE (expr
)) != ARRAY_TYPE
)
9776 error_at (loc
, "expression statement has incomplete type");
9778 /* If we're not processing a statement expression, warn about unused values.
9779 Warnings for statement expressions will be emitted later, once we figure
9780 out which is the result. */
9781 if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list
)
9782 && warn_unused_value
)
9783 emit_side_effect_warnings (loc
, expr
);
9786 while (TREE_CODE (exprv
) == COMPOUND_EXPR
)
9787 exprv
= TREE_OPERAND (exprv
, 1);
9788 while (CONVERT_EXPR_P (exprv
))
9789 exprv
= TREE_OPERAND (exprv
, 0);
9791 || handled_component_p (exprv
)
9792 || TREE_CODE (exprv
) == ADDR_EXPR
)
9793 mark_exp_read (exprv
);
9795 /* If the expression is not of a type to which we cannot assign a line
9796 number, wrap the thing in a no-op NOP_EXPR. */
9797 if (DECL_P (expr
) || CONSTANT_CLASS_P (expr
))
9799 expr
= build1 (NOP_EXPR
, TREE_TYPE (expr
), expr
);
9800 SET_EXPR_LOCATION (expr
, loc
);
9806 /* Emit an expression as a statement. LOC is the location of the
9810 c_finish_expr_stmt (location_t loc
, tree expr
)
9813 return add_stmt (c_process_expr_stmt (loc
, expr
));
9818 /* Do the opposite and emit a statement as an expression. To begin,
9819 create a new binding level and return it. */
9822 c_begin_stmt_expr (void)
9826 /* We must force a BLOCK for this level so that, if it is not expanded
9827 later, there is a way to turn off the entire subtree of blocks that
9828 are contained in it. */
9830 ret
= c_begin_compound_stmt (true);
9832 c_bindings_start_stmt_expr (c_switch_stack
== NULL
9834 : c_switch_stack
->bindings
);
9836 /* Mark the current statement list as belonging to a statement list. */
9837 STATEMENT_LIST_STMT_EXPR (ret
) = 1;
9842 /* LOC is the location of the compound statement to which this body
9846 c_finish_stmt_expr (location_t loc
, tree body
)
9848 tree last
, type
, tmp
, val
;
9851 body
= c_end_compound_stmt (loc
, body
, true);
9853 c_bindings_end_stmt_expr (c_switch_stack
== NULL
9855 : c_switch_stack
->bindings
);
9857 /* Locate the last statement in BODY. See c_end_compound_stmt
9858 about always returning a BIND_EXPR. */
9859 last_p
= &BIND_EXPR_BODY (body
);
9860 last
= BIND_EXPR_BODY (body
);
9863 if (TREE_CODE (last
) == STATEMENT_LIST
)
9865 tree_stmt_iterator i
;
9867 /* This can happen with degenerate cases like ({ }). No value. */
9868 if (!TREE_SIDE_EFFECTS (last
))
9871 /* If we're supposed to generate side effects warnings, process
9872 all of the statements except the last. */
9873 if (warn_unused_value
)
9875 for (i
= tsi_start (last
); !tsi_one_before_end_p (i
); tsi_next (&i
))
9878 tree t
= tsi_stmt (i
);
9880 tloc
= EXPR_HAS_LOCATION (t
) ? EXPR_LOCATION (t
) : loc
;
9881 emit_side_effect_warnings (tloc
, t
);
9885 i
= tsi_last (last
);
9886 last_p
= tsi_stmt_ptr (i
);
9890 /* If the end of the list is exception related, then the list was split
9891 by a call to push_cleanup. Continue searching. */
9892 if (TREE_CODE (last
) == TRY_FINALLY_EXPR
9893 || TREE_CODE (last
) == TRY_CATCH_EXPR
)
9895 last_p
= &TREE_OPERAND (last
, 0);
9897 goto continue_searching
;
9900 if (last
== error_mark_node
)
9903 /* In the case that the BIND_EXPR is not necessary, return the
9904 expression out from inside it. */
9905 if (last
== BIND_EXPR_BODY (body
)
9906 && BIND_EXPR_VARS (body
) == NULL
)
9908 /* Even if this looks constant, do not allow it in a constant
9910 last
= c_wrap_maybe_const (last
, true);
9911 /* Do not warn if the return value of a statement expression is
9913 TREE_NO_WARNING (last
) = 1;
9917 /* Extract the type of said expression. */
9918 type
= TREE_TYPE (last
);
9920 /* If we're not returning a value at all, then the BIND_EXPR that
9921 we already have is a fine expression to return. */
9922 if (!type
|| VOID_TYPE_P (type
))
9925 /* Now that we've located the expression containing the value, it seems
9926 silly to make voidify_wrapper_expr repeat the process. Create a
9927 temporary of the appropriate type and stick it in a TARGET_EXPR. */
9928 tmp
= create_tmp_var_raw (type
, NULL
);
9930 /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt. This avoids
9931 tree_expr_nonnegative_p giving up immediately. */
9933 if (TREE_CODE (val
) == NOP_EXPR
9934 && TREE_TYPE (val
) == TREE_TYPE (TREE_OPERAND (val
, 0)))
9935 val
= TREE_OPERAND (val
, 0);
9937 *last_p
= build2 (MODIFY_EXPR
, void_type_node
, tmp
, val
);
9938 SET_EXPR_LOCATION (*last_p
, EXPR_LOCATION (last
));
9941 tree t
= build4 (TARGET_EXPR
, type
, tmp
, body
, NULL_TREE
, NULL_TREE
);
9942 SET_EXPR_LOCATION (t
, loc
);
9947 /* Begin and end compound statements. This is as simple as pushing
9948 and popping new statement lists from the tree. */
9951 c_begin_compound_stmt (bool do_scope
)
9953 tree stmt
= push_stmt_list ();
9959 /* End a compound statement. STMT is the statement. LOC is the
9960 location of the compound statement-- this is usually the location
9961 of the opening brace. */
9964 c_end_compound_stmt (location_t loc
, tree stmt
, bool do_scope
)
9970 if (c_dialect_objc ())
9971 objc_clear_super_receiver ();
9972 block
= pop_scope ();
9975 stmt
= pop_stmt_list (stmt
);
9976 stmt
= c_build_bind_expr (loc
, block
, stmt
);
9978 /* If this compound statement is nested immediately inside a statement
9979 expression, then force a BIND_EXPR to be created. Otherwise we'll
9980 do the wrong thing for ({ { 1; } }) or ({ 1; { } }). In particular,
9981 STATEMENT_LISTs merge, and thus we can lose track of what statement
9983 if (building_stmt_list_p ()
9984 && STATEMENT_LIST_STMT_EXPR (cur_stmt_list
)
9985 && TREE_CODE (stmt
) != BIND_EXPR
)
9987 stmt
= build3 (BIND_EXPR
, void_type_node
, NULL
, stmt
, NULL
);
9988 TREE_SIDE_EFFECTS (stmt
) = 1;
9989 SET_EXPR_LOCATION (stmt
, loc
);
9995 /* Queue a cleanup. CLEANUP is an expression/statement to be executed
9996 when the current scope is exited. EH_ONLY is true when this is not
9997 meant to apply to normal control flow transfer. */
10000 push_cleanup (tree decl
, tree cleanup
, bool eh_only
)
10002 enum tree_code code
;
10006 code
= eh_only
? TRY_CATCH_EXPR
: TRY_FINALLY_EXPR
;
10007 stmt
= build_stmt (DECL_SOURCE_LOCATION (decl
), code
, NULL
, cleanup
);
10009 stmt_expr
= STATEMENT_LIST_STMT_EXPR (cur_stmt_list
);
10010 list
= push_stmt_list ();
10011 TREE_OPERAND (stmt
, 0) = list
;
10012 STATEMENT_LIST_STMT_EXPR (list
) = stmt_expr
;
10015 /* Build a binary-operation expression without default conversions.
10016 CODE is the kind of expression to build.
10017 LOCATION is the operator's location.
10018 This function differs from `build' in several ways:
10019 the data type of the result is computed and recorded in it,
10020 warnings are generated if arg data types are invalid,
10021 special handling for addition and subtraction of pointers is known,
10022 and some optimization is done (operations on narrow ints
10023 are done in the narrower type when that gives the same result).
10024 Constant folding is also done before the result is returned.
10026 Note that the operands will never have enumeral types, or function
10027 or array types, because either they will have the default conversions
10028 performed or they have both just been converted to some other type in which
10029 the arithmetic is to be done. */
10032 build_binary_op (location_t location
, enum tree_code code
,
10033 tree orig_op0
, tree orig_op1
, int convert_p
)
10035 tree type0
, type1
, orig_type0
, orig_type1
;
10037 enum tree_code code0
, code1
;
10039 tree ret
= error_mark_node
;
10040 const char *invalid_op_diag
;
10041 bool op0_int_operands
, op1_int_operands
;
10042 bool int_const
, int_const_or_overflow
, int_operands
;
10044 /* Expression code to give to the expression when it is built.
10045 Normally this is CODE, which is what the caller asked for,
10046 but in some special cases we change it. */
10047 enum tree_code resultcode
= code
;
10049 /* Data type in which the computation is to be performed.
10050 In the simplest cases this is the common type of the arguments. */
10051 tree result_type
= NULL
;
10053 /* When the computation is in excess precision, the type of the
10054 final EXCESS_PRECISION_EXPR. */
10055 tree semantic_result_type
= NULL
;
10057 /* Nonzero means operands have already been type-converted
10058 in whatever way is necessary.
10059 Zero means they need to be converted to RESULT_TYPE. */
10062 /* Nonzero means create the expression with this type, rather than
10064 tree build_type
= 0;
10066 /* Nonzero means after finally constructing the expression
10067 convert it to this type. */
10068 tree final_type
= 0;
10070 /* Nonzero if this is an operation like MIN or MAX which can
10071 safely be computed in short if both args are promoted shorts.
10072 Also implies COMMON.
10073 -1 indicates a bitwise operation; this makes a difference
10074 in the exact conditions for when it is safe to do the operation
10075 in a narrower mode. */
10078 /* Nonzero if this is a comparison operation;
10079 if both args are promoted shorts, compare the original shorts.
10080 Also implies COMMON. */
10081 int short_compare
= 0;
10083 /* Nonzero if this is a right-shift operation, which can be computed on the
10084 original short and then promoted if the operand is a promoted short. */
10085 int short_shift
= 0;
10087 /* Nonzero means set RESULT_TYPE to the common type of the args. */
10090 /* True means types are compatible as far as ObjC is concerned. */
10093 /* True means this is an arithmetic operation that may need excess
10095 bool may_need_excess_precision
;
10097 /* True means this is a boolean operation that converts both its
10098 operands to truth-values. */
10099 bool boolean_op
= false;
10101 /* Remember whether we're doing / or %. */
10102 bool doing_div_or_mod
= false;
10104 /* Remember whether we're doing << or >>. */
10105 bool doing_shift
= false;
10107 /* Tree holding instrumentation expression. */
10108 tree instrument_expr
= NULL
;
10110 if (location
== UNKNOWN_LOCATION
)
10111 location
= input_location
;
10116 op0_int_operands
= EXPR_INT_CONST_OPERANDS (orig_op0
);
10117 if (op0_int_operands
)
10118 op0
= remove_c_maybe_const_expr (op0
);
10119 op1_int_operands
= EXPR_INT_CONST_OPERANDS (orig_op1
);
10120 if (op1_int_operands
)
10121 op1
= remove_c_maybe_const_expr (op1
);
10122 int_operands
= (op0_int_operands
&& op1_int_operands
);
10125 int_const_or_overflow
= (TREE_CODE (orig_op0
) == INTEGER_CST
10126 && TREE_CODE (orig_op1
) == INTEGER_CST
);
10127 int_const
= (int_const_or_overflow
10128 && !TREE_OVERFLOW (orig_op0
)
10129 && !TREE_OVERFLOW (orig_op1
));
10132 int_const
= int_const_or_overflow
= false;
10134 /* Do not apply default conversion in mixed vector/scalar expression. */
10136 && !((TREE_CODE (TREE_TYPE (op0
)) == VECTOR_TYPE
)
10137 != (TREE_CODE (TREE_TYPE (op1
)) == VECTOR_TYPE
)))
10139 op0
= default_conversion (op0
);
10140 op1
= default_conversion (op1
);
10143 /* When Cilk Plus is enabled and there are array notations inside op0, then
10144 we check to see if there are builtin array notation functions. If
10145 so, then we take on the type of the array notation inside it. */
10146 if (flag_cilkplus
&& contains_array_notation_expr (op0
))
10147 orig_type0
= type0
= find_correct_array_notation_type (op0
);
10149 orig_type0
= type0
= TREE_TYPE (op0
);
10151 if (flag_cilkplus
&& contains_array_notation_expr (op1
))
10152 orig_type1
= type1
= find_correct_array_notation_type (op1
);
10154 orig_type1
= type1
= TREE_TYPE (op1
);
10156 /* The expression codes of the data types of the arguments tell us
10157 whether the arguments are integers, floating, pointers, etc. */
10158 code0
= TREE_CODE (type0
);
10159 code1
= TREE_CODE (type1
);
10161 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
10162 STRIP_TYPE_NOPS (op0
);
10163 STRIP_TYPE_NOPS (op1
);
10165 /* If an error was already reported for one of the arguments,
10166 avoid reporting another error. */
10168 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
10169 return error_mark_node
;
10171 if ((invalid_op_diag
10172 = targetm
.invalid_binary_op (code
, type0
, type1
)))
10174 error_at (location
, invalid_op_diag
);
10175 return error_mark_node
;
10183 case TRUNC_DIV_EXPR
:
10184 case CEIL_DIV_EXPR
:
10185 case FLOOR_DIV_EXPR
:
10186 case ROUND_DIV_EXPR
:
10187 case EXACT_DIV_EXPR
:
10188 may_need_excess_precision
= true;
10191 may_need_excess_precision
= false;
10194 if (TREE_CODE (op0
) == EXCESS_PRECISION_EXPR
)
10196 op0
= TREE_OPERAND (op0
, 0);
10197 type0
= TREE_TYPE (op0
);
10199 else if (may_need_excess_precision
10200 && (eptype
= excess_precision_type (type0
)) != NULL_TREE
)
10203 op0
= convert (eptype
, op0
);
10205 if (TREE_CODE (op1
) == EXCESS_PRECISION_EXPR
)
10207 op1
= TREE_OPERAND (op1
, 0);
10208 type1
= TREE_TYPE (op1
);
10210 else if (may_need_excess_precision
10211 && (eptype
= excess_precision_type (type1
)) != NULL_TREE
)
10214 op1
= convert (eptype
, op1
);
10217 objc_ok
= objc_compare_types (type0
, type1
, -3, NULL_TREE
);
10219 /* In case when one of the operands of the binary operation is
10220 a vector and another is a scalar -- convert scalar to vector. */
10221 if ((code0
== VECTOR_TYPE
) != (code1
== VECTOR_TYPE
))
10223 enum stv_conv convert_flag
= scalar_to_vector (location
, code
, op0
, op1
,
10226 switch (convert_flag
)
10229 return error_mark_node
;
10232 bool maybe_const
= true;
10234 sc
= c_fully_fold (op0
, false, &maybe_const
);
10235 sc
= save_expr (sc
);
10236 sc
= convert (TREE_TYPE (type1
), sc
);
10237 op0
= build_vector_from_val (type1
, sc
);
10239 op0
= c_wrap_maybe_const (op0
, true);
10240 orig_type0
= type0
= TREE_TYPE (op0
);
10241 code0
= TREE_CODE (type0
);
10245 case stv_secondarg
:
10247 bool maybe_const
= true;
10249 sc
= c_fully_fold (op1
, false, &maybe_const
);
10250 sc
= save_expr (sc
);
10251 sc
= convert (TREE_TYPE (type0
), sc
);
10252 op1
= build_vector_from_val (type0
, sc
);
10254 op1
= c_wrap_maybe_const (op1
, true);
10255 orig_type1
= type1
= TREE_TYPE (op1
);
10256 code1
= TREE_CODE (type1
);
10268 /* Handle the pointer + int case. */
10269 if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
10271 ret
= pointer_int_sum (location
, PLUS_EXPR
, op0
, op1
);
10272 goto return_build_binary_op
;
10274 else if (code1
== POINTER_TYPE
&& code0
== INTEGER_TYPE
)
10276 ret
= pointer_int_sum (location
, PLUS_EXPR
, op1
, op0
);
10277 goto return_build_binary_op
;
10284 /* Subtraction of two similar pointers.
10285 We must subtract them as integers, then divide by object size. */
10286 if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
10287 && comp_target_types (location
, type0
, type1
))
10289 ret
= pointer_diff (location
, op0
, op1
);
10290 goto return_build_binary_op
;
10292 /* Handle pointer minus int. Just like pointer plus int. */
10293 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
10295 ret
= pointer_int_sum (location
, MINUS_EXPR
, op0
, op1
);
10296 goto return_build_binary_op
;
10306 case TRUNC_DIV_EXPR
:
10307 case CEIL_DIV_EXPR
:
10308 case FLOOR_DIV_EXPR
:
10309 case ROUND_DIV_EXPR
:
10310 case EXACT_DIV_EXPR
:
10311 doing_div_or_mod
= true;
10312 warn_for_div_by_zero (location
, op1
);
10314 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
10315 || code0
== FIXED_POINT_TYPE
10316 || code0
== COMPLEX_TYPE
|| code0
== VECTOR_TYPE
)
10317 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
10318 || code1
== FIXED_POINT_TYPE
10319 || code1
== COMPLEX_TYPE
|| code1
== VECTOR_TYPE
))
10321 enum tree_code tcode0
= code0
, tcode1
= code1
;
10323 if (code0
== COMPLEX_TYPE
|| code0
== VECTOR_TYPE
)
10324 tcode0
= TREE_CODE (TREE_TYPE (TREE_TYPE (op0
)));
10325 if (code1
== COMPLEX_TYPE
|| code1
== VECTOR_TYPE
)
10326 tcode1
= TREE_CODE (TREE_TYPE (TREE_TYPE (op1
)));
10328 if (!((tcode0
== INTEGER_TYPE
&& tcode1
== INTEGER_TYPE
)
10329 || (tcode0
== FIXED_POINT_TYPE
&& tcode1
== FIXED_POINT_TYPE
)))
10330 resultcode
= RDIV_EXPR
;
10332 /* Although it would be tempting to shorten always here, that
10333 loses on some targets, since the modulo instruction is
10334 undefined if the quotient can't be represented in the
10335 computation mode. We shorten only if unsigned or if
10336 dividing by something we know != -1. */
10337 shorten
= (TYPE_UNSIGNED (TREE_TYPE (orig_op0
))
10338 || (TREE_CODE (op1
) == INTEGER_CST
10339 && !integer_all_onesp (op1
)));
10347 if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
10349 /* Allow vector types which are not floating point types. */
10350 else if (code0
== VECTOR_TYPE
10351 && code1
== VECTOR_TYPE
10352 && !VECTOR_FLOAT_TYPE_P (type0
)
10353 && !VECTOR_FLOAT_TYPE_P (type1
))
10357 case TRUNC_MOD_EXPR
:
10358 case FLOOR_MOD_EXPR
:
10359 doing_div_or_mod
= true;
10360 warn_for_div_by_zero (location
, op1
);
10362 if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
10363 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
10364 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
)
10366 else if (code0
== INTEGER_TYPE
&& code1
== INTEGER_TYPE
)
10368 /* Although it would be tempting to shorten always here, that loses
10369 on some targets, since the modulo instruction is undefined if the
10370 quotient can't be represented in the computation mode. We shorten
10371 only if unsigned or if dividing by something we know != -1. */
10372 shorten
= (TYPE_UNSIGNED (TREE_TYPE (orig_op0
))
10373 || (TREE_CODE (op1
) == INTEGER_CST
10374 && !integer_all_onesp (op1
)));
10379 case TRUTH_ANDIF_EXPR
:
10380 case TRUTH_ORIF_EXPR
:
10381 case TRUTH_AND_EXPR
:
10382 case TRUTH_OR_EXPR
:
10383 case TRUTH_XOR_EXPR
:
10384 if ((code0
== INTEGER_TYPE
|| code0
== POINTER_TYPE
10385 || code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
10386 || code0
== FIXED_POINT_TYPE
)
10387 && (code1
== INTEGER_TYPE
|| code1
== POINTER_TYPE
10388 || code1
== REAL_TYPE
|| code1
== COMPLEX_TYPE
10389 || code1
== FIXED_POINT_TYPE
))
10391 /* Result of these operations is always an int,
10392 but that does not mean the operands should be
10393 converted to ints! */
10394 result_type
= integer_type_node
;
10395 if (op0_int_operands
)
10397 op0
= c_objc_common_truthvalue_conversion (location
, orig_op0
);
10398 op0
= remove_c_maybe_const_expr (op0
);
10401 op0
= c_objc_common_truthvalue_conversion (location
, op0
);
10402 if (op1_int_operands
)
10404 op1
= c_objc_common_truthvalue_conversion (location
, orig_op1
);
10405 op1
= remove_c_maybe_const_expr (op1
);
10408 op1
= c_objc_common_truthvalue_conversion (location
, op1
);
10412 if (code
== TRUTH_ANDIF_EXPR
)
10414 int_const_or_overflow
= (int_operands
10415 && TREE_CODE (orig_op0
) == INTEGER_CST
10416 && (op0
== truthvalue_false_node
10417 || TREE_CODE (orig_op1
) == INTEGER_CST
));
10418 int_const
= (int_const_or_overflow
10419 && !TREE_OVERFLOW (orig_op0
)
10420 && (op0
== truthvalue_false_node
10421 || !TREE_OVERFLOW (orig_op1
)));
10423 else if (code
== TRUTH_ORIF_EXPR
)
10425 int_const_or_overflow
= (int_operands
10426 && TREE_CODE (orig_op0
) == INTEGER_CST
10427 && (op0
== truthvalue_true_node
10428 || TREE_CODE (orig_op1
) == INTEGER_CST
));
10429 int_const
= (int_const_or_overflow
10430 && !TREE_OVERFLOW (orig_op0
)
10431 && (op0
== truthvalue_true_node
10432 || !TREE_OVERFLOW (orig_op1
)));
10436 /* Shift operations: result has same type as first operand;
10437 always convert second operand to int.
10438 Also set SHORT_SHIFT if shifting rightward. */
10441 if (code0
== VECTOR_TYPE
&& code1
== INTEGER_TYPE
10442 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
)
10444 result_type
= type0
;
10447 else if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
10448 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
10449 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
10450 && TYPE_VECTOR_SUBPARTS (type0
) == TYPE_VECTOR_SUBPARTS (type1
))
10452 result_type
= type0
;
10455 else if ((code0
== INTEGER_TYPE
|| code0
== FIXED_POINT_TYPE
)
10456 && code1
== INTEGER_TYPE
)
10458 doing_shift
= true;
10459 if (TREE_CODE (op1
) == INTEGER_CST
)
10461 if (tree_int_cst_sgn (op1
) < 0)
10464 if (c_inhibit_evaluation_warnings
== 0)
10465 warning_at (location
, 0, "right shift count is negative");
10469 if (!integer_zerop (op1
))
10472 if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0)
10475 if (c_inhibit_evaluation_warnings
== 0)
10476 warning_at (location
, 0, "right shift count >= width "
10482 /* Use the type of the value to be shifted. */
10483 result_type
= type0
;
10484 /* Convert the non vector shift-count to an integer, regardless
10485 of size of value being shifted. */
10486 if (TREE_CODE (TREE_TYPE (op1
)) != VECTOR_TYPE
10487 && TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
10488 op1
= convert (integer_type_node
, op1
);
10489 /* Avoid converting op1 to result_type later. */
10495 if (code0
== VECTOR_TYPE
&& code1
== INTEGER_TYPE
10496 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
)
10498 result_type
= type0
;
10501 else if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
10502 && TREE_CODE (TREE_TYPE (type0
)) == INTEGER_TYPE
10503 && TREE_CODE (TREE_TYPE (type1
)) == INTEGER_TYPE
10504 && TYPE_VECTOR_SUBPARTS (type0
) == TYPE_VECTOR_SUBPARTS (type1
))
10506 result_type
= type0
;
10509 else if ((code0
== INTEGER_TYPE
|| code0
== FIXED_POINT_TYPE
)
10510 && code1
== INTEGER_TYPE
)
10512 doing_shift
= true;
10513 if (TREE_CODE (op1
) == INTEGER_CST
)
10515 if (tree_int_cst_sgn (op1
) < 0)
10518 if (c_inhibit_evaluation_warnings
== 0)
10519 warning_at (location
, 0, "left shift count is negative");
10522 else if (compare_tree_int (op1
, TYPE_PRECISION (type0
)) >= 0)
10525 if (c_inhibit_evaluation_warnings
== 0)
10526 warning_at (location
, 0, "left shift count >= width of "
10531 /* Use the type of the value to be shifted. */
10532 result_type
= type0
;
10533 /* Convert the non vector shift-count to an integer, regardless
10534 of size of value being shifted. */
10535 if (TREE_CODE (TREE_TYPE (op1
)) != VECTOR_TYPE
10536 && TYPE_MAIN_VARIANT (TREE_TYPE (op1
)) != integer_type_node
)
10537 op1
= convert (integer_type_node
, op1
);
10538 /* Avoid converting op1 to result_type later. */
10545 if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
)
10548 if (!vector_types_compatible_elements_p (type0
, type1
))
10550 error_at (location
, "comparing vectors with different "
10552 return error_mark_node
;
10555 if (TYPE_VECTOR_SUBPARTS (type0
) != TYPE_VECTOR_SUBPARTS (type1
))
10557 error_at (location
, "comparing vectors with different "
10558 "number of elements");
10559 return error_mark_node
;
10562 /* Always construct signed integer vector type. */
10563 intt
= c_common_type_for_size (GET_MODE_BITSIZE
10564 (TYPE_MODE (TREE_TYPE (type0
))), 0);
10565 result_type
= build_opaque_vector_type (intt
,
10566 TYPE_VECTOR_SUBPARTS (type0
));
10570 if (FLOAT_TYPE_P (type0
) || FLOAT_TYPE_P (type1
))
10571 warning_at (location
,
10573 "comparing floating point with == or != is unsafe");
10574 /* Result of comparison is always int,
10575 but don't convert the args to int! */
10576 build_type
= integer_type_node
;
10577 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
10578 || code0
== FIXED_POINT_TYPE
|| code0
== COMPLEX_TYPE
)
10579 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
10580 || code1
== FIXED_POINT_TYPE
|| code1
== COMPLEX_TYPE
))
10582 else if (code0
== POINTER_TYPE
&& null_pointer_constant_p (orig_op1
))
10584 if (TREE_CODE (op0
) == ADDR_EXPR
10585 && decl_with_nonnull_addr_p (TREE_OPERAND (op0
, 0)))
10587 if (code
== EQ_EXPR
)
10588 warning_at (location
,
10590 "the comparison will always evaluate as %<false%> "
10591 "for the address of %qD will never be NULL",
10592 TREE_OPERAND (op0
, 0));
10594 warning_at (location
,
10596 "the comparison will always evaluate as %<true%> "
10597 "for the address of %qD will never be NULL",
10598 TREE_OPERAND (op0
, 0));
10600 result_type
= type0
;
10602 else if (code1
== POINTER_TYPE
&& null_pointer_constant_p (orig_op0
))
10604 if (TREE_CODE (op1
) == ADDR_EXPR
10605 && decl_with_nonnull_addr_p (TREE_OPERAND (op1
, 0)))
10607 if (code
== EQ_EXPR
)
10608 warning_at (location
,
10610 "the comparison will always evaluate as %<false%> "
10611 "for the address of %qD will never be NULL",
10612 TREE_OPERAND (op1
, 0));
10614 warning_at (location
,
10616 "the comparison will always evaluate as %<true%> "
10617 "for the address of %qD will never be NULL",
10618 TREE_OPERAND (op1
, 0));
10620 result_type
= type1
;
10622 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
10624 tree tt0
= TREE_TYPE (type0
);
10625 tree tt1
= TREE_TYPE (type1
);
10626 addr_space_t as0
= TYPE_ADDR_SPACE (tt0
);
10627 addr_space_t as1
= TYPE_ADDR_SPACE (tt1
);
10628 addr_space_t as_common
= ADDR_SPACE_GENERIC
;
10630 /* Anything compares with void *. void * compares with anything.
10631 Otherwise, the targets must be compatible
10632 and both must be object or both incomplete. */
10633 if (comp_target_types (location
, type0
, type1
))
10634 result_type
= common_pointer_type (type0
, type1
);
10635 else if (!addr_space_superset (as0
, as1
, &as_common
))
10637 error_at (location
, "comparison of pointers to "
10638 "disjoint address spaces");
10639 return error_mark_node
;
10641 else if (VOID_TYPE_P (tt0
) && !TYPE_ATOMIC (tt0
))
10643 if (pedantic
&& TREE_CODE (tt1
) == FUNCTION_TYPE
)
10644 pedwarn (location
, OPT_Wpedantic
, "ISO C forbids "
10645 "comparison of %<void *%> with function pointer");
10647 else if (VOID_TYPE_P (tt1
) && !TYPE_ATOMIC (tt1
))
10649 if (pedantic
&& TREE_CODE (tt0
) == FUNCTION_TYPE
)
10650 pedwarn (location
, OPT_Wpedantic
, "ISO C forbids "
10651 "comparison of %<void *%> with function pointer");
10654 /* Avoid warning about the volatile ObjC EH puts on decls. */
10656 pedwarn (location
, 0,
10657 "comparison of distinct pointer types lacks a cast");
10659 if (result_type
== NULL_TREE
)
10661 int qual
= ENCODE_QUAL_ADDR_SPACE (as_common
);
10662 result_type
= build_pointer_type
10663 (build_qualified_type (void_type_node
, qual
));
10666 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
10668 result_type
= type0
;
10669 pedwarn (location
, 0, "comparison between pointer and integer");
10671 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
10673 result_type
= type1
;
10674 pedwarn (location
, 0, "comparison between pointer and integer");
10682 if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
)
10685 if (!vector_types_compatible_elements_p (type0
, type1
))
10687 error_at (location
, "comparing vectors with different "
10689 return error_mark_node
;
10692 if (TYPE_VECTOR_SUBPARTS (type0
) != TYPE_VECTOR_SUBPARTS (type1
))
10694 error_at (location
, "comparing vectors with different "
10695 "number of elements");
10696 return error_mark_node
;
10699 /* Always construct signed integer vector type. */
10700 intt
= c_common_type_for_size (GET_MODE_BITSIZE
10701 (TYPE_MODE (TREE_TYPE (type0
))), 0);
10702 result_type
= build_opaque_vector_type (intt
,
10703 TYPE_VECTOR_SUBPARTS (type0
));
10707 build_type
= integer_type_node
;
10708 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
10709 || code0
== FIXED_POINT_TYPE
)
10710 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
10711 || code1
== FIXED_POINT_TYPE
))
10713 else if (code0
== POINTER_TYPE
&& code1
== POINTER_TYPE
)
10715 addr_space_t as0
= TYPE_ADDR_SPACE (TREE_TYPE (type0
));
10716 addr_space_t as1
= TYPE_ADDR_SPACE (TREE_TYPE (type1
));
10717 addr_space_t as_common
;
10719 if (comp_target_types (location
, type0
, type1
))
10721 result_type
= common_pointer_type (type0
, type1
);
10722 if (!COMPLETE_TYPE_P (TREE_TYPE (type0
))
10723 != !COMPLETE_TYPE_P (TREE_TYPE (type1
)))
10724 pedwarn (location
, 0,
10725 "comparison of complete and incomplete pointers");
10726 else if (TREE_CODE (TREE_TYPE (type0
)) == FUNCTION_TYPE
)
10727 pedwarn (location
, OPT_Wpedantic
, "ISO C forbids "
10728 "ordered comparisons of pointers to functions");
10729 else if (null_pointer_constant_p (orig_op0
)
10730 || null_pointer_constant_p (orig_op1
))
10731 warning_at (location
, OPT_Wextra
,
10732 "ordered comparison of pointer with null pointer");
10735 else if (!addr_space_superset (as0
, as1
, &as_common
))
10737 error_at (location
, "comparison of pointers to "
10738 "disjoint address spaces");
10739 return error_mark_node
;
10743 int qual
= ENCODE_QUAL_ADDR_SPACE (as_common
);
10744 result_type
= build_pointer_type
10745 (build_qualified_type (void_type_node
, qual
));
10746 pedwarn (location
, 0,
10747 "comparison of distinct pointer types lacks a cast");
10750 else if (code0
== POINTER_TYPE
&& null_pointer_constant_p (orig_op1
))
10752 result_type
= type0
;
10754 pedwarn (location
, OPT_Wpedantic
,
10755 "ordered comparison of pointer with integer zero");
10756 else if (extra_warnings
)
10757 warning_at (location
, OPT_Wextra
,
10758 "ordered comparison of pointer with integer zero");
10760 else if (code1
== POINTER_TYPE
&& null_pointer_constant_p (orig_op0
))
10762 result_type
= type1
;
10764 pedwarn (location
, OPT_Wpedantic
,
10765 "ordered comparison of pointer with integer zero");
10766 else if (extra_warnings
)
10767 warning_at (location
, OPT_Wextra
,
10768 "ordered comparison of pointer with integer zero");
10770 else if (code0
== POINTER_TYPE
&& code1
== INTEGER_TYPE
)
10772 result_type
= type0
;
10773 pedwarn (location
, 0, "comparison between pointer and integer");
10775 else if (code0
== INTEGER_TYPE
&& code1
== POINTER_TYPE
)
10777 result_type
= type1
;
10778 pedwarn (location
, 0, "comparison between pointer and integer");
10783 gcc_unreachable ();
10786 if (code0
== ERROR_MARK
|| code1
== ERROR_MARK
)
10787 return error_mark_node
;
10789 if (code0
== VECTOR_TYPE
&& code1
== VECTOR_TYPE
10790 && (!tree_int_cst_equal (TYPE_SIZE (type0
), TYPE_SIZE (type1
))
10791 || !vector_types_compatible_elements_p (type0
, type1
)))
10793 binary_op_error (location
, code
, type0
, type1
);
10794 return error_mark_node
;
10797 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
|| code0
== COMPLEX_TYPE
10798 || code0
== FIXED_POINT_TYPE
|| code0
== VECTOR_TYPE
)
10800 (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
|| code1
== COMPLEX_TYPE
10801 || code1
== FIXED_POINT_TYPE
|| code1
== VECTOR_TYPE
))
10803 bool first_complex
= (code0
== COMPLEX_TYPE
);
10804 bool second_complex
= (code1
== COMPLEX_TYPE
);
10805 int none_complex
= (!first_complex
&& !second_complex
);
10807 if (shorten
|| common
|| short_compare
)
10809 result_type
= c_common_type (type0
, type1
);
10810 do_warn_double_promotion (result_type
, type0
, type1
,
10811 "implicit conversion from %qT to %qT "
10812 "to match other operand of binary "
10815 if (result_type
== error_mark_node
)
10816 return error_mark_node
;
10819 if (first_complex
!= second_complex
10820 && (code
== PLUS_EXPR
10821 || code
== MINUS_EXPR
10822 || code
== MULT_EXPR
10823 || (code
== TRUNC_DIV_EXPR
&& first_complex
))
10824 && TREE_CODE (TREE_TYPE (result_type
)) == REAL_TYPE
10825 && flag_signed_zeros
)
10827 /* An operation on mixed real/complex operands must be
10828 handled specially, but the language-independent code can
10829 more easily optimize the plain complex arithmetic if
10830 -fno-signed-zeros. */
10831 tree real_type
= TREE_TYPE (result_type
);
10833 if (type0
!= orig_type0
|| type1
!= orig_type1
)
10835 gcc_assert (may_need_excess_precision
&& common
);
10836 semantic_result_type
= c_common_type (orig_type0
, orig_type1
);
10840 if (TREE_TYPE (op0
) != result_type
)
10841 op0
= convert_and_check (location
, result_type
, op0
);
10842 if (TREE_TYPE (op1
) != real_type
)
10843 op1
= convert_and_check (location
, real_type
, op1
);
10847 if (TREE_TYPE (op0
) != real_type
)
10848 op0
= convert_and_check (location
, real_type
, op0
);
10849 if (TREE_TYPE (op1
) != result_type
)
10850 op1
= convert_and_check (location
, result_type
, op1
);
10852 if (TREE_CODE (op0
) == ERROR_MARK
|| TREE_CODE (op1
) == ERROR_MARK
)
10853 return error_mark_node
;
10856 op0
= c_save_expr (op0
);
10857 real
= build_unary_op (EXPR_LOCATION (orig_op0
), REALPART_EXPR
,
10859 imag
= build_unary_op (EXPR_LOCATION (orig_op0
), IMAGPART_EXPR
,
10864 case TRUNC_DIV_EXPR
:
10865 op1
= c_save_expr (op1
);
10866 imag
= build2 (resultcode
, real_type
, imag
, op1
);
10867 /* Fall through. */
10870 real
= build2 (resultcode
, real_type
, real
, op1
);
10878 op1
= c_save_expr (op1
);
10879 real
= build_unary_op (EXPR_LOCATION (orig_op1
), REALPART_EXPR
,
10881 imag
= build_unary_op (EXPR_LOCATION (orig_op1
), IMAGPART_EXPR
,
10886 op0
= c_save_expr (op0
);
10887 imag
= build2 (resultcode
, real_type
, op0
, imag
);
10888 /* Fall through. */
10890 real
= build2 (resultcode
, real_type
, op0
, real
);
10893 real
= build2 (resultcode
, real_type
, op0
, real
);
10894 imag
= build1 (NEGATE_EXPR
, real_type
, imag
);
10900 ret
= build2 (COMPLEX_EXPR
, result_type
, real
, imag
);
10901 goto return_build_binary_op
;
10904 /* For certain operations (which identify themselves by shorten != 0)
10905 if both args were extended from the same smaller type,
10906 do the arithmetic in that type and then extend.
10908 shorten !=0 and !=1 indicates a bitwise operation.
10909 For them, this optimization is safe only if
10910 both args are zero-extended or both are sign-extended.
10911 Otherwise, we might change the result.
10912 Eg, (short)-1 | (unsigned short)-1 is (int)-1
10913 but calculated in (unsigned short) it would be (unsigned short)-1. */
10915 if (shorten
&& none_complex
)
10917 final_type
= result_type
;
10918 result_type
= shorten_binary_op (result_type
, op0
, op1
,
10922 /* Shifts can be shortened if shifting right. */
10927 tree arg0
= get_narrower (op0
, &unsigned_arg
);
10929 final_type
= result_type
;
10931 if (arg0
== op0
&& final_type
== TREE_TYPE (op0
))
10932 unsigned_arg
= TYPE_UNSIGNED (TREE_TYPE (op0
));
10934 if (TYPE_PRECISION (TREE_TYPE (arg0
)) < TYPE_PRECISION (result_type
)
10935 && tree_int_cst_sgn (op1
) > 0
10936 /* We can shorten only if the shift count is less than the
10937 number of bits in the smaller type size. */
10938 && compare_tree_int (op1
, TYPE_PRECISION (TREE_TYPE (arg0
))) < 0
10939 /* We cannot drop an unsigned shift after sign-extension. */
10940 && (!TYPE_UNSIGNED (final_type
) || unsigned_arg
))
10942 /* Do an unsigned shift if the operand was zero-extended. */
10944 = c_common_signed_or_unsigned_type (unsigned_arg
,
10946 /* Convert value-to-be-shifted to that type. */
10947 if (TREE_TYPE (op0
) != result_type
)
10948 op0
= convert (result_type
, op0
);
10953 /* Comparison operations are shortened too but differently.
10954 They identify themselves by setting short_compare = 1. */
10958 /* Don't write &op0, etc., because that would prevent op0
10959 from being kept in a register.
10960 Instead, make copies of the our local variables and
10961 pass the copies by reference, then copy them back afterward. */
10962 tree xop0
= op0
, xop1
= op1
, xresult_type
= result_type
;
10963 enum tree_code xresultcode
= resultcode
;
10965 = shorten_compare (location
, &xop0
, &xop1
, &xresult_type
,
10971 goto return_build_binary_op
;
10974 op0
= xop0
, op1
= xop1
;
10976 resultcode
= xresultcode
;
10978 if (c_inhibit_evaluation_warnings
== 0)
10980 bool op0_maybe_const
= true;
10981 bool op1_maybe_const
= true;
10982 tree orig_op0_folded
, orig_op1_folded
;
10984 if (in_late_binary_op
)
10986 orig_op0_folded
= orig_op0
;
10987 orig_op1_folded
= orig_op1
;
10991 /* Fold for the sake of possible warnings, as in
10992 build_conditional_expr. This requires the
10993 "original" values to be folded, not just op0 and
10995 c_inhibit_evaluation_warnings
++;
10996 op0
= c_fully_fold (op0
, require_constant_value
,
10998 op1
= c_fully_fold (op1
, require_constant_value
,
11000 c_inhibit_evaluation_warnings
--;
11001 orig_op0_folded
= c_fully_fold (orig_op0
,
11002 require_constant_value
,
11004 orig_op1_folded
= c_fully_fold (orig_op1
,
11005 require_constant_value
,
11009 if (warn_sign_compare
)
11010 warn_for_sign_compare (location
, orig_op0_folded
,
11011 orig_op1_folded
, op0
, op1
,
11012 result_type
, resultcode
);
11013 if (!in_late_binary_op
&& !int_operands
)
11015 if (!op0_maybe_const
|| TREE_CODE (op0
) != INTEGER_CST
)
11016 op0
= c_wrap_maybe_const (op0
, !op0_maybe_const
);
11017 if (!op1_maybe_const
|| TREE_CODE (op1
) != INTEGER_CST
)
11018 op1
= c_wrap_maybe_const (op1
, !op1_maybe_const
);
11024 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
11025 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
11026 Then the expression will be built.
11027 It will be given type FINAL_TYPE if that is nonzero;
11028 otherwise, it will be given type RESULT_TYPE. */
11032 binary_op_error (location
, code
, TREE_TYPE (op0
), TREE_TYPE (op1
));
11033 return error_mark_node
;
11036 if (build_type
== NULL_TREE
)
11038 build_type
= result_type
;
11039 if ((type0
!= orig_type0
|| type1
!= orig_type1
)
11042 gcc_assert (may_need_excess_precision
&& common
);
11043 semantic_result_type
= c_common_type (orig_type0
, orig_type1
);
11049 op0
= ep_convert_and_check (location
, result_type
, op0
,
11050 semantic_result_type
);
11051 op1
= ep_convert_and_check (location
, result_type
, op1
,
11052 semantic_result_type
);
11054 /* This can happen if one operand has a vector type, and the other
11055 has a different type. */
11056 if (TREE_CODE (op0
) == ERROR_MARK
|| TREE_CODE (op1
) == ERROR_MARK
)
11057 return error_mark_node
;
11060 if ((flag_sanitize
& (SANITIZE_SHIFT
| SANITIZE_DIVIDE
11061 | SANITIZE_FLOAT_DIVIDE
))
11062 && current_function_decl
!= 0
11063 && !lookup_attribute ("no_sanitize_undefined",
11064 DECL_ATTRIBUTES (current_function_decl
))
11065 && (doing_div_or_mod
|| doing_shift
))
11067 /* OP0 and/or OP1 might have side-effects. */
11068 op0
= c_save_expr (op0
);
11069 op1
= c_save_expr (op1
);
11070 op0
= c_fully_fold (op0
, false, NULL
);
11071 op1
= c_fully_fold (op1
, false, NULL
);
11072 if (doing_div_or_mod
&& (flag_sanitize
& (SANITIZE_DIVIDE
11073 | SANITIZE_FLOAT_DIVIDE
)))
11074 instrument_expr
= ubsan_instrument_division (location
, op0
, op1
);
11075 else if (doing_shift
&& (flag_sanitize
& SANITIZE_SHIFT
))
11076 instrument_expr
= ubsan_instrument_shift (location
, code
, op0
, op1
);
11079 /* Treat expressions in initializers specially as they can't trap. */
11080 if (int_const_or_overflow
)
11081 ret
= (require_constant_value
11082 ? fold_build2_initializer_loc (location
, resultcode
, build_type
,
11084 : fold_build2_loc (location
, resultcode
, build_type
, op0
, op1
));
11086 ret
= build2 (resultcode
, build_type
, op0
, op1
);
11087 if (final_type
!= 0)
11088 ret
= convert (final_type
, ret
);
11090 return_build_binary_op
:
11091 gcc_assert (ret
!= error_mark_node
);
11092 if (TREE_CODE (ret
) == INTEGER_CST
&& !TREE_OVERFLOW (ret
) && !int_const
)
11093 ret
= (int_operands
11094 ? note_integer_operands (ret
)
11095 : build1 (NOP_EXPR
, TREE_TYPE (ret
), ret
));
11096 else if (TREE_CODE (ret
) != INTEGER_CST
&& int_operands
11097 && !in_late_binary_op
)
11098 ret
= note_integer_operands (ret
);
11099 if (semantic_result_type
)
11100 ret
= build1 (EXCESS_PRECISION_EXPR
, semantic_result_type
, ret
);
11101 protected_set_expr_location (ret
, location
);
11103 if (instrument_expr
!= NULL
)
11104 ret
= fold_build2 (COMPOUND_EXPR
, TREE_TYPE (ret
),
11105 instrument_expr
, ret
);
11111 /* Convert EXPR to be a truth-value, validating its type for this
11112 purpose. LOCATION is the source location for the expression. */
11115 c_objc_common_truthvalue_conversion (location_t location
, tree expr
)
11117 bool int_const
, int_operands
;
11119 switch (TREE_CODE (TREE_TYPE (expr
)))
11122 error_at (location
, "used array that cannot be converted to pointer where scalar is required");
11123 return error_mark_node
;
11126 error_at (location
, "used struct type value where scalar is required");
11127 return error_mark_node
;
11130 error_at (location
, "used union type value where scalar is required");
11131 return error_mark_node
;
11134 error_at (location
, "void value not ignored as it ought to be");
11135 return error_mark_node
;
11137 case FUNCTION_TYPE
:
11138 gcc_unreachable ();
11141 error_at (location
, "used vector type where scalar is required");
11142 return error_mark_node
;
11148 int_const
= (TREE_CODE (expr
) == INTEGER_CST
&& !TREE_OVERFLOW (expr
));
11149 int_operands
= EXPR_INT_CONST_OPERANDS (expr
);
11150 if (int_operands
&& TREE_CODE (expr
) != INTEGER_CST
)
11152 expr
= remove_c_maybe_const_expr (expr
);
11153 expr
= build2 (NE_EXPR
, integer_type_node
, expr
,
11154 convert (TREE_TYPE (expr
), integer_zero_node
));
11155 expr
= note_integer_operands (expr
);
11158 /* ??? Should we also give an error for vectors rather than leaving
11159 those to give errors later? */
11160 expr
= c_common_truthvalue_conversion (location
, expr
);
11162 if (TREE_CODE (expr
) == INTEGER_CST
&& int_operands
&& !int_const
)
11164 if (TREE_OVERFLOW (expr
))
11167 return note_integer_operands (expr
);
11169 if (TREE_CODE (expr
) == INTEGER_CST
&& !int_const
)
11170 return build1 (NOP_EXPR
, TREE_TYPE (expr
), expr
);
11175 /* Convert EXPR to a contained DECL, updating *TC, *TI and *SE as
11179 c_expr_to_decl (tree expr
, bool *tc ATTRIBUTE_UNUSED
, bool *se
)
11181 if (TREE_CODE (expr
) == COMPOUND_LITERAL_EXPR
)
11183 tree decl
= COMPOUND_LITERAL_EXPR_DECL (expr
);
11184 /* Executing a compound literal inside a function reinitializes
11186 if (!TREE_STATIC (decl
))
11194 /* Like c_begin_compound_stmt, except force the retention of the BLOCK. */
11197 c_begin_omp_parallel (void)
11201 keep_next_level ();
11202 block
= c_begin_compound_stmt (true);
11207 /* Generate OMP_PARALLEL, with CLAUSES and BLOCK as its compound
11208 statement. LOC is the location of the OMP_PARALLEL. */
11211 c_finish_omp_parallel (location_t loc
, tree clauses
, tree block
)
11215 block
= c_end_compound_stmt (loc
, block
, true);
11217 stmt
= make_node (OMP_PARALLEL
);
11218 TREE_TYPE (stmt
) = void_type_node
;
11219 OMP_PARALLEL_CLAUSES (stmt
) = clauses
;
11220 OMP_PARALLEL_BODY (stmt
) = block
;
11221 SET_EXPR_LOCATION (stmt
, loc
);
11223 return add_stmt (stmt
);
11226 /* Like c_begin_compound_stmt, except force the retention of the BLOCK. */
11229 c_begin_omp_task (void)
11233 keep_next_level ();
11234 block
= c_begin_compound_stmt (true);
11239 /* Generate OMP_TASK, with CLAUSES and BLOCK as its compound
11240 statement. LOC is the location of the #pragma. */
11243 c_finish_omp_task (location_t loc
, tree clauses
, tree block
)
11247 block
= c_end_compound_stmt (loc
, block
, true);
11249 stmt
= make_node (OMP_TASK
);
11250 TREE_TYPE (stmt
) = void_type_node
;
11251 OMP_TASK_CLAUSES (stmt
) = clauses
;
11252 OMP_TASK_BODY (stmt
) = block
;
11253 SET_EXPR_LOCATION (stmt
, loc
);
11255 return add_stmt (stmt
);
11258 /* Generate GOMP_cancel call for #pragma omp cancel. */
11261 c_finish_omp_cancel (location_t loc
, tree clauses
)
11263 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_CANCEL
);
11265 if (find_omp_clause (clauses
, OMP_CLAUSE_PARALLEL
))
11267 else if (find_omp_clause (clauses
, OMP_CLAUSE_FOR
))
11269 else if (find_omp_clause (clauses
, OMP_CLAUSE_SECTIONS
))
11271 else if (find_omp_clause (clauses
, OMP_CLAUSE_TASKGROUP
))
11275 error_at (loc
, "%<#pragma omp cancel must specify one of "
11276 "%<parallel%>, %<for%>, %<sections%> or %<taskgroup%> "
11280 tree ifc
= find_omp_clause (clauses
, OMP_CLAUSE_IF
);
11281 if (ifc
!= NULL_TREE
)
11283 tree type
= TREE_TYPE (OMP_CLAUSE_IF_EXPR (ifc
));
11284 ifc
= fold_build2_loc (OMP_CLAUSE_LOCATION (ifc
), NE_EXPR
,
11285 boolean_type_node
, OMP_CLAUSE_IF_EXPR (ifc
),
11286 build_zero_cst (type
));
11289 ifc
= boolean_true_node
;
11290 tree stmt
= build_call_expr_loc (loc
, fn
, 2,
11291 build_int_cst (integer_type_node
, mask
),
11296 /* Generate GOMP_cancellation_point call for
11297 #pragma omp cancellation point. */
11300 c_finish_omp_cancellation_point (location_t loc
, tree clauses
)
11302 tree fn
= builtin_decl_explicit (BUILT_IN_GOMP_CANCELLATION_POINT
);
11304 if (find_omp_clause (clauses
, OMP_CLAUSE_PARALLEL
))
11306 else if (find_omp_clause (clauses
, OMP_CLAUSE_FOR
))
11308 else if (find_omp_clause (clauses
, OMP_CLAUSE_SECTIONS
))
11310 else if (find_omp_clause (clauses
, OMP_CLAUSE_TASKGROUP
))
11314 error_at (loc
, "%<#pragma omp cancellation point must specify one of "
11315 "%<parallel%>, %<for%>, %<sections%> or %<taskgroup%> "
11319 tree stmt
= build_call_expr_loc (loc
, fn
, 1,
11320 build_int_cst (integer_type_node
, mask
));
11324 /* Helper function for handle_omp_array_sections. Called recursively
11325 to handle multiple array-section-subscripts. C is the clause,
11326 T current expression (initially OMP_CLAUSE_DECL), which is either
11327 a TREE_LIST for array-section-subscript (TREE_PURPOSE is low-bound
11328 expression if specified, TREE_VALUE length expression if specified,
11329 TREE_CHAIN is what it has been specified after, or some decl.
11330 TYPES vector is populated with array section types, MAYBE_ZERO_LEN
11331 set to true if any of the array-section-subscript could have length
11332 of zero (explicit or implicit), FIRST_NON_ONE is the index of the
11333 first array-section-subscript which is known not to have length
11335 map(a[:b][2:1][:c][:2][:d][e:f][2:5])
11336 FIRST_NON_ONE will be 3, array-section-subscript [:b], [2:1] and [:c]
11337 all are or may have length of 1, array-section-subscript [:2] is the
11338 first one knonwn not to have length 1. For array-section-subscript
11339 <= FIRST_NON_ONE we diagnose non-contiguous arrays if low bound isn't
11340 0 or length isn't the array domain max + 1, for > FIRST_NON_ONE we
11341 can if MAYBE_ZERO_LEN is false. MAYBE_ZERO_LEN will be true in the above
11342 case though, as some lengths could be zero. */
11345 handle_omp_array_sections_1 (tree c
, tree t
, vec
<tree
> &types
,
11346 bool &maybe_zero_len
, unsigned int &first_non_one
)
11348 tree ret
, low_bound
, length
, type
;
11349 if (TREE_CODE (t
) != TREE_LIST
)
11351 if (t
== error_mark_node
|| TREE_TYPE (t
) == error_mark_node
)
11352 return error_mark_node
;
11353 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
11356 error_at (OMP_CLAUSE_LOCATION (c
),
11357 "%qD is not a variable in %qs clause", t
,
11358 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
11360 error_at (OMP_CLAUSE_LOCATION (c
),
11361 "%qE is not a variable in %qs clause", t
,
11362 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
11363 return error_mark_node
;
11365 else if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
11366 && TREE_CODE (t
) == VAR_DECL
&& DECL_THREAD_LOCAL_P (t
))
11368 error_at (OMP_CLAUSE_LOCATION (c
),
11369 "%qD is threadprivate variable in %qs clause", t
,
11370 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
11371 return error_mark_node
;
11376 ret
= handle_omp_array_sections_1 (c
, TREE_CHAIN (t
), types
,
11377 maybe_zero_len
, first_non_one
);
11378 if (ret
== error_mark_node
|| ret
== NULL_TREE
)
11381 type
= TREE_TYPE (ret
);
11382 low_bound
= TREE_PURPOSE (t
);
11383 length
= TREE_VALUE (t
);
11385 if (low_bound
== error_mark_node
|| length
== error_mark_node
)
11386 return error_mark_node
;
11388 if (low_bound
&& !INTEGRAL_TYPE_P (TREE_TYPE (low_bound
)))
11390 error_at (OMP_CLAUSE_LOCATION (c
),
11391 "low bound %qE of array section does not have integral type",
11393 return error_mark_node
;
11395 if (length
&& !INTEGRAL_TYPE_P (TREE_TYPE (length
)))
11397 error_at (OMP_CLAUSE_LOCATION (c
),
11398 "length %qE of array section does not have integral type",
11400 return error_mark_node
;
11403 && TREE_CODE (low_bound
) == INTEGER_CST
11404 && TYPE_PRECISION (TREE_TYPE (low_bound
))
11405 > TYPE_PRECISION (sizetype
))
11406 low_bound
= fold_convert (sizetype
, low_bound
);
11408 && TREE_CODE (length
) == INTEGER_CST
11409 && TYPE_PRECISION (TREE_TYPE (length
))
11410 > TYPE_PRECISION (sizetype
))
11411 length
= fold_convert (sizetype
, length
);
11412 if (low_bound
== NULL_TREE
)
11413 low_bound
= integer_zero_node
;
11415 if (length
!= NULL_TREE
)
11417 if (!integer_nonzerop (length
))
11418 maybe_zero_len
= true;
11419 if (first_non_one
== types
.length ()
11420 && (TREE_CODE (length
) != INTEGER_CST
|| integer_onep (length
)))
11423 if (TREE_CODE (type
) == ARRAY_TYPE
)
11425 if (length
== NULL_TREE
11426 && (TYPE_DOMAIN (type
) == NULL_TREE
11427 || TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) == NULL_TREE
))
11429 error_at (OMP_CLAUSE_LOCATION (c
),
11430 "for unknown bound array type length expression must "
11432 return error_mark_node
;
11434 if (TREE_CODE (low_bound
) == INTEGER_CST
11435 && tree_int_cst_sgn (low_bound
) == -1)
11437 error_at (OMP_CLAUSE_LOCATION (c
),
11438 "negative low bound in array section in %qs clause",
11439 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
11440 return error_mark_node
;
11442 if (length
!= NULL_TREE
11443 && TREE_CODE (length
) == INTEGER_CST
11444 && tree_int_cst_sgn (length
) == -1)
11446 error_at (OMP_CLAUSE_LOCATION (c
),
11447 "negative length in array section in %qs clause",
11448 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
11449 return error_mark_node
;
11451 if (TYPE_DOMAIN (type
)
11452 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
))
11453 && TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)))
11456 tree size
= size_binop (PLUS_EXPR
,
11457 TYPE_MAX_VALUE (TYPE_DOMAIN (type
)),
11459 if (TREE_CODE (low_bound
) == INTEGER_CST
)
11461 if (tree_int_cst_lt (size
, low_bound
))
11463 error_at (OMP_CLAUSE_LOCATION (c
),
11464 "low bound %qE above array section size "
11465 "in %qs clause", low_bound
,
11466 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
11467 return error_mark_node
;
11469 if (tree_int_cst_equal (size
, low_bound
))
11470 maybe_zero_len
= true;
11471 else if (length
== NULL_TREE
11472 && first_non_one
== types
.length ()
11473 && tree_int_cst_equal
11474 (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)),
11478 else if (length
== NULL_TREE
)
11480 maybe_zero_len
= true;
11481 if (first_non_one
== types
.length ())
11484 if (length
&& TREE_CODE (length
) == INTEGER_CST
)
11486 if (tree_int_cst_lt (size
, length
))
11488 error_at (OMP_CLAUSE_LOCATION (c
),
11489 "length %qE above array section size "
11490 "in %qs clause", length
,
11491 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
11492 return error_mark_node
;
11494 if (TREE_CODE (low_bound
) == INTEGER_CST
)
11497 = size_binop (PLUS_EXPR
,
11498 fold_convert (sizetype
, low_bound
),
11499 fold_convert (sizetype
, length
));
11500 if (TREE_CODE (lbpluslen
) == INTEGER_CST
11501 && tree_int_cst_lt (size
, lbpluslen
))
11503 error_at (OMP_CLAUSE_LOCATION (c
),
11504 "high bound %qE above array section size "
11505 "in %qs clause", lbpluslen
,
11506 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
11507 return error_mark_node
;
11512 else if (length
== NULL_TREE
)
11514 maybe_zero_len
= true;
11515 if (first_non_one
== types
.length ())
11519 /* For [lb:] we will need to evaluate lb more than once. */
11520 if (length
== NULL_TREE
&& OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
)
11522 tree lb
= c_save_expr (low_bound
);
11523 if (lb
!= low_bound
)
11525 TREE_PURPOSE (t
) = lb
;
11530 else if (TREE_CODE (type
) == POINTER_TYPE
)
11532 if (length
== NULL_TREE
)
11534 error_at (OMP_CLAUSE_LOCATION (c
),
11535 "for pointer type length expression must be specified");
11536 return error_mark_node
;
11538 /* If there is a pointer type anywhere but in the very first
11539 array-section-subscript, the array section can't be contiguous. */
11540 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
11541 && TREE_CODE (TREE_CHAIN (t
)) == TREE_LIST
)
11543 error_at (OMP_CLAUSE_LOCATION (c
),
11544 "array section is not contiguous in %qs clause",
11545 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
11546 return error_mark_node
;
11551 error_at (OMP_CLAUSE_LOCATION (c
),
11552 "%qE does not have pointer or array type", ret
);
11553 return error_mark_node
;
11555 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_DEPEND
)
11556 types
.safe_push (TREE_TYPE (ret
));
11557 /* We will need to evaluate lb more than once. */
11558 tree lb
= c_save_expr (low_bound
);
11559 if (lb
!= low_bound
)
11561 TREE_PURPOSE (t
) = lb
;
11564 ret
= build_array_ref (OMP_CLAUSE_LOCATION (c
), ret
, low_bound
);
11568 /* Handle array sections for clause C. */
11571 handle_omp_array_sections (tree c
)
11573 bool maybe_zero_len
= false;
11574 unsigned int first_non_one
= 0;
11575 vec
<tree
> types
= vNULL
;
11576 tree first
= handle_omp_array_sections_1 (c
, OMP_CLAUSE_DECL (c
), types
,
11577 maybe_zero_len
, first_non_one
);
11578 if (first
== error_mark_node
)
11583 if (first
== NULL_TREE
)
11588 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_DEPEND
)
11590 tree t
= OMP_CLAUSE_DECL (c
);
11591 tree tem
= NULL_TREE
;
11593 /* Need to evaluate side effects in the length expressions
11595 while (TREE_CODE (t
) == TREE_LIST
)
11597 if (TREE_VALUE (t
) && TREE_SIDE_EFFECTS (TREE_VALUE (t
)))
11599 if (tem
== NULL_TREE
)
11600 tem
= TREE_VALUE (t
);
11602 tem
= build2 (COMPOUND_EXPR
, TREE_TYPE (tem
),
11603 TREE_VALUE (t
), tem
);
11605 t
= TREE_CHAIN (t
);
11608 first
= build2 (COMPOUND_EXPR
, TREE_TYPE (first
), tem
, first
);
11609 first
= c_fully_fold (first
, false, NULL
);
11610 OMP_CLAUSE_DECL (c
) = first
;
11614 unsigned int num
= types
.length (), i
;
11615 tree t
, side_effects
= NULL_TREE
, size
= NULL_TREE
;
11616 tree condition
= NULL_TREE
;
11618 if (int_size_in_bytes (TREE_TYPE (first
)) <= 0)
11619 maybe_zero_len
= true;
11621 for (i
= num
, t
= OMP_CLAUSE_DECL (c
); i
> 0;
11622 t
= TREE_CHAIN (t
))
11624 tree low_bound
= TREE_PURPOSE (t
);
11625 tree length
= TREE_VALUE (t
);
11629 && TREE_CODE (low_bound
) == INTEGER_CST
11630 && TYPE_PRECISION (TREE_TYPE (low_bound
))
11631 > TYPE_PRECISION (sizetype
))
11632 low_bound
= fold_convert (sizetype
, low_bound
);
11634 && TREE_CODE (length
) == INTEGER_CST
11635 && TYPE_PRECISION (TREE_TYPE (length
))
11636 > TYPE_PRECISION (sizetype
))
11637 length
= fold_convert (sizetype
, length
);
11638 if (low_bound
== NULL_TREE
)
11639 low_bound
= integer_zero_node
;
11640 if (!maybe_zero_len
&& i
> first_non_one
)
11642 if (integer_nonzerop (low_bound
))
11643 goto do_warn_noncontiguous
;
11644 if (length
!= NULL_TREE
11645 && TREE_CODE (length
) == INTEGER_CST
11646 && TYPE_DOMAIN (types
[i
])
11647 && TYPE_MAX_VALUE (TYPE_DOMAIN (types
[i
]))
11648 && TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (types
[i
])))
11652 size
= size_binop (PLUS_EXPR
,
11653 TYPE_MAX_VALUE (TYPE_DOMAIN (types
[i
])),
11655 if (!tree_int_cst_equal (length
, size
))
11657 do_warn_noncontiguous
:
11658 error_at (OMP_CLAUSE_LOCATION (c
),
11659 "array section is not contiguous in %qs "
11661 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
11666 if (length
!= NULL_TREE
11667 && TREE_SIDE_EFFECTS (length
))
11669 if (side_effects
== NULL_TREE
)
11670 side_effects
= length
;
11672 side_effects
= build2 (COMPOUND_EXPR
,
11673 TREE_TYPE (side_effects
),
11674 length
, side_effects
);
11681 if (i
> first_non_one
&& length
&& integer_nonzerop (length
))
11684 l
= fold_convert (sizetype
, length
);
11687 l
= size_binop (PLUS_EXPR
,
11688 TYPE_MAX_VALUE (TYPE_DOMAIN (types
[i
])),
11690 l
= size_binop (MINUS_EXPR
, l
,
11691 fold_convert (sizetype
, low_bound
));
11693 if (i
> first_non_one
)
11695 l
= fold_build2 (NE_EXPR
, boolean_type_node
, l
,
11697 if (condition
== NULL_TREE
)
11700 condition
= fold_build2 (BIT_AND_EXPR
, boolean_type_node
,
11703 else if (size
== NULL_TREE
)
11705 size
= size_in_bytes (TREE_TYPE (types
[i
]));
11706 size
= size_binop (MULT_EXPR
, size
, l
);
11708 size
= fold_build3 (COND_EXPR
, sizetype
, condition
,
11709 size
, size_zero_node
);
11712 size
= size_binop (MULT_EXPR
, size
, l
);
11717 size
= build2 (COMPOUND_EXPR
, sizetype
, side_effects
, size
);
11718 first
= c_fully_fold (first
, false, NULL
);
11719 OMP_CLAUSE_DECL (c
) = first
;
11721 size
= c_fully_fold (size
, false, NULL
);
11722 OMP_CLAUSE_SIZE (c
) = size
;
11723 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_MAP
)
11725 tree c2
= build_omp_clause (OMP_CLAUSE_LOCATION (c
), OMP_CLAUSE_MAP
);
11726 OMP_CLAUSE_MAP_KIND (c2
) = OMP_CLAUSE_MAP_POINTER
;
11727 if (!c_mark_addressable (t
))
11729 OMP_CLAUSE_DECL (c2
) = t
;
11730 t
= build_fold_addr_expr (first
);
11731 t
= fold_convert_loc (OMP_CLAUSE_LOCATION (c
), ptrdiff_type_node
, t
);
11732 tree ptr
= OMP_CLAUSE_DECL (c2
);
11733 if (!POINTER_TYPE_P (TREE_TYPE (ptr
)))
11734 ptr
= build_fold_addr_expr (ptr
);
11735 t
= fold_build2_loc (OMP_CLAUSE_LOCATION (c
), MINUS_EXPR
,
11736 ptrdiff_type_node
, t
,
11737 fold_convert_loc (OMP_CLAUSE_LOCATION (c
),
11738 ptrdiff_type_node
, ptr
));
11739 t
= c_fully_fold (t
, false, NULL
);
11740 OMP_CLAUSE_SIZE (c2
) = t
;
11741 OMP_CLAUSE_CHAIN (c2
) = OMP_CLAUSE_CHAIN (c
);
11742 OMP_CLAUSE_CHAIN (c
) = c2
;
11747 /* Helper function of finish_omp_clauses. Clone STMT as if we were making
11748 an inline call. But, remap
11749 the OMP_DECL1 VAR_DECL (omp_out resp. omp_orig) to PLACEHOLDER
11750 and OMP_DECL2 VAR_DECL (omp_in resp. omp_priv) to DECL. */
11753 c_clone_omp_udr (tree stmt
, tree omp_decl1
, tree omp_decl2
,
11754 tree decl
, tree placeholder
)
11757 struct pointer_map_t
*decl_map
= pointer_map_create ();
11759 *pointer_map_insert (decl_map
, omp_decl1
) = placeholder
;
11760 *pointer_map_insert (decl_map
, omp_decl2
) = decl
;
11761 memset (&id
, 0, sizeof (id
));
11762 id
.src_fn
= DECL_CONTEXT (omp_decl1
);
11763 id
.dst_fn
= current_function_decl
;
11764 id
.src_cfun
= DECL_STRUCT_FUNCTION (id
.src_fn
);
11765 id
.decl_map
= decl_map
;
11767 id
.copy_decl
= copy_decl_no_change
;
11768 id
.transform_call_graph_edges
= CB_CGE_DUPLICATE
;
11769 id
.transform_new_cfg
= true;
11770 id
.transform_return_to_modify
= false;
11771 id
.transform_lang_insert_block
= NULL
;
11773 walk_tree (&stmt
, copy_tree_body_r
, &id
, NULL
);
11774 pointer_map_destroy (decl_map
);
11778 /* Helper function of c_finish_omp_clauses, called via walk_tree.
11779 Find OMP_CLAUSE_PLACEHOLDER (passed in DATA) in *TP. */
11782 c_find_omp_placeholder_r (tree
*tp
, int *, void *data
)
11784 if (*tp
== (tree
) data
)
11789 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
11790 Remove any elements from the list that are invalid. */
11793 c_finish_omp_clauses (tree clauses
)
11795 bitmap_head generic_head
, firstprivate_head
, lastprivate_head
;
11796 bitmap_head aligned_head
;
11798 bool branch_seen
= false;
11799 bool copyprivate_seen
= false;
11800 tree
*nowait_clause
= NULL
;
11802 bitmap_obstack_initialize (NULL
);
11803 bitmap_initialize (&generic_head
, &bitmap_default_obstack
);
11804 bitmap_initialize (&firstprivate_head
, &bitmap_default_obstack
);
11805 bitmap_initialize (&lastprivate_head
, &bitmap_default_obstack
);
11806 bitmap_initialize (&aligned_head
, &bitmap_default_obstack
);
11808 for (pc
= &clauses
, c
= clauses
; c
; c
= *pc
)
11810 bool remove
= false;
11811 bool need_complete
= false;
11812 bool need_implicitly_determined
= false;
11814 switch (OMP_CLAUSE_CODE (c
))
11816 case OMP_CLAUSE_SHARED
:
11817 need_implicitly_determined
= true;
11818 goto check_dup_generic
;
11820 case OMP_CLAUSE_PRIVATE
:
11821 need_complete
= true;
11822 need_implicitly_determined
= true;
11823 goto check_dup_generic
;
11825 case OMP_CLAUSE_REDUCTION
:
11826 need_implicitly_determined
= true;
11827 t
= OMP_CLAUSE_DECL (c
);
11828 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
) == NULL_TREE
11829 && (FLOAT_TYPE_P (TREE_TYPE (t
))
11830 || TREE_CODE (TREE_TYPE (t
)) == COMPLEX_TYPE
))
11832 enum tree_code r_code
= OMP_CLAUSE_REDUCTION_CODE (c
);
11833 const char *r_name
= NULL
;
11842 if (TREE_CODE (TREE_TYPE (t
)) == COMPLEX_TYPE
)
11846 if (TREE_CODE (TREE_TYPE (t
)) == COMPLEX_TYPE
)
11858 case TRUTH_ANDIF_EXPR
:
11859 if (FLOAT_TYPE_P (TREE_TYPE (t
)))
11862 case TRUTH_ORIF_EXPR
:
11863 if (FLOAT_TYPE_P (TREE_TYPE (t
)))
11867 gcc_unreachable ();
11871 error_at (OMP_CLAUSE_LOCATION (c
),
11872 "%qE has invalid type for %<reduction(%s)%>",
11878 else if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
) == error_mark_node
)
11880 error_at (OMP_CLAUSE_LOCATION (c
),
11881 "user defined reduction not found for %qD", t
);
11885 else if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
))
11887 tree list
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
);
11888 tree type
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
11889 tree placeholder
= build_decl (OMP_CLAUSE_LOCATION (c
),
11890 VAR_DECL
, NULL_TREE
, type
);
11891 OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
) = placeholder
;
11892 DECL_ARTIFICIAL (placeholder
) = 1;
11893 DECL_IGNORED_P (placeholder
) = 1;
11894 if (TREE_ADDRESSABLE (TREE_VEC_ELT (list
, 0)))
11895 c_mark_addressable (placeholder
);
11896 if (TREE_ADDRESSABLE (TREE_VEC_ELT (list
, 1)))
11897 c_mark_addressable (OMP_CLAUSE_DECL (c
));
11898 OMP_CLAUSE_REDUCTION_MERGE (c
)
11899 = c_clone_omp_udr (TREE_VEC_ELT (list
, 2),
11900 TREE_VEC_ELT (list
, 0),
11901 TREE_VEC_ELT (list
, 1),
11902 OMP_CLAUSE_DECL (c
), placeholder
);
11903 OMP_CLAUSE_REDUCTION_MERGE (c
)
11904 = build3_loc (OMP_CLAUSE_LOCATION (c
), BIND_EXPR
,
11905 void_type_node
, NULL_TREE
,
11906 OMP_CLAUSE_REDUCTION_MERGE (c
), NULL_TREE
);
11907 TREE_SIDE_EFFECTS (OMP_CLAUSE_REDUCTION_MERGE (c
)) = 1;
11908 if (TREE_VEC_LENGTH (list
) == 6)
11910 if (TREE_ADDRESSABLE (TREE_VEC_ELT (list
, 3)))
11911 c_mark_addressable (OMP_CLAUSE_DECL (c
));
11912 if (TREE_ADDRESSABLE (TREE_VEC_ELT (list
, 4)))
11913 c_mark_addressable (placeholder
);
11914 tree init
= TREE_VEC_ELT (list
, 5);
11915 if (init
== error_mark_node
)
11916 init
= DECL_INITIAL (TREE_VEC_ELT (list
, 3));
11917 OMP_CLAUSE_REDUCTION_INIT (c
)
11918 = c_clone_omp_udr (init
, TREE_VEC_ELT (list
, 4),
11919 TREE_VEC_ELT (list
, 3),
11920 OMP_CLAUSE_DECL (c
), placeholder
);
11921 if (TREE_VEC_ELT (list
, 5) == error_mark_node
)
11922 OMP_CLAUSE_REDUCTION_INIT (c
)
11923 = build2 (INIT_EXPR
, TREE_TYPE (t
), t
,
11924 OMP_CLAUSE_REDUCTION_INIT (c
));
11925 if (walk_tree (&OMP_CLAUSE_REDUCTION_INIT (c
),
11926 c_find_omp_placeholder_r
,
11927 placeholder
, NULL
))
11928 OMP_CLAUSE_REDUCTION_OMP_ORIG_REF (c
) = 1;
11933 if (AGGREGATE_TYPE_P (TREE_TYPE (t
)))
11934 init
= build_constructor (TREE_TYPE (t
), NULL
);
11936 init
= fold_convert (TREE_TYPE (t
), integer_zero_node
);
11937 OMP_CLAUSE_REDUCTION_INIT (c
)
11938 = build2 (INIT_EXPR
, TREE_TYPE (t
), t
, init
);
11940 OMP_CLAUSE_REDUCTION_INIT (c
)
11941 = build3_loc (OMP_CLAUSE_LOCATION (c
), BIND_EXPR
,
11942 void_type_node
, NULL_TREE
,
11943 OMP_CLAUSE_REDUCTION_INIT (c
), NULL_TREE
);
11944 TREE_SIDE_EFFECTS (OMP_CLAUSE_REDUCTION_INIT (c
)) = 1;
11946 goto check_dup_generic
;
11948 case OMP_CLAUSE_COPYPRIVATE
:
11949 copyprivate_seen
= true;
11952 error_at (OMP_CLAUSE_LOCATION (*nowait_clause
),
11953 "%<nowait%> clause must not be used together "
11954 "with %<copyprivate%>");
11955 *nowait_clause
= OMP_CLAUSE_CHAIN (*nowait_clause
);
11956 nowait_clause
= NULL
;
11958 goto check_dup_generic
;
11960 case OMP_CLAUSE_COPYIN
:
11961 t
= OMP_CLAUSE_DECL (c
);
11962 if (TREE_CODE (t
) != VAR_DECL
|| !DECL_THREAD_LOCAL_P (t
))
11964 error_at (OMP_CLAUSE_LOCATION (c
),
11965 "%qE must be %<threadprivate%> for %<copyin%>", t
);
11969 goto check_dup_generic
;
11971 case OMP_CLAUSE_LINEAR
:
11972 t
= OMP_CLAUSE_DECL (c
);
11973 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
))
11974 && TREE_CODE (TREE_TYPE (t
)) != POINTER_TYPE
)
11976 error_at (OMP_CLAUSE_LOCATION (c
),
11977 "linear clause applied to non-integral non-pointer "
11978 "variable with type %qT", TREE_TYPE (t
));
11982 if (TREE_CODE (TREE_TYPE (OMP_CLAUSE_DECL (c
))) == POINTER_TYPE
)
11984 tree s
= OMP_CLAUSE_LINEAR_STEP (c
);
11985 s
= pointer_int_sum (OMP_CLAUSE_LOCATION (c
), PLUS_EXPR
,
11986 OMP_CLAUSE_DECL (c
), s
);
11987 s
= fold_build2_loc (OMP_CLAUSE_LOCATION (c
), MINUS_EXPR
,
11988 sizetype
, s
, OMP_CLAUSE_DECL (c
));
11989 if (s
== error_mark_node
)
11991 OMP_CLAUSE_LINEAR_STEP (c
) = s
;
11993 goto check_dup_generic
;
11996 t
= OMP_CLAUSE_DECL (c
);
11997 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
11999 error_at (OMP_CLAUSE_LOCATION (c
),
12000 "%qE is not a variable in clause %qs", t
,
12001 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
12004 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
12005 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
))
12006 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
12008 error_at (OMP_CLAUSE_LOCATION (c
),
12009 "%qE appears more than once in data clauses", t
);
12013 bitmap_set_bit (&generic_head
, DECL_UID (t
));
12016 case OMP_CLAUSE_FIRSTPRIVATE
:
12017 t
= OMP_CLAUSE_DECL (c
);
12018 need_complete
= true;
12019 need_implicitly_determined
= true;
12020 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
12022 error_at (OMP_CLAUSE_LOCATION (c
),
12023 "%qE is not a variable in clause %<firstprivate%>", t
);
12026 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
12027 || bitmap_bit_p (&firstprivate_head
, DECL_UID (t
)))
12029 error_at (OMP_CLAUSE_LOCATION (c
),
12030 "%qE appears more than once in data clauses", t
);
12034 bitmap_set_bit (&firstprivate_head
, DECL_UID (t
));
12037 case OMP_CLAUSE_LASTPRIVATE
:
12038 t
= OMP_CLAUSE_DECL (c
);
12039 need_complete
= true;
12040 need_implicitly_determined
= true;
12041 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
12043 error_at (OMP_CLAUSE_LOCATION (c
),
12044 "%qE is not a variable in clause %<lastprivate%>", t
);
12047 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
))
12048 || bitmap_bit_p (&lastprivate_head
, DECL_UID (t
)))
12050 error_at (OMP_CLAUSE_LOCATION (c
),
12051 "%qE appears more than once in data clauses", t
);
12055 bitmap_set_bit (&lastprivate_head
, DECL_UID (t
));
12058 case OMP_CLAUSE_ALIGNED
:
12059 t
= OMP_CLAUSE_DECL (c
);
12060 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
12062 error_at (OMP_CLAUSE_LOCATION (c
),
12063 "%qE is not a variable in %<aligned%> clause", t
);
12066 else if (!POINTER_TYPE_P (TREE_TYPE (t
))
12067 && TREE_CODE (TREE_TYPE (t
)) != ARRAY_TYPE
)
12069 error_at (OMP_CLAUSE_LOCATION (c
),
12070 "%qE in %<aligned%> clause is neither a pointer nor "
12074 else if (bitmap_bit_p (&aligned_head
, DECL_UID (t
)))
12076 error_at (OMP_CLAUSE_LOCATION (c
),
12077 "%qE appears more than once in %<aligned%> clauses",
12082 bitmap_set_bit (&aligned_head
, DECL_UID (t
));
12085 case OMP_CLAUSE_DEPEND
:
12086 t
= OMP_CLAUSE_DECL (c
);
12087 if (TREE_CODE (t
) == TREE_LIST
)
12089 if (handle_omp_array_sections (c
))
12093 if (t
== error_mark_node
)
12095 else if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
12097 error_at (OMP_CLAUSE_LOCATION (c
),
12098 "%qE is not a variable in %<depend%> clause", t
);
12101 else if (!c_mark_addressable (t
))
12105 case OMP_CLAUSE_MAP
:
12106 case OMP_CLAUSE_TO
:
12107 case OMP_CLAUSE_FROM
:
12108 t
= OMP_CLAUSE_DECL (c
);
12109 if (TREE_CODE (t
) == TREE_LIST
)
12111 if (handle_omp_array_sections (c
))
12115 t
= OMP_CLAUSE_DECL (c
);
12116 if (!lang_hooks
.types
.omp_mappable_type (TREE_TYPE (t
)))
12118 error_at (OMP_CLAUSE_LOCATION (c
),
12119 "array section does not have mappable type "
12121 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
12127 if (t
== error_mark_node
)
12129 else if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != PARM_DECL
)
12131 error_at (OMP_CLAUSE_LOCATION (c
),
12132 "%qE is not a variable in %qs clause", t
,
12133 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
12136 else if (TREE_CODE (t
) == VAR_DECL
&& DECL_THREAD_LOCAL_P (t
))
12138 error_at (OMP_CLAUSE_LOCATION (c
),
12139 "%qD is threadprivate variable in %qs clause", t
,
12140 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
12143 else if (!c_mark_addressable (t
))
12145 else if (!(OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
12146 && OMP_CLAUSE_MAP_KIND (c
) == OMP_CLAUSE_MAP_POINTER
)
12147 && !lang_hooks
.types
.omp_mappable_type (TREE_TYPE (t
)))
12149 error_at (OMP_CLAUSE_LOCATION (c
),
12150 "%qD does not have a mappable type in %qs clause", t
,
12151 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
12154 else if (bitmap_bit_p (&generic_head
, DECL_UID (t
)))
12156 if (OMP_CLAUSE_CODE (c
) != OMP_CLAUSE_MAP
)
12157 error ("%qD appears more than once in motion clauses", t
);
12159 error ("%qD appears more than once in map clauses", t
);
12163 bitmap_set_bit (&generic_head
, DECL_UID (t
));
12166 case OMP_CLAUSE_UNIFORM
:
12167 t
= OMP_CLAUSE_DECL (c
);
12168 if (TREE_CODE (t
) != PARM_DECL
)
12171 error_at (OMP_CLAUSE_LOCATION (c
),
12172 "%qD is not an argument in %<uniform%> clause", t
);
12174 error_at (OMP_CLAUSE_LOCATION (c
),
12175 "%qE is not an argument in %<uniform%> clause", t
);
12179 goto check_dup_generic
;
12181 case OMP_CLAUSE_NOWAIT
:
12182 if (copyprivate_seen
)
12184 error_at (OMP_CLAUSE_LOCATION (c
),
12185 "%<nowait%> clause must not be used together "
12186 "with %<copyprivate%>");
12190 nowait_clause
= pc
;
12191 pc
= &OMP_CLAUSE_CHAIN (c
);
12194 case OMP_CLAUSE_IF
:
12195 case OMP_CLAUSE_NUM_THREADS
:
12196 case OMP_CLAUSE_NUM_TEAMS
:
12197 case OMP_CLAUSE_THREAD_LIMIT
:
12198 case OMP_CLAUSE_SCHEDULE
:
12199 case OMP_CLAUSE_ORDERED
:
12200 case OMP_CLAUSE_DEFAULT
:
12201 case OMP_CLAUSE_UNTIED
:
12202 case OMP_CLAUSE_COLLAPSE
:
12203 case OMP_CLAUSE_FINAL
:
12204 case OMP_CLAUSE_MERGEABLE
:
12205 case OMP_CLAUSE_SAFELEN
:
12206 case OMP_CLAUSE_SIMDLEN
:
12207 case OMP_CLAUSE_DEVICE
:
12208 case OMP_CLAUSE_DIST_SCHEDULE
:
12209 case OMP_CLAUSE_PARALLEL
:
12210 case OMP_CLAUSE_FOR
:
12211 case OMP_CLAUSE_SECTIONS
:
12212 case OMP_CLAUSE_TASKGROUP
:
12213 case OMP_CLAUSE_PROC_BIND
:
12214 pc
= &OMP_CLAUSE_CHAIN (c
);
12217 case OMP_CLAUSE_INBRANCH
:
12218 case OMP_CLAUSE_NOTINBRANCH
:
12221 error_at (OMP_CLAUSE_LOCATION (c
),
12222 "%<inbranch%> clause is incompatible with "
12223 "%<notinbranch%>");
12227 branch_seen
= true;
12228 pc
= &OMP_CLAUSE_CHAIN (c
);
12232 gcc_unreachable ();
12237 t
= OMP_CLAUSE_DECL (c
);
12241 t
= require_complete_type (t
);
12242 if (t
== error_mark_node
)
12246 if (need_implicitly_determined
)
12248 const char *share_name
= NULL
;
12250 if (TREE_CODE (t
) == VAR_DECL
&& DECL_THREAD_LOCAL_P (t
))
12251 share_name
= "threadprivate";
12252 else switch (c_omp_predetermined_sharing (t
))
12254 case OMP_CLAUSE_DEFAULT_UNSPECIFIED
:
12256 case OMP_CLAUSE_DEFAULT_SHARED
:
12257 /* const vars may be specified in firstprivate clause. */
12258 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
12259 && TREE_READONLY (t
))
12261 share_name
= "shared";
12263 case OMP_CLAUSE_DEFAULT_PRIVATE
:
12264 share_name
= "private";
12267 gcc_unreachable ();
12271 error_at (OMP_CLAUSE_LOCATION (c
),
12272 "%qE is predetermined %qs for %qs",
12274 omp_clause_code_name
[OMP_CLAUSE_CODE (c
)]);
12281 *pc
= OMP_CLAUSE_CHAIN (c
);
12283 pc
= &OMP_CLAUSE_CHAIN (c
);
12286 bitmap_obstack_release (NULL
);
12290 /* Create a transaction node. */
12293 c_finish_transaction (location_t loc
, tree block
, int flags
)
12295 tree stmt
= build_stmt (loc
, TRANSACTION_EXPR
, block
);
12296 if (flags
& TM_STMT_ATTR_OUTER
)
12297 TRANSACTION_EXPR_OUTER (stmt
) = 1;
12298 if (flags
& TM_STMT_ATTR_RELAXED
)
12299 TRANSACTION_EXPR_RELAXED (stmt
) = 1;
12300 return add_stmt (stmt
);
12303 /* Make a variant type in the proper way for C/C++, propagating qualifiers
12304 down to the element type of an array. */
12307 c_build_qualified_type (tree type
, int type_quals
)
12309 if (type
== error_mark_node
)
12312 if (TREE_CODE (type
) == ARRAY_TYPE
)
12315 tree element_type
= c_build_qualified_type (TREE_TYPE (type
),
12318 /* See if we already have an identically qualified type. */
12319 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
12321 if (TYPE_QUALS (strip_array_types (t
)) == type_quals
12322 && TYPE_NAME (t
) == TYPE_NAME (type
)
12323 && TYPE_CONTEXT (t
) == TYPE_CONTEXT (type
)
12324 && attribute_list_equal (TYPE_ATTRIBUTES (t
),
12325 TYPE_ATTRIBUTES (type
)))
12330 tree domain
= TYPE_DOMAIN (type
);
12332 t
= build_variant_type_copy (type
);
12333 TREE_TYPE (t
) = element_type
;
12335 if (TYPE_STRUCTURAL_EQUALITY_P (element_type
)
12336 || (domain
&& TYPE_STRUCTURAL_EQUALITY_P (domain
)))
12337 SET_TYPE_STRUCTURAL_EQUALITY (t
);
12338 else if (TYPE_CANONICAL (element_type
) != element_type
12339 || (domain
&& TYPE_CANONICAL (domain
) != domain
))
12341 tree unqualified_canon
12342 = build_array_type (TYPE_CANONICAL (element_type
),
12343 domain
? TYPE_CANONICAL (domain
)
12346 = c_build_qualified_type (unqualified_canon
, type_quals
);
12349 TYPE_CANONICAL (t
) = t
;
12354 /* A restrict-qualified pointer type must be a pointer to object or
12355 incomplete type. Note that the use of POINTER_TYPE_P also allows
12356 REFERENCE_TYPEs, which is appropriate for C++. */
12357 if ((type_quals
& TYPE_QUAL_RESTRICT
)
12358 && (!POINTER_TYPE_P (type
)
12359 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
))))
12361 error ("invalid use of %<restrict%>");
12362 type_quals
&= ~TYPE_QUAL_RESTRICT
;
12365 return build_qualified_type (type
, type_quals
);
12368 /* Build a VA_ARG_EXPR for the C parser. */
12371 c_build_va_arg (location_t loc
, tree expr
, tree type
)
12373 if (warn_cxx_compat
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
12374 warning_at (loc
, OPT_Wc___compat
,
12375 "C++ requires promoted type, not enum type, in %<va_arg%>");
12376 return build_va_arg (loc
, expr
, type
);
12379 /* Return truthvalue of whether T1 is the same tree structure as T2.
12380 Return 1 if they are the same. Return 0 if they are different. */
12383 c_tree_equal (tree t1
, tree t2
)
12385 enum tree_code code1
, code2
;
12392 for (code1
= TREE_CODE (t1
);
12393 CONVERT_EXPR_CODE_P (code1
)
12394 || code1
== NON_LVALUE_EXPR
;
12395 code1
= TREE_CODE (t1
))
12396 t1
= TREE_OPERAND (t1
, 0);
12397 for (code2
= TREE_CODE (t2
);
12398 CONVERT_EXPR_CODE_P (code2
)
12399 || code2
== NON_LVALUE_EXPR
;
12400 code2
= TREE_CODE (t2
))
12401 t2
= TREE_OPERAND (t2
, 0);
12403 /* They might have become equal now. */
12407 if (code1
!= code2
)
12413 return wi::eq_p (t1
, t2
);
12416 return REAL_VALUES_EQUAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
12419 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
12420 && !memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
12421 TREE_STRING_LENGTH (t1
));
12424 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1
),
12425 TREE_FIXED_CST (t2
));
12428 return c_tree_equal (TREE_REALPART (t1
), TREE_REALPART (t2
))
12429 && c_tree_equal (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
12432 return operand_equal_p (t1
, t2
, OEP_ONLY_CONST
);
12435 /* We need to do this when determining whether or not two
12436 non-type pointer to member function template arguments
12438 if (!comptypes (TREE_TYPE (t1
), TREE_TYPE (t2
))
12439 || CONSTRUCTOR_NELTS (t1
) != CONSTRUCTOR_NELTS (t2
))
12444 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, field
, value
)
12446 constructor_elt
*elt2
= CONSTRUCTOR_ELT (t2
, i
);
12447 if (!c_tree_equal (field
, elt2
->index
)
12448 || !c_tree_equal (value
, elt2
->value
))
12455 if (!c_tree_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
)))
12457 if (!c_tree_equal (TREE_VALUE (t1
), TREE_VALUE (t2
)))
12459 return c_tree_equal (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
12462 return c_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
12467 call_expr_arg_iterator iter1
, iter2
;
12468 if (!c_tree_equal (CALL_EXPR_FN (t1
), CALL_EXPR_FN (t2
)))
12470 for (arg1
= first_call_expr_arg (t1
, &iter1
),
12471 arg2
= first_call_expr_arg (t2
, &iter2
);
12473 arg1
= next_call_expr_arg (&iter1
),
12474 arg2
= next_call_expr_arg (&iter2
))
12475 if (!c_tree_equal (arg1
, arg2
))
12484 tree o1
= TREE_OPERAND (t1
, 0);
12485 tree o2
= TREE_OPERAND (t2
, 0);
12487 /* Special case: if either target is an unallocated VAR_DECL,
12488 it means that it's going to be unified with whatever the
12489 TARGET_EXPR is really supposed to initialize, so treat it
12490 as being equivalent to anything. */
12491 if (TREE_CODE (o1
) == VAR_DECL
&& DECL_NAME (o1
) == NULL_TREE
12492 && !DECL_RTL_SET_P (o1
))
12494 else if (TREE_CODE (o2
) == VAR_DECL
&& DECL_NAME (o2
) == NULL_TREE
12495 && !DECL_RTL_SET_P (o2
))
12497 else if (!c_tree_equal (o1
, o2
))
12500 return c_tree_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
12503 case COMPONENT_REF
:
12504 if (TREE_OPERAND (t1
, 1) != TREE_OPERAND (t2
, 1))
12506 return c_tree_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
12512 case FUNCTION_DECL
:
12513 case IDENTIFIER_NODE
:
12520 if (TREE_VEC_LENGTH (t1
) != TREE_VEC_LENGTH (t2
))
12522 for (ix
= TREE_VEC_LENGTH (t1
); ix
--;)
12523 if (!c_tree_equal (TREE_VEC_ELT (t1
, ix
),
12524 TREE_VEC_ELT (t2
, ix
)))
12533 switch (TREE_CODE_CLASS (code1
))
12537 case tcc_comparison
:
12538 case tcc_expression
:
12540 case tcc_reference
:
12541 case tcc_statement
:
12543 int i
, n
= TREE_OPERAND_LENGTH (t1
);
12547 case PREINCREMENT_EXPR
:
12548 case PREDECREMENT_EXPR
:
12549 case POSTINCREMENT_EXPR
:
12550 case POSTDECREMENT_EXPR
:
12560 if (TREE_CODE_CLASS (code1
) == tcc_vl_exp
12561 && n
!= TREE_OPERAND_LENGTH (t2
))
12564 for (i
= 0; i
< n
; ++i
)
12565 if (!c_tree_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
)))
12572 return comptypes (t1
, t2
);
12574 gcc_unreachable ();
12576 /* We can get here with --disable-checking. */
12580 /* Inserts "cleanup" functions after the function-body of FNDECL. FNDECL is a
12581 spawn-helper and BODY is the newly created body for FNDECL. */
12584 cilk_install_body_with_frame_cleanup (tree fndecl
, tree body
, void *w
)
12586 tree list
= alloc_stmt_list ();
12587 tree frame
= make_cilk_frame (fndecl
);
12588 tree dtor
= create_cilk_function_exit (frame
, false, true);
12589 add_local_decl (cfun
, frame
);
12591 DECL_SAVED_TREE (fndecl
) = list
;
12592 tree frame_ptr
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (frame
)),
12594 tree body_list
= cilk_install_body_pedigree_operations (frame_ptr
);
12595 gcc_assert (TREE_CODE (body_list
) == STATEMENT_LIST
);
12597 tree detach_expr
= build_call_expr (cilk_detach_fndecl
, 1, frame_ptr
);
12598 append_to_statement_list (detach_expr
, &body_list
);
12600 cilk_outline (fndecl
, &body
, (struct wrapper_data
*) w
);
12601 body
= fold_build_cleanup_point_expr (void_type_node
, body
);
12603 append_to_statement_list (body
, &body_list
);
12604 append_to_statement_list (build_stmt (EXPR_LOCATION (body
), TRY_FINALLY_EXPR
,
12605 body_list
, dtor
), &list
);