1 /* Build expressions with type checking for C compiler.
2 Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
23 /* This file is part of the C front end.
24 It contains routines to build C expressions given their operands,
25 including computing the types of the result, C-specific error checks,
26 and some optimization. */
30 #include "coretypes.h"
33 #include "langhooks.h"
40 #include "tree-iterator.h"
43 #include "c-family/c-objc.h"
45 /* Possible cases of implicit bad conversions. Used to select
46 diagnostic messages in convert_for_assignment. */
54 /* Possibe cases of scalar_to_vector conversion. */
56 stv_error, /* Error occured. */
57 stv_nothing, /* Nothing happened. */
58 stv_firstarg, /* First argument must be expanded. */
59 stv_secondarg /* Second argument must be expanded. */
62 /* The level of nesting inside "__alignof__". */
65 /* The level of nesting inside "sizeof". */
68 /* The level of nesting inside "typeof". */
71 /* Nonzero if we've already printed a "missing braces around initializer"
72 message within this initializer. */
73 static int missing_braces_mentioned;
75 static int require_constant_value;
76 static int require_constant_elements;
78 static bool null_pointer_constant_p (const_tree);
79 static tree qualify_type (tree, tree);
80 static int tagged_types_tu_compatible_p (const_tree, const_tree, bool *,
82 static int comp_target_types (location_t, tree, tree);
83 static int function_types_compatible_p (const_tree, const_tree, bool *,
85 static int type_lists_compatible_p (const_tree, const_tree, bool *, bool *);
86 static tree lookup_field (tree, tree);
87 static int convert_arguments (tree, VEC(tree,gc) *, VEC(tree,gc) *, tree,
89 static tree pointer_diff (location_t, tree, tree);
90 static tree convert_for_assignment (location_t, tree, tree, tree,
91 enum impl_conv, bool, tree, tree, int);
92 static tree valid_compound_expr_initializer (tree, tree);
93 static void push_string (const char *);
94 static void push_member_name (tree);
95 static int spelling_length (void);
96 static char *print_spelling (char *);
97 static void warning_init (int, const char *);
98 static tree digest_init (location_t, tree, tree, tree, bool, bool, int);
99 static void output_init_element (tree, tree, bool, tree, tree, int, bool,
101 static void output_pending_init_elements (int, struct obstack *);
102 static int set_designator (int, struct obstack *);
103 static void push_range_stack (tree, struct obstack *);
104 static void add_pending_init (tree, tree, tree, bool, struct obstack *);
105 static void set_nonincremental_init (struct obstack *);
106 static void set_nonincremental_init_from_string (tree, struct obstack *);
107 static tree find_init_member (tree, struct obstack *);
108 static void readonly_warning (tree, enum lvalue_use);
109 static int lvalue_or_else (location_t, const_tree, enum lvalue_use);
110 static void record_maybe_used_decl (tree);
111 static int comptypes_internal (const_tree, const_tree, bool *, bool *);
113 /* Return true if EXP is a null pointer constant, false otherwise. */
116 null_pointer_constant_p (const_tree expr)
118 /* This should really operate on c_expr structures, but they aren't
119 yet available everywhere required. */
120 tree type = TREE_TYPE (expr);
121 return (TREE_CODE (expr) == INTEGER_CST
122 && !TREE_OVERFLOW (expr)
123 && integer_zerop (expr)
124 && (INTEGRAL_TYPE_P (type)
125 || (TREE_CODE (type) == POINTER_TYPE
126 && VOID_TYPE_P (TREE_TYPE (type))
127 && TYPE_QUALS (TREE_TYPE (type)) == TYPE_UNQUALIFIED)));
130 /* EXPR may appear in an unevaluated part of an integer constant
131 expression, but not in an evaluated part. Wrap it in a
132 C_MAYBE_CONST_EXPR, or mark it with TREE_OVERFLOW if it is just an
133 INTEGER_CST and we cannot create a C_MAYBE_CONST_EXPR. */
136 note_integer_operands (tree expr)
139 if (TREE_CODE (expr) == INTEGER_CST && in_late_binary_op)
141 ret = copy_node (expr);
142 TREE_OVERFLOW (ret) = 1;
146 ret = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (expr), NULL_TREE, expr);
147 C_MAYBE_CONST_EXPR_INT_OPERANDS (ret) = 1;
152 /* Having checked whether EXPR may appear in an unevaluated part of an
153 integer constant expression and found that it may, remove any
154 C_MAYBE_CONST_EXPR noting this fact and return the resulting
158 remove_c_maybe_const_expr (tree expr)
160 if (TREE_CODE (expr) == C_MAYBE_CONST_EXPR)
161 return C_MAYBE_CONST_EXPR_EXPR (expr);
166 \f/* This is a cache to hold if two types are compatible or not. */
168 struct tagged_tu_seen_cache {
169 const struct tagged_tu_seen_cache * next;
172 /* The return value of tagged_types_tu_compatible_p if we had seen
173 these two types already. */
177 static const struct tagged_tu_seen_cache * tagged_tu_seen_base;
178 static void free_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache *);
180 /* Do `exp = require_complete_type (exp);' to make sure exp
181 does not have an incomplete type. (That includes void types.) */
184 require_complete_type (tree value)
186 tree type = TREE_TYPE (value);
188 if (value == error_mark_node || type == error_mark_node)
189 return error_mark_node;
191 /* First, detect a valid value with a complete type. */
192 if (COMPLETE_TYPE_P (type))
195 c_incomplete_type_error (value, type);
196 return error_mark_node;
199 /* Print an error message for invalid use of an incomplete type.
200 VALUE is the expression that was used (or 0 if that isn't known)
201 and TYPE is the type that was invalid. */
204 c_incomplete_type_error (const_tree value, const_tree type)
206 const char *type_code_string;
208 /* Avoid duplicate error message. */
209 if (TREE_CODE (type) == ERROR_MARK)
212 if (value != 0 && (TREE_CODE (value) == VAR_DECL
213 || TREE_CODE (value) == PARM_DECL))
214 error ("%qD has an incomplete type", value);
218 /* We must print an error message. Be clever about what it says. */
220 switch (TREE_CODE (type))
223 type_code_string = "struct";
227 type_code_string = "union";
231 type_code_string = "enum";
235 error ("invalid use of void expression");
239 if (TYPE_DOMAIN (type))
241 if (TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL)
243 error ("invalid use of flexible array member");
246 type = TREE_TYPE (type);
249 error ("invalid use of array with unspecified bounds");
256 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
257 error ("invalid use of undefined type %<%s %E%>",
258 type_code_string, TYPE_NAME (type));
260 /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
261 error ("invalid use of incomplete typedef %qD", TYPE_NAME (type));
265 /* Given a type, apply default promotions wrt unnamed function
266 arguments and return the new type. */
269 c_type_promotes_to (tree type)
271 if (TYPE_MAIN_VARIANT (type) == float_type_node)
272 return double_type_node;
274 if (c_promoting_integer_type_p (type))
276 /* Preserve unsignedness if not really getting any wider. */
277 if (TYPE_UNSIGNED (type)
278 && (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
279 return unsigned_type_node;
280 return integer_type_node;
286 /* Return true if between two named address spaces, whether there is a superset
287 named address space that encompasses both address spaces. If there is a
288 superset, return which address space is the superset. */
291 addr_space_superset (addr_space_t as1, addr_space_t as2, addr_space_t *common)
298 else if (targetm.addr_space.subset_p (as1, as2))
303 else if (targetm.addr_space.subset_p (as2, as1))
312 /* Return a variant of TYPE which has all the type qualifiers of LIKE
313 as well as those of TYPE. */
316 qualify_type (tree type, tree like)
318 addr_space_t as_type = TYPE_ADDR_SPACE (type);
319 addr_space_t as_like = TYPE_ADDR_SPACE (like);
320 addr_space_t as_common;
322 /* If the two named address spaces are different, determine the common
323 superset address space. If there isn't one, raise an error. */
324 if (!addr_space_superset (as_type, as_like, &as_common))
327 error ("%qT and %qT are in disjoint named address spaces",
331 return c_build_qualified_type (type,
332 TYPE_QUALS_NO_ADDR_SPACE (type)
333 | TYPE_QUALS_NO_ADDR_SPACE (like)
334 | ENCODE_QUAL_ADDR_SPACE (as_common));
337 /* Return true iff the given tree T is a variable length array. */
340 c_vla_type_p (const_tree t)
342 if (TREE_CODE (t) == ARRAY_TYPE
343 && C_TYPE_VARIABLE_SIZE (t))
348 /* Return the composite type of two compatible types.
350 We assume that comptypes has already been done and returned
351 nonzero; if that isn't so, this may crash. In particular, we
352 assume that qualifiers match. */
355 composite_type (tree t1, tree t2)
357 enum tree_code code1;
358 enum tree_code code2;
361 /* Save time if the two types are the same. */
363 if (t1 == t2) return t1;
365 /* If one type is nonsense, use the other. */
366 if (t1 == error_mark_node)
368 if (t2 == error_mark_node)
371 code1 = TREE_CODE (t1);
372 code2 = TREE_CODE (t2);
374 /* Merge the attributes. */
375 attributes = targetm.merge_type_attributes (t1, t2);
377 /* If one is an enumerated type and the other is the compatible
378 integer type, the composite type might be either of the two
379 (DR#013 question 3). For consistency, use the enumerated type as
380 the composite type. */
382 if (code1 == ENUMERAL_TYPE && code2 == INTEGER_TYPE)
384 if (code2 == ENUMERAL_TYPE && code1 == INTEGER_TYPE)
387 gcc_assert (code1 == code2);
392 /* For two pointers, do this recursively on the target type. */
394 tree pointed_to_1 = TREE_TYPE (t1);
395 tree pointed_to_2 = TREE_TYPE (t2);
396 tree target = composite_type (pointed_to_1, pointed_to_2);
397 t1 = build_pointer_type (target);
398 t1 = build_type_attribute_variant (t1, attributes);
399 return qualify_type (t1, t2);
404 tree elt = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
407 tree d1 = TYPE_DOMAIN (t1);
408 tree d2 = TYPE_DOMAIN (t2);
409 bool d1_variable, d2_variable;
410 bool d1_zero, d2_zero;
411 bool t1_complete, t2_complete;
413 /* We should not have any type quals on arrays at all. */
414 gcc_assert (!TYPE_QUALS_NO_ADDR_SPACE (t1)
415 && !TYPE_QUALS_NO_ADDR_SPACE (t2));
417 t1_complete = COMPLETE_TYPE_P (t1);
418 t2_complete = COMPLETE_TYPE_P (t2);
420 d1_zero = d1 == 0 || !TYPE_MAX_VALUE (d1);
421 d2_zero = d2 == 0 || !TYPE_MAX_VALUE (d2);
423 d1_variable = (!d1_zero
424 && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
425 || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
426 d2_variable = (!d2_zero
427 && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
428 || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
429 d1_variable = d1_variable || (d1_zero && c_vla_type_p (t1));
430 d2_variable = d2_variable || (d2_zero && c_vla_type_p (t2));
432 /* Save space: see if the result is identical to one of the args. */
433 if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1)
434 && (d2_variable || d2_zero || !d1_variable))
435 return build_type_attribute_variant (t1, attributes);
436 if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2)
437 && (d1_variable || d1_zero || !d2_variable))
438 return build_type_attribute_variant (t2, attributes);
440 if (elt == TREE_TYPE (t1) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1))
441 return build_type_attribute_variant (t1, attributes);
442 if (elt == TREE_TYPE (t2) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1))
443 return build_type_attribute_variant (t2, attributes);
445 /* Merge the element types, and have a size if either arg has
446 one. We may have qualifiers on the element types. To set
447 up TYPE_MAIN_VARIANT correctly, we need to form the
448 composite of the unqualified types and add the qualifiers
450 quals = TYPE_QUALS (strip_array_types (elt));
451 unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
452 t1 = build_array_type (unqual_elt,
453 TYPE_DOMAIN ((TYPE_DOMAIN (t1)
459 /* Ensure a composite type involving a zero-length array type
460 is a zero-length type not an incomplete type. */
461 if (d1_zero && d2_zero
462 && (t1_complete || t2_complete)
463 && !COMPLETE_TYPE_P (t1))
465 TYPE_SIZE (t1) = bitsize_zero_node;
466 TYPE_SIZE_UNIT (t1) = size_zero_node;
468 t1 = c_build_qualified_type (t1, quals);
469 return build_type_attribute_variant (t1, attributes);
475 if (attributes != NULL)
477 /* Try harder not to create a new aggregate type. */
478 if (attribute_list_equal (TYPE_ATTRIBUTES (t1), attributes))
480 if (attribute_list_equal (TYPE_ATTRIBUTES (t2), attributes))
483 return build_type_attribute_variant (t1, attributes);
486 /* Function types: prefer the one that specified arg types.
487 If both do, merge the arg types. Also merge the return types. */
489 tree valtype = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
490 tree p1 = TYPE_ARG_TYPES (t1);
491 tree p2 = TYPE_ARG_TYPES (t2);
496 /* Save space: see if the result is identical to one of the args. */
497 if (valtype == TREE_TYPE (t1) && !TYPE_ARG_TYPES (t2))
498 return build_type_attribute_variant (t1, attributes);
499 if (valtype == TREE_TYPE (t2) && !TYPE_ARG_TYPES (t1))
500 return build_type_attribute_variant (t2, attributes);
502 /* Simple way if one arg fails to specify argument types. */
503 if (TYPE_ARG_TYPES (t1) == 0)
505 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2));
506 t1 = build_type_attribute_variant (t1, attributes);
507 return qualify_type (t1, t2);
509 if (TYPE_ARG_TYPES (t2) == 0)
511 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1));
512 t1 = build_type_attribute_variant (t1, attributes);
513 return qualify_type (t1, t2);
516 /* If both args specify argument types, we must merge the two
517 lists, argument by argument. */
519 len = list_length (p1);
522 for (i = 0; i < len; i++)
523 newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
528 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n))
530 /* A null type means arg type is not specified.
531 Take whatever the other function type has. */
532 if (TREE_VALUE (p1) == 0)
534 TREE_VALUE (n) = TREE_VALUE (p2);
537 if (TREE_VALUE (p2) == 0)
539 TREE_VALUE (n) = TREE_VALUE (p1);
543 /* Given wait (union {union wait *u; int *i} *)
544 and wait (union wait *),
545 prefer union wait * as type of parm. */
546 if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE
547 && TREE_VALUE (p1) != TREE_VALUE (p2))
550 tree mv2 = TREE_VALUE (p2);
551 if (mv2 && mv2 != error_mark_node
552 && TREE_CODE (mv2) != ARRAY_TYPE)
553 mv2 = TYPE_MAIN_VARIANT (mv2);
554 for (memb = TYPE_FIELDS (TREE_VALUE (p1));
555 memb; memb = DECL_CHAIN (memb))
557 tree mv3 = TREE_TYPE (memb);
558 if (mv3 && mv3 != error_mark_node
559 && TREE_CODE (mv3) != ARRAY_TYPE)
560 mv3 = TYPE_MAIN_VARIANT (mv3);
561 if (comptypes (mv3, mv2))
563 TREE_VALUE (n) = composite_type (TREE_TYPE (memb),
565 pedwarn (input_location, OPT_pedantic,
566 "function types not truly compatible in ISO C");
571 if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE
572 && TREE_VALUE (p2) != TREE_VALUE (p1))
575 tree mv1 = TREE_VALUE (p1);
576 if (mv1 && mv1 != error_mark_node
577 && TREE_CODE (mv1) != ARRAY_TYPE)
578 mv1 = TYPE_MAIN_VARIANT (mv1);
579 for (memb = TYPE_FIELDS (TREE_VALUE (p2));
580 memb; memb = DECL_CHAIN (memb))
582 tree mv3 = TREE_TYPE (memb);
583 if (mv3 && mv3 != error_mark_node
584 && TREE_CODE (mv3) != ARRAY_TYPE)
585 mv3 = TYPE_MAIN_VARIANT (mv3);
586 if (comptypes (mv3, mv1))
588 TREE_VALUE (n) = composite_type (TREE_TYPE (memb),
590 pedwarn (input_location, OPT_pedantic,
591 "function types not truly compatible in ISO C");
596 TREE_VALUE (n) = composite_type (TREE_VALUE (p1), TREE_VALUE (p2));
600 t1 = build_function_type (valtype, newargs);
601 t1 = qualify_type (t1, t2);
602 /* ... falls through ... */
606 return build_type_attribute_variant (t1, attributes);
611 /* Return the type of a conditional expression between pointers to
612 possibly differently qualified versions of compatible types.
614 We assume that comp_target_types has already been done and returned
615 nonzero; if that isn't so, this may crash. */
618 common_pointer_type (tree t1, tree t2)
621 tree pointed_to_1, mv1;
622 tree pointed_to_2, mv2;
624 unsigned target_quals;
625 addr_space_t as1, as2, as_common;
628 /* Save time if the two types are the same. */
630 if (t1 == t2) return t1;
632 /* If one type is nonsense, use the other. */
633 if (t1 == error_mark_node)
635 if (t2 == error_mark_node)
638 gcc_assert (TREE_CODE (t1) == POINTER_TYPE
639 && TREE_CODE (t2) == POINTER_TYPE);
641 /* Merge the attributes. */
642 attributes = targetm.merge_type_attributes (t1, t2);
644 /* Find the composite type of the target types, and combine the
645 qualifiers of the two types' targets. Do not lose qualifiers on
646 array element types by taking the TYPE_MAIN_VARIANT. */
647 mv1 = pointed_to_1 = TREE_TYPE (t1);
648 mv2 = pointed_to_2 = TREE_TYPE (t2);
649 if (TREE_CODE (mv1) != ARRAY_TYPE)
650 mv1 = TYPE_MAIN_VARIANT (pointed_to_1);
651 if (TREE_CODE (mv2) != ARRAY_TYPE)
652 mv2 = TYPE_MAIN_VARIANT (pointed_to_2);
653 target = composite_type (mv1, mv2);
655 /* For function types do not merge const qualifiers, but drop them
656 if used inconsistently. The middle-end uses these to mark const
657 and noreturn functions. */
658 quals1 = TYPE_QUALS_NO_ADDR_SPACE (pointed_to_1);
659 quals2 = TYPE_QUALS_NO_ADDR_SPACE (pointed_to_2);
661 if (TREE_CODE (pointed_to_1) == FUNCTION_TYPE)
662 target_quals = (quals1 & quals2);
664 target_quals = (quals1 | quals2);
666 /* If the two named address spaces are different, determine the common
667 superset address space. This is guaranteed to exist due to the
668 assumption that comp_target_type returned non-zero. */
669 as1 = TYPE_ADDR_SPACE (pointed_to_1);
670 as2 = TYPE_ADDR_SPACE (pointed_to_2);
671 if (!addr_space_superset (as1, as2, &as_common))
674 target_quals |= ENCODE_QUAL_ADDR_SPACE (as_common);
676 t1 = build_pointer_type (c_build_qualified_type (target, target_quals));
677 return build_type_attribute_variant (t1, attributes);
680 /* Return the common type for two arithmetic types under the usual
681 arithmetic conversions. The default conversions have already been
682 applied, and enumerated types converted to their compatible integer
683 types. The resulting type is unqualified and has no attributes.
685 This is the type for the result of most arithmetic operations
686 if the operands have the given two types. */
689 c_common_type (tree t1, tree t2)
691 enum tree_code code1;
692 enum tree_code code2;
694 /* If one type is nonsense, use the other. */
695 if (t1 == error_mark_node)
697 if (t2 == error_mark_node)
700 if (TYPE_QUALS (t1) != TYPE_UNQUALIFIED)
701 t1 = TYPE_MAIN_VARIANT (t1);
703 if (TYPE_QUALS (t2) != TYPE_UNQUALIFIED)
704 t2 = TYPE_MAIN_VARIANT (t2);
706 if (TYPE_ATTRIBUTES (t1) != NULL_TREE)
707 t1 = build_type_attribute_variant (t1, NULL_TREE);
709 if (TYPE_ATTRIBUTES (t2) != NULL_TREE)
710 t2 = build_type_attribute_variant (t2, NULL_TREE);
712 /* Save time if the two types are the same. */
714 if (t1 == t2) return t1;
716 code1 = TREE_CODE (t1);
717 code2 = TREE_CODE (t2);
719 gcc_assert (code1 == VECTOR_TYPE || code1 == COMPLEX_TYPE
720 || code1 == FIXED_POINT_TYPE || code1 == REAL_TYPE
721 || code1 == INTEGER_TYPE);
722 gcc_assert (code2 == VECTOR_TYPE || code2 == COMPLEX_TYPE
723 || code2 == FIXED_POINT_TYPE || code2 == REAL_TYPE
724 || code2 == INTEGER_TYPE);
726 /* When one operand is a decimal float type, the other operand cannot be
727 a generic float type or a complex type. We also disallow vector types
729 if ((DECIMAL_FLOAT_TYPE_P (t1) || DECIMAL_FLOAT_TYPE_P (t2))
730 && !(DECIMAL_FLOAT_TYPE_P (t1) && DECIMAL_FLOAT_TYPE_P (t2)))
732 if (code1 == VECTOR_TYPE || code2 == VECTOR_TYPE)
734 error ("can%'t mix operands of decimal float and vector types");
735 return error_mark_node;
737 if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
739 error ("can%'t mix operands of decimal float and complex types");
740 return error_mark_node;
742 if (code1 == REAL_TYPE && code2 == REAL_TYPE)
744 error ("can%'t mix operands of decimal float and other float types");
745 return error_mark_node;
749 /* If one type is a vector type, return that type. (How the usual
750 arithmetic conversions apply to the vector types extension is not
751 precisely specified.) */
752 if (code1 == VECTOR_TYPE)
755 if (code2 == VECTOR_TYPE)
758 /* If one type is complex, form the common type of the non-complex
759 components, then make that complex. Use T1 or T2 if it is the
761 if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
763 tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
764 tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
765 tree subtype = c_common_type (subtype1, subtype2);
767 if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
769 else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
772 return build_complex_type (subtype);
775 /* If only one is real, use it as the result. */
777 if (code1 == REAL_TYPE && code2 != REAL_TYPE)
780 if (code2 == REAL_TYPE && code1 != REAL_TYPE)
783 /* If both are real and either are decimal floating point types, use
784 the decimal floating point type with the greater precision. */
786 if (code1 == REAL_TYPE && code2 == REAL_TYPE)
788 if (TYPE_MAIN_VARIANT (t1) == dfloat128_type_node
789 || TYPE_MAIN_VARIANT (t2) == dfloat128_type_node)
790 return dfloat128_type_node;
791 else if (TYPE_MAIN_VARIANT (t1) == dfloat64_type_node
792 || TYPE_MAIN_VARIANT (t2) == dfloat64_type_node)
793 return dfloat64_type_node;
794 else if (TYPE_MAIN_VARIANT (t1) == dfloat32_type_node
795 || TYPE_MAIN_VARIANT (t2) == dfloat32_type_node)
796 return dfloat32_type_node;
799 /* Deal with fixed-point types. */
800 if (code1 == FIXED_POINT_TYPE || code2 == FIXED_POINT_TYPE)
802 unsigned int unsignedp = 0, satp = 0;
803 enum machine_mode m1, m2;
804 unsigned int fbit1, ibit1, fbit2, ibit2, max_fbit, max_ibit;
809 /* If one input type is saturating, the result type is saturating. */
810 if (TYPE_SATURATING (t1) || TYPE_SATURATING (t2))
813 /* If both fixed-point types are unsigned, the result type is unsigned.
814 When mixing fixed-point and integer types, follow the sign of the
816 Otherwise, the result type is signed. */
817 if ((TYPE_UNSIGNED (t1) && TYPE_UNSIGNED (t2)
818 && code1 == FIXED_POINT_TYPE && code2 == FIXED_POINT_TYPE)
819 || (code1 == FIXED_POINT_TYPE && code2 != FIXED_POINT_TYPE
820 && TYPE_UNSIGNED (t1))
821 || (code1 != FIXED_POINT_TYPE && code2 == FIXED_POINT_TYPE
822 && TYPE_UNSIGNED (t2)))
825 /* The result type is signed. */
828 /* If the input type is unsigned, we need to convert to the
830 if (code1 == FIXED_POINT_TYPE && TYPE_UNSIGNED (t1))
832 enum mode_class mclass = (enum mode_class) 0;
833 if (GET_MODE_CLASS (m1) == MODE_UFRACT)
835 else if (GET_MODE_CLASS (m1) == MODE_UACCUM)
839 m1 = mode_for_size (GET_MODE_PRECISION (m1), mclass, 0);
841 if (code2 == FIXED_POINT_TYPE && TYPE_UNSIGNED (t2))
843 enum mode_class mclass = (enum mode_class) 0;
844 if (GET_MODE_CLASS (m2) == MODE_UFRACT)
846 else if (GET_MODE_CLASS (m2) == MODE_UACCUM)
850 m2 = mode_for_size (GET_MODE_PRECISION (m2), mclass, 0);
854 if (code1 == FIXED_POINT_TYPE)
856 fbit1 = GET_MODE_FBIT (m1);
857 ibit1 = GET_MODE_IBIT (m1);
862 /* Signed integers need to subtract one sign bit. */
863 ibit1 = TYPE_PRECISION (t1) - (!TYPE_UNSIGNED (t1));
866 if (code2 == FIXED_POINT_TYPE)
868 fbit2 = GET_MODE_FBIT (m2);
869 ibit2 = GET_MODE_IBIT (m2);
874 /* Signed integers need to subtract one sign bit. */
875 ibit2 = TYPE_PRECISION (t2) - (!TYPE_UNSIGNED (t2));
878 max_ibit = ibit1 >= ibit2 ? ibit1 : ibit2;
879 max_fbit = fbit1 >= fbit2 ? fbit1 : fbit2;
880 return c_common_fixed_point_type_for_size (max_ibit, max_fbit, unsignedp,
884 /* Both real or both integers; use the one with greater precision. */
886 if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
888 else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
891 /* Same precision. Prefer long longs to longs to ints when the
892 same precision, following the C99 rules on integer type rank
893 (which are equivalent to the C90 rules for C90 types). */
895 if (TYPE_MAIN_VARIANT (t1) == long_long_unsigned_type_node
896 || TYPE_MAIN_VARIANT (t2) == long_long_unsigned_type_node)
897 return long_long_unsigned_type_node;
899 if (TYPE_MAIN_VARIANT (t1) == long_long_integer_type_node
900 || TYPE_MAIN_VARIANT (t2) == long_long_integer_type_node)
902 if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
903 return long_long_unsigned_type_node;
905 return long_long_integer_type_node;
908 if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
909 || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
910 return long_unsigned_type_node;
912 if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
913 || TYPE_MAIN_VARIANT (t2) == long_integer_type_node)
915 /* But preserve unsignedness from the other type,
916 since long cannot hold all the values of an unsigned int. */
917 if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
918 return long_unsigned_type_node;
920 return long_integer_type_node;
923 /* Likewise, prefer long double to double even if same size. */
924 if (TYPE_MAIN_VARIANT (t1) == long_double_type_node
925 || TYPE_MAIN_VARIANT (t2) == long_double_type_node)
926 return long_double_type_node;
928 /* Otherwise prefer the unsigned one. */
930 if (TYPE_UNSIGNED (t1))
936 /* Wrapper around c_common_type that is used by c-common.c and other
937 front end optimizations that remove promotions. ENUMERAL_TYPEs
938 are allowed here and are converted to their compatible integer types.
939 BOOLEAN_TYPEs are allowed here and return either boolean_type_node or
940 preferably a non-Boolean type as the common type. */
942 common_type (tree t1, tree t2)
944 if (TREE_CODE (t1) == ENUMERAL_TYPE)
945 t1 = c_common_type_for_size (TYPE_PRECISION (t1), 1);
946 if (TREE_CODE (t2) == ENUMERAL_TYPE)
947 t2 = c_common_type_for_size (TYPE_PRECISION (t2), 1);
949 /* If both types are BOOLEAN_TYPE, then return boolean_type_node. */
950 if (TREE_CODE (t1) == BOOLEAN_TYPE
951 && TREE_CODE (t2) == BOOLEAN_TYPE)
952 return boolean_type_node;
954 /* If either type is BOOLEAN_TYPE, then return the other. */
955 if (TREE_CODE (t1) == BOOLEAN_TYPE)
957 if (TREE_CODE (t2) == BOOLEAN_TYPE)
960 return c_common_type (t1, t2);
963 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
964 or various other operations. Return 2 if they are compatible
965 but a warning may be needed if you use them together. */
968 comptypes (tree type1, tree type2)
970 const struct tagged_tu_seen_cache * tagged_tu_seen_base1 = tagged_tu_seen_base;
973 val = comptypes_internal (type1, type2, NULL, NULL);
974 free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1);
979 /* Like comptypes, but if it returns non-zero because enum and int are
980 compatible, it sets *ENUM_AND_INT_P to true. */
983 comptypes_check_enum_int (tree type1, tree type2, bool *enum_and_int_p)
985 const struct tagged_tu_seen_cache * tagged_tu_seen_base1 = tagged_tu_seen_base;
988 val = comptypes_internal (type1, type2, enum_and_int_p, NULL);
989 free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1);
994 /* Like comptypes, but if it returns nonzero for different types, it
995 sets *DIFFERENT_TYPES_P to true. */
998 comptypes_check_different_types (tree type1, tree type2,
999 bool *different_types_p)
1001 const struct tagged_tu_seen_cache * tagged_tu_seen_base1 = tagged_tu_seen_base;
1004 val = comptypes_internal (type1, type2, NULL, different_types_p);
1005 free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1);
1010 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
1011 or various other operations. Return 2 if they are compatible
1012 but a warning may be needed if you use them together. If
1013 ENUM_AND_INT_P is not NULL, and one type is an enum and the other a
1014 compatible integer type, then this sets *ENUM_AND_INT_P to true;
1015 *ENUM_AND_INT_P is never set to false. If DIFFERENT_TYPES_P is not
1016 NULL, and the types are compatible but different enough not to be
1017 permitted in C1X typedef redeclarations, then this sets
1018 *DIFFERENT_TYPES_P to true; *DIFFERENT_TYPES_P is never set to
1019 false, but may or may not be set if the types are incompatible.
1020 This differs from comptypes, in that we don't free the seen
1024 comptypes_internal (const_tree type1, const_tree type2, bool *enum_and_int_p,
1025 bool *different_types_p)
1027 const_tree t1 = type1;
1028 const_tree t2 = type2;
1031 /* Suppress errors caused by previously reported errors. */
1033 if (t1 == t2 || !t1 || !t2
1034 || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK)
1037 /* Enumerated types are compatible with integer types, but this is
1038 not transitive: two enumerated types in the same translation unit
1039 are compatible with each other only if they are the same type. */
1041 if (TREE_CODE (t1) == ENUMERAL_TYPE && TREE_CODE (t2) != ENUMERAL_TYPE)
1043 t1 = c_common_type_for_size (TYPE_PRECISION (t1), TYPE_UNSIGNED (t1));
1044 if (TREE_CODE (t2) != VOID_TYPE)
1046 if (enum_and_int_p != NULL)
1047 *enum_and_int_p = true;
1048 if (different_types_p != NULL)
1049 *different_types_p = true;
1052 else if (TREE_CODE (t2) == ENUMERAL_TYPE && TREE_CODE (t1) != ENUMERAL_TYPE)
1054 t2 = c_common_type_for_size (TYPE_PRECISION (t2), TYPE_UNSIGNED (t2));
1055 if (TREE_CODE (t1) != VOID_TYPE)
1057 if (enum_and_int_p != NULL)
1058 *enum_and_int_p = true;
1059 if (different_types_p != NULL)
1060 *different_types_p = true;
1067 /* Different classes of types can't be compatible. */
1069 if (TREE_CODE (t1) != TREE_CODE (t2))
1072 /* Qualifiers must match. C99 6.7.3p9 */
1074 if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
1077 /* Allow for two different type nodes which have essentially the same
1078 definition. Note that we already checked for equality of the type
1079 qualifiers (just above). */
1081 if (TREE_CODE (t1) != ARRAY_TYPE
1082 && TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
1085 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1086 if (!(attrval = comp_type_attributes (t1, t2)))
1089 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1092 switch (TREE_CODE (t1))
1095 /* Do not remove mode or aliasing information. */
1096 if (TYPE_MODE (t1) != TYPE_MODE (t2)
1097 || TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2))
1099 val = (TREE_TYPE (t1) == TREE_TYPE (t2)
1100 ? 1 : comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2),
1101 enum_and_int_p, different_types_p));
1105 val = function_types_compatible_p (t1, t2, enum_and_int_p,
1111 tree d1 = TYPE_DOMAIN (t1);
1112 tree d2 = TYPE_DOMAIN (t2);
1113 bool d1_variable, d2_variable;
1114 bool d1_zero, d2_zero;
1117 /* Target types must match incl. qualifiers. */
1118 if (TREE_TYPE (t1) != TREE_TYPE (t2)
1119 && 0 == (val = comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2),
1121 different_types_p)))
1124 if (different_types_p != NULL
1125 && (d1 == 0) != (d2 == 0))
1126 *different_types_p = true;
1127 /* Sizes must match unless one is missing or variable. */
1128 if (d1 == 0 || d2 == 0 || d1 == d2)
1131 d1_zero = !TYPE_MAX_VALUE (d1);
1132 d2_zero = !TYPE_MAX_VALUE (d2);
1134 d1_variable = (!d1_zero
1135 && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
1136 || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
1137 d2_variable = (!d2_zero
1138 && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
1139 || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
1140 d1_variable = d1_variable || (d1_zero && c_vla_type_p (t1));
1141 d2_variable = d2_variable || (d2_zero && c_vla_type_p (t2));
1143 if (different_types_p != NULL
1144 && d1_variable != d2_variable)
1145 *different_types_p = true;
1146 if (d1_variable || d2_variable)
1148 if (d1_zero && d2_zero)
1150 if (d1_zero || d2_zero
1151 || !tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2))
1152 || !tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2)))
1161 if (val != 1 && !same_translation_unit_p (t1, t2))
1163 tree a1 = TYPE_ATTRIBUTES (t1);
1164 tree a2 = TYPE_ATTRIBUTES (t2);
1166 if (! attribute_list_contained (a1, a2)
1167 && ! attribute_list_contained (a2, a1))
1171 return tagged_types_tu_compatible_p (t1, t2, enum_and_int_p,
1173 val = tagged_types_tu_compatible_p (t1, t2, enum_and_int_p,
1179 val = (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1180 && comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2),
1181 enum_and_int_p, different_types_p));
1187 return attrval == 2 && val == 1 ? 2 : val;
1190 /* Return 1 if TTL and TTR are pointers to types that are equivalent, ignoring
1191 their qualifiers, except for named address spaces. If the pointers point to
1192 different named addresses, then we must determine if one address space is a
1193 subset of the other. */
1196 comp_target_types (location_t location, tree ttl, tree ttr)
1199 tree mvl = TREE_TYPE (ttl);
1200 tree mvr = TREE_TYPE (ttr);
1201 addr_space_t asl = TYPE_ADDR_SPACE (mvl);
1202 addr_space_t asr = TYPE_ADDR_SPACE (mvr);
1203 addr_space_t as_common;
1204 bool enum_and_int_p;
1206 /* Fail if pointers point to incompatible address spaces. */
1207 if (!addr_space_superset (asl, asr, &as_common))
1210 /* Do not lose qualifiers on element types of array types that are
1211 pointer targets by taking their TYPE_MAIN_VARIANT. */
1212 if (TREE_CODE (mvl) != ARRAY_TYPE)
1213 mvl = TYPE_MAIN_VARIANT (mvl);
1214 if (TREE_CODE (mvr) != ARRAY_TYPE)
1215 mvr = TYPE_MAIN_VARIANT (mvr);
1216 enum_and_int_p = false;
1217 val = comptypes_check_enum_int (mvl, mvr, &enum_and_int_p);
1220 pedwarn (location, OPT_pedantic, "types are not quite compatible");
1222 if (val == 1 && enum_and_int_p && warn_cxx_compat)
1223 warning_at (location, OPT_Wc___compat,
1224 "pointer target types incompatible in C++");
1229 /* Subroutines of `comptypes'. */
1231 /* Determine whether two trees derive from the same translation unit.
1232 If the CONTEXT chain ends in a null, that tree's context is still
1233 being parsed, so if two trees have context chains ending in null,
1234 they're in the same translation unit. */
1236 same_translation_unit_p (const_tree t1, const_tree t2)
1238 while (t1 && TREE_CODE (t1) != TRANSLATION_UNIT_DECL)
1239 switch (TREE_CODE_CLASS (TREE_CODE (t1)))
1241 case tcc_declaration:
1242 t1 = DECL_CONTEXT (t1); break;
1244 t1 = TYPE_CONTEXT (t1); break;
1245 case tcc_exceptional:
1246 t1 = BLOCK_SUPERCONTEXT (t1); break; /* assume block */
1247 default: gcc_unreachable ();
1250 while (t2 && TREE_CODE (t2) != TRANSLATION_UNIT_DECL)
1251 switch (TREE_CODE_CLASS (TREE_CODE (t2)))
1253 case tcc_declaration:
1254 t2 = DECL_CONTEXT (t2); break;
1256 t2 = TYPE_CONTEXT (t2); break;
1257 case tcc_exceptional:
1258 t2 = BLOCK_SUPERCONTEXT (t2); break; /* assume block */
1259 default: gcc_unreachable ();
1265 /* Allocate the seen two types, assuming that they are compatible. */
1267 static struct tagged_tu_seen_cache *
1268 alloc_tagged_tu_seen_cache (const_tree t1, const_tree t2)
1270 struct tagged_tu_seen_cache *tu = XNEW (struct tagged_tu_seen_cache);
1271 tu->next = tagged_tu_seen_base;
1275 tagged_tu_seen_base = tu;
1277 /* The C standard says that two structures in different translation
1278 units are compatible with each other only if the types of their
1279 fields are compatible (among other things). We assume that they
1280 are compatible until proven otherwise when building the cache.
1281 An example where this can occur is:
1286 If we are comparing this against a similar struct in another TU,
1287 and did not assume they were compatible, we end up with an infinite
1293 /* Free the seen types until we get to TU_TIL. */
1296 free_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache *tu_til)
1298 const struct tagged_tu_seen_cache *tu = tagged_tu_seen_base;
1299 while (tu != tu_til)
1301 const struct tagged_tu_seen_cache *const tu1
1302 = (const struct tagged_tu_seen_cache *) tu;
1304 free (CONST_CAST (struct tagged_tu_seen_cache *, tu1));
1306 tagged_tu_seen_base = tu_til;
1309 /* Return 1 if two 'struct', 'union', or 'enum' types T1 and T2 are
1310 compatible. If the two types are not the same (which has been
1311 checked earlier), this can only happen when multiple translation
1312 units are being compiled. See C99 6.2.7 paragraph 1 for the exact
1313 rules. ENUM_AND_INT_P and DIFFERENT_TYPES_P are as in
1314 comptypes_internal. */
1317 tagged_types_tu_compatible_p (const_tree t1, const_tree t2,
1318 bool *enum_and_int_p, bool *different_types_p)
1321 bool needs_warning = false;
1323 /* We have to verify that the tags of the types are the same. This
1324 is harder than it looks because this may be a typedef, so we have
1325 to go look at the original type. It may even be a typedef of a
1327 In the case of compiler-created builtin structs the TYPE_DECL
1328 may be a dummy, with no DECL_ORIGINAL_TYPE. Don't fault. */
1329 while (TYPE_NAME (t1)
1330 && TREE_CODE (TYPE_NAME (t1)) == TYPE_DECL
1331 && DECL_ORIGINAL_TYPE (TYPE_NAME (t1)))
1332 t1 = DECL_ORIGINAL_TYPE (TYPE_NAME (t1));
1334 while (TYPE_NAME (t2)
1335 && TREE_CODE (TYPE_NAME (t2)) == TYPE_DECL
1336 && DECL_ORIGINAL_TYPE (TYPE_NAME (t2)))
1337 t2 = DECL_ORIGINAL_TYPE (TYPE_NAME (t2));
1339 /* C90 didn't have the requirement that the two tags be the same. */
1340 if (flag_isoc99 && TYPE_NAME (t1) != TYPE_NAME (t2))
1343 /* C90 didn't say what happened if one or both of the types were
1344 incomplete; we choose to follow C99 rules here, which is that they
1346 if (TYPE_SIZE (t1) == NULL
1347 || TYPE_SIZE (t2) == NULL)
1351 const struct tagged_tu_seen_cache * tts_i;
1352 for (tts_i = tagged_tu_seen_base; tts_i != NULL; tts_i = tts_i->next)
1353 if (tts_i->t1 == t1 && tts_i->t2 == t2)
1357 switch (TREE_CODE (t1))
1361 struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2);
1362 /* Speed up the case where the type values are in the same order. */
1363 tree tv1 = TYPE_VALUES (t1);
1364 tree tv2 = TYPE_VALUES (t2);
1371 for (;tv1 && tv2; tv1 = TREE_CHAIN (tv1), tv2 = TREE_CHAIN (tv2))
1373 if (TREE_PURPOSE (tv1) != TREE_PURPOSE (tv2))
1375 if (simple_cst_equal (TREE_VALUE (tv1), TREE_VALUE (tv2)) != 1)
1382 if (tv1 == NULL_TREE && tv2 == NULL_TREE)
1386 if (tv1 == NULL_TREE || tv2 == NULL_TREE)
1392 if (list_length (TYPE_VALUES (t1)) != list_length (TYPE_VALUES (t2)))
1398 for (s1 = TYPE_VALUES (t1); s1; s1 = TREE_CHAIN (s1))
1400 s2 = purpose_member (TREE_PURPOSE (s1), TYPE_VALUES (t2));
1402 || simple_cst_equal (TREE_VALUE (s1), TREE_VALUE (s2)) != 1)
1413 struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2);
1414 if (list_length (TYPE_FIELDS (t1)) != list_length (TYPE_FIELDS (t2)))
1420 /* Speed up the common case where the fields are in the same order. */
1421 for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2); s1 && s2;
1422 s1 = DECL_CHAIN (s1), s2 = DECL_CHAIN (s2))
1426 if (DECL_NAME (s1) != DECL_NAME (s2))
1428 result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2),
1429 enum_and_int_p, different_types_p);
1431 if (result != 1 && !DECL_NAME (s1))
1439 needs_warning = true;
1441 if (TREE_CODE (s1) == FIELD_DECL
1442 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
1443 DECL_FIELD_BIT_OFFSET (s2)) != 1)
1451 tu->val = needs_warning ? 2 : 1;
1455 for (s1 = TYPE_FIELDS (t1); s1; s1 = DECL_CHAIN (s1))
1459 for (s2 = TYPE_FIELDS (t2); s2; s2 = DECL_CHAIN (s2))
1460 if (DECL_NAME (s1) == DECL_NAME (s2))
1464 result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2),
1468 if (result != 1 && !DECL_NAME (s1))
1476 needs_warning = true;
1478 if (TREE_CODE (s1) == FIELD_DECL
1479 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
1480 DECL_FIELD_BIT_OFFSET (s2)) != 1)
1492 tu->val = needs_warning ? 2 : 10;
1498 struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2);
1500 for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2);
1502 s1 = DECL_CHAIN (s1), s2 = DECL_CHAIN (s2))
1505 if (TREE_CODE (s1) != TREE_CODE (s2)
1506 || DECL_NAME (s1) != DECL_NAME (s2))
1508 result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2),
1509 enum_and_int_p, different_types_p);
1513 needs_warning = true;
1515 if (TREE_CODE (s1) == FIELD_DECL
1516 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
1517 DECL_FIELD_BIT_OFFSET (s2)) != 1)
1523 tu->val = needs_warning ? 2 : 1;
1532 /* Return 1 if two function types F1 and F2 are compatible.
1533 If either type specifies no argument types,
1534 the other must specify a fixed number of self-promoting arg types.
1535 Otherwise, if one type specifies only the number of arguments,
1536 the other must specify that number of self-promoting arg types.
1537 Otherwise, the argument types must match.
1538 ENUM_AND_INT_P and DIFFERENT_TYPES_P are as in comptypes_internal. */
1541 function_types_compatible_p (const_tree f1, const_tree f2,
1542 bool *enum_and_int_p, bool *different_types_p)
1545 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1550 ret1 = TREE_TYPE (f1);
1551 ret2 = TREE_TYPE (f2);
1553 /* 'volatile' qualifiers on a function's return type used to mean
1554 the function is noreturn. */
1555 if (TYPE_VOLATILE (ret1) != TYPE_VOLATILE (ret2))
1556 pedwarn (input_location, 0, "function return types not compatible due to %<volatile%>");
1557 if (TYPE_VOLATILE (ret1))
1558 ret1 = build_qualified_type (TYPE_MAIN_VARIANT (ret1),
1559 TYPE_QUALS (ret1) & ~TYPE_QUAL_VOLATILE);
1560 if (TYPE_VOLATILE (ret2))
1561 ret2 = build_qualified_type (TYPE_MAIN_VARIANT (ret2),
1562 TYPE_QUALS (ret2) & ~TYPE_QUAL_VOLATILE);
1563 val = comptypes_internal (ret1, ret2, enum_and_int_p, different_types_p);
1567 args1 = TYPE_ARG_TYPES (f1);
1568 args2 = TYPE_ARG_TYPES (f2);
1570 if (different_types_p != NULL
1571 && (args1 == 0) != (args2 == 0))
1572 *different_types_p = true;
1574 /* An unspecified parmlist matches any specified parmlist
1575 whose argument types don't need default promotions. */
1579 if (!self_promoting_args_p (args2))
1581 /* If one of these types comes from a non-prototype fn definition,
1582 compare that with the other type's arglist.
1583 If they don't match, ask for a warning (but no error). */
1584 if (TYPE_ACTUAL_ARG_TYPES (f1)
1585 && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1),
1586 enum_and_int_p, different_types_p))
1592 if (!self_promoting_args_p (args1))
1594 if (TYPE_ACTUAL_ARG_TYPES (f2)
1595 && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2),
1596 enum_and_int_p, different_types_p))
1601 /* Both types have argument lists: compare them and propagate results. */
1602 val1 = type_lists_compatible_p (args1, args2, enum_and_int_p,
1604 return val1 != 1 ? val1 : val;
1607 /* Check two lists of types for compatibility, returning 0 for
1608 incompatible, 1 for compatible, or 2 for compatible with
1609 warning. ENUM_AND_INT_P and DIFFERENT_TYPES_P are as in
1610 comptypes_internal. */
1613 type_lists_compatible_p (const_tree args1, const_tree args2,
1614 bool *enum_and_int_p, bool *different_types_p)
1616 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1622 tree a1, mv1, a2, mv2;
1623 if (args1 == 0 && args2 == 0)
1625 /* If one list is shorter than the other,
1626 they fail to match. */
1627 if (args1 == 0 || args2 == 0)
1629 mv1 = a1 = TREE_VALUE (args1);
1630 mv2 = a2 = TREE_VALUE (args2);
1631 if (mv1 && mv1 != error_mark_node && TREE_CODE (mv1) != ARRAY_TYPE)
1632 mv1 = TYPE_MAIN_VARIANT (mv1);
1633 if (mv2 && mv2 != error_mark_node && TREE_CODE (mv2) != ARRAY_TYPE)
1634 mv2 = TYPE_MAIN_VARIANT (mv2);
1635 /* A null pointer instead of a type
1636 means there is supposed to be an argument
1637 but nothing is specified about what type it has.
1638 So match anything that self-promotes. */
1639 if (different_types_p != NULL
1640 && (a1 == 0) != (a2 == 0))
1641 *different_types_p = true;
1644 if (c_type_promotes_to (a2) != a2)
1649 if (c_type_promotes_to (a1) != a1)
1652 /* If one of the lists has an error marker, ignore this arg. */
1653 else if (TREE_CODE (a1) == ERROR_MARK
1654 || TREE_CODE (a2) == ERROR_MARK)
1656 else if (!(newval = comptypes_internal (mv1, mv2, enum_and_int_p,
1657 different_types_p)))
1659 if (different_types_p != NULL)
1660 *different_types_p = true;
1661 /* Allow wait (union {union wait *u; int *i} *)
1662 and wait (union wait *) to be compatible. */
1663 if (TREE_CODE (a1) == UNION_TYPE
1664 && (TYPE_NAME (a1) == 0
1665 || TYPE_TRANSPARENT_AGGR (a1))
1666 && TREE_CODE (TYPE_SIZE (a1)) == INTEGER_CST
1667 && tree_int_cst_equal (TYPE_SIZE (a1),
1671 for (memb = TYPE_FIELDS (a1);
1672 memb; memb = DECL_CHAIN (memb))
1674 tree mv3 = TREE_TYPE (memb);
1675 if (mv3 && mv3 != error_mark_node
1676 && TREE_CODE (mv3) != ARRAY_TYPE)
1677 mv3 = TYPE_MAIN_VARIANT (mv3);
1678 if (comptypes_internal (mv3, mv2, enum_and_int_p,
1685 else if (TREE_CODE (a2) == UNION_TYPE
1686 && (TYPE_NAME (a2) == 0
1687 || TYPE_TRANSPARENT_AGGR (a2))
1688 && TREE_CODE (TYPE_SIZE (a2)) == INTEGER_CST
1689 && tree_int_cst_equal (TYPE_SIZE (a2),
1693 for (memb = TYPE_FIELDS (a2);
1694 memb; memb = DECL_CHAIN (memb))
1696 tree mv3 = TREE_TYPE (memb);
1697 if (mv3 && mv3 != error_mark_node
1698 && TREE_CODE (mv3) != ARRAY_TYPE)
1699 mv3 = TYPE_MAIN_VARIANT (mv3);
1700 if (comptypes_internal (mv3, mv1, enum_and_int_p,
1711 /* comptypes said ok, but record if it said to warn. */
1715 args1 = TREE_CHAIN (args1);
1716 args2 = TREE_CHAIN (args2);
1720 /* Compute the size to increment a pointer by. */
1723 c_size_in_bytes (const_tree type)
1725 enum tree_code code = TREE_CODE (type);
1727 if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
1728 return size_one_node;
1730 if (!COMPLETE_OR_VOID_TYPE_P (type))
1732 error ("arithmetic on pointer to an incomplete type");
1733 return size_one_node;
1736 /* Convert in case a char is more than one unit. */
1737 return size_binop_loc (input_location, CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
1738 size_int (TYPE_PRECISION (char_type_node)
1742 /* Return either DECL or its known constant value (if it has one). */
1745 decl_constant_value (tree decl)
1747 if (/* Don't change a variable array bound or initial value to a constant
1748 in a place where a variable is invalid. Note that DECL_INITIAL
1749 isn't valid for a PARM_DECL. */
1750 current_function_decl != 0
1751 && TREE_CODE (decl) != PARM_DECL
1752 && !TREE_THIS_VOLATILE (decl)
1753 && TREE_READONLY (decl)
1754 && DECL_INITIAL (decl) != 0
1755 && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
1756 /* This is invalid if initial value is not constant.
1757 If it has either a function call, a memory reference,
1758 or a variable, then re-evaluating it could give different results. */
1759 && TREE_CONSTANT (DECL_INITIAL (decl))
1760 /* Check for cases where this is sub-optimal, even though valid. */
1761 && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
1762 return DECL_INITIAL (decl);
1766 /* Convert the array expression EXP to a pointer. */
1768 array_to_pointer_conversion (location_t loc, tree exp)
1770 tree orig_exp = exp;
1771 tree type = TREE_TYPE (exp);
1773 tree restype = TREE_TYPE (type);
1776 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
1778 STRIP_TYPE_NOPS (exp);
1780 if (TREE_NO_WARNING (orig_exp))
1781 TREE_NO_WARNING (exp) = 1;
1783 ptrtype = build_pointer_type (restype);
1785 if (TREE_CODE (exp) == INDIRECT_REF)
1786 return convert (ptrtype, TREE_OPERAND (exp, 0));
1788 adr = build_unary_op (loc, ADDR_EXPR, exp, 1);
1789 return convert (ptrtype, adr);
1792 /* Convert the function expression EXP to a pointer. */
1794 function_to_pointer_conversion (location_t loc, tree exp)
1796 tree orig_exp = exp;
1798 gcc_assert (TREE_CODE (TREE_TYPE (exp)) == FUNCTION_TYPE);
1800 STRIP_TYPE_NOPS (exp);
1802 if (TREE_NO_WARNING (orig_exp))
1803 TREE_NO_WARNING (exp) = 1;
1805 return build_unary_op (loc, ADDR_EXPR, exp, 0);
1808 /* Mark EXP as read, not just set, for set but not used -Wunused
1809 warning purposes. */
1812 mark_exp_read (tree exp)
1814 switch (TREE_CODE (exp))
1818 DECL_READ_P (exp) = 1;
1827 mark_exp_read (TREE_OPERAND (exp, 0));
1830 case C_MAYBE_CONST_EXPR:
1831 mark_exp_read (TREE_OPERAND (exp, 1));
1838 /* Perform the default conversion of arrays and functions to pointers.
1839 Return the result of converting EXP. For any other expression, just
1842 LOC is the location of the expression. */
1845 default_function_array_conversion (location_t loc, struct c_expr exp)
1847 tree orig_exp = exp.value;
1848 tree type = TREE_TYPE (exp.value);
1849 enum tree_code code = TREE_CODE (type);
1855 bool not_lvalue = false;
1856 bool lvalue_array_p;
1858 while ((TREE_CODE (exp.value) == NON_LVALUE_EXPR
1859 || CONVERT_EXPR_P (exp.value))
1860 && TREE_TYPE (TREE_OPERAND (exp.value, 0)) == type)
1862 if (TREE_CODE (exp.value) == NON_LVALUE_EXPR)
1864 exp.value = TREE_OPERAND (exp.value, 0);
1867 if (TREE_NO_WARNING (orig_exp))
1868 TREE_NO_WARNING (exp.value) = 1;
1870 lvalue_array_p = !not_lvalue && lvalue_p (exp.value);
1871 if (!flag_isoc99 && !lvalue_array_p)
1873 /* Before C99, non-lvalue arrays do not decay to pointers.
1874 Normally, using such an array would be invalid; but it can
1875 be used correctly inside sizeof or as a statement expression.
1876 Thus, do not give an error here; an error will result later. */
1880 exp.value = array_to_pointer_conversion (loc, exp.value);
1884 exp.value = function_to_pointer_conversion (loc, exp.value);
1894 default_function_array_read_conversion (location_t loc, struct c_expr exp)
1896 mark_exp_read (exp.value);
1897 return default_function_array_conversion (loc, exp);
1900 /* EXP is an expression of integer type. Apply the integer promotions
1901 to it and return the promoted value. */
1904 perform_integral_promotions (tree exp)
1906 tree type = TREE_TYPE (exp);
1907 enum tree_code code = TREE_CODE (type);
1909 gcc_assert (INTEGRAL_TYPE_P (type));
1911 /* Normally convert enums to int,
1912 but convert wide enums to something wider. */
1913 if (code == ENUMERAL_TYPE)
1915 type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
1916 TYPE_PRECISION (integer_type_node)),
1917 ((TYPE_PRECISION (type)
1918 >= TYPE_PRECISION (integer_type_node))
1919 && TYPE_UNSIGNED (type)));
1921 return convert (type, exp);
1924 /* ??? This should no longer be needed now bit-fields have their
1926 if (TREE_CODE (exp) == COMPONENT_REF
1927 && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1))
1928 /* If it's thinner than an int, promote it like a
1929 c_promoting_integer_type_p, otherwise leave it alone. */
1930 && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
1931 TYPE_PRECISION (integer_type_node)))
1932 return convert (integer_type_node, exp);
1934 if (c_promoting_integer_type_p (type))
1936 /* Preserve unsignedness if not really getting any wider. */
1937 if (TYPE_UNSIGNED (type)
1938 && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1939 return convert (unsigned_type_node, exp);
1941 return convert (integer_type_node, exp);
1948 /* Perform default promotions for C data used in expressions.
1949 Enumeral types or short or char are converted to int.
1950 In addition, manifest constants symbols are replaced by their values. */
1953 default_conversion (tree exp)
1956 tree type = TREE_TYPE (exp);
1957 enum tree_code code = TREE_CODE (type);
1960 mark_exp_read (exp);
1962 /* Functions and arrays have been converted during parsing. */
1963 gcc_assert (code != FUNCTION_TYPE);
1964 if (code == ARRAY_TYPE)
1967 /* Constants can be used directly unless they're not loadable. */
1968 if (TREE_CODE (exp) == CONST_DECL)
1969 exp = DECL_INITIAL (exp);
1971 /* Strip no-op conversions. */
1973 STRIP_TYPE_NOPS (exp);
1975 if (TREE_NO_WARNING (orig_exp))
1976 TREE_NO_WARNING (exp) = 1;
1978 if (code == VOID_TYPE)
1980 error ("void value not ignored as it ought to be");
1981 return error_mark_node;
1984 exp = require_complete_type (exp);
1985 if (exp == error_mark_node)
1986 return error_mark_node;
1988 promoted_type = targetm.promoted_type (type);
1990 return convert (promoted_type, exp);
1992 if (INTEGRAL_TYPE_P (type))
1993 return perform_integral_promotions (exp);
1998 /* Look up COMPONENT in a structure or union TYPE.
2000 If the component name is not found, returns NULL_TREE. Otherwise,
2001 the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL
2002 stepping down the chain to the component, which is in the last
2003 TREE_VALUE of the list. Normally the list is of length one, but if
2004 the component is embedded within (nested) anonymous structures or
2005 unions, the list steps down the chain to the component. */
2008 lookup_field (tree type, tree component)
2012 /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
2013 to the field elements. Use a binary search on this array to quickly
2014 find the element. Otherwise, do a linear search. TYPE_LANG_SPECIFIC
2015 will always be set for structures which have many elements. */
2017 if (TYPE_LANG_SPECIFIC (type) && TYPE_LANG_SPECIFIC (type)->s)
2020 tree *field_array = &TYPE_LANG_SPECIFIC (type)->s->elts[0];
2022 field = TYPE_FIELDS (type);
2024 top = TYPE_LANG_SPECIFIC (type)->s->len;
2025 while (top - bot > 1)
2027 half = (top - bot + 1) >> 1;
2028 field = field_array[bot+half];
2030 if (DECL_NAME (field) == NULL_TREE)
2032 /* Step through all anon unions in linear fashion. */
2033 while (DECL_NAME (field_array[bot]) == NULL_TREE)
2035 field = field_array[bot++];
2036 if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
2037 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
2039 tree anon = lookup_field (TREE_TYPE (field), component);
2042 return tree_cons (NULL_TREE, field, anon);
2044 /* The Plan 9 compiler permits referring
2045 directly to an anonymous struct/union field
2046 using a typedef name. */
2047 if (flag_plan9_extensions
2048 && TYPE_NAME (TREE_TYPE (field)) != NULL_TREE
2049 && (TREE_CODE (TYPE_NAME (TREE_TYPE (field)))
2051 && (DECL_NAME (TYPE_NAME (TREE_TYPE (field)))
2057 /* Entire record is only anon unions. */
2061 /* Restart the binary search, with new lower bound. */
2065 if (DECL_NAME (field) == component)
2067 if (DECL_NAME (field) < component)
2073 if (DECL_NAME (field_array[bot]) == component)
2074 field = field_array[bot];
2075 else if (DECL_NAME (field) != component)
2080 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
2082 if (DECL_NAME (field) == NULL_TREE
2083 && (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
2084 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE))
2086 tree anon = lookup_field (TREE_TYPE (field), component);
2089 return tree_cons (NULL_TREE, field, anon);
2091 /* The Plan 9 compiler permits referring directly to an
2092 anonymous struct/union field using a typedef
2094 if (flag_plan9_extensions
2095 && TYPE_NAME (TREE_TYPE (field)) != NULL_TREE
2096 && TREE_CODE (TYPE_NAME (TREE_TYPE (field))) == TYPE_DECL
2097 && (DECL_NAME (TYPE_NAME (TREE_TYPE (field)))
2102 if (DECL_NAME (field) == component)
2106 if (field == NULL_TREE)
2110 return tree_cons (NULL_TREE, field, NULL_TREE);
2113 /* Make an expression to refer to the COMPONENT field of structure or
2114 union value DATUM. COMPONENT is an IDENTIFIER_NODE. LOC is the
2115 location of the COMPONENT_REF. */
2118 build_component_ref (location_t loc, tree datum, tree component)
2120 tree type = TREE_TYPE (datum);
2121 enum tree_code code = TREE_CODE (type);
2124 bool datum_lvalue = lvalue_p (datum);
2126 if (!objc_is_public (datum, component))
2127 return error_mark_node;
2129 /* Detect Objective-C property syntax object.property. */
2130 if (c_dialect_objc ()
2131 && (ref = objc_maybe_build_component_ref (datum, component)))
2134 /* See if there is a field or component with name COMPONENT. */
2136 if (code == RECORD_TYPE || code == UNION_TYPE)
2138 if (!COMPLETE_TYPE_P (type))
2140 c_incomplete_type_error (NULL_TREE, type);
2141 return error_mark_node;
2144 field = lookup_field (type, component);
2148 error_at (loc, "%qT has no member named %qE", type, component);
2149 return error_mark_node;
2152 /* Chain the COMPONENT_REFs if necessary down to the FIELD.
2153 This might be better solved in future the way the C++ front
2154 end does it - by giving the anonymous entities each a
2155 separate name and type, and then have build_component_ref
2156 recursively call itself. We can't do that here. */
2159 tree subdatum = TREE_VALUE (field);
2162 bool use_datum_quals;
2164 if (TREE_TYPE (subdatum) == error_mark_node)
2165 return error_mark_node;
2167 /* If this is an rvalue, it does not have qualifiers in C
2168 standard terms and we must avoid propagating such
2169 qualifiers down to a non-lvalue array that is then
2170 converted to a pointer. */
2171 use_datum_quals = (datum_lvalue
2172 || TREE_CODE (TREE_TYPE (subdatum)) != ARRAY_TYPE);
2174 quals = TYPE_QUALS (strip_array_types (TREE_TYPE (subdatum)));
2175 if (use_datum_quals)
2176 quals |= TYPE_QUALS (TREE_TYPE (datum));
2177 subtype = c_build_qualified_type (TREE_TYPE (subdatum), quals);
2179 ref = build3 (COMPONENT_REF, subtype, datum, subdatum,
2181 SET_EXPR_LOCATION (ref, loc);
2182 if (TREE_READONLY (subdatum)
2183 || (use_datum_quals && TREE_READONLY (datum)))
2184 TREE_READONLY (ref) = 1;
2185 if (TREE_THIS_VOLATILE (subdatum)
2186 || (use_datum_quals && TREE_THIS_VOLATILE (datum)))
2187 TREE_THIS_VOLATILE (ref) = 1;
2189 if (TREE_DEPRECATED (subdatum))
2190 warn_deprecated_use (subdatum, NULL_TREE);
2194 field = TREE_CHAIN (field);
2200 else if (code != ERROR_MARK)
2202 "request for member %qE in something not a structure or union",
2205 return error_mark_node;
2208 /* Given an expression PTR for a pointer, return an expression
2209 for the value pointed to.
2210 ERRORSTRING is the name of the operator to appear in error messages.
2212 LOC is the location to use for the generated tree. */
2215 build_indirect_ref (location_t loc, tree ptr, ref_operator errstring)
2217 tree pointer = default_conversion (ptr);
2218 tree type = TREE_TYPE (pointer);
2221 if (TREE_CODE (type) == POINTER_TYPE)
2223 if (CONVERT_EXPR_P (pointer)
2224 || TREE_CODE (pointer) == VIEW_CONVERT_EXPR)
2226 /* If a warning is issued, mark it to avoid duplicates from
2227 the backend. This only needs to be done at
2228 warn_strict_aliasing > 2. */
2229 if (warn_strict_aliasing > 2)
2230 if (strict_aliasing_warning (TREE_TYPE (TREE_OPERAND (pointer, 0)),
2231 type, TREE_OPERAND (pointer, 0)))
2232 TREE_NO_WARNING (pointer) = 1;
2235 if (TREE_CODE (pointer) == ADDR_EXPR
2236 && (TREE_TYPE (TREE_OPERAND (pointer, 0))
2237 == TREE_TYPE (type)))
2239 ref = TREE_OPERAND (pointer, 0);
2240 protected_set_expr_location (ref, loc);
2245 tree t = TREE_TYPE (type);
2247 ref = build1 (INDIRECT_REF, t, pointer);
2249 if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE)
2251 error_at (loc, "dereferencing pointer to incomplete type");
2252 return error_mark_node;
2254 if (VOID_TYPE_P (t) && c_inhibit_evaluation_warnings == 0)
2255 warning_at (loc, 0, "dereferencing %<void *%> pointer");
2257 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2258 so that we get the proper error message if the result is used
2259 to assign to. Also, &* is supposed to be a no-op.
2260 And ANSI C seems to specify that the type of the result
2261 should be the const type. */
2262 /* A de-reference of a pointer to const is not a const. It is valid
2263 to change it via some other pointer. */
2264 TREE_READONLY (ref) = TYPE_READONLY (t);
2265 TREE_SIDE_EFFECTS (ref)
2266 = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer);
2267 TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
2268 protected_set_expr_location (ref, loc);
2272 else if (TREE_CODE (pointer) != ERROR_MARK)
2273 invalid_indirection_error (loc, type, errstring);
2275 return error_mark_node;
2278 /* This handles expressions of the form "a[i]", which denotes
2281 This is logically equivalent in C to *(a+i), but we may do it differently.
2282 If A is a variable or a member, we generate a primitive ARRAY_REF.
2283 This avoids forcing the array out of registers, and can work on
2284 arrays that are not lvalues (for example, members of structures returned
2287 For vector types, allow vector[i] but not i[vector], and create
2288 *(((type*)&vectortype) + i) for the expression.
2290 LOC is the location to use for the returned expression. */
2293 build_array_ref (location_t loc, tree array, tree index)
2296 bool swapped = false;
2297 if (TREE_TYPE (array) == error_mark_node
2298 || TREE_TYPE (index) == error_mark_node)
2299 return error_mark_node;
2301 if (TREE_CODE (TREE_TYPE (array)) != ARRAY_TYPE
2302 && TREE_CODE (TREE_TYPE (array)) != POINTER_TYPE
2303 /* Allow vector[index] but not index[vector]. */
2304 && TREE_CODE (TREE_TYPE (array)) != VECTOR_TYPE)
2307 if (TREE_CODE (TREE_TYPE (index)) != ARRAY_TYPE
2308 && TREE_CODE (TREE_TYPE (index)) != POINTER_TYPE)
2311 "subscripted value is neither array nor pointer nor vector");
2313 return error_mark_node;
2321 if (!INTEGRAL_TYPE_P (TREE_TYPE (index)))
2323 error_at (loc, "array subscript is not an integer");
2324 return error_mark_node;
2327 if (TREE_CODE (TREE_TYPE (TREE_TYPE (array))) == FUNCTION_TYPE)
2329 error_at (loc, "subscripted value is pointer to function");
2330 return error_mark_node;
2333 /* ??? Existing practice has been to warn only when the char
2334 index is syntactically the index, not for char[array]. */
2336 warn_array_subscript_with_type_char (index);
2338 /* Apply default promotions *after* noticing character types. */
2339 index = default_conversion (index);
2341 gcc_assert (TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE);
2343 /* For vector[index], convert the vector to a
2344 pointer of the underlying type. */
2345 if (TREE_CODE (TREE_TYPE (array)) == VECTOR_TYPE)
2347 tree type = TREE_TYPE (array);
2350 if (TREE_CODE (index) == INTEGER_CST)
2351 if (!host_integerp (index, 1)
2352 || ((unsigned HOST_WIDE_INT) tree_low_cst (index, 1)
2353 >= TYPE_VECTOR_SUBPARTS (TREE_TYPE (array))))
2354 warning_at (loc, OPT_Warray_bounds, "index value is out of bound");
2356 c_common_mark_addressable_vec (array);
2357 type = build_qualified_type (TREE_TYPE (type), TYPE_QUALS (type));
2358 type = build_pointer_type (type);
2359 type1 = build_pointer_type (TREE_TYPE (array));
2360 array = build1 (ADDR_EXPR, type1, array);
2361 array = convert (type, array);
2364 if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE)
2368 /* An array that is indexed by a non-constant
2369 cannot be stored in a register; we must be able to do
2370 address arithmetic on its address.
2371 Likewise an array of elements of variable size. */
2372 if (TREE_CODE (index) != INTEGER_CST
2373 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
2374 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
2376 if (!c_mark_addressable (array))
2377 return error_mark_node;
2379 /* An array that is indexed by a constant value which is not within
2380 the array bounds cannot be stored in a register either; because we
2381 would get a crash in store_bit_field/extract_bit_field when trying
2382 to access a non-existent part of the register. */
2383 if (TREE_CODE (index) == INTEGER_CST
2384 && TYPE_DOMAIN (TREE_TYPE (array))
2385 && !int_fits_type_p (index, TYPE_DOMAIN (TREE_TYPE (array))))
2387 if (!c_mark_addressable (array))
2388 return error_mark_node;
2394 while (TREE_CODE (foo) == COMPONENT_REF)
2395 foo = TREE_OPERAND (foo, 0);
2396 if (TREE_CODE (foo) == VAR_DECL && C_DECL_REGISTER (foo))
2397 pedwarn (loc, OPT_pedantic,
2398 "ISO C forbids subscripting %<register%> array");
2399 else if (!flag_isoc99 && !lvalue_p (foo))
2400 pedwarn (loc, OPT_pedantic,
2401 "ISO C90 forbids subscripting non-lvalue array");
2404 type = TREE_TYPE (TREE_TYPE (array));
2405 rval = build4 (ARRAY_REF, type, array, index, NULL_TREE, NULL_TREE);
2406 /* Array ref is const/volatile if the array elements are
2407 or if the array is. */
2408 TREE_READONLY (rval)
2409 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
2410 | TREE_READONLY (array));
2411 TREE_SIDE_EFFECTS (rval)
2412 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
2413 | TREE_SIDE_EFFECTS (array));
2414 TREE_THIS_VOLATILE (rval)
2415 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
2416 /* This was added by rms on 16 Nov 91.
2417 It fixes vol struct foo *a; a->elts[1]
2418 in an inline function.
2419 Hope it doesn't break something else. */
2420 | TREE_THIS_VOLATILE (array));
2421 ret = require_complete_type (rval);
2422 protected_set_expr_location (ret, loc);
2427 tree ar = default_conversion (array);
2429 if (ar == error_mark_node)
2432 gcc_assert (TREE_CODE (TREE_TYPE (ar)) == POINTER_TYPE);
2433 gcc_assert (TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) != FUNCTION_TYPE);
2435 return build_indirect_ref
2436 (loc, build_binary_op (loc, PLUS_EXPR, ar, index, 0),
2441 /* Build an external reference to identifier ID. FUN indicates
2442 whether this will be used for a function call. LOC is the source
2443 location of the identifier. This sets *TYPE to the type of the
2444 identifier, which is not the same as the type of the returned value
2445 for CONST_DECLs defined as enum constants. If the type of the
2446 identifier is not available, *TYPE is set to NULL. */
2448 build_external_ref (location_t loc, tree id, int fun, tree *type)
2451 tree decl = lookup_name (id);
2453 /* In Objective-C, an instance variable (ivar) may be preferred to
2454 whatever lookup_name() found. */
2455 decl = objc_lookup_ivar (decl, id);
2458 if (decl && decl != error_mark_node)
2461 *type = TREE_TYPE (ref);
2464 /* Implicit function declaration. */
2465 ref = implicitly_declare (loc, id);
2466 else if (decl == error_mark_node)
2467 /* Don't complain about something that's already been
2468 complained about. */
2469 return error_mark_node;
2472 undeclared_variable (loc, id);
2473 return error_mark_node;
2476 if (TREE_TYPE (ref) == error_mark_node)
2477 return error_mark_node;
2479 if (TREE_DEPRECATED (ref))
2480 warn_deprecated_use (ref, NULL_TREE);
2482 /* Recursive call does not count as usage. */
2483 if (ref != current_function_decl)
2485 TREE_USED (ref) = 1;
2488 if (TREE_CODE (ref) == FUNCTION_DECL && !in_alignof)
2490 if (!in_sizeof && !in_typeof)
2491 C_DECL_USED (ref) = 1;
2492 else if (DECL_INITIAL (ref) == 0
2493 && DECL_EXTERNAL (ref)
2494 && !TREE_PUBLIC (ref))
2495 record_maybe_used_decl (ref);
2498 if (TREE_CODE (ref) == CONST_DECL)
2500 used_types_insert (TREE_TYPE (ref));
2503 && TREE_CODE (TREE_TYPE (ref)) == ENUMERAL_TYPE
2504 && C_TYPE_DEFINED_IN_STRUCT (TREE_TYPE (ref)))
2506 warning_at (loc, OPT_Wc___compat,
2507 ("enum constant defined in struct or union "
2508 "is not visible in C++"));
2509 inform (DECL_SOURCE_LOCATION (ref), "enum constant defined here");
2512 ref = DECL_INITIAL (ref);
2513 TREE_CONSTANT (ref) = 1;
2515 else if (current_function_decl != 0
2516 && !DECL_FILE_SCOPE_P (current_function_decl)
2517 && (TREE_CODE (ref) == VAR_DECL
2518 || TREE_CODE (ref) == PARM_DECL
2519 || TREE_CODE (ref) == FUNCTION_DECL))
2521 tree context = decl_function_context (ref);
2523 if (context != 0 && context != current_function_decl)
2524 DECL_NONLOCAL (ref) = 1;
2526 /* C99 6.7.4p3: An inline definition of a function with external
2527 linkage ... shall not contain a reference to an identifier with
2528 internal linkage. */
2529 else if (current_function_decl != 0
2530 && DECL_DECLARED_INLINE_P (current_function_decl)
2531 && DECL_EXTERNAL (current_function_decl)
2532 && VAR_OR_FUNCTION_DECL_P (ref)
2533 && (TREE_CODE (ref) != VAR_DECL || TREE_STATIC (ref))
2534 && ! TREE_PUBLIC (ref)
2535 && DECL_CONTEXT (ref) != current_function_decl)
2536 record_inline_static (loc, current_function_decl, ref,
2542 /* Record details of decls possibly used inside sizeof or typeof. */
2543 struct maybe_used_decl
2547 /* The level seen at (in_sizeof + in_typeof). */
2549 /* The next one at this level or above, or NULL. */
2550 struct maybe_used_decl *next;
2553 static struct maybe_used_decl *maybe_used_decls;
2555 /* Record that DECL, an undefined static function reference seen
2556 inside sizeof or typeof, might be used if the operand of sizeof is
2557 a VLA type or the operand of typeof is a variably modified
2561 record_maybe_used_decl (tree decl)
2563 struct maybe_used_decl *t = XOBNEW (&parser_obstack, struct maybe_used_decl);
2565 t->level = in_sizeof + in_typeof;
2566 t->next = maybe_used_decls;
2567 maybe_used_decls = t;
2570 /* Pop the stack of decls possibly used inside sizeof or typeof. If
2571 USED is false, just discard them. If it is true, mark them used
2572 (if no longer inside sizeof or typeof) or move them to the next
2573 level up (if still inside sizeof or typeof). */
2576 pop_maybe_used (bool used)
2578 struct maybe_used_decl *p = maybe_used_decls;
2579 int cur_level = in_sizeof + in_typeof;
2580 while (p && p->level > cur_level)
2585 C_DECL_USED (p->decl) = 1;
2587 p->level = cur_level;
2591 if (!used || cur_level == 0)
2592 maybe_used_decls = p;
2595 /* Return the result of sizeof applied to EXPR. */
2598 c_expr_sizeof_expr (location_t loc, struct c_expr expr)
2601 if (expr.value == error_mark_node)
2603 ret.value = error_mark_node;
2604 ret.original_code = ERROR_MARK;
2605 ret.original_type = NULL;
2606 pop_maybe_used (false);
2610 bool expr_const_operands = true;
2611 tree folded_expr = c_fully_fold (expr.value, require_constant_value,
2612 &expr_const_operands);
2613 ret.value = c_sizeof (loc, TREE_TYPE (folded_expr));
2614 ret.original_code = ERROR_MARK;
2615 ret.original_type = NULL;
2616 if (c_vla_type_p (TREE_TYPE (folded_expr)))
2618 /* sizeof is evaluated when given a vla (C99 6.5.3.4p2). */
2619 ret.value = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (ret.value),
2620 folded_expr, ret.value);
2621 C_MAYBE_CONST_EXPR_NON_CONST (ret.value) = !expr_const_operands;
2622 SET_EXPR_LOCATION (ret.value, loc);
2624 pop_maybe_used (C_TYPE_VARIABLE_SIZE (TREE_TYPE (folded_expr)));
2629 /* Return the result of sizeof applied to T, a structure for the type
2630 name passed to sizeof (rather than the type itself). LOC is the
2631 location of the original expression. */
2634 c_expr_sizeof_type (location_t loc, struct c_type_name *t)
2638 tree type_expr = NULL_TREE;
2639 bool type_expr_const = true;
2640 type = groktypename (t, &type_expr, &type_expr_const);
2641 ret.value = c_sizeof (loc, type);
2642 ret.original_code = ERROR_MARK;
2643 ret.original_type = NULL;
2644 if ((type_expr || TREE_CODE (ret.value) == INTEGER_CST)
2645 && c_vla_type_p (type))
2647 /* If the type is a [*] array, it is a VLA but is represented as
2648 having a size of zero. In such a case we must ensure that
2649 the result of sizeof does not get folded to a constant by
2650 c_fully_fold, because if the size is evaluated the result is
2651 not constant and so constraints on zero or negative size
2652 arrays must not be applied when this sizeof call is inside
2653 another array declarator. */
2655 type_expr = integer_zero_node;
2656 ret.value = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (ret.value),
2657 type_expr, ret.value);
2658 C_MAYBE_CONST_EXPR_NON_CONST (ret.value) = !type_expr_const;
2660 pop_maybe_used (type != error_mark_node
2661 ? C_TYPE_VARIABLE_SIZE (type) : false);
2665 /* Build a function call to function FUNCTION with parameters PARAMS.
2666 The function call is at LOC.
2667 PARAMS is a list--a chain of TREE_LIST nodes--in which the
2668 TREE_VALUE of each node is a parameter-expression.
2669 FUNCTION's data type may be a function type or a pointer-to-function. */
2672 build_function_call (location_t loc, tree function, tree params)
2677 vec = VEC_alloc (tree, gc, list_length (params));
2678 for (; params; params = TREE_CHAIN (params))
2679 VEC_quick_push (tree, vec, TREE_VALUE (params));
2680 ret = build_function_call_vec (loc, function, vec, NULL);
2681 VEC_free (tree, gc, vec);
2685 /* Build a function call to function FUNCTION with parameters PARAMS.
2686 ORIGTYPES, if not NULL, is a vector of types; each element is
2687 either NULL or the original type of the corresponding element in
2688 PARAMS. The original type may differ from TREE_TYPE of the
2689 parameter for enums. FUNCTION's data type may be a function type
2690 or pointer-to-function. This function changes the elements of
2694 build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
2695 VEC(tree,gc) *origtypes)
2697 tree fntype, fundecl = 0;
2698 tree name = NULL_TREE, result;
2704 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
2705 STRIP_TYPE_NOPS (function);
2707 /* Convert anything with function type to a pointer-to-function. */
2708 if (TREE_CODE (function) == FUNCTION_DECL)
2710 /* Implement type-directed function overloading for builtins.
2711 resolve_overloaded_builtin and targetm.resolve_overloaded_builtin
2712 handle all the type checking. The result is a complete expression
2713 that implements this function call. */
2714 tem = resolve_overloaded_builtin (loc, function, params);
2718 name = DECL_NAME (function);
2721 if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE)
2722 function = function_to_pointer_conversion (loc, function);
2724 /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
2725 expressions, like those used for ObjC messenger dispatches. */
2726 if (!VEC_empty (tree, params))
2727 function = objc_rewrite_function_call (function,
2728 VEC_index (tree, params, 0));
2730 function = c_fully_fold (function, false, NULL);
2732 fntype = TREE_TYPE (function);
2734 if (TREE_CODE (fntype) == ERROR_MARK)
2735 return error_mark_node;
2737 if (!(TREE_CODE (fntype) == POINTER_TYPE
2738 && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
2740 error_at (loc, "called object %qE is not a function", function);
2741 return error_mark_node;
2744 if (fundecl && TREE_THIS_VOLATILE (fundecl))
2745 current_function_returns_abnormally = 1;
2747 /* fntype now gets the type of function pointed to. */
2748 fntype = TREE_TYPE (fntype);
2750 /* Convert the parameters to the types declared in the
2751 function prototype, or apply default promotions. */
2753 nargs = convert_arguments (TYPE_ARG_TYPES (fntype), params, origtypes,
2756 return error_mark_node;
2758 /* Check that the function is called through a compatible prototype.
2759 If it is not, replace the call by a trap, wrapped up in a compound
2760 expression if necessary. This has the nice side-effect to prevent
2761 the tree-inliner from generating invalid assignment trees which may
2762 blow up in the RTL expander later. */
2763 if (CONVERT_EXPR_P (function)
2764 && TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR
2765 && TREE_CODE (tem = TREE_OPERAND (tem, 0)) == FUNCTION_DECL
2766 && !comptypes (fntype, TREE_TYPE (tem)))
2768 tree return_type = TREE_TYPE (fntype);
2769 tree trap = build_function_call (loc, built_in_decls[BUILT_IN_TRAP],
2773 /* This situation leads to run-time undefined behavior. We can't,
2774 therefore, simply error unless we can prove that all possible
2775 executions of the program must execute the code. */
2776 if (warning_at (loc, 0, "function called through a non-compatible type"))
2777 /* We can, however, treat "undefined" any way we please.
2778 Call abort to encourage the user to fix the program. */
2779 inform (loc, "if this code is reached, the program will abort");
2780 /* Before the abort, allow the function arguments to exit or
2782 for (i = 0; i < nargs; i++)
2783 trap = build2 (COMPOUND_EXPR, void_type_node,
2784 VEC_index (tree, params, i), trap);
2786 if (VOID_TYPE_P (return_type))
2788 if (TYPE_QUALS (return_type) != TYPE_UNQUALIFIED)
2790 "function with qualified void return type called");
2797 if (AGGREGATE_TYPE_P (return_type))
2798 rhs = build_compound_literal (loc, return_type,
2799 build_constructor (return_type, 0),
2802 rhs = build_zero_cst (return_type);
2804 return require_complete_type (build2 (COMPOUND_EXPR, return_type,
2809 argarray = VEC_address (tree, params);
2811 /* Check that arguments to builtin functions match the expectations. */
2813 && DECL_BUILT_IN (fundecl)
2814 && DECL_BUILT_IN_CLASS (fundecl) == BUILT_IN_NORMAL
2815 && !check_builtin_function_arguments (fundecl, nargs, argarray))
2816 return error_mark_node;
2818 /* Check that the arguments to the function are valid. */
2819 check_function_arguments (fntype, nargs, argarray);
2821 if (name != NULL_TREE
2822 && !strncmp (IDENTIFIER_POINTER (name), "__builtin_", 10))
2824 if (require_constant_value)
2826 fold_build_call_array_initializer_loc (loc, TREE_TYPE (fntype),
2827 function, nargs, argarray);
2829 result = fold_build_call_array_loc (loc, TREE_TYPE (fntype),
2830 function, nargs, argarray);
2831 if (TREE_CODE (result) == NOP_EXPR
2832 && TREE_CODE (TREE_OPERAND (result, 0)) == INTEGER_CST)
2833 STRIP_TYPE_NOPS (result);
2836 result = build_call_array_loc (loc, TREE_TYPE (fntype),
2837 function, nargs, argarray);
2839 if (VOID_TYPE_P (TREE_TYPE (result)))
2841 if (TYPE_QUALS (TREE_TYPE (result)) != TYPE_UNQUALIFIED)
2843 "function with qualified void return type called");
2846 return require_complete_type (result);
2849 /* Build a VEC_SHUFFLE_EXPR if V0, V1 and MASK are not error_mark_nodes
2850 and have vector types, V0 has the same type as V1, and the number of
2851 elements of V0, V1, MASK is the same.
2853 In case V1 is a NULL_TREE it is assumed that __builtin_shuffle was
2854 called with two arguments. In this case implementation passes the
2855 first argument twice in order to share the same tree code. This fact
2856 could enable the mask-values being twice the vector length. This is
2857 an implementation accident and this semantics is not guaranteed to
2860 c_build_vec_shuffle_expr (location_t loc, tree v0, tree v1, tree mask)
2864 bool maybe_const = false;
2865 bool two_arguments = false;
2867 if (v1 == NULL_TREE)
2869 two_arguments = true;
2873 if (v0 == error_mark_node || v1 == error_mark_node
2874 || mask == error_mark_node)
2875 return error_mark_node;
2877 if (TREE_CODE (TREE_TYPE (mask)) != VECTOR_TYPE
2878 || TREE_CODE (TREE_TYPE (TREE_TYPE (mask))) != INTEGER_TYPE)
2880 error_at (loc, "__builtin_shuffle last argument must "
2881 "be an integer vector");
2882 return error_mark_node;
2885 if (TREE_CODE (TREE_TYPE (v0)) != VECTOR_TYPE
2886 || TREE_CODE (TREE_TYPE (v1)) != VECTOR_TYPE)
2888 error_at (loc, "__builtin_shuffle arguments must be vectors");
2889 return error_mark_node;
2892 if (TYPE_MAIN_VARIANT (TREE_TYPE (v0)) != TYPE_MAIN_VARIANT (TREE_TYPE (v1)))
2894 error_at (loc, "__builtin_shuffle argument vectors must be of "
2896 return error_mark_node;
2899 if (TYPE_VECTOR_SUBPARTS (TREE_TYPE (v0))
2900 != TYPE_VECTOR_SUBPARTS (TREE_TYPE (mask))
2901 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (v1))
2902 != TYPE_VECTOR_SUBPARTS (TREE_TYPE (mask)))
2904 error_at (loc, "__builtin_shuffle number of elements of the "
2905 "argument vector(s) and the mask vector should "
2907 return error_mark_node;
2910 if (GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (v0))))
2911 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (mask)))))
2913 error_at (loc, "__builtin_shuffle argument vector(s) inner type "
2914 "must have the same size as inner type of the mask");
2915 return error_mark_node;
2918 /* Avoid C_MAYBE_CONST_EXPRs inside VEC_SHUFFLE_EXPR. */
2919 v0 = c_fully_fold (v0, false, &maybe_const);
2920 wrap &= maybe_const;
2923 v1 = v0 = save_expr (v0);
2926 v1 = c_fully_fold (v1, false, &maybe_const);
2927 wrap &= maybe_const;
2930 mask = c_fully_fold (mask, false, &maybe_const);
2931 wrap &= maybe_const;
2933 vec_shuffle = build3 (VEC_SHUFFLE_EXPR, TREE_TYPE (v0), v0, v1, mask);
2936 vec_shuffle = c_wrap_maybe_const (vec_shuffle, true);
2941 /* Convert the argument expressions in the vector VALUES
2942 to the types in the list TYPELIST.
2944 If TYPELIST is exhausted, or when an element has NULL as its type,
2945 perform the default conversions.
2947 ORIGTYPES is the original types of the expressions in VALUES. This
2948 holds the type of enum values which have been converted to integral
2949 types. It may be NULL.
2951 FUNCTION is a tree for the called function. It is used only for
2952 error messages, where it is formatted with %qE.
2954 This is also where warnings about wrong number of args are generated.
2956 Returns the actual number of arguments processed (which may be less
2957 than the length of VALUES in some error situations), or -1 on
2961 convert_arguments (tree typelist, VEC(tree,gc) *values,
2962 VEC(tree,gc) *origtypes, tree function, tree fundecl)
2965 unsigned int parmnum;
2966 bool error_args = false;
2967 const bool type_generic = fundecl
2968 && lookup_attribute ("type generic", TYPE_ATTRIBUTES(TREE_TYPE (fundecl)));
2969 bool type_generic_remove_excess_precision = false;
2972 /* Change pointer to function to the function itself for
2974 if (TREE_CODE (function) == ADDR_EXPR
2975 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
2976 function = TREE_OPERAND (function, 0);
2978 /* Handle an ObjC selector specially for diagnostics. */
2979 selector = objc_message_selector ();
2981 /* For type-generic built-in functions, determine whether excess
2982 precision should be removed (classification) or not
2985 && DECL_BUILT_IN (fundecl)
2986 && DECL_BUILT_IN_CLASS (fundecl) == BUILT_IN_NORMAL)
2988 switch (DECL_FUNCTION_CODE (fundecl))
2990 case BUILT_IN_ISFINITE:
2991 case BUILT_IN_ISINF:
2992 case BUILT_IN_ISINF_SIGN:
2993 case BUILT_IN_ISNAN:
2994 case BUILT_IN_ISNORMAL:
2995 case BUILT_IN_FPCLASSIFY:
2996 type_generic_remove_excess_precision = true;
3000 type_generic_remove_excess_precision = false;
3005 /* Scan the given expressions and types, producing individual
3006 converted arguments. */
3008 for (typetail = typelist, parmnum = 0;
3009 VEC_iterate (tree, values, parmnum, val);
3012 tree type = typetail ? TREE_VALUE (typetail) : 0;
3013 tree valtype = TREE_TYPE (val);
3014 tree rname = function;
3015 int argnum = parmnum + 1;
3016 const char *invalid_func_diag;
3017 bool excess_precision = false;
3021 if (type == void_type_node)
3024 error_at (input_location,
3025 "too many arguments to method %qE", selector);
3027 error_at (input_location,
3028 "too many arguments to function %qE", function);
3030 if (fundecl && !DECL_BUILT_IN (fundecl))
3031 inform (DECL_SOURCE_LOCATION (fundecl), "declared here");
3035 if (selector && argnum > 2)
3041 npc = null_pointer_constant_p (val);
3043 /* If there is excess precision and a prototype, convert once to
3044 the required type rather than converting via the semantic
3045 type. Likewise without a prototype a float value represented
3046 as long double should be converted once to double. But for
3047 type-generic classification functions excess precision must
3049 if (TREE_CODE (val) == EXCESS_PRECISION_EXPR
3050 && (type || !type_generic || !type_generic_remove_excess_precision))
3052 val = TREE_OPERAND (val, 0);
3053 excess_precision = true;
3055 val = c_fully_fold (val, false, NULL);
3056 STRIP_TYPE_NOPS (val);
3058 val = require_complete_type (val);
3062 /* Formal parm type is specified by a function prototype. */
3064 if (type == error_mark_node || !COMPLETE_TYPE_P (type))
3066 error ("type of formal parameter %d is incomplete", parmnum + 1);
3073 /* Optionally warn about conversions that
3074 differ from the default conversions. */
3075 if (warn_traditional_conversion || warn_traditional)
3077 unsigned int formal_prec = TYPE_PRECISION (type);
3079 if (INTEGRAL_TYPE_P (type)
3080 && TREE_CODE (valtype) == REAL_TYPE)
3081 warning (0, "passing argument %d of %qE as integer "
3082 "rather than floating due to prototype",
3084 if (INTEGRAL_TYPE_P (type)
3085 && TREE_CODE (valtype) == COMPLEX_TYPE)
3086 warning (0, "passing argument %d of %qE as integer "
3087 "rather than complex due to prototype",
3089 else if (TREE_CODE (type) == COMPLEX_TYPE
3090 && TREE_CODE (valtype) == REAL_TYPE)
3091 warning (0, "passing argument %d of %qE as complex "
3092 "rather than floating due to prototype",
3094 else if (TREE_CODE (type) == REAL_TYPE
3095 && INTEGRAL_TYPE_P (valtype))
3096 warning (0, "passing argument %d of %qE as floating "
3097 "rather than integer due to prototype",
3099 else if (TREE_CODE (type) == COMPLEX_TYPE
3100 && INTEGRAL_TYPE_P (valtype))
3101 warning (0, "passing argument %d of %qE as complex "
3102 "rather than integer due to prototype",
3104 else if (TREE_CODE (type) == REAL_TYPE
3105 && TREE_CODE (valtype) == COMPLEX_TYPE)
3106 warning (0, "passing argument %d of %qE as floating "
3107 "rather than complex due to prototype",
3109 /* ??? At some point, messages should be written about
3110 conversions between complex types, but that's too messy
3112 else if (TREE_CODE (type) == REAL_TYPE
3113 && TREE_CODE (valtype) == REAL_TYPE)
3115 /* Warn if any argument is passed as `float',
3116 since without a prototype it would be `double'. */
3117 if (formal_prec == TYPE_PRECISION (float_type_node)
3118 && type != dfloat32_type_node)
3119 warning (0, "passing argument %d of %qE as %<float%> "
3120 "rather than %<double%> due to prototype",
3123 /* Warn if mismatch between argument and prototype
3124 for decimal float types. Warn of conversions with
3125 binary float types and of precision narrowing due to
3127 else if (type != valtype
3128 && (type == dfloat32_type_node
3129 || type == dfloat64_type_node
3130 || type == dfloat128_type_node
3131 || valtype == dfloat32_type_node
3132 || valtype == dfloat64_type_node
3133 || valtype == dfloat128_type_node)
3135 <= TYPE_PRECISION (valtype)
3136 || (type == dfloat128_type_node
3138 != dfloat64_type_node
3140 != dfloat32_type_node)))
3141 || (type == dfloat64_type_node
3143 != dfloat32_type_node))))
3144 warning (0, "passing argument %d of %qE as %qT "
3145 "rather than %qT due to prototype",
3146 argnum, rname, type, valtype);
3149 /* Detect integer changing in width or signedness.
3150 These warnings are only activated with
3151 -Wtraditional-conversion, not with -Wtraditional. */
3152 else if (warn_traditional_conversion && INTEGRAL_TYPE_P (type)
3153 && INTEGRAL_TYPE_P (valtype))
3155 tree would_have_been = default_conversion (val);
3156 tree type1 = TREE_TYPE (would_have_been);
3158 if (TREE_CODE (type) == ENUMERAL_TYPE
3159 && (TYPE_MAIN_VARIANT (type)
3160 == TYPE_MAIN_VARIANT (valtype)))
3161 /* No warning if function asks for enum
3162 and the actual arg is that enum type. */
3164 else if (formal_prec != TYPE_PRECISION (type1))
3165 warning (OPT_Wtraditional_conversion,
3166 "passing argument %d of %qE "
3167 "with different width due to prototype",
3169 else if (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (type1))
3171 /* Don't complain if the formal parameter type
3172 is an enum, because we can't tell now whether
3173 the value was an enum--even the same enum. */
3174 else if (TREE_CODE (type) == ENUMERAL_TYPE)
3176 else if (TREE_CODE (val) == INTEGER_CST
3177 && int_fits_type_p (val, type))
3178 /* Change in signedness doesn't matter
3179 if a constant value is unaffected. */
3181 /* If the value is extended from a narrower
3182 unsigned type, it doesn't matter whether we
3183 pass it as signed or unsigned; the value
3184 certainly is the same either way. */
3185 else if (TYPE_PRECISION (valtype) < TYPE_PRECISION (type)
3186 && TYPE_UNSIGNED (valtype))
3188 else if (TYPE_UNSIGNED (type))
3189 warning (OPT_Wtraditional_conversion,
3190 "passing argument %d of %qE "
3191 "as unsigned due to prototype",
3194 warning (OPT_Wtraditional_conversion,
3195 "passing argument %d of %qE "
3196 "as signed due to prototype", argnum, rname);
3200 /* Possibly restore an EXCESS_PRECISION_EXPR for the
3201 sake of better warnings from convert_and_check. */
3202 if (excess_precision)
3203 val = build1 (EXCESS_PRECISION_EXPR, valtype, val);
3204 origtype = (origtypes == NULL
3206 : VEC_index (tree, origtypes, parmnum));
3207 parmval = convert_for_assignment (input_location, type, val,
3208 origtype, ic_argpass, npc,
3212 if (targetm.calls.promote_prototypes (fundecl ? TREE_TYPE (fundecl) : 0)
3213 && INTEGRAL_TYPE_P (type)
3214 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
3215 parmval = default_conversion (parmval);
3218 else if (TREE_CODE (valtype) == REAL_TYPE
3219 && (TYPE_PRECISION (valtype)
3220 < TYPE_PRECISION (double_type_node))
3221 && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (valtype)))
3227 /* Convert `float' to `double'. */
3228 if (warn_double_promotion && !c_inhibit_evaluation_warnings)
3229 warning (OPT_Wdouble_promotion,
3230 "implicit conversion from %qT to %qT when passing "
3231 "argument to function",
3232 valtype, double_type_node);
3233 parmval = convert (double_type_node, val);
3236 else if (excess_precision && !type_generic)
3237 /* A "double" argument with excess precision being passed
3238 without a prototype or in variable arguments. */
3239 parmval = convert (valtype, val);
3240 else if ((invalid_func_diag =
3241 targetm.calls.invalid_arg_for_unprototyped_fn (typelist, fundecl, val)))
3243 error (invalid_func_diag);
3247 /* Convert `short' and `char' to full-size `int'. */
3248 parmval = default_conversion (val);
3250 VEC_replace (tree, values, parmnum, parmval);
3251 if (parmval == error_mark_node)
3255 typetail = TREE_CHAIN (typetail);
3258 gcc_assert (parmnum == VEC_length (tree, values));
3260 if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
3262 error_at (input_location,
3263 "too few arguments to function %qE", function);
3264 if (fundecl && !DECL_BUILT_IN (fundecl))
3265 inform (DECL_SOURCE_LOCATION (fundecl), "declared here");
3269 return error_args ? -1 : (int) parmnum;
3272 /* This is the entry point used by the parser to build unary operators
3273 in the input. CODE, a tree_code, specifies the unary operator, and
3274 ARG is the operand. For unary plus, the C parser currently uses
3275 CONVERT_EXPR for code.
3277 LOC is the location to use for the tree generated.
3281 parser_build_unary_op (location_t loc, enum tree_code code, struct c_expr arg)
3283 struct c_expr result;
3285 result.value = build_unary_op (loc, code, arg.value, 0);
3286 result.original_code = code;
3287 result.original_type = NULL;
3289 if (TREE_OVERFLOW_P (result.value) && !TREE_OVERFLOW_P (arg.value))
3290 overflow_warning (loc, result.value);
3295 /* This is the entry point used by the parser to build binary operators
3296 in the input. CODE, a tree_code, specifies the binary operator, and
3297 ARG1 and ARG2 are the operands. In addition to constructing the
3298 expression, we check for operands that were written with other binary
3299 operators in a way that is likely to confuse the user.
3301 LOCATION is the location of the binary operator. */
3304 parser_build_binary_op (location_t location, enum tree_code code,
3305 struct c_expr arg1, struct c_expr arg2)
3307 struct c_expr result;
3309 enum tree_code code1 = arg1.original_code;
3310 enum tree_code code2 = arg2.original_code;
3311 tree type1 = (arg1.original_type
3312 ? arg1.original_type
3313 : TREE_TYPE (arg1.value));
3314 tree type2 = (arg2.original_type
3315 ? arg2.original_type
3316 : TREE_TYPE (arg2.value));
3318 result.value = build_binary_op (location, code,
3319 arg1.value, arg2.value, 1);
3320 result.original_code = code;
3321 result.original_type = NULL;
3323 if (TREE_CODE (result.value) == ERROR_MARK)
3326 if (location != UNKNOWN_LOCATION)
3327 protected_set_expr_location (result.value, location);
3329 /* Check for cases such as x+y<<z which users are likely
3331 if (warn_parentheses)
3332 warn_about_parentheses (code, code1, arg1.value, code2, arg2.value);
3334 if (warn_logical_op)
3335 warn_logical_operator (input_location, code, TREE_TYPE (result.value),
3336 code1, arg1.value, code2, arg2.value);
3338 /* Warn about comparisons against string literals, with the exception
3339 of testing for equality or inequality of a string literal with NULL. */
3340 if (code == EQ_EXPR || code == NE_EXPR)
3342 if ((code1 == STRING_CST && !integer_zerop (arg2.value))
3343 || (code2 == STRING_CST && !integer_zerop (arg1.value)))
3344 warning_at (location, OPT_Waddress,
3345 "comparison with string literal results in unspecified behavior");
3347 else if (TREE_CODE_CLASS (code) == tcc_comparison
3348 && (code1 == STRING_CST || code2 == STRING_CST))
3349 warning_at (location, OPT_Waddress,
3350 "comparison with string literal results in unspecified behavior");
3352 if (TREE_OVERFLOW_P (result.value)
3353 && !TREE_OVERFLOW_P (arg1.value)
3354 && !TREE_OVERFLOW_P (arg2.value))
3355 overflow_warning (location, result.value);
3357 /* Warn about comparisons of different enum types. */
3358 if (warn_enum_compare
3359 && TREE_CODE_CLASS (code) == tcc_comparison
3360 && TREE_CODE (type1) == ENUMERAL_TYPE
3361 && TREE_CODE (type2) == ENUMERAL_TYPE
3362 && TYPE_MAIN_VARIANT (type1) != TYPE_MAIN_VARIANT (type2))
3363 warning_at (location, OPT_Wenum_compare,
3364 "comparison between %qT and %qT",
3370 /* Return a tree for the difference of pointers OP0 and OP1.
3371 The resulting tree has type int. */
3374 pointer_diff (location_t loc, tree op0, tree op1)
3376 tree restype = ptrdiff_type_node;
3377 tree result, inttype;
3379 addr_space_t as0 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op0)));
3380 addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op1)));
3381 tree target_type = TREE_TYPE (TREE_TYPE (op0));
3382 tree con0, con1, lit0, lit1;
3383 tree orig_op1 = op1;
3385 /* If the operands point into different address spaces, we need to
3386 explicitly convert them to pointers into the common address space
3387 before we can subtract the numerical address values. */
3390 addr_space_t as_common;
3393 /* Determine the common superset address space. This is guaranteed
3394 to exist because the caller verified that comp_target_types
3395 returned non-zero. */
3396 if (!addr_space_superset (as0, as1, &as_common))
3399 common_type = common_pointer_type (TREE_TYPE (op0), TREE_TYPE (op1));
3400 op0 = convert (common_type, op0);
3401 op1 = convert (common_type, op1);
3404 /* Determine integer type to perform computations in. This will usually
3405 be the same as the result type (ptrdiff_t), but may need to be a wider
3406 type if pointers for the address space are wider than ptrdiff_t. */
3407 if (TYPE_PRECISION (restype) < TYPE_PRECISION (TREE_TYPE (op0)))
3408 inttype = lang_hooks.types.type_for_size
3409 (TYPE_PRECISION (TREE_TYPE (op0)), 0);
3414 if (TREE_CODE (target_type) == VOID_TYPE)
3415 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3416 "pointer of type %<void *%> used in subtraction");
3417 if (TREE_CODE (target_type) == FUNCTION_TYPE)
3418 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3419 "pointer to a function used in subtraction");
3421 /* If the conversion to ptrdiff_type does anything like widening or
3422 converting a partial to an integral mode, we get a convert_expression
3423 that is in the way to do any simplifications.
3424 (fold-const.c doesn't know that the extra bits won't be needed.
3425 split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a
3426 different mode in place.)
3427 So first try to find a common term here 'by hand'; we want to cover
3428 at least the cases that occur in legal static initializers. */
3429 if (CONVERT_EXPR_P (op0)
3430 && (TYPE_PRECISION (TREE_TYPE (op0))
3431 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))))
3432 con0 = TREE_OPERAND (op0, 0);
3435 if (CONVERT_EXPR_P (op1)
3436 && (TYPE_PRECISION (TREE_TYPE (op1))
3437 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0)))))
3438 con1 = TREE_OPERAND (op1, 0);
3442 if (TREE_CODE (con0) == PLUS_EXPR)
3444 lit0 = TREE_OPERAND (con0, 1);
3445 con0 = TREE_OPERAND (con0, 0);
3448 lit0 = integer_zero_node;
3450 if (TREE_CODE (con1) == PLUS_EXPR)
3452 lit1 = TREE_OPERAND (con1, 1);
3453 con1 = TREE_OPERAND (con1, 0);
3456 lit1 = integer_zero_node;
3458 if (operand_equal_p (con0, con1, 0))
3465 /* First do the subtraction as integers;
3466 then drop through to build the divide operator.
3467 Do not do default conversions on the minus operator
3468 in case restype is a short type. */
3470 op0 = build_binary_op (loc,
3471 MINUS_EXPR, convert (inttype, op0),
3472 convert (inttype, op1), 0);
3473 /* This generates an error if op1 is pointer to incomplete type. */
3474 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1))))
3475 error_at (loc, "arithmetic on pointer to an incomplete type");
3477 /* This generates an error if op0 is pointer to incomplete type. */
3478 op1 = c_size_in_bytes (target_type);
3480 /* Divide by the size, in easiest possible way. */
3481 result = fold_build2_loc (loc, EXACT_DIV_EXPR, inttype,
3482 op0, convert (inttype, op1));
3484 /* Convert to final result type if necessary. */
3485 return convert (restype, result);
3488 /* Construct and perhaps optimize a tree representation
3489 for a unary operation. CODE, a tree_code, specifies the operation
3490 and XARG is the operand.
3491 For any CODE other than ADDR_EXPR, FLAG nonzero suppresses
3492 the default promotions (such as from short to int).
3493 For ADDR_EXPR, the default promotions are not applied; FLAG nonzero
3494 allows non-lvalues; this is only used to handle conversion of non-lvalue
3495 arrays to pointers in C99.
3497 LOCATION is the location of the operator. */
3500 build_unary_op (location_t location,
3501 enum tree_code code, tree xarg, int flag)
3503 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
3506 enum tree_code typecode;
3508 tree ret = error_mark_node;
3509 tree eptype = NULL_TREE;
3510 int noconvert = flag;
3511 const char *invalid_op_diag;
3514 int_operands = EXPR_INT_CONST_OPERANDS (xarg);
3516 arg = remove_c_maybe_const_expr (arg);
3518 if (code != ADDR_EXPR)
3519 arg = require_complete_type (arg);
3521 typecode = TREE_CODE (TREE_TYPE (arg));
3522 if (typecode == ERROR_MARK)
3523 return error_mark_node;
3524 if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE)
3525 typecode = INTEGER_TYPE;
3527 if ((invalid_op_diag
3528 = targetm.invalid_unary_op (code, TREE_TYPE (xarg))))
3530 error_at (location, invalid_op_diag);
3531 return error_mark_node;
3534 if (TREE_CODE (arg) == EXCESS_PRECISION_EXPR)
3536 eptype = TREE_TYPE (arg);
3537 arg = TREE_OPERAND (arg, 0);
3543 /* This is used for unary plus, because a CONVERT_EXPR
3544 is enough to prevent anybody from looking inside for
3545 associativity, but won't generate any code. */
3546 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
3547 || typecode == FIXED_POINT_TYPE || typecode == COMPLEX_TYPE
3548 || typecode == VECTOR_TYPE))
3550 error_at (location, "wrong type argument to unary plus");
3551 return error_mark_node;
3553 else if (!noconvert)
3554 arg = default_conversion (arg);
3555 arg = non_lvalue_loc (location, arg);
3559 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
3560 || typecode == FIXED_POINT_TYPE || typecode == COMPLEX_TYPE
3561 || typecode == VECTOR_TYPE))
3563 error_at (location, "wrong type argument to unary minus");
3564 return error_mark_node;
3566 else if (!noconvert)
3567 arg = default_conversion (arg);
3571 /* ~ works on integer types and non float vectors. */
3572 if (typecode == INTEGER_TYPE
3573 || (typecode == VECTOR_TYPE
3574 && !VECTOR_FLOAT_TYPE_P (TREE_TYPE (arg))))
3577 arg = default_conversion (arg);
3579 else if (typecode == COMPLEX_TYPE)
3582 pedwarn (location, OPT_pedantic,
3583 "ISO C does not support %<~%> for complex conjugation");
3585 arg = default_conversion (arg);
3589 error_at (location, "wrong type argument to bit-complement");
3590 return error_mark_node;
3595 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE))
3597 error_at (location, "wrong type argument to abs");
3598 return error_mark_node;
3600 else if (!noconvert)
3601 arg = default_conversion (arg);
3605 /* Conjugating a real value is a no-op, but allow it anyway. */
3606 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
3607 || typecode == COMPLEX_TYPE))
3609 error_at (location, "wrong type argument to conjugation");
3610 return error_mark_node;
3612 else if (!noconvert)
3613 arg = default_conversion (arg);
3616 case TRUTH_NOT_EXPR:
3617 if (typecode != INTEGER_TYPE && typecode != FIXED_POINT_TYPE
3618 && typecode != REAL_TYPE && typecode != POINTER_TYPE
3619 && typecode != COMPLEX_TYPE)
3622 "wrong type argument to unary exclamation mark");
3623 return error_mark_node;
3625 arg = c_objc_common_truthvalue_conversion (location, arg);
3626 ret = invert_truthvalue_loc (location, arg);
3627 /* If the TRUTH_NOT_EXPR has been folded, reset the location. */
3628 if (EXPR_P (ret) && EXPR_HAS_LOCATION (ret))
3629 location = EXPR_LOCATION (ret);
3630 goto return_build_unary_op;
3634 ret = build_real_imag_expr (location, code, arg);
3635 if (ret == error_mark_node)
3636 return error_mark_node;
3637 if (eptype && TREE_CODE (eptype) == COMPLEX_TYPE)
3638 eptype = TREE_TYPE (eptype);
3639 goto return_build_unary_op;
3641 case PREINCREMENT_EXPR:
3642 case POSTINCREMENT_EXPR:
3643 case PREDECREMENT_EXPR:
3644 case POSTDECREMENT_EXPR:
3646 if (TREE_CODE (arg) == C_MAYBE_CONST_EXPR)
3648 tree inner = build_unary_op (location, code,
3649 C_MAYBE_CONST_EXPR_EXPR (arg), flag);
3650 if (inner == error_mark_node)
3651 return error_mark_node;
3652 ret = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (inner),
3653 C_MAYBE_CONST_EXPR_PRE (arg), inner);
3654 gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (arg));
3655 C_MAYBE_CONST_EXPR_NON_CONST (ret) = 1;
3656 goto return_build_unary_op;
3659 /* Complain about anything that is not a true lvalue. In
3660 Objective-C, skip this check for property_refs. */
3661 if (!objc_is_property_ref (arg)
3662 && !lvalue_or_else (location,
3663 arg, ((code == PREINCREMENT_EXPR
3664 || code == POSTINCREMENT_EXPR)
3667 return error_mark_node;
3669 if (warn_cxx_compat && TREE_CODE (TREE_TYPE (arg)) == ENUMERAL_TYPE)
3671 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
3672 warning_at (location, OPT_Wc___compat,
3673 "increment of enumeration value is invalid in C++");
3675 warning_at (location, OPT_Wc___compat,
3676 "decrement of enumeration value is invalid in C++");
3679 /* Ensure the argument is fully folded inside any SAVE_EXPR. */
3680 arg = c_fully_fold (arg, false, NULL);
3682 /* Increment or decrement the real part of the value,
3683 and don't change the imaginary part. */
3684 if (typecode == COMPLEX_TYPE)
3688 pedwarn (location, OPT_pedantic,
3689 "ISO C does not support %<++%> and %<--%> on complex types");
3691 arg = stabilize_reference (arg);
3692 real = build_unary_op (EXPR_LOCATION (arg), REALPART_EXPR, arg, 1);
3693 imag = build_unary_op (EXPR_LOCATION (arg), IMAGPART_EXPR, arg, 1);
3694 real = build_unary_op (EXPR_LOCATION (arg), code, real, 1);
3695 if (real == error_mark_node || imag == error_mark_node)
3696 return error_mark_node;
3697 ret = build2 (COMPLEX_EXPR, TREE_TYPE (arg),
3699 goto return_build_unary_op;
3702 /* Report invalid types. */
3704 if (typecode != POINTER_TYPE && typecode != FIXED_POINT_TYPE
3705 && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
3707 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
3708 error_at (location, "wrong type argument to increment");
3710 error_at (location, "wrong type argument to decrement");
3712 return error_mark_node;
3718 argtype = TREE_TYPE (arg);
3720 /* Compute the increment. */
3722 if (typecode == POINTER_TYPE)
3724 /* If pointer target is an undefined struct,
3725 we just cannot know how to do the arithmetic. */
3726 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (argtype)))
3728 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
3730 "increment of pointer to unknown structure");
3733 "decrement of pointer to unknown structure");
3735 else if (TREE_CODE (TREE_TYPE (argtype)) == FUNCTION_TYPE
3736 || TREE_CODE (TREE_TYPE (argtype)) == VOID_TYPE)
3738 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
3739 pedwarn (location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3740 "wrong type argument to increment");
3742 pedwarn (location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3743 "wrong type argument to decrement");
3746 inc = c_size_in_bytes (TREE_TYPE (argtype));
3747 inc = convert_to_ptrofftype_loc (location, inc);
3749 else if (FRACT_MODE_P (TYPE_MODE (argtype)))
3751 /* For signed fract types, we invert ++ to -- or
3752 -- to ++, and change inc from 1 to -1, because
3753 it is not possible to represent 1 in signed fract constants.
3754 For unsigned fract types, the result always overflows and
3755 we get an undefined (original) or the maximum value. */
3756 if (code == PREINCREMENT_EXPR)
3757 code = PREDECREMENT_EXPR;
3758 else if (code == PREDECREMENT_EXPR)
3759 code = PREINCREMENT_EXPR;
3760 else if (code == POSTINCREMENT_EXPR)
3761 code = POSTDECREMENT_EXPR;
3762 else /* code == POSTDECREMENT_EXPR */
3763 code = POSTINCREMENT_EXPR;
3765 inc = integer_minus_one_node;
3766 inc = convert (argtype, inc);
3770 inc = integer_one_node;
3771 inc = convert (argtype, inc);
3774 /* If 'arg' is an Objective-C PROPERTY_REF expression, then we
3775 need to ask Objective-C to build the increment or decrement
3776 expression for it. */
3777 if (objc_is_property_ref (arg))
3778 return objc_build_incr_expr_for_property_ref (location, code,
3781 /* Report a read-only lvalue. */
3782 if (TYPE_READONLY (argtype))
3784 readonly_error (arg,
3785 ((code == PREINCREMENT_EXPR
3786 || code == POSTINCREMENT_EXPR)
3787 ? lv_increment : lv_decrement));
3788 return error_mark_node;
3790 else if (TREE_READONLY (arg))
3791 readonly_warning (arg,
3792 ((code == PREINCREMENT_EXPR
3793 || code == POSTINCREMENT_EXPR)
3794 ? lv_increment : lv_decrement));
3796 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
3797 val = boolean_increment (code, arg);
3799 val = build2 (code, TREE_TYPE (arg), arg, inc);
3800 TREE_SIDE_EFFECTS (val) = 1;
3801 if (TREE_CODE (val) != code)
3802 TREE_NO_WARNING (val) = 1;
3804 goto return_build_unary_op;
3808 /* Note that this operation never does default_conversion. */
3810 /* The operand of unary '&' must be an lvalue (which excludes
3811 expressions of type void), or, in C99, the result of a [] or
3812 unary '*' operator. */
3813 if (VOID_TYPE_P (TREE_TYPE (arg))
3814 && TYPE_QUALS (TREE_TYPE (arg)) == TYPE_UNQUALIFIED
3815 && (TREE_CODE (arg) != INDIRECT_REF
3817 pedwarn (location, 0, "taking address of expression of type %<void%>");
3819 /* Let &* cancel out to simplify resulting code. */
3820 if (TREE_CODE (arg) == INDIRECT_REF)
3822 /* Don't let this be an lvalue. */
3823 if (lvalue_p (TREE_OPERAND (arg, 0)))
3824 return non_lvalue_loc (location, TREE_OPERAND (arg, 0));
3825 ret = TREE_OPERAND (arg, 0);
3826 goto return_build_unary_op;
3829 /* For &x[y], return x+y */
3830 if (TREE_CODE (arg) == ARRAY_REF)
3832 tree op0 = TREE_OPERAND (arg, 0);
3833 if (!c_mark_addressable (op0))
3834 return error_mark_node;
3837 /* Anything not already handled and not a true memory reference
3838 or a non-lvalue array is an error. */
3839 else if (typecode != FUNCTION_TYPE && !flag
3840 && !lvalue_or_else (location, arg, lv_addressof))
3841 return error_mark_node;
3843 /* Move address operations inside C_MAYBE_CONST_EXPR to simplify
3845 if (TREE_CODE (arg) == C_MAYBE_CONST_EXPR)
3847 tree inner = build_unary_op (location, code,
3848 C_MAYBE_CONST_EXPR_EXPR (arg), flag);
3849 ret = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (inner),
3850 C_MAYBE_CONST_EXPR_PRE (arg), inner);
3851 gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (arg));
3852 C_MAYBE_CONST_EXPR_NON_CONST (ret)
3853 = C_MAYBE_CONST_EXPR_NON_CONST (arg);
3854 goto return_build_unary_op;
3857 /* Ordinary case; arg is a COMPONENT_REF or a decl. */
3858 argtype = TREE_TYPE (arg);
3860 /* If the lvalue is const or volatile, merge that into the type
3861 to which the address will point. This is only needed
3862 for function types. */
3863 if ((DECL_P (arg) || REFERENCE_CLASS_P (arg))
3864 && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg))
3865 && TREE_CODE (argtype) == FUNCTION_TYPE)
3867 int orig_quals = TYPE_QUALS (strip_array_types (argtype));
3868 int quals = orig_quals;
3870 if (TREE_READONLY (arg))
3871 quals |= TYPE_QUAL_CONST;
3872 if (TREE_THIS_VOLATILE (arg))
3873 quals |= TYPE_QUAL_VOLATILE;
3875 argtype = c_build_qualified_type (argtype, quals);
3878 if (!c_mark_addressable (arg))
3879 return error_mark_node;
3881 gcc_assert (TREE_CODE (arg) != COMPONENT_REF
3882 || !DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)));
3884 argtype = build_pointer_type (argtype);
3886 /* ??? Cope with user tricks that amount to offsetof. Delete this
3887 when we have proper support for integer constant expressions. */
3888 val = get_base_address (arg);
3889 if (val && TREE_CODE (val) == INDIRECT_REF
3890 && TREE_CONSTANT (TREE_OPERAND (val, 0)))
3892 tree op0 = fold_offsetof (arg, val), op1;
3894 op1 = fold_convert_loc (location, argtype, TREE_OPERAND (val, 0));
3895 ret = fold_build_pointer_plus_loc (location, op1, op0);
3896 goto return_build_unary_op;
3899 val = build1 (ADDR_EXPR, argtype, arg);
3902 goto return_build_unary_op;
3909 argtype = TREE_TYPE (arg);
3910 if (TREE_CODE (arg) == INTEGER_CST)
3911 ret = (require_constant_value
3912 ? fold_build1_initializer_loc (location, code, argtype, arg)
3913 : fold_build1_loc (location, code, argtype, arg));
3915 ret = build1 (code, argtype, arg);
3916 return_build_unary_op:
3917 gcc_assert (ret != error_mark_node);
3918 if (TREE_CODE (ret) == INTEGER_CST && !TREE_OVERFLOW (ret)
3919 && !(TREE_CODE (xarg) == INTEGER_CST && !TREE_OVERFLOW (xarg)))
3920 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
3921 else if (TREE_CODE (ret) != INTEGER_CST && int_operands)
3922 ret = note_integer_operands (ret);
3924 ret = build1 (EXCESS_PRECISION_EXPR, eptype, ret);
3925 protected_set_expr_location (ret, location);
3929 /* Return nonzero if REF is an lvalue valid for this language.
3930 Lvalues can be assigned, unless their type has TYPE_READONLY.
3931 Lvalues can have their address taken, unless they have C_DECL_REGISTER. */
3934 lvalue_p (const_tree ref)
3936 const enum tree_code code = TREE_CODE (ref);
3943 return lvalue_p (TREE_OPERAND (ref, 0));
3945 case C_MAYBE_CONST_EXPR:
3946 return lvalue_p (TREE_OPERAND (ref, 1));
3948 case COMPOUND_LITERAL_EXPR:
3958 return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
3959 && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
3962 return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
3969 /* Give a warning for storing in something that is read-only in GCC
3970 terms but not const in ISO C terms. */
3973 readonly_warning (tree arg, enum lvalue_use use)
3978 warning (0, "assignment of read-only location %qE", arg);
3981 warning (0, "increment of read-only location %qE", arg);
3984 warning (0, "decrement of read-only location %qE", arg);
3993 /* Return nonzero if REF is an lvalue valid for this language;
3994 otherwise, print an error message and return zero. USE says
3995 how the lvalue is being used and so selects the error message.
3996 LOCATION is the location at which any error should be reported. */
3999 lvalue_or_else (location_t loc, const_tree ref, enum lvalue_use use)
4001 int win = lvalue_p (ref);
4004 lvalue_error (loc, use);
4009 /* Mark EXP saying that we need to be able to take the
4010 address of it; it should not be allocated in a register.
4011 Returns true if successful. */
4014 c_mark_addressable (tree exp)
4019 switch (TREE_CODE (x))
4022 if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
4025 ("cannot take address of bit-field %qD", TREE_OPERAND (x, 1));
4029 /* ... fall through ... */
4035 x = TREE_OPERAND (x, 0);
4038 case COMPOUND_LITERAL_EXPR:
4040 TREE_ADDRESSABLE (x) = 1;
4047 if (C_DECL_REGISTER (x)
4048 && DECL_NONLOCAL (x))
4050 if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x))
4053 ("global register variable %qD used in nested function", x);
4056 pedwarn (input_location, 0, "register variable %qD used in nested function", x);
4058 else if (C_DECL_REGISTER (x))
4060 if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x))
4061 error ("address of global register variable %qD requested", x);
4063 error ("address of register variable %qD requested", x);
4069 TREE_ADDRESSABLE (x) = 1;
4076 /* Convert EXPR to TYPE, warning about conversion problems with
4077 constants. SEMANTIC_TYPE is the type this conversion would use
4078 without excess precision. If SEMANTIC_TYPE is NULL, this function
4079 is equivalent to convert_and_check. This function is a wrapper that
4080 handles conversions that may be different than
4081 the usual ones because of excess precision. */
4084 ep_convert_and_check (tree type, tree expr, tree semantic_type)
4086 if (TREE_TYPE (expr) == type)
4090 return convert_and_check (type, expr);
4092 if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
4093 && TREE_TYPE (expr) != semantic_type)
4095 /* For integers, we need to check the real conversion, not
4096 the conversion to the excess precision type. */
4097 expr = convert_and_check (semantic_type, expr);
4099 /* Result type is the excess precision type, which should be
4100 large enough, so do not check. */
4101 return convert (type, expr);
4104 /* Build and return a conditional expression IFEXP ? OP1 : OP2. If
4105 IFEXP_BCP then the condition is a call to __builtin_constant_p, and
4106 if folded to an integer constant then the unselected half may
4107 contain arbitrary operations not normally permitted in constant
4108 expressions. Set the location of the expression to LOC. */
4111 build_conditional_expr (location_t colon_loc, tree ifexp, bool ifexp_bcp,
4112 tree op1, tree op1_original_type, tree op2,
4113 tree op2_original_type)
4117 enum tree_code code1;
4118 enum tree_code code2;
4119 tree result_type = NULL;
4120 tree semantic_result_type = NULL;
4121 tree orig_op1 = op1, orig_op2 = op2;
4122 bool int_const, op1_int_operands, op2_int_operands, int_operands;
4123 bool ifexp_int_operands;
4126 op1_int_operands = EXPR_INT_CONST_OPERANDS (orig_op1);
4127 if (op1_int_operands)
4128 op1 = remove_c_maybe_const_expr (op1);
4129 op2_int_operands = EXPR_INT_CONST_OPERANDS (orig_op2);
4130 if (op2_int_operands)
4131 op2 = remove_c_maybe_const_expr (op2);
4132 ifexp_int_operands = EXPR_INT_CONST_OPERANDS (ifexp);
4133 if (ifexp_int_operands)
4134 ifexp = remove_c_maybe_const_expr (ifexp);
4136 /* Promote both alternatives. */
4138 if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
4139 op1 = default_conversion (op1);
4140 if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
4141 op2 = default_conversion (op2);
4143 if (TREE_CODE (ifexp) == ERROR_MARK
4144 || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
4145 || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
4146 return error_mark_node;
4148 type1 = TREE_TYPE (op1);
4149 code1 = TREE_CODE (type1);
4150 type2 = TREE_TYPE (op2);
4151 code2 = TREE_CODE (type2);
4153 /* C90 does not permit non-lvalue arrays in conditional expressions.
4154 In C99 they will be pointers by now. */
4155 if (code1 == ARRAY_TYPE || code2 == ARRAY_TYPE)
4157 error_at (colon_loc, "non-lvalue array in conditional expression");
4158 return error_mark_node;
4161 if ((TREE_CODE (op1) == EXCESS_PRECISION_EXPR
4162 || TREE_CODE (op2) == EXCESS_PRECISION_EXPR)
4163 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
4164 || code1 == COMPLEX_TYPE)
4165 && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
4166 || code2 == COMPLEX_TYPE))
4168 semantic_result_type = c_common_type (type1, type2);
4169 if (TREE_CODE (op1) == EXCESS_PRECISION_EXPR)
4171 op1 = TREE_OPERAND (op1, 0);
4172 type1 = TREE_TYPE (op1);
4173 gcc_assert (TREE_CODE (type1) == code1);
4175 if (TREE_CODE (op2) == EXCESS_PRECISION_EXPR)
4177 op2 = TREE_OPERAND (op2, 0);
4178 type2 = TREE_TYPE (op2);
4179 gcc_assert (TREE_CODE (type2) == code2);
4183 if (warn_cxx_compat)
4185 tree t1 = op1_original_type ? op1_original_type : TREE_TYPE (orig_op1);
4186 tree t2 = op2_original_type ? op2_original_type : TREE_TYPE (orig_op2);
4188 if (TREE_CODE (t1) == ENUMERAL_TYPE
4189 && TREE_CODE (t2) == ENUMERAL_TYPE
4190 && TYPE_MAIN_VARIANT (t1) != TYPE_MAIN_VARIANT (t2))
4191 warning_at (colon_loc, OPT_Wc___compat,
4192 ("different enum types in conditional is "
4193 "invalid in C++: %qT vs %qT"),
4197 /* Quickly detect the usual case where op1 and op2 have the same type
4199 if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
4202 result_type = type1;
4204 result_type = TYPE_MAIN_VARIANT (type1);
4206 else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE
4207 || code1 == COMPLEX_TYPE)
4208 && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
4209 || code2 == COMPLEX_TYPE))
4211 result_type = c_common_type (type1, type2);
4212 do_warn_double_promotion (result_type, type1, type2,
4213 "implicit conversion from %qT to %qT to "
4214 "match other result of conditional",
4217 /* If -Wsign-compare, warn here if type1 and type2 have
4218 different signedness. We'll promote the signed to unsigned
4219 and later code won't know it used to be different.
4220 Do this check on the original types, so that explicit casts
4221 will be considered, but default promotions won't. */
4222 if (c_inhibit_evaluation_warnings == 0)
4224 int unsigned_op1 = TYPE_UNSIGNED (TREE_TYPE (orig_op1));
4225 int unsigned_op2 = TYPE_UNSIGNED (TREE_TYPE (orig_op2));
4227 if (unsigned_op1 ^ unsigned_op2)
4231 /* Do not warn if the result type is signed, since the
4232 signed type will only be chosen if it can represent
4233 all the values of the unsigned type. */
4234 if (!TYPE_UNSIGNED (result_type))
4238 bool op1_maybe_const = true;
4239 bool op2_maybe_const = true;
4241 /* Do not warn if the signed quantity is an
4242 unsuffixed integer literal (or some static
4243 constant expression involving such literals) and
4244 it is non-negative. This warning requires the
4245 operands to be folded for best results, so do
4246 that folding in this case even without
4247 warn_sign_compare to avoid warning options
4248 possibly affecting code generation. */
4249 c_inhibit_evaluation_warnings
4250 += (ifexp == truthvalue_false_node);
4251 op1 = c_fully_fold (op1, require_constant_value,
4253 c_inhibit_evaluation_warnings
4254 -= (ifexp == truthvalue_false_node);
4256 c_inhibit_evaluation_warnings
4257 += (ifexp == truthvalue_true_node);
4258 op2 = c_fully_fold (op2, require_constant_value,
4260 c_inhibit_evaluation_warnings
4261 -= (ifexp == truthvalue_true_node);
4263 if (warn_sign_compare)
4266 && tree_expr_nonnegative_warnv_p (op1, &ovf))
4268 && tree_expr_nonnegative_warnv_p (op2, &ovf)))
4271 warning_at (colon_loc, OPT_Wsign_compare,
4272 ("signed and unsigned type in "
4273 "conditional expression"));
4275 if (!op1_maybe_const || TREE_CODE (op1) != INTEGER_CST)
4276 op1 = c_wrap_maybe_const (op1, !op1_maybe_const);
4277 if (!op2_maybe_const || TREE_CODE (op2) != INTEGER_CST)
4278 op2 = c_wrap_maybe_const (op2, !op2_maybe_const);
4283 else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
4285 if (code1 != VOID_TYPE || code2 != VOID_TYPE)
4286 pedwarn (colon_loc, OPT_pedantic,
4287 "ISO C forbids conditional expr with only one void side");
4288 result_type = void_type_node;
4290 else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
4292 addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (type1));
4293 addr_space_t as2 = TYPE_ADDR_SPACE (TREE_TYPE (type2));
4294 addr_space_t as_common;
4296 if (comp_target_types (colon_loc, type1, type2))
4297 result_type = common_pointer_type (type1, type2);
4298 else if (null_pointer_constant_p (orig_op1))
4299 result_type = type2;
4300 else if (null_pointer_constant_p (orig_op2))
4301 result_type = type1;
4302 else if (!addr_space_superset (as1, as2, &as_common))
4304 error_at (colon_loc, "pointers to disjoint address spaces "
4305 "used in conditional expression");
4306 return error_mark_node;
4308 else if (VOID_TYPE_P (TREE_TYPE (type1)))
4310 if (TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
4311 pedwarn (colon_loc, OPT_pedantic,
4312 "ISO C forbids conditional expr between "
4313 "%<void *%> and function pointer");
4314 result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
4315 TREE_TYPE (type2)));
4317 else if (VOID_TYPE_P (TREE_TYPE (type2)))
4319 if (TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
4320 pedwarn (colon_loc, OPT_pedantic,
4321 "ISO C forbids conditional expr between "
4322 "%<void *%> and function pointer");
4323 result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
4324 TREE_TYPE (type1)));
4326 /* Objective-C pointer comparisons are a bit more lenient. */
4327 else if (objc_have_common_type (type1, type2, -3, NULL_TREE))
4328 result_type = objc_common_type (type1, type2);
4331 int qual = ENCODE_QUAL_ADDR_SPACE (as_common);
4333 pedwarn (colon_loc, 0,
4334 "pointer type mismatch in conditional expression");
4335 result_type = build_pointer_type
4336 (build_qualified_type (void_type_node, qual));
4339 else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
4341 if (!null_pointer_constant_p (orig_op2))
4342 pedwarn (colon_loc, 0,
4343 "pointer/integer type mismatch in conditional expression");
4346 op2 = null_pointer_node;
4348 result_type = type1;
4350 else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
4352 if (!null_pointer_constant_p (orig_op1))
4353 pedwarn (colon_loc, 0,
4354 "pointer/integer type mismatch in conditional expression");
4357 op1 = null_pointer_node;
4359 result_type = type2;
4364 if (flag_cond_mismatch)
4365 result_type = void_type_node;
4368 error_at (colon_loc, "type mismatch in conditional expression");
4369 return error_mark_node;
4373 /* Merge const and volatile flags of the incoming types. */
4375 = build_type_variant (result_type,
4376 TYPE_READONLY (type1) || TYPE_READONLY (type2),
4377 TYPE_VOLATILE (type1) || TYPE_VOLATILE (type2));
4379 op1 = ep_convert_and_check (result_type, op1, semantic_result_type);
4380 op2 = ep_convert_and_check (result_type, op2, semantic_result_type);
4382 if (ifexp_bcp && ifexp == truthvalue_true_node)
4384 op2_int_operands = true;
4385 op1 = c_fully_fold (op1, require_constant_value, NULL);
4387 if (ifexp_bcp && ifexp == truthvalue_false_node)
4389 op1_int_operands = true;
4390 op2 = c_fully_fold (op2, require_constant_value, NULL);
4392 int_const = int_operands = (ifexp_int_operands
4394 && op2_int_operands);
4397 int_const = ((ifexp == truthvalue_true_node
4398 && TREE_CODE (orig_op1) == INTEGER_CST
4399 && !TREE_OVERFLOW (orig_op1))
4400 || (ifexp == truthvalue_false_node
4401 && TREE_CODE (orig_op2) == INTEGER_CST
4402 && !TREE_OVERFLOW (orig_op2)));
4404 if (int_const || (ifexp_bcp && TREE_CODE (ifexp) == INTEGER_CST))
4405 ret = fold_build3_loc (colon_loc, COND_EXPR, result_type, ifexp, op1, op2);
4408 ret = build3 (COND_EXPR, result_type, ifexp, op1, op2);
4410 ret = note_integer_operands (ret);
4412 if (semantic_result_type)
4413 ret = build1 (EXCESS_PRECISION_EXPR, semantic_result_type, ret);
4415 protected_set_expr_location (ret, colon_loc);
4419 /* Return a compound expression that performs two expressions and
4420 returns the value of the second of them.
4422 LOC is the location of the COMPOUND_EXPR. */
4425 build_compound_expr (location_t loc, tree expr1, tree expr2)
4427 bool expr1_int_operands, expr2_int_operands;
4428 tree eptype = NULL_TREE;
4431 expr1_int_operands = EXPR_INT_CONST_OPERANDS (expr1);
4432 if (expr1_int_operands)
4433 expr1 = remove_c_maybe_const_expr (expr1);
4434 expr2_int_operands = EXPR_INT_CONST_OPERANDS (expr2);
4435 if (expr2_int_operands)
4436 expr2 = remove_c_maybe_const_expr (expr2);
4438 if (TREE_CODE (expr1) == EXCESS_PRECISION_EXPR)
4439 expr1 = TREE_OPERAND (expr1, 0);
4440 if (TREE_CODE (expr2) == EXCESS_PRECISION_EXPR)
4442 eptype = TREE_TYPE (expr2);
4443 expr2 = TREE_OPERAND (expr2, 0);
4446 if (!TREE_SIDE_EFFECTS (expr1))
4448 /* The left-hand operand of a comma expression is like an expression
4449 statement: with -Wunused, we should warn if it doesn't have
4450 any side-effects, unless it was explicitly cast to (void). */
4451 if (warn_unused_value)
4453 if (VOID_TYPE_P (TREE_TYPE (expr1))
4454 && CONVERT_EXPR_P (expr1))
4456 else if (VOID_TYPE_P (TREE_TYPE (expr1))
4457 && TREE_CODE (expr1) == COMPOUND_EXPR
4458 && CONVERT_EXPR_P (TREE_OPERAND (expr1, 1)))
4459 ; /* (void) a, (void) b, c */
4461 warning_at (loc, OPT_Wunused_value,
4462 "left-hand operand of comma expression has no effect");
4466 /* With -Wunused, we should also warn if the left-hand operand does have
4467 side-effects, but computes a value which is not used. For example, in
4468 `foo() + bar(), baz()' the result of the `+' operator is not used,
4469 so we should issue a warning. */
4470 else if (warn_unused_value)
4471 warn_if_unused_value (expr1, loc);
4473 if (expr2 == error_mark_node)
4474 return error_mark_node;
4476 ret = build2 (COMPOUND_EXPR, TREE_TYPE (expr2), expr1, expr2);
4479 && expr1_int_operands
4480 && expr2_int_operands)
4481 ret = note_integer_operands (ret);
4484 ret = build1 (EXCESS_PRECISION_EXPR, eptype, ret);
4486 protected_set_expr_location (ret, loc);
4490 /* Issue -Wcast-qual warnings when appropriate. TYPE is the type to
4491 which we are casting. OTYPE is the type of the expression being
4492 cast. Both TYPE and OTYPE are pointer types. LOC is the location
4493 of the cast. -Wcast-qual appeared on the command line. Named
4494 address space qualifiers are not handled here, because they result
4495 in different warnings. */
4498 handle_warn_cast_qual (location_t loc, tree type, tree otype)
4500 tree in_type = type;
4501 tree in_otype = otype;
4506 /* Check that the qualifiers on IN_TYPE are a superset of the
4507 qualifiers of IN_OTYPE. The outermost level of POINTER_TYPE
4508 nodes is uninteresting and we stop as soon as we hit a
4509 non-POINTER_TYPE node on either type. */
4512 in_otype = TREE_TYPE (in_otype);
4513 in_type = TREE_TYPE (in_type);
4515 /* GNU C allows cv-qualified function types. 'const' means the
4516 function is very pure, 'volatile' means it can't return. We
4517 need to warn when such qualifiers are added, not when they're
4519 if (TREE_CODE (in_otype) == FUNCTION_TYPE
4520 && TREE_CODE (in_type) == FUNCTION_TYPE)
4521 added |= (TYPE_QUALS_NO_ADDR_SPACE (in_type)
4522 & ~TYPE_QUALS_NO_ADDR_SPACE (in_otype));
4524 discarded |= (TYPE_QUALS_NO_ADDR_SPACE (in_otype)
4525 & ~TYPE_QUALS_NO_ADDR_SPACE (in_type));
4527 while (TREE_CODE (in_type) == POINTER_TYPE
4528 && TREE_CODE (in_otype) == POINTER_TYPE);
4531 warning_at (loc, OPT_Wcast_qual,
4532 "cast adds %q#v qualifier to function type", added);
4535 /* There are qualifiers present in IN_OTYPE that are not present
4537 warning_at (loc, OPT_Wcast_qual,
4538 "cast discards %q#v qualifier from pointer target type",
4541 if (added || discarded)
4544 /* A cast from **T to const **T is unsafe, because it can cause a
4545 const value to be changed with no additional warning. We only
4546 issue this warning if T is the same on both sides, and we only
4547 issue the warning if there are the same number of pointers on
4548 both sides, as otherwise the cast is clearly unsafe anyhow. A
4549 cast is unsafe when a qualifier is added at one level and const
4550 is not present at all outer levels.
4552 To issue this warning, we check at each level whether the cast
4553 adds new qualifiers not already seen. We don't need to special
4554 case function types, as they won't have the same
4555 TYPE_MAIN_VARIANT. */
4557 if (TYPE_MAIN_VARIANT (in_type) != TYPE_MAIN_VARIANT (in_otype))
4559 if (TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE)
4564 is_const = TYPE_READONLY (TREE_TYPE (in_type));
4567 in_type = TREE_TYPE (in_type);
4568 in_otype = TREE_TYPE (in_otype);
4569 if ((TYPE_QUALS (in_type) &~ TYPE_QUALS (in_otype)) != 0
4572 warning_at (loc, OPT_Wcast_qual,
4573 "to be safe all intermediate pointers in cast from "
4574 "%qT to %qT must be %<const%> qualified",
4579 is_const = TYPE_READONLY (in_type);
4581 while (TREE_CODE (in_type) == POINTER_TYPE);
4584 /* Build an expression representing a cast to type TYPE of expression EXPR.
4585 LOC is the location of the cast-- typically the open paren of the cast. */
4588 build_c_cast (location_t loc, tree type, tree expr)
4592 if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
4593 expr = TREE_OPERAND (expr, 0);
4597 if (type == error_mark_node || expr == error_mark_node)
4598 return error_mark_node;
4600 /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
4601 only in <protocol> qualifications. But when constructing cast expressions,
4602 the protocols do matter and must be kept around. */
4603 if (objc_is_object_ptr (type) && objc_is_object_ptr (TREE_TYPE (expr)))
4604 return build1 (NOP_EXPR, type, expr);
4606 type = TYPE_MAIN_VARIANT (type);
4608 if (TREE_CODE (type) == ARRAY_TYPE)
4610 error_at (loc, "cast specifies array type");
4611 return error_mark_node;
4614 if (TREE_CODE (type) == FUNCTION_TYPE)
4616 error_at (loc, "cast specifies function type");
4617 return error_mark_node;
4620 if (!VOID_TYPE_P (type))
4622 value = require_complete_type (value);
4623 if (value == error_mark_node)
4624 return error_mark_node;
4627 if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
4629 if (TREE_CODE (type) == RECORD_TYPE
4630 || TREE_CODE (type) == UNION_TYPE)
4631 pedwarn (loc, OPT_pedantic,
4632 "ISO C forbids casting nonscalar to the same type");
4634 else if (TREE_CODE (type) == UNION_TYPE)
4638 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
4639 if (TREE_TYPE (field) != error_mark_node
4640 && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
4641 TYPE_MAIN_VARIANT (TREE_TYPE (value))))
4647 bool maybe_const = true;
4649 pedwarn (loc, OPT_pedantic, "ISO C forbids casts to union type");
4650 t = c_fully_fold (value, false, &maybe_const);
4651 t = build_constructor_single (type, field, t);
4653 t = c_wrap_maybe_const (t, true);
4654 t = digest_init (loc, type, t,
4655 NULL_TREE, false, true, 0);
4656 TREE_CONSTANT (t) = TREE_CONSTANT (value);
4659 error_at (loc, "cast to union type from type not present in union");
4660 return error_mark_node;
4666 if (type == void_type_node)
4668 tree t = build1 (CONVERT_EXPR, type, value);
4669 SET_EXPR_LOCATION (t, loc);
4673 otype = TREE_TYPE (value);
4675 /* Optionally warn about potentially worrisome casts. */
4677 && TREE_CODE (type) == POINTER_TYPE
4678 && TREE_CODE (otype) == POINTER_TYPE)
4679 handle_warn_cast_qual (loc, type, otype);
4681 /* Warn about conversions between pointers to disjoint
4683 if (TREE_CODE (type) == POINTER_TYPE
4684 && TREE_CODE (otype) == POINTER_TYPE
4685 && !null_pointer_constant_p (value))
4687 addr_space_t as_to = TYPE_ADDR_SPACE (TREE_TYPE (type));
4688 addr_space_t as_from = TYPE_ADDR_SPACE (TREE_TYPE (otype));
4689 addr_space_t as_common;
4691 if (!addr_space_superset (as_to, as_from, &as_common))
4693 if (ADDR_SPACE_GENERIC_P (as_from))
4694 warning_at (loc, 0, "cast to %s address space pointer "
4695 "from disjoint generic address space pointer",
4696 c_addr_space_name (as_to));
4698 else if (ADDR_SPACE_GENERIC_P (as_to))
4699 warning_at (loc, 0, "cast to generic address space pointer "
4700 "from disjoint %s address space pointer",
4701 c_addr_space_name (as_from));
4704 warning_at (loc, 0, "cast to %s address space pointer "
4705 "from disjoint %s address space pointer",
4706 c_addr_space_name (as_to),
4707 c_addr_space_name (as_from));
4711 /* Warn about possible alignment problems. */
4712 if (STRICT_ALIGNMENT
4713 && TREE_CODE (type) == POINTER_TYPE
4714 && TREE_CODE (otype) == POINTER_TYPE
4715 && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
4716 && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
4717 /* Don't warn about opaque types, where the actual alignment
4718 restriction is unknown. */
4719 && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
4720 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
4721 && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
4722 && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
4723 warning_at (loc, OPT_Wcast_align,
4724 "cast increases required alignment of target type");
4726 if (TREE_CODE (type) == INTEGER_TYPE
4727 && TREE_CODE (otype) == POINTER_TYPE
4728 && TYPE_PRECISION (type) != TYPE_PRECISION (otype))
4729 /* Unlike conversion of integers to pointers, where the
4730 warning is disabled for converting constants because
4731 of cases such as SIG_*, warn about converting constant
4732 pointers to integers. In some cases it may cause unwanted
4733 sign extension, and a warning is appropriate. */
4734 warning_at (loc, OPT_Wpointer_to_int_cast,
4735 "cast from pointer to integer of different size");
4737 if (TREE_CODE (value) == CALL_EXPR
4738 && TREE_CODE (type) != TREE_CODE (otype))
4739 warning_at (loc, OPT_Wbad_function_cast,
4740 "cast from function call of type %qT "
4741 "to non-matching type %qT", otype, type);
4743 if (TREE_CODE (type) == POINTER_TYPE
4744 && TREE_CODE (otype) == INTEGER_TYPE
4745 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
4746 /* Don't warn about converting any constant. */
4747 && !TREE_CONSTANT (value))
4749 OPT_Wint_to_pointer_cast, "cast to pointer from integer "
4750 "of different size");
4752 if (warn_strict_aliasing <= 2)
4753 strict_aliasing_warning (otype, type, expr);
4755 /* If pedantic, warn for conversions between function and object
4756 pointer types, except for converting a null pointer constant
4757 to function pointer type. */
4759 && TREE_CODE (type) == POINTER_TYPE
4760 && TREE_CODE (otype) == POINTER_TYPE
4761 && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE
4762 && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE)
4763 pedwarn (loc, OPT_pedantic, "ISO C forbids "
4764 "conversion of function pointer to object pointer type");
4767 && TREE_CODE (type) == POINTER_TYPE
4768 && TREE_CODE (otype) == POINTER_TYPE
4769 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
4770 && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
4771 && !null_pointer_constant_p (value))
4772 pedwarn (loc, OPT_pedantic, "ISO C forbids "
4773 "conversion of object pointer to function pointer type");
4776 value = convert (type, value);
4778 /* Ignore any integer overflow caused by the cast. */
4779 if (TREE_CODE (value) == INTEGER_CST && !FLOAT_TYPE_P (otype))
4781 if (CONSTANT_CLASS_P (ovalue) && TREE_OVERFLOW (ovalue))
4783 if (!TREE_OVERFLOW (value))
4785 /* Avoid clobbering a shared constant. */
4786 value = copy_node (value);
4787 TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
4790 else if (TREE_OVERFLOW (value))
4791 /* Reset VALUE's overflow flags, ensuring constant sharing. */
4792 value = build_int_cst_wide (TREE_TYPE (value),
4793 TREE_INT_CST_LOW (value),
4794 TREE_INT_CST_HIGH (value));
4798 /* Don't let a cast be an lvalue. */
4800 value = non_lvalue_loc (loc, value);
4802 /* Don't allow the results of casting to floating-point or complex
4803 types be confused with actual constants, or casts involving
4804 integer and pointer types other than direct integer-to-integer
4805 and integer-to-pointer be confused with integer constant
4806 expressions and null pointer constants. */
4807 if (TREE_CODE (value) == REAL_CST
4808 || TREE_CODE (value) == COMPLEX_CST
4809 || (TREE_CODE (value) == INTEGER_CST
4810 && !((TREE_CODE (expr) == INTEGER_CST
4811 && INTEGRAL_TYPE_P (TREE_TYPE (expr)))
4812 || TREE_CODE (expr) == REAL_CST
4813 || TREE_CODE (expr) == COMPLEX_CST)))
4814 value = build1 (NOP_EXPR, type, value);
4816 if (CAN_HAVE_LOCATION_P (value))
4817 SET_EXPR_LOCATION (value, loc);
4821 /* Interpret a cast of expression EXPR to type TYPE. LOC is the
4822 location of the open paren of the cast, or the position of the cast
4825 c_cast_expr (location_t loc, struct c_type_name *type_name, tree expr)
4828 tree type_expr = NULL_TREE;
4829 bool type_expr_const = true;
4831 int saved_wsp = warn_strict_prototypes;
4833 /* This avoids warnings about unprototyped casts on
4834 integers. E.g. "#define SIG_DFL (void(*)())0". */
4835 if (TREE_CODE (expr) == INTEGER_CST)
4836 warn_strict_prototypes = 0;
4837 type = groktypename (type_name, &type_expr, &type_expr_const);
4838 warn_strict_prototypes = saved_wsp;
4840 ret = build_c_cast (loc, type, expr);
4843 ret = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (ret), type_expr, ret);
4844 C_MAYBE_CONST_EXPR_NON_CONST (ret) = !type_expr_const;
4845 SET_EXPR_LOCATION (ret, loc);
4848 if (CAN_HAVE_LOCATION_P (ret) && !EXPR_HAS_LOCATION (ret))
4849 SET_EXPR_LOCATION (ret, loc);
4851 /* C++ does not permits types to be defined in a cast, but it
4852 allows references to incomplete types. */
4853 if (warn_cxx_compat && type_name->specs->typespec_kind == ctsk_tagdef)
4854 warning_at (loc, OPT_Wc___compat,
4855 "defining a type in a cast is invalid in C++");
4860 /* Build an assignment expression of lvalue LHS from value RHS.
4861 If LHS_ORIGTYPE is not NULL, it is the original type of LHS, which
4862 may differ from TREE_TYPE (LHS) for an enum bitfield.
4863 MODIFYCODE is the code for a binary operator that we use
4864 to combine the old value of LHS with RHS to get the new value.
4865 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
4866 If RHS_ORIGTYPE is not NULL_TREE, it is the original type of RHS,
4867 which may differ from TREE_TYPE (RHS) for an enum value.
4869 LOCATION is the location of the MODIFYCODE operator.
4870 RHS_LOC is the location of the RHS. */
4873 build_modify_expr (location_t location, tree lhs, tree lhs_origtype,
4874 enum tree_code modifycode,
4875 location_t rhs_loc, tree rhs, tree rhs_origtype)
4879 tree rhs_semantic_type = NULL_TREE;
4880 tree lhstype = TREE_TYPE (lhs);
4881 tree olhstype = lhstype;
4884 /* Types that aren't fully specified cannot be used in assignments. */
4885 lhs = require_complete_type (lhs);
4887 /* Avoid duplicate error messages from operands that had errors. */
4888 if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
4889 return error_mark_node;
4891 /* For ObjC properties, defer this check. */
4892 if (!objc_is_property_ref (lhs) && !lvalue_or_else (location, lhs, lv_assign))
4893 return error_mark_node;
4895 if (TREE_CODE (rhs) == EXCESS_PRECISION_EXPR)
4897 rhs_semantic_type = TREE_TYPE (rhs);
4898 rhs = TREE_OPERAND (rhs, 0);
4903 if (TREE_CODE (lhs) == C_MAYBE_CONST_EXPR)
4905 tree inner = build_modify_expr (location, C_MAYBE_CONST_EXPR_EXPR (lhs),
4906 lhs_origtype, modifycode, rhs_loc, rhs,
4908 if (inner == error_mark_node)
4909 return error_mark_node;
4910 result = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (inner),
4911 C_MAYBE_CONST_EXPR_PRE (lhs), inner);
4912 gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (lhs));
4913 C_MAYBE_CONST_EXPR_NON_CONST (result) = 1;
4914 protected_set_expr_location (result, location);
4918 /* If a binary op has been requested, combine the old LHS value with the RHS
4919 producing the value we should actually store into the LHS. */
4921 if (modifycode != NOP_EXPR)
4923 lhs = c_fully_fold (lhs, false, NULL);
4924 lhs = stabilize_reference (lhs);
4925 newrhs = build_binary_op (location,
4926 modifycode, lhs, rhs, 1);
4928 /* The original type of the right hand side is no longer
4930 rhs_origtype = NULL_TREE;
4933 if (c_dialect_objc ())
4935 /* Check if we are modifying an Objective-C property reference;
4936 if so, we need to generate setter calls. */
4937 result = objc_maybe_build_modify_expr (lhs, newrhs);
4941 /* Else, do the check that we postponed for Objective-C. */
4942 if (!lvalue_or_else (location, lhs, lv_assign))
4943 return error_mark_node;
4946 /* Give an error for storing in something that is 'const'. */
4948 if (TYPE_READONLY (lhstype)
4949 || ((TREE_CODE (lhstype) == RECORD_TYPE
4950 || TREE_CODE (lhstype) == UNION_TYPE)
4951 && C_TYPE_FIELDS_READONLY (lhstype)))
4953 readonly_error (lhs, lv_assign);
4954 return error_mark_node;
4956 else if (TREE_READONLY (lhs))
4957 readonly_warning (lhs, lv_assign);
4959 /* If storing into a structure or union member,
4960 it has probably been given type `int'.
4961 Compute the type that would go with
4962 the actual amount of storage the member occupies. */
4964 if (TREE_CODE (lhs) == COMPONENT_REF
4965 && (TREE_CODE (lhstype) == INTEGER_TYPE
4966 || TREE_CODE (lhstype) == BOOLEAN_TYPE
4967 || TREE_CODE (lhstype) == REAL_TYPE
4968 || TREE_CODE (lhstype) == ENUMERAL_TYPE))
4969 lhstype = TREE_TYPE (get_unwidened (lhs, 0));
4971 /* If storing in a field that is in actuality a short or narrower than one,
4972 we must store in the field in its actual type. */
4974 if (lhstype != TREE_TYPE (lhs))
4976 lhs = copy_node (lhs);
4977 TREE_TYPE (lhs) = lhstype;
4980 /* Issue -Wc++-compat warnings about an assignment to an enum type
4981 when LHS does not have its original type. This happens for,
4982 e.g., an enum bitfield in a struct. */
4984 && lhs_origtype != NULL_TREE
4985 && lhs_origtype != lhstype
4986 && TREE_CODE (lhs_origtype) == ENUMERAL_TYPE)
4988 tree checktype = (rhs_origtype != NULL_TREE
4991 if (checktype != error_mark_node
4992 && TYPE_MAIN_VARIANT (checktype) != TYPE_MAIN_VARIANT (lhs_origtype))
4993 warning_at (location, OPT_Wc___compat,
4994 "enum conversion in assignment is invalid in C++");
4997 /* Convert new value to destination type. Fold it first, then
4998 restore any excess precision information, for the sake of
4999 conversion warnings. */
5001 npc = null_pointer_constant_p (newrhs);
5002 newrhs = c_fully_fold (newrhs, false, NULL);
5003 if (rhs_semantic_type)
5004 newrhs = build1 (EXCESS_PRECISION_EXPR, rhs_semantic_type, newrhs);
5005 newrhs = convert_for_assignment (location, lhstype, newrhs, rhs_origtype,
5006 ic_assign, npc, NULL_TREE, NULL_TREE, 0);
5007 if (TREE_CODE (newrhs) == ERROR_MARK)
5008 return error_mark_node;
5010 /* Emit ObjC write barrier, if necessary. */
5011 if (c_dialect_objc () && flag_objc_gc)
5013 result = objc_generate_write_barrier (lhs, modifycode, newrhs);
5016 protected_set_expr_location (result, location);
5021 /* Scan operands. */
5023 result = build2 (MODIFY_EXPR, lhstype, lhs, newrhs);
5024 TREE_SIDE_EFFECTS (result) = 1;
5025 protected_set_expr_location (result, location);
5027 /* If we got the LHS in a different type for storing in,
5028 convert the result back to the nominal type of LHS
5029 so that the value we return always has the same type
5030 as the LHS argument. */
5032 if (olhstype == TREE_TYPE (result))
5035 result = convert_for_assignment (location, olhstype, result, rhs_origtype,
5036 ic_assign, false, NULL_TREE, NULL_TREE, 0);
5037 protected_set_expr_location (result, location);
5041 /* Return whether STRUCT_TYPE has an anonymous field with type TYPE.
5042 This is used to implement -fplan9-extensions. */
5045 find_anonymous_field_with_type (tree struct_type, tree type)
5050 gcc_assert (TREE_CODE (struct_type) == RECORD_TYPE
5051 || TREE_CODE (struct_type) == UNION_TYPE);
5053 for (field = TYPE_FIELDS (struct_type);
5055 field = TREE_CHAIN (field))
5057 if (DECL_NAME (field) == NULL
5058 && comptypes (type, TYPE_MAIN_VARIANT (TREE_TYPE (field))))
5064 else if (DECL_NAME (field) == NULL
5065 && (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
5066 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
5067 && find_anonymous_field_with_type (TREE_TYPE (field), type))
5077 /* RHS is an expression whose type is pointer to struct. If there is
5078 an anonymous field in RHS with type TYPE, then return a pointer to
5079 that field in RHS. This is used with -fplan9-extensions. This
5080 returns NULL if no conversion could be found. */
5083 convert_to_anonymous_field (location_t location, tree type, tree rhs)
5085 tree rhs_struct_type, lhs_main_type;
5086 tree field, found_field;
5087 bool found_sub_field;
5090 gcc_assert (POINTER_TYPE_P (TREE_TYPE (rhs)));
5091 rhs_struct_type = TREE_TYPE (TREE_TYPE (rhs));
5092 gcc_assert (TREE_CODE (rhs_struct_type) == RECORD_TYPE
5093 || TREE_CODE (rhs_struct_type) == UNION_TYPE);
5095 gcc_assert (POINTER_TYPE_P (type));
5096 lhs_main_type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
5098 found_field = NULL_TREE;
5099 found_sub_field = false;
5100 for (field = TYPE_FIELDS (rhs_struct_type);
5102 field = TREE_CHAIN (field))
5104 if (DECL_NAME (field) != NULL_TREE
5105 || (TREE_CODE (TREE_TYPE (field)) != RECORD_TYPE
5106 && TREE_CODE (TREE_TYPE (field)) != UNION_TYPE))
5108 if (comptypes (lhs_main_type, TYPE_MAIN_VARIANT (TREE_TYPE (field))))
5110 if (found_field != NULL_TREE)
5112 found_field = field;
5114 else if (find_anonymous_field_with_type (TREE_TYPE (field),
5117 if (found_field != NULL_TREE)
5119 found_field = field;
5120 found_sub_field = true;
5124 if (found_field == NULL_TREE)
5127 ret = fold_build3_loc (location, COMPONENT_REF, TREE_TYPE (found_field),
5128 build_fold_indirect_ref (rhs), found_field,
5130 ret = build_fold_addr_expr_loc (location, ret);
5132 if (found_sub_field)
5134 ret = convert_to_anonymous_field (location, type, ret);
5135 gcc_assert (ret != NULL_TREE);
5141 /* Convert value RHS to type TYPE as preparation for an assignment to
5142 an lvalue of type TYPE. If ORIGTYPE is not NULL_TREE, it is the
5143 original type of RHS; this differs from TREE_TYPE (RHS) for enum
5144 types. NULL_POINTER_CONSTANT says whether RHS was a null pointer
5145 constant before any folding.
5146 The real work of conversion is done by `convert'.
5147 The purpose of this function is to generate error messages
5148 for assignments that are not allowed in C.
5149 ERRTYPE says whether it is argument passing, assignment,
5150 initialization or return.
5152 LOCATION is the location of the RHS.
5153 FUNCTION is a tree for the function being called.
5154 PARMNUM is the number of the argument, for printing in error messages. */
5157 convert_for_assignment (location_t location, tree type, tree rhs,
5158 tree origtype, enum impl_conv errtype,
5159 bool null_pointer_constant, tree fundecl,
5160 tree function, int parmnum)
5162 enum tree_code codel = TREE_CODE (type);
5163 tree orig_rhs = rhs;
5165 enum tree_code coder;
5166 tree rname = NULL_TREE;
5167 bool objc_ok = false;
5169 if (errtype == ic_argpass)
5172 /* Change pointer to function to the function itself for
5174 if (TREE_CODE (function) == ADDR_EXPR
5175 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
5176 function = TREE_OPERAND (function, 0);
5178 /* Handle an ObjC selector specially for diagnostics. */
5179 selector = objc_message_selector ();
5181 if (selector && parmnum > 2)
5188 /* This macro is used to emit diagnostics to ensure that all format
5189 strings are complete sentences, visible to gettext and checked at
5191 #define WARN_FOR_ASSIGNMENT(LOCATION, OPT, AR, AS, IN, RE) \
5196 if (pedwarn (LOCATION, OPT, AR, parmnum, rname)) \
5197 inform ((fundecl && !DECL_IS_BUILTIN (fundecl)) \
5198 ? DECL_SOURCE_LOCATION (fundecl) : LOCATION, \
5199 "expected %qT but argument is of type %qT", \
5203 pedwarn (LOCATION, OPT, AS); \
5206 pedwarn_init (LOCATION, OPT, IN); \
5209 pedwarn (LOCATION, OPT, RE); \
5212 gcc_unreachable (); \
5216 /* This macro is used to emit diagnostics to ensure that all format
5217 strings are complete sentences, visible to gettext and checked at
5218 compile time. It is the same as WARN_FOR_ASSIGNMENT but with an
5219 extra parameter to enumerate qualifiers. */
5221 #define WARN_FOR_QUALIFIERS(LOCATION, OPT, AR, AS, IN, RE, QUALS) \
5226 if (pedwarn (LOCATION, OPT, AR, parmnum, rname, QUALS)) \
5227 inform ((fundecl && !DECL_IS_BUILTIN (fundecl)) \
5228 ? DECL_SOURCE_LOCATION (fundecl) : LOCATION, \
5229 "expected %qT but argument is of type %qT", \
5233 pedwarn (LOCATION, OPT, AS, QUALS); \
5236 pedwarn (LOCATION, OPT, IN, QUALS); \
5239 pedwarn (LOCATION, OPT, RE, QUALS); \
5242 gcc_unreachable (); \
5246 if (TREE_CODE (rhs) == EXCESS_PRECISION_EXPR)
5247 rhs = TREE_OPERAND (rhs, 0);
5249 rhstype = TREE_TYPE (rhs);
5250 coder = TREE_CODE (rhstype);
5252 if (coder == ERROR_MARK)
5253 return error_mark_node;
5255 if (c_dialect_objc ())
5278 objc_ok = objc_compare_types (type, rhstype, parmno, rname);
5281 if (warn_cxx_compat)
5283 tree checktype = origtype != NULL_TREE ? origtype : rhstype;
5284 if (checktype != error_mark_node
5285 && TREE_CODE (type) == ENUMERAL_TYPE
5286 && TYPE_MAIN_VARIANT (checktype) != TYPE_MAIN_VARIANT (type))
5288 WARN_FOR_ASSIGNMENT (input_location, OPT_Wc___compat,
5289 G_("enum conversion when passing argument "
5290 "%d of %qE is invalid in C++"),
5291 G_("enum conversion in assignment is "
5293 G_("enum conversion in initialization is "
5295 G_("enum conversion in return is "
5300 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
5303 if (coder == VOID_TYPE)
5305 /* Except for passing an argument to an unprototyped function,
5306 this is a constraint violation. When passing an argument to
5307 an unprototyped function, it is compile-time undefined;
5308 making it a constraint in that case was rejected in
5310 error_at (location, "void value not ignored as it ought to be");
5311 return error_mark_node;
5313 rhs = require_complete_type (rhs);
5314 if (rhs == error_mark_node)
5315 return error_mark_node;
5316 /* A type converts to a reference to it.
5317 This code doesn't fully support references, it's just for the
5318 special case of va_start and va_copy. */
5319 if (codel == REFERENCE_TYPE
5320 && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1)
5322 if (!lvalue_p (rhs))
5324 error_at (location, "cannot pass rvalue to reference parameter");
5325 return error_mark_node;
5327 if (!c_mark_addressable (rhs))
5328 return error_mark_node;
5329 rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
5330 SET_EXPR_LOCATION (rhs, location);
5332 /* We already know that these two types are compatible, but they
5333 may not be exactly identical. In fact, `TREE_TYPE (type)' is
5334 likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
5335 likely to be va_list, a typedef to __builtin_va_list, which
5336 is different enough that it will cause problems later. */
5337 if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
5339 rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
5340 SET_EXPR_LOCATION (rhs, location);
5343 rhs = build1 (NOP_EXPR, type, rhs);
5344 SET_EXPR_LOCATION (rhs, location);
5347 /* Some types can interconvert without explicit casts. */
5348 else if (codel == VECTOR_TYPE && coder == VECTOR_TYPE
5349 && vector_types_convertible_p (type, TREE_TYPE (rhs), true))
5350 return convert (type, rhs);
5351 /* Arithmetic types all interconvert, and enum is treated like int. */
5352 else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
5353 || codel == FIXED_POINT_TYPE
5354 || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
5355 || codel == BOOLEAN_TYPE)
5356 && (coder == INTEGER_TYPE || coder == REAL_TYPE
5357 || coder == FIXED_POINT_TYPE
5358 || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE
5359 || coder == BOOLEAN_TYPE))
5362 bool save = in_late_binary_op;
5363 if (codel == BOOLEAN_TYPE || codel == COMPLEX_TYPE)
5364 in_late_binary_op = true;
5365 ret = convert_and_check (type, orig_rhs);
5366 if (codel == BOOLEAN_TYPE || codel == COMPLEX_TYPE)
5367 in_late_binary_op = save;
5371 /* Aggregates in different TUs might need conversion. */
5372 if ((codel == RECORD_TYPE || codel == UNION_TYPE)
5374 && comptypes (type, rhstype))
5375 return convert_and_check (type, rhs);
5377 /* Conversion to a transparent union or record from its member types.
5378 This applies only to function arguments. */
5379 if (((codel == UNION_TYPE || codel == RECORD_TYPE)
5380 && TYPE_TRANSPARENT_AGGR (type))
5381 && errtype == ic_argpass)
5383 tree memb, marginal_memb = NULL_TREE;
5385 for (memb = TYPE_FIELDS (type); memb ; memb = DECL_CHAIN (memb))
5387 tree memb_type = TREE_TYPE (memb);
5389 if (comptypes (TYPE_MAIN_VARIANT (memb_type),
5390 TYPE_MAIN_VARIANT (rhstype)))
5393 if (TREE_CODE (memb_type) != POINTER_TYPE)
5396 if (coder == POINTER_TYPE)
5398 tree ttl = TREE_TYPE (memb_type);
5399 tree ttr = TREE_TYPE (rhstype);
5401 /* Any non-function converts to a [const][volatile] void *
5402 and vice versa; otherwise, targets must be the same.
5403 Meanwhile, the lhs target must have all the qualifiers of
5405 if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
5406 || comp_target_types (location, memb_type, rhstype))
5408 /* If this type won't generate any warnings, use it. */
5409 if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
5410 || ((TREE_CODE (ttr) == FUNCTION_TYPE
5411 && TREE_CODE (ttl) == FUNCTION_TYPE)
5412 ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
5413 == TYPE_QUALS (ttr))
5414 : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
5415 == TYPE_QUALS (ttl))))
5418 /* Keep looking for a better type, but remember this one. */
5420 marginal_memb = memb;
5424 /* Can convert integer zero to any pointer type. */
5425 if (null_pointer_constant)
5427 rhs = null_pointer_node;
5432 if (memb || marginal_memb)
5436 /* We have only a marginally acceptable member type;
5437 it needs a warning. */
5438 tree ttl = TREE_TYPE (TREE_TYPE (marginal_memb));
5439 tree ttr = TREE_TYPE (rhstype);
5441 /* Const and volatile mean something different for function
5442 types, so the usual warnings are not appropriate. */
5443 if (TREE_CODE (ttr) == FUNCTION_TYPE
5444 && TREE_CODE (ttl) == FUNCTION_TYPE)
5446 /* Because const and volatile on functions are
5447 restrictions that say the function will not do
5448 certain things, it is okay to use a const or volatile
5449 function where an ordinary one is wanted, but not
5451 if (TYPE_QUALS_NO_ADDR_SPACE (ttl)
5452 & ~TYPE_QUALS_NO_ADDR_SPACE (ttr))
5453 WARN_FOR_QUALIFIERS (location, 0,
5454 G_("passing argument %d of %qE "
5455 "makes %q#v qualified function "
5456 "pointer from unqualified"),
5457 G_("assignment makes %q#v qualified "
5458 "function pointer from "
5460 G_("initialization makes %q#v qualified "
5461 "function pointer from "
5463 G_("return makes %q#v qualified function "
5464 "pointer from unqualified"),
5465 TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr));
5467 else if (TYPE_QUALS_NO_ADDR_SPACE (ttr)
5468 & ~TYPE_QUALS_NO_ADDR_SPACE (ttl))
5469 WARN_FOR_QUALIFIERS (location, 0,
5470 G_("passing argument %d of %qE discards "
5471 "%qv qualifier from pointer target type"),
5472 G_("assignment discards %qv qualifier "
5473 "from pointer target type"),
5474 G_("initialization discards %qv qualifier "
5475 "from pointer target type"),
5476 G_("return discards %qv qualifier from "
5477 "pointer target type"),
5478 TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl));
5480 memb = marginal_memb;
5483 if (!fundecl || !DECL_IN_SYSTEM_HEADER (fundecl))
5484 pedwarn (location, OPT_pedantic,
5485 "ISO C prohibits argument conversion to union type");
5487 rhs = fold_convert_loc (location, TREE_TYPE (memb), rhs);
5488 return build_constructor_single (type, memb, rhs);
5492 /* Conversions among pointers */
5493 else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
5494 && (coder == codel))
5496 tree ttl = TREE_TYPE (type);
5497 tree ttr = TREE_TYPE (rhstype);
5500 bool is_opaque_pointer;
5501 int target_cmp = 0; /* Cache comp_target_types () result. */
5505 if (TREE_CODE (mvl) != ARRAY_TYPE)
5506 mvl = TYPE_MAIN_VARIANT (mvl);
5507 if (TREE_CODE (mvr) != ARRAY_TYPE)
5508 mvr = TYPE_MAIN_VARIANT (mvr);
5509 /* Opaque pointers are treated like void pointers. */
5510 is_opaque_pointer = vector_targets_convertible_p (ttl, ttr);
5512 /* The Plan 9 compiler permits a pointer to a struct to be
5513 automatically converted into a pointer to an anonymous field
5514 within the struct. */
5515 if (flag_plan9_extensions
5516 && (TREE_CODE (mvl) == RECORD_TYPE || TREE_CODE(mvl) == UNION_TYPE)
5517 && (TREE_CODE (mvr) == RECORD_TYPE || TREE_CODE(mvr) == UNION_TYPE)
5520 tree new_rhs = convert_to_anonymous_field (location, type, rhs);
5521 if (new_rhs != NULL_TREE)
5524 rhstype = TREE_TYPE (rhs);
5525 coder = TREE_CODE (rhstype);
5526 ttr = TREE_TYPE (rhstype);
5527 mvr = TYPE_MAIN_VARIANT (ttr);
5531 /* C++ does not allow the implicit conversion void* -> T*. However,
5532 for the purpose of reducing the number of false positives, we
5533 tolerate the special case of
5537 where NULL is typically defined in C to be '(void *) 0'. */
5538 if (VOID_TYPE_P (ttr) && rhs != null_pointer_node && !VOID_TYPE_P (ttl))
5539 warning_at (location, OPT_Wc___compat,
5540 "request for implicit conversion "
5541 "from %qT to %qT not permitted in C++", rhstype, type);
5543 /* See if the pointers point to incompatible address spaces. */
5544 asl = TYPE_ADDR_SPACE (ttl);
5545 asr = TYPE_ADDR_SPACE (ttr);
5546 if (!null_pointer_constant_p (rhs)
5547 && asr != asl && !targetm.addr_space.subset_p (asr, asl))
5552 error_at (location, "passing argument %d of %qE from pointer to "
5553 "non-enclosed address space", parmnum, rname);
5556 error_at (location, "assignment from pointer to "
5557 "non-enclosed address space");
5560 error_at (location, "initialization from pointer to "
5561 "non-enclosed address space");
5564 error_at (location, "return from pointer to "
5565 "non-enclosed address space");
5570 return error_mark_node;
5573 /* Check if the right-hand side has a format attribute but the
5574 left-hand side doesn't. */
5575 if (warn_missing_format_attribute
5576 && check_missing_format_attribute (type, rhstype))
5581 warning_at (location, OPT_Wmissing_format_attribute,
5582 "argument %d of %qE might be "
5583 "a candidate for a format attribute",
5587 warning_at (location, OPT_Wmissing_format_attribute,
5588 "assignment left-hand side might be "
5589 "a candidate for a format attribute");
5592 warning_at (location, OPT_Wmissing_format_attribute,
5593 "initialization left-hand side might be "
5594 "a candidate for a format attribute");
5597 warning_at (location, OPT_Wmissing_format_attribute,
5598 "return type might be "
5599 "a candidate for a format attribute");
5606 /* Any non-function converts to a [const][volatile] void *
5607 and vice versa; otherwise, targets must be the same.
5608 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
5609 if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
5610 || (target_cmp = comp_target_types (location, type, rhstype))
5611 || is_opaque_pointer
5612 || (c_common_unsigned_type (mvl)
5613 == c_common_unsigned_type (mvr)))
5616 && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
5619 && !null_pointer_constant
5620 && TREE_CODE (ttl) == FUNCTION_TYPE)))
5621 WARN_FOR_ASSIGNMENT (location, OPT_pedantic,
5622 G_("ISO C forbids passing argument %d of "
5623 "%qE between function pointer "
5625 G_("ISO C forbids assignment between "
5626 "function pointer and %<void *%>"),
5627 G_("ISO C forbids initialization between "
5628 "function pointer and %<void *%>"),
5629 G_("ISO C forbids return between function "
5630 "pointer and %<void *%>"));
5631 /* Const and volatile mean something different for function types,
5632 so the usual warnings are not appropriate. */
5633 else if (TREE_CODE (ttr) != FUNCTION_TYPE
5634 && TREE_CODE (ttl) != FUNCTION_TYPE)
5636 if (TYPE_QUALS_NO_ADDR_SPACE (ttr)
5637 & ~TYPE_QUALS_NO_ADDR_SPACE (ttl))
5639 WARN_FOR_QUALIFIERS (location, 0,
5640 G_("passing argument %d of %qE discards "
5641 "%qv qualifier from pointer target type"),
5642 G_("assignment discards %qv qualifier "
5643 "from pointer target type"),
5644 G_("initialization discards %qv qualifier "
5645 "from pointer target type"),
5646 G_("return discards %qv qualifier from "
5647 "pointer target type"),
5648 TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl));
5650 /* If this is not a case of ignoring a mismatch in signedness,
5652 else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
5655 /* If there is a mismatch, do warn. */
5656 else if (warn_pointer_sign)
5657 WARN_FOR_ASSIGNMENT (location, OPT_Wpointer_sign,
5658 G_("pointer targets in passing argument "
5659 "%d of %qE differ in signedness"),
5660 G_("pointer targets in assignment "
5661 "differ in signedness"),
5662 G_("pointer targets in initialization "
5663 "differ in signedness"),
5664 G_("pointer targets in return differ "
5667 else if (TREE_CODE (ttl) == FUNCTION_TYPE
5668 && TREE_CODE (ttr) == FUNCTION_TYPE)
5670 /* Because const and volatile on functions are restrictions
5671 that say the function will not do certain things,
5672 it is okay to use a const or volatile function
5673 where an ordinary one is wanted, but not vice-versa. */
5674 if (TYPE_QUALS_NO_ADDR_SPACE (ttl)
5675 & ~TYPE_QUALS_NO_ADDR_SPACE (ttr))
5676 WARN_FOR_QUALIFIERS (location, 0,
5677 G_("passing argument %d of %qE makes "
5678 "%q#v qualified function pointer "
5679 "from unqualified"),
5680 G_("assignment makes %q#v qualified function "
5681 "pointer from unqualified"),
5682 G_("initialization makes %q#v qualified "
5683 "function pointer from unqualified"),
5684 G_("return makes %q#v qualified function "
5685 "pointer from unqualified"),
5686 TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr));
5690 /* Avoid warning about the volatile ObjC EH puts on decls. */
5692 WARN_FOR_ASSIGNMENT (location, 0,
5693 G_("passing argument %d of %qE from "
5694 "incompatible pointer type"),
5695 G_("assignment from incompatible pointer type"),
5696 G_("initialization from incompatible "
5698 G_("return from incompatible pointer type"));
5700 return convert (type, rhs);
5702 else if (codel == POINTER_TYPE && coder == ARRAY_TYPE)
5704 /* ??? This should not be an error when inlining calls to
5705 unprototyped functions. */
5706 error_at (location, "invalid use of non-lvalue array");
5707 return error_mark_node;
5709 else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
5711 /* An explicit constant 0 can convert to a pointer,
5712 or one that results from arithmetic, even including
5713 a cast to integer type. */
5714 if (!null_pointer_constant)
5715 WARN_FOR_ASSIGNMENT (location, 0,
5716 G_("passing argument %d of %qE makes "
5717 "pointer from integer without a cast"),
5718 G_("assignment makes pointer from integer "
5720 G_("initialization makes pointer from "
5721 "integer without a cast"),
5722 G_("return makes pointer from integer "
5725 return convert (type, rhs);
5727 else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
5729 WARN_FOR_ASSIGNMENT (location, 0,
5730 G_("passing argument %d of %qE makes integer "
5731 "from pointer without a cast"),
5732 G_("assignment makes integer from pointer "
5734 G_("initialization makes integer from pointer "
5736 G_("return makes integer from pointer "
5738 return convert (type, rhs);
5740 else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
5743 bool save = in_late_binary_op;
5744 in_late_binary_op = true;
5745 ret = convert (type, rhs);
5746 in_late_binary_op = save;
5753 error_at (location, "incompatible type for argument %d of %qE", parmnum, rname);
5754 inform ((fundecl && !DECL_IS_BUILTIN (fundecl))
5755 ? DECL_SOURCE_LOCATION (fundecl) : input_location,
5756 "expected %qT but argument is of type %qT", type, rhstype);
5759 error_at (location, "incompatible types when assigning to type %qT from "
5760 "type %qT", type, rhstype);
5764 "incompatible types when initializing type %qT using type %qT",
5769 "incompatible types when returning type %qT but %qT was "
5770 "expected", rhstype, type);
5776 return error_mark_node;
5779 /* If VALUE is a compound expr all of whose expressions are constant, then
5780 return its value. Otherwise, return error_mark_node.
5782 This is for handling COMPOUND_EXPRs as initializer elements
5783 which is allowed with a warning when -pedantic is specified. */
5786 valid_compound_expr_initializer (tree value, tree endtype)
5788 if (TREE_CODE (value) == COMPOUND_EXPR)
5790 if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
5792 return error_mark_node;
5793 return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
5796 else if (!initializer_constant_valid_p (value, endtype))
5797 return error_mark_node;
5802 /* Perform appropriate conversions on the initial value of a variable,
5803 store it in the declaration DECL,
5804 and print any error messages that are appropriate.
5805 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
5806 If the init is invalid, store an ERROR_MARK.
5808 INIT_LOC is the location of the initial value. */
5811 store_init_value (location_t init_loc, tree decl, tree init, tree origtype)
5816 /* If variable's type was invalidly declared, just ignore it. */
5818 type = TREE_TYPE (decl);
5819 if (TREE_CODE (type) == ERROR_MARK)
5822 /* Digest the specified initializer into an expression. */
5825 npc = null_pointer_constant_p (init);
5826 value = digest_init (init_loc, type, init, origtype, npc,
5827 true, TREE_STATIC (decl));
5829 /* Store the expression if valid; else report error. */
5831 if (!in_system_header
5832 && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && !TREE_STATIC (decl))
5833 warning (OPT_Wtraditional, "traditional C rejects automatic "
5834 "aggregate initialization");
5836 DECL_INITIAL (decl) = value;
5838 /* ANSI wants warnings about out-of-range constant initializers. */
5839 STRIP_TYPE_NOPS (value);
5840 if (TREE_STATIC (decl))
5841 constant_expression_warning (value);
5843 /* Check if we need to set array size from compound literal size. */
5844 if (TREE_CODE (type) == ARRAY_TYPE
5845 && TYPE_DOMAIN (type) == 0
5846 && value != error_mark_node)
5848 tree inside_init = init;
5850 STRIP_TYPE_NOPS (inside_init);
5851 inside_init = fold (inside_init);
5853 if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
5855 tree cldecl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
5857 if (TYPE_DOMAIN (TREE_TYPE (cldecl)))
5859 /* For int foo[] = (int [3]){1}; we need to set array size
5860 now since later on array initializer will be just the
5861 brace enclosed list of the compound literal. */
5862 tree etype = strip_array_types (TREE_TYPE (decl));
5863 type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
5864 TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (cldecl));
5866 layout_decl (cldecl, 0);
5868 = c_build_qualified_type (type, TYPE_QUALS (etype));
5874 /* Methods for storing and printing names for error messages. */
5876 /* Implement a spelling stack that allows components of a name to be pushed
5877 and popped. Each element on the stack is this structure. */
5884 unsigned HOST_WIDE_INT i;
5889 #define SPELLING_STRING 1
5890 #define SPELLING_MEMBER 2
5891 #define SPELLING_BOUNDS 3
5893 static struct spelling *spelling; /* Next stack element (unused). */
5894 static struct spelling *spelling_base; /* Spelling stack base. */
5895 static int spelling_size; /* Size of the spelling stack. */
5897 /* Macros to save and restore the spelling stack around push_... functions.
5898 Alternative to SAVE_SPELLING_STACK. */
5900 #define SPELLING_DEPTH() (spelling - spelling_base)
5901 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
5903 /* Push an element on the spelling stack with type KIND and assign VALUE
5906 #define PUSH_SPELLING(KIND, VALUE, MEMBER) \
5908 int depth = SPELLING_DEPTH (); \
5910 if (depth >= spelling_size) \
5912 spelling_size += 10; \
5913 spelling_base = XRESIZEVEC (struct spelling, spelling_base, \
5915 RESTORE_SPELLING_DEPTH (depth); \
5918 spelling->kind = (KIND); \
5919 spelling->MEMBER = (VALUE); \
5923 /* Push STRING on the stack. Printed literally. */
5926 push_string (const char *string)
5928 PUSH_SPELLING (SPELLING_STRING, string, u.s);
5931 /* Push a member name on the stack. Printed as '.' STRING. */
5934 push_member_name (tree decl)
5936 const char *const string
5938 ? identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl)))
5939 : _("<anonymous>"));
5940 PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
5943 /* Push an array bounds on the stack. Printed as [BOUNDS]. */
5946 push_array_bounds (unsigned HOST_WIDE_INT bounds)
5948 PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
5951 /* Compute the maximum size in bytes of the printed spelling. */
5954 spelling_length (void)
5959 for (p = spelling_base; p < spelling; p++)
5961 if (p->kind == SPELLING_BOUNDS)
5964 size += strlen (p->u.s) + 1;
5970 /* Print the spelling to BUFFER and return it. */
5973 print_spelling (char *buffer)
5978 for (p = spelling_base; p < spelling; p++)
5979 if (p->kind == SPELLING_BOUNDS)
5981 sprintf (d, "[" HOST_WIDE_INT_PRINT_UNSIGNED "]", p->u.i);
5987 if (p->kind == SPELLING_MEMBER)
5989 for (s = p->u.s; (*d = *s++); d++)
5996 /* Issue an error message for a bad initializer component.
5997 GMSGID identifies the message.
5998 The component name is taken from the spelling stack. */
6001 error_init (const char *gmsgid)
6005 /* The gmsgid may be a format string with %< and %>. */
6007 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
6009 error ("(near initialization for %qs)", ofwhat);
6012 /* Issue a pedantic warning for a bad initializer component. OPT is
6013 the option OPT_* (from options.h) controlling this warning or 0 if
6014 it is unconditionally given. GMSGID identifies the message. The
6015 component name is taken from the spelling stack. */
6018 pedwarn_init (location_t location, int opt, const char *gmsgid)
6022 /* The gmsgid may be a format string with %< and %>. */
6023 pedwarn (location, opt, gmsgid);
6024 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
6026 pedwarn (location, opt, "(near initialization for %qs)", ofwhat);
6029 /* Issue a warning for a bad initializer component.
6031 OPT is the OPT_W* value corresponding to the warning option that
6032 controls this warning. GMSGID identifies the message. The
6033 component name is taken from the spelling stack. */
6036 warning_init (int opt, const char *gmsgid)
6040 /* The gmsgid may be a format string with %< and %>. */
6041 warning (opt, gmsgid);
6042 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
6044 warning (opt, "(near initialization for %qs)", ofwhat);
6047 /* If TYPE is an array type and EXPR is a parenthesized string
6048 constant, warn if pedantic that EXPR is being used to initialize an
6049 object of type TYPE. */
6052 maybe_warn_string_init (tree type, struct c_expr expr)
6055 && TREE_CODE (type) == ARRAY_TYPE
6056 && TREE_CODE (expr.value) == STRING_CST
6057 && expr.original_code != STRING_CST)
6058 pedwarn_init (input_location, OPT_pedantic,
6059 "array initialized from parenthesized string constant");
6062 /* Digest the parser output INIT as an initializer for type TYPE.
6063 Return a C expression of type TYPE to represent the initial value.
6065 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
6067 NULL_POINTER_CONSTANT is true if INIT is a null pointer constant.
6069 If INIT is a string constant, STRICT_STRING is true if it is
6070 unparenthesized or we should not warn here for it being parenthesized.
6071 For other types of INIT, STRICT_STRING is not used.
6073 INIT_LOC is the location of the INIT.
6075 REQUIRE_CONSTANT requests an error if non-constant initializers or
6076 elements are seen. */
6079 digest_init (location_t init_loc, tree type, tree init, tree origtype,
6080 bool null_pointer_constant, bool strict_string,
6081 int require_constant)
6083 enum tree_code code = TREE_CODE (type);
6084 tree inside_init = init;
6085 tree semantic_type = NULL_TREE;
6086 bool maybe_const = true;
6088 if (type == error_mark_node
6090 || init == error_mark_node
6091 || TREE_TYPE (init) == error_mark_node)
6092 return error_mark_node;
6094 STRIP_TYPE_NOPS (inside_init);
6096 if (TREE_CODE (inside_init) == EXCESS_PRECISION_EXPR)
6098 semantic_type = TREE_TYPE (inside_init);
6099 inside_init = TREE_OPERAND (inside_init, 0);
6101 inside_init = c_fully_fold (inside_init, require_constant, &maybe_const);
6102 inside_init = decl_constant_value_for_optimization (inside_init);
6104 /* Initialization of an array of chars from a string constant
6105 optionally enclosed in braces. */
6107 if (code == ARRAY_TYPE && inside_init
6108 && TREE_CODE (inside_init) == STRING_CST)
6110 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
6111 /* Note that an array could be both an array of character type
6112 and an array of wchar_t if wchar_t is signed char or unsigned
6114 bool char_array = (typ1 == char_type_node
6115 || typ1 == signed_char_type_node
6116 || typ1 == unsigned_char_type_node);
6117 bool wchar_array = !!comptypes (typ1, wchar_type_node);
6118 bool char16_array = !!comptypes (typ1, char16_type_node);
6119 bool char32_array = !!comptypes (typ1, char32_type_node);
6121 if (char_array || wchar_array || char16_array || char32_array)
6124 tree typ2 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)));
6125 expr.value = inside_init;
6126 expr.original_code = (strict_string ? STRING_CST : ERROR_MARK);
6127 expr.original_type = NULL;
6128 maybe_warn_string_init (type, expr);
6130 if (TYPE_DOMAIN (type) && !TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
6131 pedwarn_init (init_loc, OPT_pedantic,
6132 "initialization of a flexible array member");
6134 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
6135 TYPE_MAIN_VARIANT (type)))
6140 if (typ2 != char_type_node)
6142 error_init ("char-array initialized from wide string");
6143 return error_mark_node;
6148 if (typ2 == char_type_node)
6150 error_init ("wide character array initialized from non-wide "
6152 return error_mark_node;
6154 else if (!comptypes(typ1, typ2))
6156 error_init ("wide character array initialized from "
6157 "incompatible wide string");
6158 return error_mark_node;
6162 TREE_TYPE (inside_init) = type;
6163 if (TYPE_DOMAIN (type) != 0
6164 && TYPE_SIZE (type) != 0
6165 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
6167 unsigned HOST_WIDE_INT len = TREE_STRING_LENGTH (inside_init);
6169 /* Subtract the size of a single (possibly wide) character
6170 because it's ok to ignore the terminating null char
6171 that is counted in the length of the constant. */
6172 if (0 > compare_tree_int (TYPE_SIZE_UNIT (type),
6174 - (TYPE_PRECISION (typ1)
6176 pedwarn_init (init_loc, 0,
6177 ("initializer-string for array of chars "
6179 else if (warn_cxx_compat
6180 && 0 > compare_tree_int (TYPE_SIZE_UNIT (type), len))
6181 warning_at (init_loc, OPT_Wc___compat,
6182 ("initializer-string for array chars "
6183 "is too long for C++"));
6188 else if (INTEGRAL_TYPE_P (typ1))
6190 error_init ("array of inappropriate type initialized "
6191 "from string constant");
6192 return error_mark_node;
6196 /* Build a VECTOR_CST from a *constant* vector constructor. If the
6197 vector constructor is not constant (e.g. {1,2,3,foo()}) then punt
6198 below and handle as a constructor. */
6199 if (code == VECTOR_TYPE
6200 && TREE_CODE (TREE_TYPE (inside_init)) == VECTOR_TYPE
6201 && vector_types_convertible_p (TREE_TYPE (inside_init), type, true)
6202 && TREE_CONSTANT (inside_init))
6204 if (TREE_CODE (inside_init) == VECTOR_CST
6205 && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
6206 TYPE_MAIN_VARIANT (type)))
6209 if (TREE_CODE (inside_init) == CONSTRUCTOR)
6211 unsigned HOST_WIDE_INT ix;
6213 bool constant_p = true;
6215 /* Iterate through elements and check if all constructor
6216 elements are *_CSTs. */
6217 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (inside_init), ix, value)
6218 if (!CONSTANT_CLASS_P (value))
6225 return build_vector_from_ctor (type,
6226 CONSTRUCTOR_ELTS (inside_init));
6230 if (warn_sequence_point)
6231 verify_sequence_points (inside_init);
6233 /* Any type can be initialized
6234 from an expression of the same type, optionally with braces. */
6236 if (inside_init && TREE_TYPE (inside_init) != 0
6237 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
6238 TYPE_MAIN_VARIANT (type))
6239 || (code == ARRAY_TYPE
6240 && comptypes (TREE_TYPE (inside_init), type))
6241 || (code == VECTOR_TYPE
6242 && comptypes (TREE_TYPE (inside_init), type))
6243 || (code == POINTER_TYPE
6244 && TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
6245 && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
6246 TREE_TYPE (type)))))
6248 if (code == POINTER_TYPE)
6250 if (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE)
6252 if (TREE_CODE (inside_init) == STRING_CST
6253 || TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
6254 inside_init = array_to_pointer_conversion
6255 (init_loc, inside_init);
6258 error_init ("invalid use of non-lvalue array");
6259 return error_mark_node;
6264 if (code == VECTOR_TYPE)
6265 /* Although the types are compatible, we may require a
6267 inside_init = convert (type, inside_init);
6269 if (require_constant
6270 && (code == VECTOR_TYPE || !flag_isoc99)
6271 && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
6273 /* As an extension, allow initializing objects with static storage
6274 duration with compound literals (which are then treated just as
6275 the brace enclosed list they contain). Also allow this for
6276 vectors, as we can only assign them with compound literals. */
6277 tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
6278 inside_init = DECL_INITIAL (decl);
6281 if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
6282 && TREE_CODE (inside_init) != CONSTRUCTOR)
6284 error_init ("array initialized from non-constant array expression");
6285 return error_mark_node;
6288 /* Compound expressions can only occur here if -pedantic or
6289 -pedantic-errors is specified. In the later case, we always want
6290 an error. In the former case, we simply want a warning. */
6291 if (require_constant && pedantic
6292 && TREE_CODE (inside_init) == COMPOUND_EXPR)
6295 = valid_compound_expr_initializer (inside_init,
6296 TREE_TYPE (inside_init));
6297 if (inside_init == error_mark_node)
6298 error_init ("initializer element is not constant");
6300 pedwarn_init (init_loc, OPT_pedantic,
6301 "initializer element is not constant");
6302 if (flag_pedantic_errors)
6303 inside_init = error_mark_node;
6305 else if (require_constant
6306 && !initializer_constant_valid_p (inside_init,
6307 TREE_TYPE (inside_init)))
6309 error_init ("initializer element is not constant");
6310 inside_init = error_mark_node;
6312 else if (require_constant && !maybe_const)
6313 pedwarn_init (init_loc, 0,
6314 "initializer element is not a constant expression");
6316 /* Added to enable additional -Wmissing-format-attribute warnings. */
6317 if (TREE_CODE (TREE_TYPE (inside_init)) == POINTER_TYPE)
6318 inside_init = convert_for_assignment (init_loc, type, inside_init,
6320 ic_init, null_pointer_constant,
6321 NULL_TREE, NULL_TREE, 0);
6325 /* Handle scalar types, including conversions. */
6327 if (code == INTEGER_TYPE || code == REAL_TYPE || code == FIXED_POINT_TYPE
6328 || code == POINTER_TYPE || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE
6329 || code == COMPLEX_TYPE || code == VECTOR_TYPE)
6331 if (TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE
6332 && (TREE_CODE (init) == STRING_CST
6333 || TREE_CODE (init) == COMPOUND_LITERAL_EXPR))
6334 inside_init = init = array_to_pointer_conversion (init_loc, init);
6336 inside_init = build1 (EXCESS_PRECISION_EXPR, semantic_type,
6339 = convert_for_assignment (init_loc, type, inside_init, origtype,
6340 ic_init, null_pointer_constant,
6341 NULL_TREE, NULL_TREE, 0);
6343 /* Check to see if we have already given an error message. */
6344 if (inside_init == error_mark_node)
6346 else if (require_constant && !TREE_CONSTANT (inside_init))
6348 error_init ("initializer element is not constant");
6349 inside_init = error_mark_node;
6351 else if (require_constant
6352 && !initializer_constant_valid_p (inside_init,
6353 TREE_TYPE (inside_init)))
6355 error_init ("initializer element is not computable at load time");
6356 inside_init = error_mark_node;
6358 else if (require_constant && !maybe_const)
6359 pedwarn_init (init_loc, 0,
6360 "initializer element is not a constant expression");
6365 /* Come here only for records and arrays. */
6367 if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
6369 error_init ("variable-sized object may not be initialized");
6370 return error_mark_node;
6373 error_init ("invalid initializer");
6374 return error_mark_node;
6377 /* Handle initializers that use braces. */
6379 /* Type of object we are accumulating a constructor for.
6380 This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */
6381 static tree constructor_type;
6383 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
6385 static tree constructor_fields;
6387 /* For an ARRAY_TYPE, this is the specified index
6388 at which to store the next element we get. */
6389 static tree constructor_index;
6391 /* For an ARRAY_TYPE, this is the maximum index. */
6392 static tree constructor_max_index;
6394 /* For a RECORD_TYPE, this is the first field not yet written out. */
6395 static tree constructor_unfilled_fields;
6397 /* For an ARRAY_TYPE, this is the index of the first element
6398 not yet written out. */
6399 static tree constructor_unfilled_index;
6401 /* In a RECORD_TYPE, the byte index of the next consecutive field.
6402 This is so we can generate gaps between fields, when appropriate. */
6403 static tree constructor_bit_index;
6405 /* If we are saving up the elements rather than allocating them,
6406 this is the list of elements so far (in reverse order,
6407 most recent first). */
6408 static VEC(constructor_elt,gc) *constructor_elements;
6410 /* 1 if constructor should be incrementally stored into a constructor chain,
6411 0 if all the elements should be kept in AVL tree. */
6412 static int constructor_incremental;
6414 /* 1 if so far this constructor's elements are all compile-time constants. */
6415 static int constructor_constant;
6417 /* 1 if so far this constructor's elements are all valid address constants. */
6418 static int constructor_simple;
6420 /* 1 if this constructor has an element that cannot be part of a
6421 constant expression. */
6422 static int constructor_nonconst;
6424 /* 1 if this constructor is erroneous so far. */
6425 static int constructor_erroneous;
6427 /* Structure for managing pending initializer elements, organized as an
6432 struct init_node *left, *right;
6433 struct init_node *parent;
6440 /* Tree of pending elements at this constructor level.
6441 These are elements encountered out of order
6442 which belong at places we haven't reached yet in actually
6444 Will never hold tree nodes across GC runs. */
6445 static struct init_node *constructor_pending_elts;
6447 /* The SPELLING_DEPTH of this constructor. */
6448 static int constructor_depth;
6450 /* DECL node for which an initializer is being read.
6451 0 means we are reading a constructor expression
6452 such as (struct foo) {...}. */
6453 static tree constructor_decl;
6455 /* Nonzero if this is an initializer for a top-level decl. */
6456 static int constructor_top_level;
6458 /* Nonzero if there were any member designators in this initializer. */
6459 static int constructor_designated;
6461 /* Nesting depth of designator list. */
6462 static int designator_depth;
6464 /* Nonzero if there were diagnosed errors in this designator list. */
6465 static int designator_erroneous;
6468 /* This stack has a level for each implicit or explicit level of
6469 structuring in the initializer, including the outermost one. It
6470 saves the values of most of the variables above. */
6472 struct constructor_range_stack;
6474 struct constructor_stack
6476 struct constructor_stack *next;
6481 tree unfilled_index;
6482 tree unfilled_fields;
6484 VEC(constructor_elt,gc) *elements;
6485 struct init_node *pending_elts;
6488 /* If value nonzero, this value should replace the entire
6489 constructor at this level. */
6490 struct c_expr replacement_value;
6491 struct constructor_range_stack *range_stack;
6502 static struct constructor_stack *constructor_stack;
6504 /* This stack represents designators from some range designator up to
6505 the last designator in the list. */
6507 struct constructor_range_stack
6509 struct constructor_range_stack *next, *prev;
6510 struct constructor_stack *stack;
6517 static struct constructor_range_stack *constructor_range_stack;
6519 /* This stack records separate initializers that are nested.
6520 Nested initializers can't happen in ANSI C, but GNU C allows them
6521 in cases like { ... (struct foo) { ... } ... }. */
6523 struct initializer_stack
6525 struct initializer_stack *next;
6527 struct constructor_stack *constructor_stack;
6528 struct constructor_range_stack *constructor_range_stack;
6529 VEC(constructor_elt,gc) *elements;
6530 struct spelling *spelling;
6531 struct spelling *spelling_base;
6534 char require_constant_value;
6535 char require_constant_elements;
6538 static struct initializer_stack *initializer_stack;
6540 /* Prepare to parse and output the initializer for variable DECL. */
6543 start_init (tree decl, tree asmspec_tree ATTRIBUTE_UNUSED, int top_level)
6546 struct initializer_stack *p = XNEW (struct initializer_stack);
6548 p->decl = constructor_decl;
6549 p->require_constant_value = require_constant_value;
6550 p->require_constant_elements = require_constant_elements;
6551 p->constructor_stack = constructor_stack;
6552 p->constructor_range_stack = constructor_range_stack;
6553 p->elements = constructor_elements;
6554 p->spelling = spelling;
6555 p->spelling_base = spelling_base;
6556 p->spelling_size = spelling_size;
6557 p->top_level = constructor_top_level;
6558 p->next = initializer_stack;
6559 initializer_stack = p;
6561 constructor_decl = decl;
6562 constructor_designated = 0;
6563 constructor_top_level = top_level;
6565 if (decl != 0 && decl != error_mark_node)
6567 require_constant_value = TREE_STATIC (decl);
6568 require_constant_elements
6569 = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
6570 /* For a scalar, you can always use any value to initialize,
6571 even within braces. */
6572 && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
6573 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
6574 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
6575 || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
6576 locus = identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl)));
6580 require_constant_value = 0;
6581 require_constant_elements = 0;
6582 locus = _("(anonymous)");
6585 constructor_stack = 0;
6586 constructor_range_stack = 0;
6588 missing_braces_mentioned = 0;
6592 RESTORE_SPELLING_DEPTH (0);
6595 push_string (locus);
6601 struct initializer_stack *p = initializer_stack;
6603 /* Free the whole constructor stack of this initializer. */
6604 while (constructor_stack)
6606 struct constructor_stack *q = constructor_stack;
6607 constructor_stack = q->next;
6611 gcc_assert (!constructor_range_stack);
6613 /* Pop back to the data of the outer initializer (if any). */
6614 free (spelling_base);
6616 constructor_decl = p->decl;
6617 require_constant_value = p->require_constant_value;
6618 require_constant_elements = p->require_constant_elements;
6619 constructor_stack = p->constructor_stack;
6620 constructor_range_stack = p->constructor_range_stack;
6621 constructor_elements = p->elements;
6622 spelling = p->spelling;
6623 spelling_base = p->spelling_base;
6624 spelling_size = p->spelling_size;
6625 constructor_top_level = p->top_level;
6626 initializer_stack = p->next;
6630 /* Call here when we see the initializer is surrounded by braces.
6631 This is instead of a call to push_init_level;
6632 it is matched by a call to pop_init_level.
6634 TYPE is the type to initialize, for a constructor expression.
6635 For an initializer for a decl, TYPE is zero. */
6638 really_start_incremental_init (tree type)
6640 struct constructor_stack *p = XNEW (struct constructor_stack);
6643 type = TREE_TYPE (constructor_decl);
6645 if (TREE_CODE (type) == VECTOR_TYPE
6646 && TYPE_VECTOR_OPAQUE (type))
6647 error ("opaque vector types cannot be initialized");
6649 p->type = constructor_type;
6650 p->fields = constructor_fields;
6651 p->index = constructor_index;
6652 p->max_index = constructor_max_index;
6653 p->unfilled_index = constructor_unfilled_index;
6654 p->unfilled_fields = constructor_unfilled_fields;
6655 p->bit_index = constructor_bit_index;
6656 p->elements = constructor_elements;
6657 p->constant = constructor_constant;
6658 p->simple = constructor_simple;
6659 p->nonconst = constructor_nonconst;
6660 p->erroneous = constructor_erroneous;
6661 p->pending_elts = constructor_pending_elts;
6662 p->depth = constructor_depth;
6663 p->replacement_value.value = 0;
6664 p->replacement_value.original_code = ERROR_MARK;
6665 p->replacement_value.original_type = NULL;
6669 p->incremental = constructor_incremental;
6670 p->designated = constructor_designated;
6672 constructor_stack = p;
6674 constructor_constant = 1;
6675 constructor_simple = 1;
6676 constructor_nonconst = 0;
6677 constructor_depth = SPELLING_DEPTH ();
6678 constructor_elements = 0;
6679 constructor_pending_elts = 0;
6680 constructor_type = type;
6681 constructor_incremental = 1;
6682 constructor_designated = 0;
6683 designator_depth = 0;
6684 designator_erroneous = 0;
6686 if (TREE_CODE (constructor_type) == RECORD_TYPE
6687 || TREE_CODE (constructor_type) == UNION_TYPE)
6689 constructor_fields = TYPE_FIELDS (constructor_type);
6690 /* Skip any nameless bit fields at the beginning. */
6691 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
6692 && DECL_NAME (constructor_fields) == 0)
6693 constructor_fields = DECL_CHAIN (constructor_fields);
6695 constructor_unfilled_fields = constructor_fields;
6696 constructor_bit_index = bitsize_zero_node;
6698 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6700 if (TYPE_DOMAIN (constructor_type))
6702 constructor_max_index
6703 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
6705 /* Detect non-empty initializations of zero-length arrays. */
6706 if (constructor_max_index == NULL_TREE
6707 && TYPE_SIZE (constructor_type))
6708 constructor_max_index = integer_minus_one_node;
6710 /* constructor_max_index needs to be an INTEGER_CST. Attempts
6711 to initialize VLAs will cause a proper error; avoid tree
6712 checking errors as well by setting a safe value. */
6713 if (constructor_max_index
6714 && TREE_CODE (constructor_max_index) != INTEGER_CST)
6715 constructor_max_index = integer_minus_one_node;
6718 = convert (bitsizetype,
6719 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
6723 constructor_index = bitsize_zero_node;
6724 constructor_max_index = NULL_TREE;
6727 constructor_unfilled_index = constructor_index;
6729 else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
6731 /* Vectors are like simple fixed-size arrays. */
6732 constructor_max_index =
6733 bitsize_int (TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
6734 constructor_index = bitsize_zero_node;
6735 constructor_unfilled_index = constructor_index;
6739 /* Handle the case of int x = {5}; */
6740 constructor_fields = constructor_type;
6741 constructor_unfilled_fields = constructor_type;
6745 /* Push down into a subobject, for initialization.
6746 If this is for an explicit set of braces, IMPLICIT is 0.
6747 If it is because the next element belongs at a lower level,
6748 IMPLICIT is 1 (or 2 if the push is because of designator list). */
6751 push_init_level (int implicit, struct obstack * braced_init_obstack)
6753 struct constructor_stack *p;
6754 tree value = NULL_TREE;
6756 /* If we've exhausted any levels that didn't have braces,
6757 pop them now. If implicit == 1, this will have been done in
6758 process_init_element; do not repeat it here because in the case
6759 of excess initializers for an empty aggregate this leads to an
6760 infinite cycle of popping a level and immediately recreating
6764 while (constructor_stack->implicit)
6766 if ((TREE_CODE (constructor_type) == RECORD_TYPE
6767 || TREE_CODE (constructor_type) == UNION_TYPE)
6768 && constructor_fields == 0)
6769 process_init_element (pop_init_level (1, braced_init_obstack),
6770 true, braced_init_obstack);
6771 else if (TREE_CODE (constructor_type) == ARRAY_TYPE
6772 && constructor_max_index
6773 && tree_int_cst_lt (constructor_max_index,
6775 process_init_element (pop_init_level (1, braced_init_obstack),
6776 true, braced_init_obstack);
6782 /* Unless this is an explicit brace, we need to preserve previous
6786 if ((TREE_CODE (constructor_type) == RECORD_TYPE
6787 || TREE_CODE (constructor_type) == UNION_TYPE)
6788 && constructor_fields)
6789 value = find_init_member (constructor_fields, braced_init_obstack);
6790 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6791 value = find_init_member (constructor_index, braced_init_obstack);
6794 p = XNEW (struct constructor_stack);
6795 p->type = constructor_type;
6796 p->fields = constructor_fields;
6797 p->index = constructor_index;
6798 p->max_index = constructor_max_index;
6799 p->unfilled_index = constructor_unfilled_index;
6800 p->unfilled_fields = constructor_unfilled_fields;
6801 p->bit_index = constructor_bit_index;
6802 p->elements = constructor_elements;
6803 p->constant = constructor_constant;
6804 p->simple = constructor_simple;
6805 p->nonconst = constructor_nonconst;
6806 p->erroneous = constructor_erroneous;
6807 p->pending_elts = constructor_pending_elts;
6808 p->depth = constructor_depth;
6809 p->replacement_value.value = 0;
6810 p->replacement_value.original_code = ERROR_MARK;
6811 p->replacement_value.original_type = NULL;
6812 p->implicit = implicit;
6814 p->incremental = constructor_incremental;
6815 p->designated = constructor_designated;
6816 p->next = constructor_stack;
6818 constructor_stack = p;
6820 constructor_constant = 1;
6821 constructor_simple = 1;
6822 constructor_nonconst = 0;
6823 constructor_depth = SPELLING_DEPTH ();
6824 constructor_elements = 0;
6825 constructor_incremental = 1;
6826 constructor_designated = 0;
6827 constructor_pending_elts = 0;
6830 p->range_stack = constructor_range_stack;
6831 constructor_range_stack = 0;
6832 designator_depth = 0;
6833 designator_erroneous = 0;
6836 /* Don't die if an entire brace-pair level is superfluous
6837 in the containing level. */
6838 if (constructor_type == 0)
6840 else if (TREE_CODE (constructor_type) == RECORD_TYPE
6841 || TREE_CODE (constructor_type) == UNION_TYPE)
6843 /* Don't die if there are extra init elts at the end. */
6844 if (constructor_fields == 0)
6845 constructor_type = 0;
6848 constructor_type = TREE_TYPE (constructor_fields);
6849 push_member_name (constructor_fields);
6850 constructor_depth++;
6853 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6855 constructor_type = TREE_TYPE (constructor_type);
6856 push_array_bounds (tree_low_cst (constructor_index, 1));
6857 constructor_depth++;
6860 if (constructor_type == 0)
6862 error_init ("extra brace group at end of initializer");
6863 constructor_fields = 0;
6864 constructor_unfilled_fields = 0;
6868 if (value && TREE_CODE (value) == CONSTRUCTOR)
6870 constructor_constant = TREE_CONSTANT (value);
6871 constructor_simple = TREE_STATIC (value);
6872 constructor_nonconst = CONSTRUCTOR_NON_CONST (value);
6873 constructor_elements = CONSTRUCTOR_ELTS (value);
6874 if (!VEC_empty (constructor_elt, constructor_elements)
6875 && (TREE_CODE (constructor_type) == RECORD_TYPE
6876 || TREE_CODE (constructor_type) == ARRAY_TYPE))
6877 set_nonincremental_init (braced_init_obstack);
6880 if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
6882 missing_braces_mentioned = 1;
6883 warning_init (OPT_Wmissing_braces, "missing braces around initializer");
6886 if (TREE_CODE (constructor_type) == RECORD_TYPE
6887 || TREE_CODE (constructor_type) == UNION_TYPE)
6889 constructor_fields = TYPE_FIELDS (constructor_type);
6890 /* Skip any nameless bit fields at the beginning. */
6891 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
6892 && DECL_NAME (constructor_fields) == 0)
6893 constructor_fields = DECL_CHAIN (constructor_fields);
6895 constructor_unfilled_fields = constructor_fields;
6896 constructor_bit_index = bitsize_zero_node;
6898 else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
6900 /* Vectors are like simple fixed-size arrays. */
6901 constructor_max_index =
6902 bitsize_int (TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
6903 constructor_index = bitsize_int (0);
6904 constructor_unfilled_index = constructor_index;
6906 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6908 if (TYPE_DOMAIN (constructor_type))
6910 constructor_max_index
6911 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
6913 /* Detect non-empty initializations of zero-length arrays. */
6914 if (constructor_max_index == NULL_TREE
6915 && TYPE_SIZE (constructor_type))
6916 constructor_max_index = integer_minus_one_node;
6918 /* constructor_max_index needs to be an INTEGER_CST. Attempts
6919 to initialize VLAs will cause a proper error; avoid tree
6920 checking errors as well by setting a safe value. */
6921 if (constructor_max_index
6922 && TREE_CODE (constructor_max_index) != INTEGER_CST)
6923 constructor_max_index = integer_minus_one_node;
6926 = convert (bitsizetype,
6927 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
6930 constructor_index = bitsize_zero_node;
6932 constructor_unfilled_index = constructor_index;
6933 if (value && TREE_CODE (value) == STRING_CST)
6935 /* We need to split the char/wchar array into individual
6936 characters, so that we don't have to special case it
6938 set_nonincremental_init_from_string (value, braced_init_obstack);
6943 if (constructor_type != error_mark_node)
6944 warning_init (0, "braces around scalar initializer");
6945 constructor_fields = constructor_type;
6946 constructor_unfilled_fields = constructor_type;
6950 /* At the end of an implicit or explicit brace level,
6951 finish up that level of constructor. If a single expression
6952 with redundant braces initialized that level, return the
6953 c_expr structure for that expression. Otherwise, the original_code
6954 element is set to ERROR_MARK.
6955 If we were outputting the elements as they are read, return 0 as the value
6956 from inner levels (process_init_element ignores that),
6957 but return error_mark_node as the value from the outermost level
6958 (that's what we want to put in DECL_INITIAL).
6959 Otherwise, return a CONSTRUCTOR expression as the value. */
6962 pop_init_level (int implicit, struct obstack * braced_init_obstack)
6964 struct constructor_stack *p;
6967 ret.original_code = ERROR_MARK;
6968 ret.original_type = NULL;
6972 /* When we come to an explicit close brace,
6973 pop any inner levels that didn't have explicit braces. */
6974 while (constructor_stack->implicit)
6976 process_init_element (pop_init_level (1, braced_init_obstack),
6977 true, braced_init_obstack);
6979 gcc_assert (!constructor_range_stack);
6982 /* Now output all pending elements. */
6983 constructor_incremental = 1;
6984 output_pending_init_elements (1, braced_init_obstack);
6986 p = constructor_stack;
6988 /* Error for initializing a flexible array member, or a zero-length
6989 array member in an inappropriate context. */
6990 if (constructor_type && constructor_fields
6991 && TREE_CODE (constructor_type) == ARRAY_TYPE
6992 && TYPE_DOMAIN (constructor_type)
6993 && !TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
6995 /* Silently discard empty initializations. The parser will
6996 already have pedwarned for empty brackets. */
6997 if (integer_zerop (constructor_unfilled_index))
6998 constructor_type = NULL_TREE;
7001 gcc_assert (!TYPE_SIZE (constructor_type));
7003 if (constructor_depth > 2)
7004 error_init ("initialization of flexible array member in a nested context");
7006 pedwarn_init (input_location, OPT_pedantic,
7007 "initialization of a flexible array member");
7009 /* We have already issued an error message for the existence
7010 of a flexible array member not at the end of the structure.
7011 Discard the initializer so that we do not die later. */
7012 if (DECL_CHAIN (constructor_fields) != NULL_TREE)
7013 constructor_type = NULL_TREE;
7017 /* Warn when some struct elements are implicitly initialized to zero. */
7018 if (warn_missing_field_initializers
7020 && TREE_CODE (constructor_type) == RECORD_TYPE
7021 && constructor_unfilled_fields)
7023 bool constructor_zeroinit =
7024 (VEC_length (constructor_elt, constructor_elements) == 1
7026 (VEC_index (constructor_elt, constructor_elements, 0)->value));
7028 /* Do not warn for flexible array members or zero-length arrays. */
7029 while (constructor_unfilled_fields
7030 && (!DECL_SIZE (constructor_unfilled_fields)
7031 || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
7032 constructor_unfilled_fields = DECL_CHAIN (constructor_unfilled_fields);
7034 if (constructor_unfilled_fields
7035 /* Do not warn if this level of the initializer uses member
7036 designators; it is likely to be deliberate. */
7037 && !constructor_designated
7038 /* Do not warn about initializing with ` = {0}'. */
7039 && !constructor_zeroinit)
7041 push_member_name (constructor_unfilled_fields);
7042 warning_init (OPT_Wmissing_field_initializers,
7043 "missing initializer");
7044 RESTORE_SPELLING_DEPTH (constructor_depth);
7048 /* Pad out the end of the structure. */
7049 if (p->replacement_value.value)
7050 /* If this closes a superfluous brace pair,
7051 just pass out the element between them. */
7052 ret = p->replacement_value;
7053 else if (constructor_type == 0)
7055 else if (TREE_CODE (constructor_type) != RECORD_TYPE
7056 && TREE_CODE (constructor_type) != UNION_TYPE
7057 && TREE_CODE (constructor_type) != ARRAY_TYPE
7058 && TREE_CODE (constructor_type) != VECTOR_TYPE)
7060 /* A nonincremental scalar initializer--just return
7061 the element, after verifying there is just one. */
7062 if (VEC_empty (constructor_elt,constructor_elements))
7064 if (!constructor_erroneous)
7065 error_init ("empty scalar initializer");
7066 ret.value = error_mark_node;
7068 else if (VEC_length (constructor_elt,constructor_elements) != 1)
7070 error_init ("extra elements in scalar initializer");
7071 ret.value = VEC_index (constructor_elt,constructor_elements,0)->value;
7074 ret.value = VEC_index (constructor_elt,constructor_elements,0)->value;
7078 if (constructor_erroneous)
7079 ret.value = error_mark_node;
7082 ret.value = build_constructor (constructor_type,
7083 constructor_elements);
7084 if (constructor_constant)
7085 TREE_CONSTANT (ret.value) = 1;
7086 if (constructor_constant && constructor_simple)
7087 TREE_STATIC (ret.value) = 1;
7088 if (constructor_nonconst)
7089 CONSTRUCTOR_NON_CONST (ret.value) = 1;
7093 if (ret.value && TREE_CODE (ret.value) != CONSTRUCTOR)
7095 if (constructor_nonconst)
7096 ret.original_code = C_MAYBE_CONST_EXPR;
7097 else if (ret.original_code == C_MAYBE_CONST_EXPR)
7098 ret.original_code = ERROR_MARK;
7101 constructor_type = p->type;
7102 constructor_fields = p->fields;
7103 constructor_index = p->index;
7104 constructor_max_index = p->max_index;
7105 constructor_unfilled_index = p->unfilled_index;
7106 constructor_unfilled_fields = p->unfilled_fields;
7107 constructor_bit_index = p->bit_index;
7108 constructor_elements = p->elements;
7109 constructor_constant = p->constant;
7110 constructor_simple = p->simple;
7111 constructor_nonconst = p->nonconst;
7112 constructor_erroneous = p->erroneous;
7113 constructor_incremental = p->incremental;
7114 constructor_designated = p->designated;
7115 constructor_pending_elts = p->pending_elts;
7116 constructor_depth = p->depth;
7118 constructor_range_stack = p->range_stack;
7119 RESTORE_SPELLING_DEPTH (constructor_depth);
7121 constructor_stack = p->next;
7124 if (ret.value == 0 && constructor_stack == 0)
7125 ret.value = error_mark_node;
7129 /* Common handling for both array range and field name designators.
7130 ARRAY argument is nonzero for array ranges. Returns zero for success. */
7133 set_designator (int array, struct obstack * braced_init_obstack)
7136 enum tree_code subcode;
7138 /* Don't die if an entire brace-pair level is superfluous
7139 in the containing level. */
7140 if (constructor_type == 0)
7143 /* If there were errors in this designator list already, bail out
7145 if (designator_erroneous)
7148 if (!designator_depth)
7150 gcc_assert (!constructor_range_stack);
7152 /* Designator list starts at the level of closest explicit
7154 while (constructor_stack->implicit)
7156 process_init_element (pop_init_level (1, braced_init_obstack),
7157 true, braced_init_obstack);
7159 constructor_designated = 1;
7163 switch (TREE_CODE (constructor_type))
7167 subtype = TREE_TYPE (constructor_fields);
7168 if (subtype != error_mark_node)
7169 subtype = TYPE_MAIN_VARIANT (subtype);
7172 subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
7178 subcode = TREE_CODE (subtype);
7179 if (array && subcode != ARRAY_TYPE)
7181 error_init ("array index in non-array initializer");
7184 else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
7186 error_init ("field name not in record or union initializer");
7190 constructor_designated = 1;
7191 push_init_level (2, braced_init_obstack);
7195 /* If there are range designators in designator list, push a new designator
7196 to constructor_range_stack. RANGE_END is end of such stack range or
7197 NULL_TREE if there is no range designator at this level. */
7200 push_range_stack (tree range_end, struct obstack * braced_init_obstack)
7202 struct constructor_range_stack *p;
7204 p = (struct constructor_range_stack *)
7205 obstack_alloc (braced_init_obstack,
7206 sizeof (struct constructor_range_stack));
7207 p->prev = constructor_range_stack;
7209 p->fields = constructor_fields;
7210 p->range_start = constructor_index;
7211 p->index = constructor_index;
7212 p->stack = constructor_stack;
7213 p->range_end = range_end;
7214 if (constructor_range_stack)
7215 constructor_range_stack->next = p;
7216 constructor_range_stack = p;
7219 /* Within an array initializer, specify the next index to be initialized.
7220 FIRST is that index. If LAST is nonzero, then initialize a range
7221 of indices, running from FIRST through LAST. */
7224 set_init_index (tree first, tree last,
7225 struct obstack * braced_init_obstack)
7227 if (set_designator (1, braced_init_obstack))
7230 designator_erroneous = 1;
7232 if (!INTEGRAL_TYPE_P (TREE_TYPE (first))
7233 || (last && !INTEGRAL_TYPE_P (TREE_TYPE (last))))
7235 error_init ("array index in initializer not of integer type");
7239 if (TREE_CODE (first) != INTEGER_CST)
7241 first = c_fully_fold (first, false, NULL);
7242 if (TREE_CODE (first) == INTEGER_CST)
7243 pedwarn_init (input_location, OPT_pedantic,
7244 "array index in initializer is not "
7245 "an integer constant expression");
7248 if (last && TREE_CODE (last) != INTEGER_CST)
7250 last = c_fully_fold (last, false, NULL);
7251 if (TREE_CODE (last) == INTEGER_CST)
7252 pedwarn_init (input_location, OPT_pedantic,
7253 "array index in initializer is not "
7254 "an integer constant expression");
7257 if (TREE_CODE (first) != INTEGER_CST)
7258 error_init ("nonconstant array index in initializer");
7259 else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
7260 error_init ("nonconstant array index in initializer");
7261 else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
7262 error_init ("array index in non-array initializer");
7263 else if (tree_int_cst_sgn (first) == -1)
7264 error_init ("array index in initializer exceeds array bounds");
7265 else if (constructor_max_index
7266 && tree_int_cst_lt (constructor_max_index, first))
7267 error_init ("array index in initializer exceeds array bounds");
7270 constant_expression_warning (first);
7272 constant_expression_warning (last);
7273 constructor_index = convert (bitsizetype, first);
7277 if (tree_int_cst_equal (first, last))
7279 else if (tree_int_cst_lt (last, first))
7281 error_init ("empty index range in initializer");
7286 last = convert (bitsizetype, last);
7287 if (constructor_max_index != 0
7288 && tree_int_cst_lt (constructor_max_index, last))
7290 error_init ("array index range in initializer exceeds array bounds");
7297 designator_erroneous = 0;
7298 if (constructor_range_stack || last)
7299 push_range_stack (last, braced_init_obstack);
7303 /* Within a struct initializer, specify the next field to be initialized. */
7306 set_init_label (tree fieldname, struct obstack * braced_init_obstack)
7310 if (set_designator (0, braced_init_obstack))
7313 designator_erroneous = 1;
7315 if (TREE_CODE (constructor_type) != RECORD_TYPE
7316 && TREE_CODE (constructor_type) != UNION_TYPE)
7318 error_init ("field name not in record or union initializer");
7322 field = lookup_field (constructor_type, fieldname);
7325 error ("unknown field %qE specified in initializer", fieldname);
7329 constructor_fields = TREE_VALUE (field);
7331 designator_erroneous = 0;
7332 if (constructor_range_stack)
7333 push_range_stack (NULL_TREE, braced_init_obstack);
7334 field = TREE_CHAIN (field);
7337 if (set_designator (0, braced_init_obstack))
7341 while (field != NULL_TREE);
7344 /* Add a new initializer to the tree of pending initializers. PURPOSE
7345 identifies the initializer, either array index or field in a structure.
7346 VALUE is the value of that index or field. If ORIGTYPE is not
7347 NULL_TREE, it is the original type of VALUE.
7349 IMPLICIT is true if value comes from pop_init_level (1),
7350 the new initializer has been merged with the existing one
7351 and thus no warnings should be emitted about overriding an
7352 existing initializer. */
7355 add_pending_init (tree purpose, tree value, tree origtype, bool implicit,
7356 struct obstack * braced_init_obstack)
7358 struct init_node *p, **q, *r;
7360 q = &constructor_pending_elts;
7363 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
7368 if (tree_int_cst_lt (purpose, p->purpose))
7370 else if (tree_int_cst_lt (p->purpose, purpose))
7376 if (TREE_SIDE_EFFECTS (p->value))
7377 warning_init (0, "initialized field with side-effects overwritten");
7378 else if (warn_override_init)
7379 warning_init (OPT_Woverride_init, "initialized field overwritten");
7382 p->origtype = origtype;
7391 bitpos = bit_position (purpose);
7395 if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
7397 else if (p->purpose != purpose)
7403 if (TREE_SIDE_EFFECTS (p->value))
7404 warning_init (0, "initialized field with side-effects overwritten");
7405 else if (warn_override_init)
7406 warning_init (OPT_Woverride_init, "initialized field overwritten");
7409 p->origtype = origtype;
7415 r = (struct init_node *) obstack_alloc (braced_init_obstack,
7416 sizeof (struct init_node));
7417 r->purpose = purpose;
7419 r->origtype = origtype;
7429 struct init_node *s;
7433 if (p->balance == 0)
7435 else if (p->balance < 0)
7442 p->left->parent = p;
7459 constructor_pending_elts = r;
7464 struct init_node *t = r->right;
7468 r->right->parent = r;
7473 p->left->parent = p;
7476 p->balance = t->balance < 0;
7477 r->balance = -(t->balance > 0);
7492 constructor_pending_elts = t;
7498 /* p->balance == +1; growth of left side balances the node. */
7503 else /* r == p->right */
7505 if (p->balance == 0)
7506 /* Growth propagation from right side. */
7508 else if (p->balance > 0)
7515 p->right->parent = p;
7532 constructor_pending_elts = r;
7534 else /* r->balance == -1 */
7537 struct init_node *t = r->left;
7541 r->left->parent = r;
7546 p->right->parent = p;
7549 r->balance = (t->balance < 0);
7550 p->balance = -(t->balance > 0);
7565 constructor_pending_elts = t;
7571 /* p->balance == -1; growth of right side balances the node. */
7582 /* Build AVL tree from a sorted chain. */
7585 set_nonincremental_init (struct obstack * braced_init_obstack)
7587 unsigned HOST_WIDE_INT ix;
7590 if (TREE_CODE (constructor_type) != RECORD_TYPE
7591 && TREE_CODE (constructor_type) != ARRAY_TYPE)
7594 FOR_EACH_CONSTRUCTOR_ELT (constructor_elements, ix, index, value)
7596 add_pending_init (index, value, NULL_TREE, false,
7597 braced_init_obstack);
7599 constructor_elements = 0;
7600 if (TREE_CODE (constructor_type) == RECORD_TYPE)
7602 constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
7603 /* Skip any nameless bit fields at the beginning. */
7604 while (constructor_unfilled_fields != 0
7605 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
7606 && DECL_NAME (constructor_unfilled_fields) == 0)
7607 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
7610 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
7612 if (TYPE_DOMAIN (constructor_type))
7613 constructor_unfilled_index
7614 = convert (bitsizetype,
7615 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
7617 constructor_unfilled_index = bitsize_zero_node;
7619 constructor_incremental = 0;
7622 /* Build AVL tree from a string constant. */
7625 set_nonincremental_init_from_string (tree str,
7626 struct obstack * braced_init_obstack)
7628 tree value, purpose, type;
7629 HOST_WIDE_INT val[2];
7630 const char *p, *end;
7631 int byte, wchar_bytes, charwidth, bitpos;
7633 gcc_assert (TREE_CODE (constructor_type) == ARRAY_TYPE);
7635 wchar_bytes = TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str))) / BITS_PER_UNIT;
7636 charwidth = TYPE_PRECISION (char_type_node);
7637 type = TREE_TYPE (constructor_type);
7638 p = TREE_STRING_POINTER (str);
7639 end = p + TREE_STRING_LENGTH (str);
7641 for (purpose = bitsize_zero_node;
7642 p < end && !tree_int_cst_lt (constructor_max_index, purpose);
7643 purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
7645 if (wchar_bytes == 1)
7647 val[1] = (unsigned char) *p++;
7654 for (byte = 0; byte < wchar_bytes; byte++)
7656 if (BYTES_BIG_ENDIAN)
7657 bitpos = (wchar_bytes - byte - 1) * charwidth;
7659 bitpos = byte * charwidth;
7660 val[bitpos < HOST_BITS_PER_WIDE_INT]
7661 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
7662 << (bitpos % HOST_BITS_PER_WIDE_INT);
7666 if (!TYPE_UNSIGNED (type))
7668 bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
7669 if (bitpos < HOST_BITS_PER_WIDE_INT)
7671 if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
7673 val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
7677 else if (bitpos == HOST_BITS_PER_WIDE_INT)
7682 else if (val[0] & (((HOST_WIDE_INT) 1)
7683 << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
7684 val[0] |= ((HOST_WIDE_INT) -1)
7685 << (bitpos - HOST_BITS_PER_WIDE_INT);
7688 value = build_int_cst_wide (type, val[1], val[0]);
7689 add_pending_init (purpose, value, NULL_TREE, false,
7690 braced_init_obstack);
7693 constructor_incremental = 0;
7696 /* Return value of FIELD in pending initializer or zero if the field was
7697 not initialized yet. */
7700 find_init_member (tree field, struct obstack * braced_init_obstack)
7702 struct init_node *p;
7704 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
7706 if (constructor_incremental
7707 && tree_int_cst_lt (field, constructor_unfilled_index))
7708 set_nonincremental_init (braced_init_obstack);
7710 p = constructor_pending_elts;
7713 if (tree_int_cst_lt (field, p->purpose))
7715 else if (tree_int_cst_lt (p->purpose, field))
7721 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
7723 tree bitpos = bit_position (field);
7725 if (constructor_incremental
7726 && (!constructor_unfilled_fields
7727 || tree_int_cst_lt (bitpos,
7728 bit_position (constructor_unfilled_fields))))
7729 set_nonincremental_init (braced_init_obstack);
7731 p = constructor_pending_elts;
7734 if (field == p->purpose)
7736 else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
7742 else if (TREE_CODE (constructor_type) == UNION_TYPE)
7744 if (!VEC_empty (constructor_elt, constructor_elements)
7745 && (VEC_last (constructor_elt, constructor_elements)->index
7747 return VEC_last (constructor_elt, constructor_elements)->value;
7752 /* "Output" the next constructor element.
7753 At top level, really output it to assembler code now.
7754 Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
7755 If ORIGTYPE is not NULL_TREE, it is the original type of VALUE.
7756 TYPE is the data type that the containing data type wants here.
7757 FIELD is the field (a FIELD_DECL) or the index that this element fills.
7758 If VALUE is a string constant, STRICT_STRING is true if it is
7759 unparenthesized or we should not warn here for it being parenthesized.
7760 For other types of VALUE, STRICT_STRING is not used.
7762 PENDING if non-nil means output pending elements that belong
7763 right after this element. (PENDING is normally 1;
7764 it is 0 while outputting pending elements, to avoid recursion.)
7766 IMPLICIT is true if value comes from pop_init_level (1),
7767 the new initializer has been merged with the existing one
7768 and thus no warnings should be emitted about overriding an
7769 existing initializer. */
7772 output_init_element (tree value, tree origtype, bool strict_string, tree type,
7773 tree field, int pending, bool implicit,
7774 struct obstack * braced_init_obstack)
7776 tree semantic_type = NULL_TREE;
7777 constructor_elt *celt;
7778 bool maybe_const = true;
7781 if (type == error_mark_node || value == error_mark_node)
7783 constructor_erroneous = 1;
7786 if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
7787 && (TREE_CODE (value) == STRING_CST
7788 || TREE_CODE (value) == COMPOUND_LITERAL_EXPR)
7789 && !(TREE_CODE (value) == STRING_CST
7790 && TREE_CODE (type) == ARRAY_TYPE
7791 && INTEGRAL_TYPE_P (TREE_TYPE (type)))
7792 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
7793 TYPE_MAIN_VARIANT (type)))
7794 value = array_to_pointer_conversion (input_location, value);
7796 if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR
7797 && require_constant_value && !flag_isoc99 && pending)
7799 /* As an extension, allow initializing objects with static storage
7800 duration with compound literals (which are then treated just as
7801 the brace enclosed list they contain). */
7802 tree decl = COMPOUND_LITERAL_EXPR_DECL (value);
7803 value = DECL_INITIAL (decl);
7806 npc = null_pointer_constant_p (value);
7807 if (TREE_CODE (value) == EXCESS_PRECISION_EXPR)
7809 semantic_type = TREE_TYPE (value);
7810 value = TREE_OPERAND (value, 0);
7812 value = c_fully_fold (value, require_constant_value, &maybe_const);
7814 if (value == error_mark_node)
7815 constructor_erroneous = 1;
7816 else if (!TREE_CONSTANT (value))
7817 constructor_constant = 0;
7818 else if (!initializer_constant_valid_p (value, TREE_TYPE (value))
7819 || ((TREE_CODE (constructor_type) == RECORD_TYPE
7820 || TREE_CODE (constructor_type) == UNION_TYPE)
7821 && DECL_C_BIT_FIELD (field)
7822 && TREE_CODE (value) != INTEGER_CST))
7823 constructor_simple = 0;
7825 constructor_nonconst = 1;
7827 if (!initializer_constant_valid_p (value, TREE_TYPE (value)))
7829 if (require_constant_value)
7831 error_init ("initializer element is not constant");
7832 value = error_mark_node;
7834 else if (require_constant_elements)
7835 pedwarn (input_location, 0,
7836 "initializer element is not computable at load time");
7838 else if (!maybe_const
7839 && (require_constant_value || require_constant_elements))
7840 pedwarn_init (input_location, 0,
7841 "initializer element is not a constant expression");
7843 /* Issue -Wc++-compat warnings about initializing a bitfield with
7846 && field != NULL_TREE
7847 && TREE_CODE (field) == FIELD_DECL
7848 && DECL_BIT_FIELD_TYPE (field) != NULL_TREE
7849 && (TYPE_MAIN_VARIANT (DECL_BIT_FIELD_TYPE (field))
7850 != TYPE_MAIN_VARIANT (type))
7851 && TREE_CODE (DECL_BIT_FIELD_TYPE (field)) == ENUMERAL_TYPE)
7853 tree checktype = origtype != NULL_TREE ? origtype : TREE_TYPE (value);
7854 if (checktype != error_mark_node
7855 && (TYPE_MAIN_VARIANT (checktype)
7856 != TYPE_MAIN_VARIANT (DECL_BIT_FIELD_TYPE (field))))
7857 warning_init (OPT_Wc___compat,
7858 "enum conversion in initialization is invalid in C++");
7861 /* If this field is empty (and not at the end of structure),
7862 don't do anything other than checking the initializer. */
7864 && (TREE_TYPE (field) == error_mark_node
7865 || (COMPLETE_TYPE_P (TREE_TYPE (field))
7866 && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
7867 && (TREE_CODE (constructor_type) == ARRAY_TYPE
7868 || DECL_CHAIN (field)))))
7872 value = build1 (EXCESS_PRECISION_EXPR, semantic_type, value);
7873 value = digest_init (input_location, type, value, origtype, npc,
7874 strict_string, require_constant_value);
7875 if (value == error_mark_node)
7877 constructor_erroneous = 1;
7880 if (require_constant_value || require_constant_elements)
7881 constant_expression_warning (value);
7883 /* If this element doesn't come next in sequence,
7884 put it on constructor_pending_elts. */
7885 if (TREE_CODE (constructor_type) == ARRAY_TYPE
7886 && (!constructor_incremental
7887 || !tree_int_cst_equal (field, constructor_unfilled_index)))
7889 if (constructor_incremental
7890 && tree_int_cst_lt (field, constructor_unfilled_index))
7891 set_nonincremental_init (braced_init_obstack);
7893 add_pending_init (field, value, origtype, implicit,
7894 braced_init_obstack);
7897 else if (TREE_CODE (constructor_type) == RECORD_TYPE
7898 && (!constructor_incremental
7899 || field != constructor_unfilled_fields))
7901 /* We do this for records but not for unions. In a union,
7902 no matter which field is specified, it can be initialized
7903 right away since it starts at the beginning of the union. */
7904 if (constructor_incremental)
7906 if (!constructor_unfilled_fields)
7907 set_nonincremental_init (braced_init_obstack);
7910 tree bitpos, unfillpos;
7912 bitpos = bit_position (field);
7913 unfillpos = bit_position (constructor_unfilled_fields);
7915 if (tree_int_cst_lt (bitpos, unfillpos))
7916 set_nonincremental_init (braced_init_obstack);
7920 add_pending_init (field, value, origtype, implicit,
7921 braced_init_obstack);
7924 else if (TREE_CODE (constructor_type) == UNION_TYPE
7925 && !VEC_empty (constructor_elt, constructor_elements))
7929 if (TREE_SIDE_EFFECTS (VEC_last (constructor_elt,
7930 constructor_elements)->value))
7932 "initialized field with side-effects overwritten");
7933 else if (warn_override_init)
7934 warning_init (OPT_Woverride_init, "initialized field overwritten");
7937 /* We can have just one union field set. */
7938 constructor_elements = 0;
7941 /* Otherwise, output this element either to
7942 constructor_elements or to the assembler file. */
7944 celt = VEC_safe_push (constructor_elt, gc, constructor_elements, NULL);
7945 celt->index = field;
7946 celt->value = value;
7948 /* Advance the variable that indicates sequential elements output. */
7949 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
7950 constructor_unfilled_index
7951 = size_binop_loc (input_location, PLUS_EXPR, constructor_unfilled_index,
7953 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
7955 constructor_unfilled_fields
7956 = DECL_CHAIN (constructor_unfilled_fields);
7958 /* Skip any nameless bit fields. */
7959 while (constructor_unfilled_fields != 0
7960 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
7961 && DECL_NAME (constructor_unfilled_fields) == 0)
7962 constructor_unfilled_fields =
7963 DECL_CHAIN (constructor_unfilled_fields);
7965 else if (TREE_CODE (constructor_type) == UNION_TYPE)
7966 constructor_unfilled_fields = 0;
7968 /* Now output any pending elements which have become next. */
7970 output_pending_init_elements (0, braced_init_obstack);
7973 /* Output any pending elements which have become next.
7974 As we output elements, constructor_unfilled_{fields,index}
7975 advances, which may cause other elements to become next;
7976 if so, they too are output.
7978 If ALL is 0, we return when there are
7979 no more pending elements to output now.
7981 If ALL is 1, we output space as necessary so that
7982 we can output all the pending elements. */
7984 output_pending_init_elements (int all, struct obstack * braced_init_obstack)
7986 struct init_node *elt = constructor_pending_elts;
7991 /* Look through the whole pending tree.
7992 If we find an element that should be output now,
7993 output it. Otherwise, set NEXT to the element
7994 that comes first among those still pending. */
7999 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
8001 if (tree_int_cst_equal (elt->purpose,
8002 constructor_unfilled_index))
8003 output_init_element (elt->value, elt->origtype, true,
8004 TREE_TYPE (constructor_type),
8005 constructor_unfilled_index, 0, false,
8006 braced_init_obstack);
8007 else if (tree_int_cst_lt (constructor_unfilled_index,
8010 /* Advance to the next smaller node. */
8015 /* We have reached the smallest node bigger than the
8016 current unfilled index. Fill the space first. */
8017 next = elt->purpose;
8023 /* Advance to the next bigger node. */
8028 /* We have reached the biggest node in a subtree. Find
8029 the parent of it, which is the next bigger node. */
8030 while (elt->parent && elt->parent->right == elt)
8033 if (elt && tree_int_cst_lt (constructor_unfilled_index,
8036 next = elt->purpose;
8042 else if (TREE_CODE (constructor_type) == RECORD_TYPE
8043 || TREE_CODE (constructor_type) == UNION_TYPE)
8045 tree ctor_unfilled_bitpos, elt_bitpos;
8047 /* If the current record is complete we are done. */
8048 if (constructor_unfilled_fields == 0)
8051 ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
8052 elt_bitpos = bit_position (elt->purpose);
8053 /* We can't compare fields here because there might be empty
8054 fields in between. */
8055 if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
8057 constructor_unfilled_fields = elt->purpose;
8058 output_init_element (elt->value, elt->origtype, true,
8059 TREE_TYPE (elt->purpose),
8060 elt->purpose, 0, false,
8061 braced_init_obstack);
8063 else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
8065 /* Advance to the next smaller node. */
8070 /* We have reached the smallest node bigger than the
8071 current unfilled field. Fill the space first. */
8072 next = elt->purpose;
8078 /* Advance to the next bigger node. */
8083 /* We have reached the biggest node in a subtree. Find
8084 the parent of it, which is the next bigger node. */
8085 while (elt->parent && elt->parent->right == elt)
8089 && (tree_int_cst_lt (ctor_unfilled_bitpos,
8090 bit_position (elt->purpose))))
8092 next = elt->purpose;
8100 /* Ordinarily return, but not if we want to output all
8101 and there are elements left. */
8102 if (!(all && next != 0))
8105 /* If it's not incremental, just skip over the gap, so that after
8106 jumping to retry we will output the next successive element. */
8107 if (TREE_CODE (constructor_type) == RECORD_TYPE
8108 || TREE_CODE (constructor_type) == UNION_TYPE)
8109 constructor_unfilled_fields = next;
8110 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
8111 constructor_unfilled_index = next;
8113 /* ELT now points to the node in the pending tree with the next
8114 initializer to output. */
8118 /* Add one non-braced element to the current constructor level.
8119 This adjusts the current position within the constructor's type.
8120 This may also start or terminate implicit levels
8121 to handle a partly-braced initializer.
8123 Once this has found the correct level for the new element,
8124 it calls output_init_element.
8126 IMPLICIT is true if value comes from pop_init_level (1),
8127 the new initializer has been merged with the existing one
8128 and thus no warnings should be emitted about overriding an
8129 existing initializer. */
8132 process_init_element (struct c_expr value, bool implicit,
8133 struct obstack * braced_init_obstack)
8135 tree orig_value = value.value;
8136 int string_flag = orig_value != 0 && TREE_CODE (orig_value) == STRING_CST;
8137 bool strict_string = value.original_code == STRING_CST;
8139 designator_depth = 0;
8140 designator_erroneous = 0;
8142 /* Handle superfluous braces around string cst as in
8143 char x[] = {"foo"}; */
8146 && TREE_CODE (constructor_type) == ARRAY_TYPE
8147 && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type))
8148 && integer_zerop (constructor_unfilled_index))
8150 if (constructor_stack->replacement_value.value)
8151 error_init ("excess elements in char array initializer");
8152 constructor_stack->replacement_value = value;
8156 if (constructor_stack->replacement_value.value != 0)
8158 error_init ("excess elements in struct initializer");
8162 /* Ignore elements of a brace group if it is entirely superfluous
8163 and has already been diagnosed. */
8164 if (constructor_type == 0)
8167 /* If we've exhausted any levels that didn't have braces,
8169 while (constructor_stack->implicit)
8171 if ((TREE_CODE (constructor_type) == RECORD_TYPE
8172 || TREE_CODE (constructor_type) == UNION_TYPE)
8173 && constructor_fields == 0)
8174 process_init_element (pop_init_level (1, braced_init_obstack),
8175 true, braced_init_obstack);
8176 else if ((TREE_CODE (constructor_type) == ARRAY_TYPE
8177 || TREE_CODE (constructor_type) == VECTOR_TYPE)
8178 && (constructor_max_index == 0
8179 || tree_int_cst_lt (constructor_max_index,
8180 constructor_index)))
8181 process_init_element (pop_init_level (1, braced_init_obstack),
8182 true, braced_init_obstack);
8187 /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */
8188 if (constructor_range_stack)
8190 /* If value is a compound literal and we'll be just using its
8191 content, don't put it into a SAVE_EXPR. */
8192 if (TREE_CODE (value.value) != COMPOUND_LITERAL_EXPR
8193 || !require_constant_value
8196 tree semantic_type = NULL_TREE;
8197 if (TREE_CODE (value.value) == EXCESS_PRECISION_EXPR)
8199 semantic_type = TREE_TYPE (value.value);
8200 value.value = TREE_OPERAND (value.value, 0);
8202 value.value = c_save_expr (value.value);
8204 value.value = build1 (EXCESS_PRECISION_EXPR, semantic_type,
8211 if (TREE_CODE (constructor_type) == RECORD_TYPE)
8214 enum tree_code fieldcode;
8216 if (constructor_fields == 0)
8218 pedwarn_init (input_location, 0,
8219 "excess elements in struct initializer");
8223 fieldtype = TREE_TYPE (constructor_fields);
8224 if (fieldtype != error_mark_node)
8225 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
8226 fieldcode = TREE_CODE (fieldtype);
8228 /* Error for non-static initialization of a flexible array member. */
8229 if (fieldcode == ARRAY_TYPE
8230 && !require_constant_value
8231 && TYPE_SIZE (fieldtype) == NULL_TREE
8232 && DECL_CHAIN (constructor_fields) == NULL_TREE)
8234 error_init ("non-static initialization of a flexible array member");
8238 /* Accept a string constant to initialize a subarray. */
8239 if (value.value != 0
8240 && fieldcode == ARRAY_TYPE
8241 && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
8243 value.value = orig_value;
8244 /* Otherwise, if we have come to a subaggregate,
8245 and we don't have an element of its type, push into it. */
8246 else if (value.value != 0
8247 && value.value != error_mark_node
8248 && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
8249 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
8250 || fieldcode == UNION_TYPE || fieldcode == VECTOR_TYPE))
8252 push_init_level (1, braced_init_obstack);
8258 push_member_name (constructor_fields);
8259 output_init_element (value.value, value.original_type,
8260 strict_string, fieldtype,
8261 constructor_fields, 1, implicit,
8262 braced_init_obstack);
8263 RESTORE_SPELLING_DEPTH (constructor_depth);
8266 /* Do the bookkeeping for an element that was
8267 directly output as a constructor. */
8269 /* For a record, keep track of end position of last field. */
8270 if (DECL_SIZE (constructor_fields))
8271 constructor_bit_index
8272 = size_binop_loc (input_location, PLUS_EXPR,
8273 bit_position (constructor_fields),
8274 DECL_SIZE (constructor_fields));
8276 /* If the current field was the first one not yet written out,
8277 it isn't now, so update. */
8278 if (constructor_unfilled_fields == constructor_fields)
8280 constructor_unfilled_fields = DECL_CHAIN (constructor_fields);
8281 /* Skip any nameless bit fields. */
8282 while (constructor_unfilled_fields != 0
8283 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
8284 && DECL_NAME (constructor_unfilled_fields) == 0)
8285 constructor_unfilled_fields =
8286 DECL_CHAIN (constructor_unfilled_fields);
8290 constructor_fields = DECL_CHAIN (constructor_fields);
8291 /* Skip any nameless bit fields at the beginning. */
8292 while (constructor_fields != 0
8293 && DECL_C_BIT_FIELD (constructor_fields)
8294 && DECL_NAME (constructor_fields) == 0)
8295 constructor_fields = DECL_CHAIN (constructor_fields);
8297 else if (TREE_CODE (constructor_type) == UNION_TYPE)
8300 enum tree_code fieldcode;
8302 if (constructor_fields == 0)
8304 pedwarn_init (input_location, 0,
8305 "excess elements in union initializer");
8309 fieldtype = TREE_TYPE (constructor_fields);
8310 if (fieldtype != error_mark_node)
8311 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
8312 fieldcode = TREE_CODE (fieldtype);
8314 /* Warn that traditional C rejects initialization of unions.
8315 We skip the warning if the value is zero. This is done
8316 under the assumption that the zero initializer in user
8317 code appears conditioned on e.g. __STDC__ to avoid
8318 "missing initializer" warnings and relies on default
8319 initialization to zero in the traditional C case.
8320 We also skip the warning if the initializer is designated,
8321 again on the assumption that this must be conditional on
8322 __STDC__ anyway (and we've already complained about the
8323 member-designator already). */
8324 if (!in_system_header && !constructor_designated
8325 && !(value.value && (integer_zerop (value.value)
8326 || real_zerop (value.value))))
8327 warning (OPT_Wtraditional, "traditional C rejects initialization "
8330 /* Accept a string constant to initialize a subarray. */
8331 if (value.value != 0
8332 && fieldcode == ARRAY_TYPE
8333 && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
8335 value.value = orig_value;
8336 /* Otherwise, if we have come to a subaggregate,
8337 and we don't have an element of its type, push into it. */
8338 else if (value.value != 0
8339 && value.value != error_mark_node
8340 && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
8341 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
8342 || fieldcode == UNION_TYPE || fieldcode == VECTOR_TYPE))
8344 push_init_level (1, braced_init_obstack);
8350 push_member_name (constructor_fields);
8351 output_init_element (value.value, value.original_type,
8352 strict_string, fieldtype,
8353 constructor_fields, 1, implicit,
8354 braced_init_obstack);
8355 RESTORE_SPELLING_DEPTH (constructor_depth);
8358 /* Do the bookkeeping for an element that was
8359 directly output as a constructor. */
8361 constructor_bit_index = DECL_SIZE (constructor_fields);
8362 constructor_unfilled_fields = DECL_CHAIN (constructor_fields);
8365 constructor_fields = 0;
8367 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
8369 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
8370 enum tree_code eltcode = TREE_CODE (elttype);
8372 /* Accept a string constant to initialize a subarray. */
8373 if (value.value != 0
8374 && eltcode == ARRAY_TYPE
8375 && INTEGRAL_TYPE_P (TREE_TYPE (elttype))
8377 value.value = orig_value;
8378 /* Otherwise, if we have come to a subaggregate,
8379 and we don't have an element of its type, push into it. */
8380 else if (value.value != 0
8381 && value.value != error_mark_node
8382 && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != elttype
8383 && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
8384 || eltcode == UNION_TYPE || eltcode == VECTOR_TYPE))
8386 push_init_level (1, braced_init_obstack);
8390 if (constructor_max_index != 0
8391 && (tree_int_cst_lt (constructor_max_index, constructor_index)
8392 || integer_all_onesp (constructor_max_index)))
8394 pedwarn_init (input_location, 0,
8395 "excess elements in array initializer");
8399 /* Now output the actual element. */
8402 push_array_bounds (tree_low_cst (constructor_index, 1));
8403 output_init_element (value.value, value.original_type,
8404 strict_string, elttype,
8405 constructor_index, 1, implicit,
8406 braced_init_obstack);
8407 RESTORE_SPELLING_DEPTH (constructor_depth);
8411 = size_binop_loc (input_location, PLUS_EXPR,
8412 constructor_index, bitsize_one_node);
8415 /* If we are doing the bookkeeping for an element that was
8416 directly output as a constructor, we must update
8417 constructor_unfilled_index. */
8418 constructor_unfilled_index = constructor_index;
8420 else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
8422 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
8424 /* Do a basic check of initializer size. Note that vectors
8425 always have a fixed size derived from their type. */
8426 if (tree_int_cst_lt (constructor_max_index, constructor_index))
8428 pedwarn_init (input_location, 0,
8429 "excess elements in vector initializer");
8433 /* Now output the actual element. */
8436 if (TREE_CODE (value.value) == VECTOR_CST)
8437 elttype = TYPE_MAIN_VARIANT (constructor_type);
8438 output_init_element (value.value, value.original_type,
8439 strict_string, elttype,
8440 constructor_index, 1, implicit,
8441 braced_init_obstack);
8445 = size_binop_loc (input_location,
8446 PLUS_EXPR, constructor_index, bitsize_one_node);
8449 /* If we are doing the bookkeeping for an element that was
8450 directly output as a constructor, we must update
8451 constructor_unfilled_index. */
8452 constructor_unfilled_index = constructor_index;
8455 /* Handle the sole element allowed in a braced initializer
8456 for a scalar variable. */
8457 else if (constructor_type != error_mark_node
8458 && constructor_fields == 0)
8460 pedwarn_init (input_location, 0,
8461 "excess elements in scalar initializer");
8467 output_init_element (value.value, value.original_type,
8468 strict_string, constructor_type,
8469 NULL_TREE, 1, implicit,
8470 braced_init_obstack);
8471 constructor_fields = 0;
8474 /* Handle range initializers either at this level or anywhere higher
8475 in the designator stack. */
8476 if (constructor_range_stack)
8478 struct constructor_range_stack *p, *range_stack;
8481 range_stack = constructor_range_stack;
8482 constructor_range_stack = 0;
8483 while (constructor_stack != range_stack->stack)
8485 gcc_assert (constructor_stack->implicit);
8486 process_init_element (pop_init_level (1,
8487 braced_init_obstack),
8488 true, braced_init_obstack);
8490 for (p = range_stack;
8491 !p->range_end || tree_int_cst_equal (p->index, p->range_end);
8494 gcc_assert (constructor_stack->implicit);
8495 process_init_element (pop_init_level (1, braced_init_obstack),
8496 true, braced_init_obstack);
8499 p->index = size_binop_loc (input_location,
8500 PLUS_EXPR, p->index, bitsize_one_node);
8501 if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
8506 constructor_index = p->index;
8507 constructor_fields = p->fields;
8508 if (finish && p->range_end && p->index == p->range_start)
8516 push_init_level (2, braced_init_obstack);
8517 p->stack = constructor_stack;
8518 if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
8519 p->index = p->range_start;
8523 constructor_range_stack = range_stack;
8530 constructor_range_stack = 0;
8533 /* Build a complete asm-statement, whose components are a CV_QUALIFIER
8534 (guaranteed to be 'volatile' or null) and ARGS (represented using
8535 an ASM_EXPR node). */
8537 build_asm_stmt (tree cv_qualifier, tree args)
8539 if (!ASM_VOLATILE_P (args) && cv_qualifier)
8540 ASM_VOLATILE_P (args) = 1;
8541 return add_stmt (args);
8544 /* Build an asm-expr, whose components are a STRING, some OUTPUTS,
8545 some INPUTS, and some CLOBBERS. The latter three may be NULL.
8546 SIMPLE indicates whether there was anything at all after the
8547 string in the asm expression -- asm("blah") and asm("blah" : )
8548 are subtly different. We use a ASM_EXPR node to represent this. */
8550 build_asm_expr (location_t loc, tree string, tree outputs, tree inputs,
8551 tree clobbers, tree labels, bool simple)
8556 const char *constraint;
8557 const char **oconstraints;
8558 bool allows_mem, allows_reg, is_inout;
8559 int ninputs, noutputs;
8561 ninputs = list_length (inputs);
8562 noutputs = list_length (outputs);
8563 oconstraints = (const char **) alloca (noutputs * sizeof (const char *));
8565 string = resolve_asm_operand_names (string, outputs, inputs, labels);
8567 /* Remove output conversions that change the type but not the mode. */
8568 for (i = 0, tail = outputs; tail; ++i, tail = TREE_CHAIN (tail))
8570 tree output = TREE_VALUE (tail);
8572 /* ??? Really, this should not be here. Users should be using a
8573 proper lvalue, dammit. But there's a long history of using casts
8574 in the output operands. In cases like longlong.h, this becomes a
8575 primitive form of typechecking -- if the cast can be removed, then
8576 the output operand had a type of the proper width; otherwise we'll
8577 get an error. Gross, but ... */
8578 STRIP_NOPS (output);
8580 if (!lvalue_or_else (loc, output, lv_asm))
8581 output = error_mark_node;
8583 if (output != error_mark_node
8584 && (TREE_READONLY (output)
8585 || TYPE_READONLY (TREE_TYPE (output))
8586 || ((TREE_CODE (TREE_TYPE (output)) == RECORD_TYPE
8587 || TREE_CODE (TREE_TYPE (output)) == UNION_TYPE)
8588 && C_TYPE_FIELDS_READONLY (TREE_TYPE (output)))))
8589 readonly_error (output, lv_asm);
8591 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
8592 oconstraints[i] = constraint;
8594 if (parse_output_constraint (&constraint, i, ninputs, noutputs,
8595 &allows_mem, &allows_reg, &is_inout))
8597 /* If the operand is going to end up in memory,
8598 mark it addressable. */
8599 if (!allows_reg && !c_mark_addressable (output))
8600 output = error_mark_node;
8601 if (!(!allows_reg && allows_mem)
8602 && output != error_mark_node
8603 && VOID_TYPE_P (TREE_TYPE (output)))
8605 error_at (loc, "invalid use of void expression");
8606 output = error_mark_node;
8610 output = error_mark_node;
8612 TREE_VALUE (tail) = output;
8615 for (i = 0, tail = inputs; tail; ++i, tail = TREE_CHAIN (tail))
8619 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
8620 input = TREE_VALUE (tail);
8622 if (parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
8623 oconstraints, &allows_mem, &allows_reg))
8625 /* If the operand is going to end up in memory,
8626 mark it addressable. */
8627 if (!allows_reg && allows_mem)
8629 /* Strip the nops as we allow this case. FIXME, this really
8630 should be rejected or made deprecated. */
8632 if (!c_mark_addressable (input))
8633 input = error_mark_node;
8635 else if (input != error_mark_node && VOID_TYPE_P (TREE_TYPE (input)))
8637 error_at (loc, "invalid use of void expression");
8638 input = error_mark_node;
8642 input = error_mark_node;
8644 TREE_VALUE (tail) = input;
8647 /* ASMs with labels cannot have outputs. This should have been
8648 enforced by the parser. */
8649 gcc_assert (outputs == NULL || labels == NULL);
8651 args = build_stmt (loc, ASM_EXPR, string, outputs, inputs, clobbers, labels);
8653 /* asm statements without outputs, including simple ones, are treated
8655 ASM_INPUT_P (args) = simple;
8656 ASM_VOLATILE_P (args) = (noutputs == 0);
8661 /* Generate a goto statement to LABEL. LOC is the location of the
8665 c_finish_goto_label (location_t loc, tree label)
8667 tree decl = lookup_label_for_goto (loc, label);
8670 TREE_USED (decl) = 1;
8672 tree t = build1 (GOTO_EXPR, void_type_node, decl);
8673 SET_EXPR_LOCATION (t, loc);
8674 return add_stmt (t);
8678 /* Generate a computed goto statement to EXPR. LOC is the location of
8682 c_finish_goto_ptr (location_t loc, tree expr)
8685 pedwarn (loc, OPT_pedantic, "ISO C forbids %<goto *expr;%>");
8686 expr = c_fully_fold (expr, false, NULL);
8687 expr = convert (ptr_type_node, expr);
8688 t = build1 (GOTO_EXPR, void_type_node, expr);
8689 SET_EXPR_LOCATION (t, loc);
8690 return add_stmt (t);
8693 /* Generate a C `return' statement. RETVAL is the expression for what
8694 to return, or a null pointer for `return;' with no value. LOC is
8695 the location of the return statement. If ORIGTYPE is not NULL_TREE, it
8696 is the original type of RETVAL. */
8699 c_finish_return (location_t loc, tree retval, tree origtype)
8701 tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl)), ret_stmt;
8702 bool no_warning = false;
8705 if (TREE_THIS_VOLATILE (current_function_decl))
8707 "function declared %<noreturn%> has a %<return%> statement");
8711 tree semantic_type = NULL_TREE;
8712 npc = null_pointer_constant_p (retval);
8713 if (TREE_CODE (retval) == EXCESS_PRECISION_EXPR)
8715 semantic_type = TREE_TYPE (retval);
8716 retval = TREE_OPERAND (retval, 0);
8718 retval = c_fully_fold (retval, false, NULL);
8720 retval = build1 (EXCESS_PRECISION_EXPR, semantic_type, retval);
8725 current_function_returns_null = 1;
8726 if ((warn_return_type || flag_isoc99)
8727 && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
8729 pedwarn_c99 (loc, flag_isoc99 ? 0 : OPT_Wreturn_type,
8730 "%<return%> with no value, in "
8731 "function returning non-void");
8735 else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
8737 current_function_returns_null = 1;
8738 if (TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
8740 "%<return%> with a value, in function returning void");
8742 pedwarn (loc, OPT_pedantic, "ISO C forbids "
8743 "%<return%> with expression, in function returning void");
8747 tree t = convert_for_assignment (loc, valtype, retval, origtype,
8749 npc, NULL_TREE, NULL_TREE, 0);
8750 tree res = DECL_RESULT (current_function_decl);
8753 current_function_returns_value = 1;
8754 if (t == error_mark_node)
8757 inner = t = convert (TREE_TYPE (res), t);
8759 /* Strip any conversions, additions, and subtractions, and see if
8760 we are returning the address of a local variable. Warn if so. */
8763 switch (TREE_CODE (inner))
8766 case NON_LVALUE_EXPR:
8768 case POINTER_PLUS_EXPR:
8769 inner = TREE_OPERAND (inner, 0);
8773 /* If the second operand of the MINUS_EXPR has a pointer
8774 type (or is converted from it), this may be valid, so
8775 don't give a warning. */
8777 tree op1 = TREE_OPERAND (inner, 1);
8779 while (!POINTER_TYPE_P (TREE_TYPE (op1))
8780 && (CONVERT_EXPR_P (op1)
8781 || TREE_CODE (op1) == NON_LVALUE_EXPR))
8782 op1 = TREE_OPERAND (op1, 0);
8784 if (POINTER_TYPE_P (TREE_TYPE (op1)))
8787 inner = TREE_OPERAND (inner, 0);
8792 inner = TREE_OPERAND (inner, 0);
8794 while (REFERENCE_CLASS_P (inner)
8795 && TREE_CODE (inner) != INDIRECT_REF)
8796 inner = TREE_OPERAND (inner, 0);
8799 && !DECL_EXTERNAL (inner)
8800 && !TREE_STATIC (inner)
8801 && DECL_CONTEXT (inner) == current_function_decl)
8803 0, "function returns address of local variable");
8813 retval = build2 (MODIFY_EXPR, TREE_TYPE (res), res, t);
8814 SET_EXPR_LOCATION (retval, loc);
8816 if (warn_sequence_point)
8817 verify_sequence_points (retval);
8820 ret_stmt = build_stmt (loc, RETURN_EXPR, retval);
8821 TREE_NO_WARNING (ret_stmt) |= no_warning;
8822 return add_stmt (ret_stmt);
8826 /* The SWITCH_EXPR being built. */
8829 /* The original type of the testing expression, i.e. before the
8830 default conversion is applied. */
8833 /* A splay-tree mapping the low element of a case range to the high
8834 element, or NULL_TREE if there is no high element. Used to
8835 determine whether or not a new case label duplicates an old case
8836 label. We need a tree, rather than simply a hash table, because
8837 of the GNU case range extension. */
8840 /* The bindings at the point of the switch. This is used for
8841 warnings crossing decls when branching to a case label. */
8842 struct c_spot_bindings *bindings;
8844 /* The next node on the stack. */
8845 struct c_switch *next;
8848 /* A stack of the currently active switch statements. The innermost
8849 switch statement is on the top of the stack. There is no need to
8850 mark the stack for garbage collection because it is only active
8851 during the processing of the body of a function, and we never
8852 collect at that point. */
8854 struct c_switch *c_switch_stack;
8856 /* Start a C switch statement, testing expression EXP. Return the new
8857 SWITCH_EXPR. SWITCH_LOC is the location of the `switch'.
8858 SWITCH_COND_LOC is the location of the switch's condition. */
8861 c_start_case (location_t switch_loc,
8862 location_t switch_cond_loc,
8865 tree orig_type = error_mark_node;
8866 struct c_switch *cs;
8868 if (exp != error_mark_node)
8870 orig_type = TREE_TYPE (exp);
8872 if (!INTEGRAL_TYPE_P (orig_type))
8874 if (orig_type != error_mark_node)
8876 error_at (switch_cond_loc, "switch quantity not an integer");
8877 orig_type = error_mark_node;
8879 exp = integer_zero_node;
8883 tree type = TYPE_MAIN_VARIANT (orig_type);
8885 if (!in_system_header
8886 && (type == long_integer_type_node
8887 || type == long_unsigned_type_node))
8888 warning_at (switch_cond_loc,
8889 OPT_Wtraditional, "%<long%> switch expression not "
8890 "converted to %<int%> in ISO C");
8892 exp = c_fully_fold (exp, false, NULL);
8893 exp = default_conversion (exp);
8895 if (warn_sequence_point)
8896 verify_sequence_points (exp);
8900 /* Add this new SWITCH_EXPR to the stack. */
8901 cs = XNEW (struct c_switch);
8902 cs->switch_expr = build3 (SWITCH_EXPR, orig_type, exp, NULL_TREE, NULL_TREE);
8903 SET_EXPR_LOCATION (cs->switch_expr, switch_loc);
8904 cs->orig_type = orig_type;
8905 cs->cases = splay_tree_new (case_compare, NULL, NULL);
8906 cs->bindings = c_get_switch_bindings ();
8907 cs->next = c_switch_stack;
8908 c_switch_stack = cs;
8910 return add_stmt (cs->switch_expr);
8913 /* Process a case label at location LOC. */
8916 do_case (location_t loc, tree low_value, tree high_value)
8918 tree label = NULL_TREE;
8920 if (low_value && TREE_CODE (low_value) != INTEGER_CST)
8922 low_value = c_fully_fold (low_value, false, NULL);
8923 if (TREE_CODE (low_value) == INTEGER_CST)
8924 pedwarn (input_location, OPT_pedantic,
8925 "case label is not an integer constant expression");
8928 if (high_value && TREE_CODE (high_value) != INTEGER_CST)
8930 high_value = c_fully_fold (high_value, false, NULL);
8931 if (TREE_CODE (high_value) == INTEGER_CST)
8932 pedwarn (input_location, OPT_pedantic,
8933 "case label is not an integer constant expression");
8936 if (c_switch_stack == NULL)
8939 error_at (loc, "case label not within a switch statement");
8941 error_at (loc, "%<default%> label not within a switch statement");
8945 if (c_check_switch_jump_warnings (c_switch_stack->bindings,
8946 EXPR_LOCATION (c_switch_stack->switch_expr),
8950 label = c_add_case_label (loc, c_switch_stack->cases,
8951 SWITCH_COND (c_switch_stack->switch_expr),
8952 c_switch_stack->orig_type,
8953 low_value, high_value);
8954 if (label == error_mark_node)
8959 /* Finish the switch statement. */
8962 c_finish_case (tree body)
8964 struct c_switch *cs = c_switch_stack;
8965 location_t switch_location;
8967 SWITCH_BODY (cs->switch_expr) = body;
8969 /* Emit warnings as needed. */
8970 switch_location = EXPR_LOCATION (cs->switch_expr);
8971 c_do_switch_warnings (cs->cases, switch_location,
8972 TREE_TYPE (cs->switch_expr),
8973 SWITCH_COND (cs->switch_expr));
8975 /* Pop the stack. */
8976 c_switch_stack = cs->next;
8977 splay_tree_delete (cs->cases);
8978 c_release_switch_bindings (cs->bindings);
8982 /* Emit an if statement. IF_LOCUS is the location of the 'if'. COND,
8983 THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK
8984 may be null. NESTED_IF is true if THEN_BLOCK contains another IF
8985 statement, and was not surrounded with parenthesis. */
8988 c_finish_if_stmt (location_t if_locus, tree cond, tree then_block,
8989 tree else_block, bool nested_if)
8993 /* Diagnose an ambiguous else if if-then-else is nested inside if-then. */
8994 if (warn_parentheses && nested_if && else_block == NULL)
8996 tree inner_if = then_block;
8998 /* We know from the grammar productions that there is an IF nested
8999 within THEN_BLOCK. Due to labels and c99 conditional declarations,
9000 it might not be exactly THEN_BLOCK, but should be the last
9001 non-container statement within. */
9003 switch (TREE_CODE (inner_if))
9008 inner_if = BIND_EXPR_BODY (inner_if);
9010 case STATEMENT_LIST:
9011 inner_if = expr_last (then_block);
9013 case TRY_FINALLY_EXPR:
9014 case TRY_CATCH_EXPR:
9015 inner_if = TREE_OPERAND (inner_if, 0);
9022 if (COND_EXPR_ELSE (inner_if))
9023 warning_at (if_locus, OPT_Wparentheses,
9024 "suggest explicit braces to avoid ambiguous %<else%>");
9027 stmt = build3 (COND_EXPR, void_type_node, cond, then_block, else_block);
9028 SET_EXPR_LOCATION (stmt, if_locus);
9032 /* Emit a general-purpose loop construct. START_LOCUS is the location of
9033 the beginning of the loop. COND is the loop condition. COND_IS_FIRST
9034 is false for DO loops. INCR is the FOR increment expression. BODY is
9035 the statement controlled by the loop. BLAB is the break label. CLAB is
9036 the continue label. Everything is allowed to be NULL. */
9039 c_finish_loop (location_t start_locus, tree cond, tree incr, tree body,
9040 tree blab, tree clab, bool cond_is_first)
9042 tree entry = NULL, exit = NULL, t;
9044 /* If the condition is zero don't generate a loop construct. */
9045 if (cond && integer_zerop (cond))
9049 t = build_and_jump (&blab);
9050 SET_EXPR_LOCATION (t, start_locus);
9056 tree top = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
9058 /* If we have an exit condition, then we build an IF with gotos either
9059 out of the loop, or to the top of it. If there's no exit condition,
9060 then we just build a jump back to the top. */
9061 exit = build_and_jump (&LABEL_EXPR_LABEL (top));
9063 if (cond && !integer_nonzerop (cond))
9065 /* Canonicalize the loop condition to the end. This means
9066 generating a branch to the loop condition. Reuse the
9067 continue label, if possible. */
9072 entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
9073 t = build_and_jump (&LABEL_EXPR_LABEL (entry));
9076 t = build1 (GOTO_EXPR, void_type_node, clab);
9077 SET_EXPR_LOCATION (t, start_locus);
9081 t = build_and_jump (&blab);
9083 exit = fold_build3_loc (start_locus,
9084 COND_EXPR, void_type_node, cond, exit, t);
9086 exit = fold_build3_loc (input_location,
9087 COND_EXPR, void_type_node, cond, exit, t);
9096 add_stmt (build1 (LABEL_EXPR, void_type_node, clab));
9104 add_stmt (build1 (LABEL_EXPR, void_type_node, blab));
9108 c_finish_bc_stmt (location_t loc, tree *label_p, bool is_break)
9111 tree label = *label_p;
9113 /* In switch statements break is sometimes stylistically used after
9114 a return statement. This can lead to spurious warnings about
9115 control reaching the end of a non-void function when it is
9116 inlined. Note that we are calling block_may_fallthru with
9117 language specific tree nodes; this works because
9118 block_may_fallthru returns true when given something it does not
9120 skip = !block_may_fallthru (cur_stmt_list);
9125 *label_p = label = create_artificial_label (loc);
9127 else if (TREE_CODE (label) == LABEL_DECL)
9129 else switch (TREE_INT_CST_LOW (label))
9133 error_at (loc, "break statement not within loop or switch");
9135 error_at (loc, "continue statement not within a loop");
9139 gcc_assert (is_break);
9140 error_at (loc, "break statement used with OpenMP for loop");
9151 add_stmt (build_predict_expr (PRED_CONTINUE, NOT_TAKEN));
9153 return add_stmt (build1 (GOTO_EXPR, void_type_node, label));
9156 /* A helper routine for c_process_expr_stmt and c_finish_stmt_expr. */
9159 emit_side_effect_warnings (location_t loc, tree expr)
9161 if (expr == error_mark_node)
9163 else if (!TREE_SIDE_EFFECTS (expr))
9165 if (!VOID_TYPE_P (TREE_TYPE (expr)) && !TREE_NO_WARNING (expr))
9166 warning_at (loc, OPT_Wunused_value, "statement with no effect");
9169 warn_if_unused_value (expr, loc);
9172 /* Process an expression as if it were a complete statement. Emit
9173 diagnostics, but do not call ADD_STMT. LOC is the location of the
9177 c_process_expr_stmt (location_t loc, tree expr)
9184 expr = c_fully_fold (expr, false, NULL);
9186 if (warn_sequence_point)
9187 verify_sequence_points (expr);
9189 if (TREE_TYPE (expr) != error_mark_node
9190 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
9191 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
9192 error_at (loc, "expression statement has incomplete type");
9194 /* If we're not processing a statement expression, warn about unused values.
9195 Warnings for statement expressions will be emitted later, once we figure
9196 out which is the result. */
9197 if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
9198 && warn_unused_value)
9199 emit_side_effect_warnings (loc, expr);
9202 while (TREE_CODE (exprv) == COMPOUND_EXPR)
9203 exprv = TREE_OPERAND (exprv, 1);
9204 while (CONVERT_EXPR_P (exprv))
9205 exprv = TREE_OPERAND (exprv, 0);
9207 || handled_component_p (exprv)
9208 || TREE_CODE (exprv) == ADDR_EXPR)
9209 mark_exp_read (exprv);
9211 /* If the expression is not of a type to which we cannot assign a line
9212 number, wrap the thing in a no-op NOP_EXPR. */
9213 if (DECL_P (expr) || CONSTANT_CLASS_P (expr))
9215 expr = build1 (NOP_EXPR, TREE_TYPE (expr), expr);
9216 SET_EXPR_LOCATION (expr, loc);
9222 /* Emit an expression as a statement. LOC is the location of the
9226 c_finish_expr_stmt (location_t loc, tree expr)
9229 return add_stmt (c_process_expr_stmt (loc, expr));
9234 /* Do the opposite and emit a statement as an expression. To begin,
9235 create a new binding level and return it. */
9238 c_begin_stmt_expr (void)
9242 /* We must force a BLOCK for this level so that, if it is not expanded
9243 later, there is a way to turn off the entire subtree of blocks that
9244 are contained in it. */
9246 ret = c_begin_compound_stmt (true);
9248 c_bindings_start_stmt_expr (c_switch_stack == NULL
9250 : c_switch_stack->bindings);
9252 /* Mark the current statement list as belonging to a statement list. */
9253 STATEMENT_LIST_STMT_EXPR (ret) = 1;
9258 /* LOC is the location of the compound statement to which this body
9262 c_finish_stmt_expr (location_t loc, tree body)
9264 tree last, type, tmp, val;
9267 body = c_end_compound_stmt (loc, body, true);
9269 c_bindings_end_stmt_expr (c_switch_stack == NULL
9271 : c_switch_stack->bindings);
9273 /* Locate the last statement in BODY. See c_end_compound_stmt
9274 about always returning a BIND_EXPR. */
9275 last_p = &BIND_EXPR_BODY (body);
9276 last = BIND_EXPR_BODY (body);
9279 if (TREE_CODE (last) == STATEMENT_LIST)
9281 tree_stmt_iterator i;
9283 /* This can happen with degenerate cases like ({ }). No value. */
9284 if (!TREE_SIDE_EFFECTS (last))
9287 /* If we're supposed to generate side effects warnings, process
9288 all of the statements except the last. */
9289 if (warn_unused_value)
9291 for (i = tsi_start (last); !tsi_one_before_end_p (i); tsi_next (&i))
9294 tree t = tsi_stmt (i);
9296 tloc = EXPR_HAS_LOCATION (t) ? EXPR_LOCATION (t) : loc;
9297 emit_side_effect_warnings (tloc, t);
9301 i = tsi_last (last);
9302 last_p = tsi_stmt_ptr (i);
9306 /* If the end of the list is exception related, then the list was split
9307 by a call to push_cleanup. Continue searching. */
9308 if (TREE_CODE (last) == TRY_FINALLY_EXPR
9309 || TREE_CODE (last) == TRY_CATCH_EXPR)
9311 last_p = &TREE_OPERAND (last, 0);
9313 goto continue_searching;
9316 if (last == error_mark_node)
9319 /* In the case that the BIND_EXPR is not necessary, return the
9320 expression out from inside it. */
9321 if (last == BIND_EXPR_BODY (body)
9322 && BIND_EXPR_VARS (body) == NULL)
9324 /* Even if this looks constant, do not allow it in a constant
9326 last = c_wrap_maybe_const (last, true);
9327 /* Do not warn if the return value of a statement expression is
9329 TREE_NO_WARNING (last) = 1;
9333 /* Extract the type of said expression. */
9334 type = TREE_TYPE (last);
9336 /* If we're not returning a value at all, then the BIND_EXPR that
9337 we already have is a fine expression to return. */
9338 if (!type || VOID_TYPE_P (type))
9341 /* Now that we've located the expression containing the value, it seems
9342 silly to make voidify_wrapper_expr repeat the process. Create a
9343 temporary of the appropriate type and stick it in a TARGET_EXPR. */
9344 tmp = create_tmp_var_raw (type, NULL);
9346 /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt. This avoids
9347 tree_expr_nonnegative_p giving up immediately. */
9349 if (TREE_CODE (val) == NOP_EXPR
9350 && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0)))
9351 val = TREE_OPERAND (val, 0);
9353 *last_p = build2 (MODIFY_EXPR, void_type_node, tmp, val);
9354 SET_EXPR_LOCATION (*last_p, EXPR_LOCATION (last));
9357 tree t = build4 (TARGET_EXPR, type, tmp, body, NULL_TREE, NULL_TREE);
9358 SET_EXPR_LOCATION (t, loc);
9363 /* Begin and end compound statements. This is as simple as pushing
9364 and popping new statement lists from the tree. */
9367 c_begin_compound_stmt (bool do_scope)
9369 tree stmt = push_stmt_list ();
9375 /* End a compound statement. STMT is the statement. LOC is the
9376 location of the compound statement-- this is usually the location
9377 of the opening brace. */
9380 c_end_compound_stmt (location_t loc, tree stmt, bool do_scope)
9386 if (c_dialect_objc ())
9387 objc_clear_super_receiver ();
9388 block = pop_scope ();
9391 stmt = pop_stmt_list (stmt);
9392 stmt = c_build_bind_expr (loc, block, stmt);
9394 /* If this compound statement is nested immediately inside a statement
9395 expression, then force a BIND_EXPR to be created. Otherwise we'll
9396 do the wrong thing for ({ { 1; } }) or ({ 1; { } }). In particular,
9397 STATEMENT_LISTs merge, and thus we can lose track of what statement
9399 if (building_stmt_list_p ()
9400 && STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
9401 && TREE_CODE (stmt) != BIND_EXPR)
9403 stmt = build3 (BIND_EXPR, void_type_node, NULL, stmt, NULL);
9404 TREE_SIDE_EFFECTS (stmt) = 1;
9405 SET_EXPR_LOCATION (stmt, loc);
9411 /* Queue a cleanup. CLEANUP is an expression/statement to be executed
9412 when the current scope is exited. EH_ONLY is true when this is not
9413 meant to apply to normal control flow transfer. */
9416 push_cleanup (tree decl, tree cleanup, bool eh_only)
9418 enum tree_code code;
9422 code = eh_only ? TRY_CATCH_EXPR : TRY_FINALLY_EXPR;
9423 stmt = build_stmt (DECL_SOURCE_LOCATION (decl), code, NULL, cleanup);
9425 stmt_expr = STATEMENT_LIST_STMT_EXPR (cur_stmt_list);
9426 list = push_stmt_list ();
9427 TREE_OPERAND (stmt, 0) = list;
9428 STATEMENT_LIST_STMT_EXPR (list) = stmt_expr;
9431 /* Convert scalar to vector for the range of operations. */
9432 static enum stv_conv
9433 scalar_to_vector (location_t loc, enum tree_code code, tree op0, tree op1)
9435 tree type0 = TREE_TYPE (op0);
9436 tree type1 = TREE_TYPE (op1);
9437 bool integer_only_op = false;
9438 enum stv_conv ret = stv_firstarg;
9440 gcc_assert (TREE_CODE (type0) == VECTOR_TYPE
9441 || TREE_CODE (type1) == VECTOR_TYPE);
9446 if (TREE_CODE (type0) == INTEGER_TYPE
9447 && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE)
9449 if (unsafe_conversion_p (TREE_TYPE (type1), op0, false))
9451 error_at (loc, "conversion of scalar to vector "
9452 "involves truncation");
9456 return stv_firstarg;
9463 integer_only_op = true;
9464 /* ... fall through ... */
9469 case TRUNC_DIV_EXPR:
9470 case TRUNC_MOD_EXPR:
9472 if (TREE_CODE (type0) == VECTOR_TYPE)
9475 ret = stv_secondarg;
9476 /* Swap TYPE0 with TYPE1 and OP0 with OP1 */
9477 tmp = type0; type0 = type1; type1 = tmp;
9478 tmp = op0; op0 = op1; op1 = tmp;
9481 if (TREE_CODE (type0) == INTEGER_TYPE
9482 && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE)
9484 if (unsafe_conversion_p (TREE_TYPE (type1), op0, false))
9486 error_at (loc, "conversion of scalar to vector "
9487 "involves truncation");
9492 else if (!integer_only_op
9493 /* Allow integer --> real conversion if safe. */
9494 && (TREE_CODE (type0) == REAL_TYPE
9495 || TREE_CODE (type0) == INTEGER_TYPE)
9496 && SCALAR_FLOAT_TYPE_P (TREE_TYPE (type1)))
9498 if (unsafe_conversion_p (TREE_TYPE (type1), op0, false))
9500 error_at (loc, "conversion of scalar to vector "
9501 "involves truncation");
9513 /* Build a binary-operation expression without default conversions.
9514 CODE is the kind of expression to build.
9515 LOCATION is the operator's location.
9516 This function differs from `build' in several ways:
9517 the data type of the result is computed and recorded in it,
9518 warnings are generated if arg data types are invalid,
9519 special handling for addition and subtraction of pointers is known,
9520 and some optimization is done (operations on narrow ints
9521 are done in the narrower type when that gives the same result).
9522 Constant folding is also done before the result is returned.
9524 Note that the operands will never have enumeral types, or function
9525 or array types, because either they will have the default conversions
9526 performed or they have both just been converted to some other type in which
9527 the arithmetic is to be done. */
9530 build_binary_op (location_t location, enum tree_code code,
9531 tree orig_op0, tree orig_op1, int convert_p)
9533 tree type0, type1, orig_type0, orig_type1;
9535 enum tree_code code0, code1;
9537 tree ret = error_mark_node;
9538 const char *invalid_op_diag;
9539 bool op0_int_operands, op1_int_operands;
9540 bool int_const, int_const_or_overflow, int_operands;
9542 /* Expression code to give to the expression when it is built.
9543 Normally this is CODE, which is what the caller asked for,
9544 but in some special cases we change it. */
9545 enum tree_code resultcode = code;
9547 /* Data type in which the computation is to be performed.
9548 In the simplest cases this is the common type of the arguments. */
9549 tree result_type = NULL;
9551 /* When the computation is in excess precision, the type of the
9552 final EXCESS_PRECISION_EXPR. */
9553 tree semantic_result_type = NULL;
9555 /* Nonzero means operands have already been type-converted
9556 in whatever way is necessary.
9557 Zero means they need to be converted to RESULT_TYPE. */
9560 /* Nonzero means create the expression with this type, rather than
9562 tree build_type = 0;
9564 /* Nonzero means after finally constructing the expression
9565 convert it to this type. */
9566 tree final_type = 0;
9568 /* Nonzero if this is an operation like MIN or MAX which can
9569 safely be computed in short if both args are promoted shorts.
9570 Also implies COMMON.
9571 -1 indicates a bitwise operation; this makes a difference
9572 in the exact conditions for when it is safe to do the operation
9573 in a narrower mode. */
9576 /* Nonzero if this is a comparison operation;
9577 if both args are promoted shorts, compare the original shorts.
9578 Also implies COMMON. */
9579 int short_compare = 0;
9581 /* Nonzero if this is a right-shift operation, which can be computed on the
9582 original short and then promoted if the operand is a promoted short. */
9583 int short_shift = 0;
9585 /* Nonzero means set RESULT_TYPE to the common type of the args. */
9588 /* True means types are compatible as far as ObjC is concerned. */
9591 /* True means this is an arithmetic operation that may need excess
9593 bool may_need_excess_precision;
9595 /* True means this is a boolean operation that converts both its
9596 operands to truth-values. */
9597 bool boolean_op = false;
9599 if (location == UNKNOWN_LOCATION)
9600 location = input_location;
9605 op0_int_operands = EXPR_INT_CONST_OPERANDS (orig_op0);
9606 if (op0_int_operands)
9607 op0 = remove_c_maybe_const_expr (op0);
9608 op1_int_operands = EXPR_INT_CONST_OPERANDS (orig_op1);
9609 if (op1_int_operands)
9610 op1 = remove_c_maybe_const_expr (op1);
9611 int_operands = (op0_int_operands && op1_int_operands);
9614 int_const_or_overflow = (TREE_CODE (orig_op0) == INTEGER_CST
9615 && TREE_CODE (orig_op1) == INTEGER_CST);
9616 int_const = (int_const_or_overflow
9617 && !TREE_OVERFLOW (orig_op0)
9618 && !TREE_OVERFLOW (orig_op1));
9621 int_const = int_const_or_overflow = false;
9623 /* Do not apply default conversion in mixed vector/scalar expression. */
9625 && !((TREE_CODE (TREE_TYPE (op0)) == VECTOR_TYPE)
9626 != (TREE_CODE (TREE_TYPE (op1)) == VECTOR_TYPE)))
9628 op0 = default_conversion (op0);
9629 op1 = default_conversion (op1);
9632 orig_type0 = type0 = TREE_TYPE (op0);
9633 orig_type1 = type1 = TREE_TYPE (op1);
9635 /* The expression codes of the data types of the arguments tell us
9636 whether the arguments are integers, floating, pointers, etc. */
9637 code0 = TREE_CODE (type0);
9638 code1 = TREE_CODE (type1);
9640 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
9641 STRIP_TYPE_NOPS (op0);
9642 STRIP_TYPE_NOPS (op1);
9644 /* If an error was already reported for one of the arguments,
9645 avoid reporting another error. */
9647 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
9648 return error_mark_node;
9650 if ((invalid_op_diag
9651 = targetm.invalid_binary_op (code, type0, type1)))
9653 error_at (location, invalid_op_diag);
9654 return error_mark_node;
9662 case TRUNC_DIV_EXPR:
9664 case FLOOR_DIV_EXPR:
9665 case ROUND_DIV_EXPR:
9666 case EXACT_DIV_EXPR:
9667 may_need_excess_precision = true;
9670 may_need_excess_precision = false;
9673 if (TREE_CODE (op0) == EXCESS_PRECISION_EXPR)
9675 op0 = TREE_OPERAND (op0, 0);
9676 type0 = TREE_TYPE (op0);
9678 else if (may_need_excess_precision
9679 && (eptype = excess_precision_type (type0)) != NULL_TREE)
9682 op0 = convert (eptype, op0);
9684 if (TREE_CODE (op1) == EXCESS_PRECISION_EXPR)
9686 op1 = TREE_OPERAND (op1, 0);
9687 type1 = TREE_TYPE (op1);
9689 else if (may_need_excess_precision
9690 && (eptype = excess_precision_type (type1)) != NULL_TREE)
9693 op1 = convert (eptype, op1);
9696 objc_ok = objc_compare_types (type0, type1, -3, NULL_TREE);
9698 /* In case when one of the operands of the binary operation is
9699 a vector and another is a scalar -- convert scalar to vector. */
9700 if ((code0 == VECTOR_TYPE) != (code1 == VECTOR_TYPE))
9702 enum stv_conv convert_flag = scalar_to_vector (location, code, op0, op1);
9704 switch (convert_flag)
9707 return error_mark_node;
9710 bool maybe_const = true;
9712 sc = c_fully_fold (op0, false, &maybe_const);
9713 sc = save_expr (sc);
9714 sc = convert (TREE_TYPE (type1), sc);
9715 op0 = build_vector_from_val (type1, sc);
9717 op0 = c_wrap_maybe_const (op0, true);
9718 orig_type0 = type0 = TREE_TYPE (op0);
9719 code0 = TREE_CODE (type0);
9725 bool maybe_const = true;
9727 sc = c_fully_fold (op1, false, &maybe_const);
9728 sc = save_expr (sc);
9729 sc = convert (TREE_TYPE (type0), sc);
9730 op1 = build_vector_from_val (type0, sc);
9732 op0 = c_wrap_maybe_const (op1, true);
9733 orig_type1 = type1 = TREE_TYPE (op1);
9734 code1 = TREE_CODE (type1);
9746 /* Handle the pointer + int case. */
9747 if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
9749 ret = pointer_int_sum (location, PLUS_EXPR, op0, op1);
9750 goto return_build_binary_op;
9752 else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
9754 ret = pointer_int_sum (location, PLUS_EXPR, op1, op0);
9755 goto return_build_binary_op;
9762 /* Subtraction of two similar pointers.
9763 We must subtract them as integers, then divide by object size. */
9764 if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
9765 && comp_target_types (location, type0, type1))
9767 ret = pointer_diff (location, op0, op1);
9768 goto return_build_binary_op;
9770 /* Handle pointer minus int. Just like pointer plus int. */
9771 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
9773 ret = pointer_int_sum (location, MINUS_EXPR, op0, op1);
9774 goto return_build_binary_op;
9784 case TRUNC_DIV_EXPR:
9786 case FLOOR_DIV_EXPR:
9787 case ROUND_DIV_EXPR:
9788 case EXACT_DIV_EXPR:
9789 warn_for_div_by_zero (location, op1);
9791 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
9792 || code0 == FIXED_POINT_TYPE
9793 || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
9794 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
9795 || code1 == FIXED_POINT_TYPE
9796 || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
9798 enum tree_code tcode0 = code0, tcode1 = code1;
9800 if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
9801 tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
9802 if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)
9803 tcode1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
9805 if (!((tcode0 == INTEGER_TYPE && tcode1 == INTEGER_TYPE)
9806 || (tcode0 == FIXED_POINT_TYPE && tcode1 == FIXED_POINT_TYPE)))
9807 resultcode = RDIV_EXPR;
9809 /* Although it would be tempting to shorten always here, that
9810 loses on some targets, since the modulo instruction is
9811 undefined if the quotient can't be represented in the
9812 computation mode. We shorten only if unsigned or if
9813 dividing by something we know != -1. */
9814 shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
9815 || (TREE_CODE (op1) == INTEGER_CST
9816 && !integer_all_onesp (op1)));
9824 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
9826 /* Allow vector types which are not floating point types. */
9827 else if (code0 == VECTOR_TYPE
9828 && code1 == VECTOR_TYPE
9829 && !VECTOR_FLOAT_TYPE_P (type0)
9830 && !VECTOR_FLOAT_TYPE_P (type1))
9834 case TRUNC_MOD_EXPR:
9835 case FLOOR_MOD_EXPR:
9836 warn_for_div_by_zero (location, op1);
9838 if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
9839 && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE
9840 && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE)
9842 else if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
9844 /* Although it would be tempting to shorten always here, that loses
9845 on some targets, since the modulo instruction is undefined if the
9846 quotient can't be represented in the computation mode. We shorten
9847 only if unsigned or if dividing by something we know != -1. */
9848 shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
9849 || (TREE_CODE (op1) == INTEGER_CST
9850 && !integer_all_onesp (op1)));
9855 case TRUTH_ANDIF_EXPR:
9856 case TRUTH_ORIF_EXPR:
9857 case TRUTH_AND_EXPR:
9859 case TRUTH_XOR_EXPR:
9860 if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
9861 || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
9862 || code0 == FIXED_POINT_TYPE)
9863 && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
9864 || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
9865 || code1 == FIXED_POINT_TYPE))
9867 /* Result of these operations is always an int,
9868 but that does not mean the operands should be
9869 converted to ints! */
9870 result_type = integer_type_node;
9871 op0 = c_common_truthvalue_conversion (location, op0);
9872 op1 = c_common_truthvalue_conversion (location, op1);
9876 if (code == TRUTH_ANDIF_EXPR)
9878 int_const_or_overflow = (int_operands
9879 && TREE_CODE (orig_op0) == INTEGER_CST
9880 && (op0 == truthvalue_false_node
9881 || TREE_CODE (orig_op1) == INTEGER_CST));
9882 int_const = (int_const_or_overflow
9883 && !TREE_OVERFLOW (orig_op0)
9884 && (op0 == truthvalue_false_node
9885 || !TREE_OVERFLOW (orig_op1)));
9887 else if (code == TRUTH_ORIF_EXPR)
9889 int_const_or_overflow = (int_operands
9890 && TREE_CODE (orig_op0) == INTEGER_CST
9891 && (op0 == truthvalue_true_node
9892 || TREE_CODE (orig_op1) == INTEGER_CST));
9893 int_const = (int_const_or_overflow
9894 && !TREE_OVERFLOW (orig_op0)
9895 && (op0 == truthvalue_true_node
9896 || !TREE_OVERFLOW (orig_op1)));
9900 /* Shift operations: result has same type as first operand;
9901 always convert second operand to int.
9902 Also set SHORT_SHIFT if shifting rightward. */
9905 if (code0 == VECTOR_TYPE && code1 == INTEGER_TYPE
9906 && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE)
9908 result_type = type0;
9911 else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
9912 && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE
9913 && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE
9914 && TYPE_VECTOR_SUBPARTS (type0) == TYPE_VECTOR_SUBPARTS (type1))
9916 result_type = type0;
9919 else if ((code0 == INTEGER_TYPE || code0 == FIXED_POINT_TYPE)
9920 && code1 == INTEGER_TYPE)
9922 if (TREE_CODE (op1) == INTEGER_CST)
9924 if (tree_int_cst_sgn (op1) < 0)
9927 if (c_inhibit_evaluation_warnings == 0)
9928 warning (0, "right shift count is negative");
9932 if (!integer_zerop (op1))
9935 if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
9938 if (c_inhibit_evaluation_warnings == 0)
9939 warning (0, "right shift count >= width of type");
9944 /* Use the type of the value to be shifted. */
9945 result_type = type0;
9946 /* Convert the non vector shift-count to an integer, regardless
9947 of size of value being shifted. */
9948 if (TREE_CODE (TREE_TYPE (op1)) != VECTOR_TYPE
9949 && TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
9950 op1 = convert (integer_type_node, op1);
9951 /* Avoid converting op1 to result_type later. */
9957 if (code0 == VECTOR_TYPE && code1 == INTEGER_TYPE
9958 && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE)
9960 result_type = type0;
9963 else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
9964 && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE
9965 && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE
9966 && TYPE_VECTOR_SUBPARTS (type0) == TYPE_VECTOR_SUBPARTS (type1))
9968 result_type = type0;
9971 else if ((code0 == INTEGER_TYPE || code0 == FIXED_POINT_TYPE)
9972 && code1 == INTEGER_TYPE)
9974 if (TREE_CODE (op1) == INTEGER_CST)
9976 if (tree_int_cst_sgn (op1) < 0)
9979 if (c_inhibit_evaluation_warnings == 0)
9980 warning (0, "left shift count is negative");
9983 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
9986 if (c_inhibit_evaluation_warnings == 0)
9987 warning (0, "left shift count >= width of type");
9991 /* Use the type of the value to be shifted. */
9992 result_type = type0;
9993 /* Convert the non vector shift-count to an integer, regardless
9994 of size of value being shifted. */
9995 if (TREE_CODE (TREE_TYPE (op1)) != VECTOR_TYPE
9996 && TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
9997 op1 = convert (integer_type_node, op1);
9998 /* Avoid converting op1 to result_type later. */
10005 if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
10008 if (TREE_TYPE (type0) != TREE_TYPE (type1))
10010 error_at (location, "comparing vectors with different "
10012 return error_mark_node;
10015 if (TYPE_VECTOR_SUBPARTS (type0) != TYPE_VECTOR_SUBPARTS (type1))
10017 error_at (location, "comparing vectors with different "
10018 "number of elements");
10019 return error_mark_node;
10022 /* Always construct signed integer vector type. */
10023 intt = c_common_type_for_size (GET_MODE_BITSIZE
10024 (TYPE_MODE (TREE_TYPE (type0))), 0);
10025 result_type = build_opaque_vector_type (intt,
10026 TYPE_VECTOR_SUBPARTS (type0));
10030 if (FLOAT_TYPE_P (type0) || FLOAT_TYPE_P (type1))
10031 warning_at (location,
10033 "comparing floating point with == or != is unsafe");
10034 /* Result of comparison is always int,
10035 but don't convert the args to int! */
10036 build_type = integer_type_node;
10037 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
10038 || code0 == FIXED_POINT_TYPE || code0 == COMPLEX_TYPE)
10039 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
10040 || code1 == FIXED_POINT_TYPE || code1 == COMPLEX_TYPE))
10042 else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1))
10044 if (TREE_CODE (op0) == ADDR_EXPR
10045 && decl_with_nonnull_addr_p (TREE_OPERAND (op0, 0)))
10047 if (code == EQ_EXPR)
10048 warning_at (location,
10050 "the comparison will always evaluate as %<false%> "
10051 "for the address of %qD will never be NULL",
10052 TREE_OPERAND (op0, 0));
10054 warning_at (location,
10056 "the comparison will always evaluate as %<true%> "
10057 "for the address of %qD will never be NULL",
10058 TREE_OPERAND (op0, 0));
10060 result_type = type0;
10062 else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0))
10064 if (TREE_CODE (op1) == ADDR_EXPR
10065 && decl_with_nonnull_addr_p (TREE_OPERAND (op1, 0)))
10067 if (code == EQ_EXPR)
10068 warning_at (location,
10070 "the comparison will always evaluate as %<false%> "
10071 "for the address of %qD will never be NULL",
10072 TREE_OPERAND (op1, 0));
10074 warning_at (location,
10076 "the comparison will always evaluate as %<true%> "
10077 "for the address of %qD will never be NULL",
10078 TREE_OPERAND (op1, 0));
10080 result_type = type1;
10082 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
10084 tree tt0 = TREE_TYPE (type0);
10085 tree tt1 = TREE_TYPE (type1);
10086 addr_space_t as0 = TYPE_ADDR_SPACE (tt0);
10087 addr_space_t as1 = TYPE_ADDR_SPACE (tt1);
10088 addr_space_t as_common = ADDR_SPACE_GENERIC;
10090 /* Anything compares with void *. void * compares with anything.
10091 Otherwise, the targets must be compatible
10092 and both must be object or both incomplete. */
10093 if (comp_target_types (location, type0, type1))
10094 result_type = common_pointer_type (type0, type1);
10095 else if (!addr_space_superset (as0, as1, &as_common))
10097 error_at (location, "comparison of pointers to "
10098 "disjoint address spaces");
10099 return error_mark_node;
10101 else if (VOID_TYPE_P (tt0))
10103 if (pedantic && TREE_CODE (tt1) == FUNCTION_TYPE)
10104 pedwarn (location, OPT_pedantic, "ISO C forbids "
10105 "comparison of %<void *%> with function pointer");
10107 else if (VOID_TYPE_P (tt1))
10109 if (pedantic && TREE_CODE (tt0) == FUNCTION_TYPE)
10110 pedwarn (location, OPT_pedantic, "ISO C forbids "
10111 "comparison of %<void *%> with function pointer");
10114 /* Avoid warning about the volatile ObjC EH puts on decls. */
10116 pedwarn (location, 0,
10117 "comparison of distinct pointer types lacks a cast");
10119 if (result_type == NULL_TREE)
10121 int qual = ENCODE_QUAL_ADDR_SPACE (as_common);
10122 result_type = build_pointer_type
10123 (build_qualified_type (void_type_node, qual));
10126 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
10128 result_type = type0;
10129 pedwarn (location, 0, "comparison between pointer and integer");
10131 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
10133 result_type = type1;
10134 pedwarn (location, 0, "comparison between pointer and integer");
10142 if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
10145 if (TREE_TYPE (type0) != TREE_TYPE (type1))
10147 error_at (location, "comparing vectors with different "
10149 return error_mark_node;
10152 if (TYPE_VECTOR_SUBPARTS (type0) != TYPE_VECTOR_SUBPARTS (type1))
10154 error_at (location, "comparing vectors with different "
10155 "number of elements");
10156 return error_mark_node;
10159 /* Always construct signed integer vector type. */
10160 intt = c_common_type_for_size (GET_MODE_BITSIZE
10161 (TYPE_MODE (TREE_TYPE (type0))), 0);
10162 result_type = build_opaque_vector_type (intt,
10163 TYPE_VECTOR_SUBPARTS (type0));
10167 build_type = integer_type_node;
10168 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
10169 || code0 == FIXED_POINT_TYPE)
10170 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
10171 || code1 == FIXED_POINT_TYPE))
10173 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
10175 addr_space_t as0 = TYPE_ADDR_SPACE (TREE_TYPE (type0));
10176 addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (type1));
10177 addr_space_t as_common;
10179 if (comp_target_types (location, type0, type1))
10181 result_type = common_pointer_type (type0, type1);
10182 if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
10183 != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
10184 pedwarn (location, 0,
10185 "comparison of complete and incomplete pointers");
10186 else if (TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
10187 pedwarn (location, OPT_pedantic, "ISO C forbids "
10188 "ordered comparisons of pointers to functions");
10189 else if (null_pointer_constant_p (orig_op0)
10190 || null_pointer_constant_p (orig_op1))
10191 warning_at (location, OPT_Wextra,
10192 "ordered comparison of pointer with null pointer");
10195 else if (!addr_space_superset (as0, as1, &as_common))
10197 error_at (location, "comparison of pointers to "
10198 "disjoint address spaces");
10199 return error_mark_node;
10203 int qual = ENCODE_QUAL_ADDR_SPACE (as_common);
10204 result_type = build_pointer_type
10205 (build_qualified_type (void_type_node, qual));
10206 pedwarn (location, 0,
10207 "comparison of distinct pointer types lacks a cast");
10210 else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1))
10212 result_type = type0;
10214 pedwarn (location, OPT_pedantic,
10215 "ordered comparison of pointer with integer zero");
10216 else if (extra_warnings)
10217 warning_at (location, OPT_Wextra,
10218 "ordered comparison of pointer with integer zero");
10220 else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0))
10222 result_type = type1;
10224 pedwarn (location, OPT_pedantic,
10225 "ordered comparison of pointer with integer zero");
10226 else if (extra_warnings)
10227 warning_at (location, OPT_Wextra,
10228 "ordered comparison of pointer with integer zero");
10230 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
10232 result_type = type0;
10233 pedwarn (location, 0, "comparison between pointer and integer");
10235 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
10237 result_type = type1;
10238 pedwarn (location, 0, "comparison between pointer and integer");
10243 gcc_unreachable ();
10246 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
10247 return error_mark_node;
10249 if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
10250 && (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1))
10251 || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0),
10252 TREE_TYPE (type1))))
10254 binary_op_error (location, code, type0, type1);
10255 return error_mark_node;
10258 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
10259 || code0 == FIXED_POINT_TYPE || code0 == VECTOR_TYPE)
10261 (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
10262 || code1 == FIXED_POINT_TYPE || code1 == VECTOR_TYPE))
10264 bool first_complex = (code0 == COMPLEX_TYPE);
10265 bool second_complex = (code1 == COMPLEX_TYPE);
10266 int none_complex = (!first_complex && !second_complex);
10268 if (shorten || common || short_compare)
10270 result_type = c_common_type (type0, type1);
10271 do_warn_double_promotion (result_type, type0, type1,
10272 "implicit conversion from %qT to %qT "
10273 "to match other operand of binary "
10276 if (result_type == error_mark_node)
10277 return error_mark_node;
10280 if (first_complex != second_complex
10281 && (code == PLUS_EXPR
10282 || code == MINUS_EXPR
10283 || code == MULT_EXPR
10284 || (code == TRUNC_DIV_EXPR && first_complex))
10285 && TREE_CODE (TREE_TYPE (result_type)) == REAL_TYPE
10286 && flag_signed_zeros)
10288 /* An operation on mixed real/complex operands must be
10289 handled specially, but the language-independent code can
10290 more easily optimize the plain complex arithmetic if
10291 -fno-signed-zeros. */
10292 tree real_type = TREE_TYPE (result_type);
10294 if (type0 != orig_type0 || type1 != orig_type1)
10296 gcc_assert (may_need_excess_precision && common);
10297 semantic_result_type = c_common_type (orig_type0, orig_type1);
10301 if (TREE_TYPE (op0) != result_type)
10302 op0 = convert_and_check (result_type, op0);
10303 if (TREE_TYPE (op1) != real_type)
10304 op1 = convert_and_check (real_type, op1);
10308 if (TREE_TYPE (op0) != real_type)
10309 op0 = convert_and_check (real_type, op0);
10310 if (TREE_TYPE (op1) != result_type)
10311 op1 = convert_and_check (result_type, op1);
10313 if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK)
10314 return error_mark_node;
10317 op0 = c_save_expr (op0);
10318 real = build_unary_op (EXPR_LOCATION (orig_op0), REALPART_EXPR,
10320 imag = build_unary_op (EXPR_LOCATION (orig_op0), IMAGPART_EXPR,
10325 case TRUNC_DIV_EXPR:
10326 op1 = c_save_expr (op1);
10327 imag = build2 (resultcode, real_type, imag, op1);
10328 /* Fall through. */
10331 real = build2 (resultcode, real_type, real, op1);
10339 op1 = c_save_expr (op1);
10340 real = build_unary_op (EXPR_LOCATION (orig_op1), REALPART_EXPR,
10342 imag = build_unary_op (EXPR_LOCATION (orig_op1), IMAGPART_EXPR,
10347 op0 = c_save_expr (op0);
10348 imag = build2 (resultcode, real_type, op0, imag);
10349 /* Fall through. */
10351 real = build2 (resultcode, real_type, op0, real);
10354 real = build2 (resultcode, real_type, op0, real);
10355 imag = build1 (NEGATE_EXPR, real_type, imag);
10361 ret = build2 (COMPLEX_EXPR, result_type, real, imag);
10362 goto return_build_binary_op;
10365 /* For certain operations (which identify themselves by shorten != 0)
10366 if both args were extended from the same smaller type,
10367 do the arithmetic in that type and then extend.
10369 shorten !=0 and !=1 indicates a bitwise operation.
10370 For them, this optimization is safe only if
10371 both args are zero-extended or both are sign-extended.
10372 Otherwise, we might change the result.
10373 Eg, (short)-1 | (unsigned short)-1 is (int)-1
10374 but calculated in (unsigned short) it would be (unsigned short)-1. */
10376 if (shorten && none_complex)
10378 final_type = result_type;
10379 result_type = shorten_binary_op (result_type, op0, op1,
10383 /* Shifts can be shortened if shifting right. */
10388 tree arg0 = get_narrower (op0, &unsigned_arg);
10390 final_type = result_type;
10392 if (arg0 == op0 && final_type == TREE_TYPE (op0))
10393 unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0));
10395 if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
10396 && tree_int_cst_sgn (op1) > 0
10397 /* We can shorten only if the shift count is less than the
10398 number of bits in the smaller type size. */
10399 && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
10400 /* We cannot drop an unsigned shift after sign-extension. */
10401 && (!TYPE_UNSIGNED (final_type) || unsigned_arg))
10403 /* Do an unsigned shift if the operand was zero-extended. */
10405 = c_common_signed_or_unsigned_type (unsigned_arg,
10407 /* Convert value-to-be-shifted to that type. */
10408 if (TREE_TYPE (op0) != result_type)
10409 op0 = convert (result_type, op0);
10414 /* Comparison operations are shortened too but differently.
10415 They identify themselves by setting short_compare = 1. */
10419 /* Don't write &op0, etc., because that would prevent op0
10420 from being kept in a register.
10421 Instead, make copies of the our local variables and
10422 pass the copies by reference, then copy them back afterward. */
10423 tree xop0 = op0, xop1 = op1, xresult_type = result_type;
10424 enum tree_code xresultcode = resultcode;
10426 = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
10431 goto return_build_binary_op;
10434 op0 = xop0, op1 = xop1;
10436 resultcode = xresultcode;
10438 if (c_inhibit_evaluation_warnings == 0)
10440 bool op0_maybe_const = true;
10441 bool op1_maybe_const = true;
10442 tree orig_op0_folded, orig_op1_folded;
10444 if (in_late_binary_op)
10446 orig_op0_folded = orig_op0;
10447 orig_op1_folded = orig_op1;
10451 /* Fold for the sake of possible warnings, as in
10452 build_conditional_expr. This requires the
10453 "original" values to be folded, not just op0 and
10455 c_inhibit_evaluation_warnings++;
10456 op0 = c_fully_fold (op0, require_constant_value,
10458 op1 = c_fully_fold (op1, require_constant_value,
10460 c_inhibit_evaluation_warnings--;
10461 orig_op0_folded = c_fully_fold (orig_op0,
10462 require_constant_value,
10464 orig_op1_folded = c_fully_fold (orig_op1,
10465 require_constant_value,
10469 if (warn_sign_compare)
10470 warn_for_sign_compare (location, orig_op0_folded,
10471 orig_op1_folded, op0, op1,
10472 result_type, resultcode);
10473 if (!in_late_binary_op && !int_operands)
10475 if (!op0_maybe_const || TREE_CODE (op0) != INTEGER_CST)
10476 op0 = c_wrap_maybe_const (op0, !op0_maybe_const);
10477 if (!op1_maybe_const || TREE_CODE (op1) != INTEGER_CST)
10478 op1 = c_wrap_maybe_const (op1, !op1_maybe_const);
10484 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
10485 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
10486 Then the expression will be built.
10487 It will be given type FINAL_TYPE if that is nonzero;
10488 otherwise, it will be given type RESULT_TYPE. */
10492 binary_op_error (location, code, TREE_TYPE (op0), TREE_TYPE (op1));
10493 return error_mark_node;
10496 if (build_type == NULL_TREE)
10498 build_type = result_type;
10499 if ((type0 != orig_type0 || type1 != orig_type1)
10502 gcc_assert (may_need_excess_precision && common);
10503 semantic_result_type = c_common_type (orig_type0, orig_type1);
10509 op0 = ep_convert_and_check (result_type, op0, semantic_result_type);
10510 op1 = ep_convert_and_check (result_type, op1, semantic_result_type);
10512 /* This can happen if one operand has a vector type, and the other
10513 has a different type. */
10514 if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK)
10515 return error_mark_node;
10518 /* Treat expressions in initializers specially as they can't trap. */
10519 if (int_const_or_overflow)
10520 ret = (require_constant_value
10521 ? fold_build2_initializer_loc (location, resultcode, build_type,
10523 : fold_build2_loc (location, resultcode, build_type, op0, op1));
10525 ret = build2 (resultcode, build_type, op0, op1);
10526 if (final_type != 0)
10527 ret = convert (final_type, ret);
10529 return_build_binary_op:
10530 gcc_assert (ret != error_mark_node);
10531 if (TREE_CODE (ret) == INTEGER_CST && !TREE_OVERFLOW (ret) && !int_const)
10532 ret = (int_operands
10533 ? note_integer_operands (ret)
10534 : build1 (NOP_EXPR, TREE_TYPE (ret), ret));
10535 else if (TREE_CODE (ret) != INTEGER_CST && int_operands
10536 && !in_late_binary_op)
10537 ret = note_integer_operands (ret);
10538 if (semantic_result_type)
10539 ret = build1 (EXCESS_PRECISION_EXPR, semantic_result_type, ret);
10540 protected_set_expr_location (ret, location);
10545 /* Convert EXPR to be a truth-value, validating its type for this
10546 purpose. LOCATION is the source location for the expression. */
10549 c_objc_common_truthvalue_conversion (location_t location, tree expr)
10551 bool int_const, int_operands;
10553 switch (TREE_CODE (TREE_TYPE (expr)))
10556 error_at (location, "used array that cannot be converted to pointer where scalar is required");
10557 return error_mark_node;
10560 error_at (location, "used struct type value where scalar is required");
10561 return error_mark_node;
10564 error_at (location, "used union type value where scalar is required");
10565 return error_mark_node;
10568 error_at (location, "void value not ignored as it ought to be");
10569 return error_mark_node;
10571 case FUNCTION_TYPE:
10572 gcc_unreachable ();
10575 error_at (location, "used vector type where scalar is required");
10576 return error_mark_node;
10582 int_const = (TREE_CODE (expr) == INTEGER_CST && !TREE_OVERFLOW (expr));
10583 int_operands = EXPR_INT_CONST_OPERANDS (expr);
10585 expr = remove_c_maybe_const_expr (expr);
10587 /* ??? Should we also give an error for vectors rather than leaving
10588 those to give errors later? */
10589 expr = c_common_truthvalue_conversion (location, expr);
10591 if (TREE_CODE (expr) == INTEGER_CST && int_operands && !int_const)
10593 if (TREE_OVERFLOW (expr))
10596 return note_integer_operands (expr);
10598 if (TREE_CODE (expr) == INTEGER_CST && !int_const)
10599 return build1 (NOP_EXPR, TREE_TYPE (expr), expr);
10604 /* Convert EXPR to a contained DECL, updating *TC, *TI and *SE as
10608 c_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, bool *se)
10610 if (TREE_CODE (expr) == COMPOUND_LITERAL_EXPR)
10612 tree decl = COMPOUND_LITERAL_EXPR_DECL (expr);
10613 /* Executing a compound literal inside a function reinitializes
10615 if (!TREE_STATIC (decl))
10623 /* Like c_begin_compound_stmt, except force the retention of the BLOCK. */
10626 c_begin_omp_parallel (void)
10630 keep_next_level ();
10631 block = c_begin_compound_stmt (true);
10636 /* Generate OMP_PARALLEL, with CLAUSES and BLOCK as its compound
10637 statement. LOC is the location of the OMP_PARALLEL. */
10640 c_finish_omp_parallel (location_t loc, tree clauses, tree block)
10644 block = c_end_compound_stmt (loc, block, true);
10646 stmt = make_node (OMP_PARALLEL);
10647 TREE_TYPE (stmt) = void_type_node;
10648 OMP_PARALLEL_CLAUSES (stmt) = clauses;
10649 OMP_PARALLEL_BODY (stmt) = block;
10650 SET_EXPR_LOCATION (stmt, loc);
10652 return add_stmt (stmt);
10655 /* Like c_begin_compound_stmt, except force the retention of the BLOCK. */
10658 c_begin_omp_task (void)
10662 keep_next_level ();
10663 block = c_begin_compound_stmt (true);
10668 /* Generate OMP_TASK, with CLAUSES and BLOCK as its compound
10669 statement. LOC is the location of the #pragma. */
10672 c_finish_omp_task (location_t loc, tree clauses, tree block)
10676 block = c_end_compound_stmt (loc, block, true);
10678 stmt = make_node (OMP_TASK);
10679 TREE_TYPE (stmt) = void_type_node;
10680 OMP_TASK_CLAUSES (stmt) = clauses;
10681 OMP_TASK_BODY (stmt) = block;
10682 SET_EXPR_LOCATION (stmt, loc);
10684 return add_stmt (stmt);
10687 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
10688 Remove any elements from the list that are invalid. */
10691 c_finish_omp_clauses (tree clauses)
10693 bitmap_head generic_head, firstprivate_head, lastprivate_head;
10694 tree c, t, *pc = &clauses;
10697 bitmap_obstack_initialize (NULL);
10698 bitmap_initialize (&generic_head, &bitmap_default_obstack);
10699 bitmap_initialize (&firstprivate_head, &bitmap_default_obstack);
10700 bitmap_initialize (&lastprivate_head, &bitmap_default_obstack);
10702 for (pc = &clauses, c = clauses; c ; c = *pc)
10704 bool remove = false;
10705 bool need_complete = false;
10706 bool need_implicitly_determined = false;
10708 switch (OMP_CLAUSE_CODE (c))
10710 case OMP_CLAUSE_SHARED:
10712 need_implicitly_determined = true;
10713 goto check_dup_generic;
10715 case OMP_CLAUSE_PRIVATE:
10717 need_complete = true;
10718 need_implicitly_determined = true;
10719 goto check_dup_generic;
10721 case OMP_CLAUSE_REDUCTION:
10722 name = "reduction";
10723 need_implicitly_determined = true;
10724 t = OMP_CLAUSE_DECL (c);
10725 if (AGGREGATE_TYPE_P (TREE_TYPE (t))
10726 || POINTER_TYPE_P (TREE_TYPE (t)))
10728 error_at (OMP_CLAUSE_LOCATION (c),
10729 "%qE has invalid type for %<reduction%>", t);
10732 else if (FLOAT_TYPE_P (TREE_TYPE (t)))
10734 enum tree_code r_code = OMP_CLAUSE_REDUCTION_CODE (c);
10735 const char *r_name = NULL;
10754 case TRUTH_ANDIF_EXPR:
10757 case TRUTH_ORIF_EXPR:
10761 gcc_unreachable ();
10765 error_at (OMP_CLAUSE_LOCATION (c),
10766 "%qE has invalid type for %<reduction(%s)%>",
10771 goto check_dup_generic;
10773 case OMP_CLAUSE_COPYPRIVATE:
10774 name = "copyprivate";
10775 goto check_dup_generic;
10777 case OMP_CLAUSE_COPYIN:
10779 t = OMP_CLAUSE_DECL (c);
10780 if (TREE_CODE (t) != VAR_DECL || !DECL_THREAD_LOCAL_P (t))
10782 error_at (OMP_CLAUSE_LOCATION (c),
10783 "%qE must be %<threadprivate%> for %<copyin%>", t);
10786 goto check_dup_generic;
10789 t = OMP_CLAUSE_DECL (c);
10790 if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
10792 error_at (OMP_CLAUSE_LOCATION (c),
10793 "%qE is not a variable in clause %qs", t, name);
10796 else if (bitmap_bit_p (&generic_head, DECL_UID (t))
10797 || bitmap_bit_p (&firstprivate_head, DECL_UID (t))
10798 || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
10800 error_at (OMP_CLAUSE_LOCATION (c),
10801 "%qE appears more than once in data clauses", t);
10805 bitmap_set_bit (&generic_head, DECL_UID (t));
10808 case OMP_CLAUSE_FIRSTPRIVATE:
10809 name = "firstprivate";
10810 t = OMP_CLAUSE_DECL (c);
10811 need_complete = true;
10812 need_implicitly_determined = true;
10813 if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
10815 error_at (OMP_CLAUSE_LOCATION (c),
10816 "%qE is not a variable in clause %<firstprivate%>", t);
10819 else if (bitmap_bit_p (&generic_head, DECL_UID (t))
10820 || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
10822 error_at (OMP_CLAUSE_LOCATION (c),
10823 "%qE appears more than once in data clauses", t);
10827 bitmap_set_bit (&firstprivate_head, DECL_UID (t));
10830 case OMP_CLAUSE_LASTPRIVATE:
10831 name = "lastprivate";
10832 t = OMP_CLAUSE_DECL (c);
10833 need_complete = true;
10834 need_implicitly_determined = true;
10835 if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
10837 error_at (OMP_CLAUSE_LOCATION (c),
10838 "%qE is not a variable in clause %<lastprivate%>", t);
10841 else if (bitmap_bit_p (&generic_head, DECL_UID (t))
10842 || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
10844 error_at (OMP_CLAUSE_LOCATION (c),
10845 "%qE appears more than once in data clauses", t);
10849 bitmap_set_bit (&lastprivate_head, DECL_UID (t));
10852 case OMP_CLAUSE_IF:
10853 case OMP_CLAUSE_NUM_THREADS:
10854 case OMP_CLAUSE_SCHEDULE:
10855 case OMP_CLAUSE_NOWAIT:
10856 case OMP_CLAUSE_ORDERED:
10857 case OMP_CLAUSE_DEFAULT:
10858 case OMP_CLAUSE_UNTIED:
10859 case OMP_CLAUSE_COLLAPSE:
10860 case OMP_CLAUSE_FINAL:
10861 case OMP_CLAUSE_MERGEABLE:
10862 pc = &OMP_CLAUSE_CHAIN (c);
10866 gcc_unreachable ();
10871 t = OMP_CLAUSE_DECL (c);
10875 t = require_complete_type (t);
10876 if (t == error_mark_node)
10880 if (need_implicitly_determined)
10882 const char *share_name = NULL;
10884 if (TREE_CODE (t) == VAR_DECL && DECL_THREAD_LOCAL_P (t))
10885 share_name = "threadprivate";
10886 else switch (c_omp_predetermined_sharing (t))
10888 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
10890 case OMP_CLAUSE_DEFAULT_SHARED:
10891 /* const vars may be specified in firstprivate clause. */
10892 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
10893 && TREE_READONLY (t))
10895 share_name = "shared";
10897 case OMP_CLAUSE_DEFAULT_PRIVATE:
10898 share_name = "private";
10901 gcc_unreachable ();
10905 error_at (OMP_CLAUSE_LOCATION (c),
10906 "%qE is predetermined %qs for %qs",
10907 t, share_name, name);
10914 *pc = OMP_CLAUSE_CHAIN (c);
10916 pc = &OMP_CLAUSE_CHAIN (c);
10919 bitmap_obstack_release (NULL);
10923 /* Make a variant type in the proper way for C/C++, propagating qualifiers
10924 down to the element type of an array. */
10927 c_build_qualified_type (tree type, int type_quals)
10929 if (type == error_mark_node)
10932 if (TREE_CODE (type) == ARRAY_TYPE)
10935 tree element_type = c_build_qualified_type (TREE_TYPE (type),
10938 /* See if we already have an identically qualified type. */
10939 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
10941 if (TYPE_QUALS (strip_array_types (t)) == type_quals
10942 && TYPE_NAME (t) == TYPE_NAME (type)
10943 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
10944 && attribute_list_equal (TYPE_ATTRIBUTES (t),
10945 TYPE_ATTRIBUTES (type)))
10950 tree domain = TYPE_DOMAIN (type);
10952 t = build_variant_type_copy (type);
10953 TREE_TYPE (t) = element_type;
10955 if (TYPE_STRUCTURAL_EQUALITY_P (element_type)
10956 || (domain && TYPE_STRUCTURAL_EQUALITY_P (domain)))
10957 SET_TYPE_STRUCTURAL_EQUALITY (t);
10958 else if (TYPE_CANONICAL (element_type) != element_type
10959 || (domain && TYPE_CANONICAL (domain) != domain))
10961 tree unqualified_canon
10962 = build_array_type (TYPE_CANONICAL (element_type),
10963 domain? TYPE_CANONICAL (domain)
10966 = c_build_qualified_type (unqualified_canon, type_quals);
10969 TYPE_CANONICAL (t) = t;
10974 /* A restrict-qualified pointer type must be a pointer to object or
10975 incomplete type. Note that the use of POINTER_TYPE_P also allows
10976 REFERENCE_TYPEs, which is appropriate for C++. */
10977 if ((type_quals & TYPE_QUAL_RESTRICT)
10978 && (!POINTER_TYPE_P (type)
10979 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
10981 error ("invalid use of %<restrict%>");
10982 type_quals &= ~TYPE_QUAL_RESTRICT;
10985 return build_qualified_type (type, type_quals);
10988 /* Build a VA_ARG_EXPR for the C parser. */
10991 c_build_va_arg (location_t loc, tree expr, tree type)
10993 if (warn_cxx_compat && TREE_CODE (type) == ENUMERAL_TYPE)
10994 warning_at (loc, OPT_Wc___compat,
10995 "C++ requires promoted type, not enum type, in %<va_arg%>");
10996 return build_va_arg (loc, expr, type);