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
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"
44 /* Possible cases of implicit bad conversions. Used to select
45 diagnostic messages in convert_for_assignment. */
53 /* The level of nesting inside "__alignof__". */
56 /* The level of nesting inside "sizeof". */
59 /* The level of nesting inside "typeof". */
62 /* Nonzero if we've already printed a "missing braces around initializer"
63 message within this initializer. */
64 static int missing_braces_mentioned;
66 static int require_constant_value;
67 static int require_constant_elements;
69 static bool null_pointer_constant_p (const_tree);
70 static tree qualify_type (tree, tree);
71 static int tagged_types_tu_compatible_p (const_tree, const_tree, bool *,
73 static int comp_target_types (location_t, tree, tree);
74 static int function_types_compatible_p (const_tree, const_tree, bool *,
76 static int type_lists_compatible_p (const_tree, const_tree, bool *, bool *);
77 static tree lookup_field (tree, tree);
78 static int convert_arguments (tree, VEC(tree,gc) *, VEC(tree,gc) *, tree,
80 static tree pointer_diff (location_t, tree, tree);
81 static tree convert_for_assignment (location_t, tree, tree, tree,
82 enum impl_conv, bool, tree, tree, int);
83 static tree valid_compound_expr_initializer (tree, tree);
84 static void push_string (const char *);
85 static void push_member_name (tree);
86 static int spelling_length (void);
87 static char *print_spelling (char *);
88 static void warning_init (int, const char *);
89 static tree digest_init (location_t, tree, tree, tree, bool, bool, int);
90 static void output_init_element (tree, tree, bool, tree, tree, int, bool,
92 static void output_pending_init_elements (int, struct obstack *);
93 static int set_designator (int, struct obstack *);
94 static void push_range_stack (tree, struct obstack *);
95 static void add_pending_init (tree, tree, tree, bool, struct obstack *);
96 static void set_nonincremental_init (struct obstack *);
97 static void set_nonincremental_init_from_string (tree, struct obstack *);
98 static tree find_init_member (tree, struct obstack *);
99 static void readonly_error (tree, enum lvalue_use);
100 static void readonly_warning (tree, enum lvalue_use);
101 static int lvalue_or_else (const_tree, enum lvalue_use);
102 static void record_maybe_used_decl (tree);
103 static int comptypes_internal (const_tree, const_tree, bool *, bool *);
105 /* Return true if EXP is a null pointer constant, false otherwise. */
108 null_pointer_constant_p (const_tree expr)
110 /* This should really operate on c_expr structures, but they aren't
111 yet available everywhere required. */
112 tree type = TREE_TYPE (expr);
113 return (TREE_CODE (expr) == INTEGER_CST
114 && !TREE_OVERFLOW (expr)
115 && integer_zerop (expr)
116 && (INTEGRAL_TYPE_P (type)
117 || (TREE_CODE (type) == POINTER_TYPE
118 && VOID_TYPE_P (TREE_TYPE (type))
119 && TYPE_QUALS (TREE_TYPE (type)) == TYPE_UNQUALIFIED)));
122 /* EXPR may appear in an unevaluated part of an integer constant
123 expression, but not in an evaluated part. Wrap it in a
124 C_MAYBE_CONST_EXPR, or mark it with TREE_OVERFLOW if it is just an
125 INTEGER_CST and we cannot create a C_MAYBE_CONST_EXPR. */
128 note_integer_operands (tree expr)
131 if (TREE_CODE (expr) == INTEGER_CST && in_late_binary_op)
133 ret = copy_node (expr);
134 TREE_OVERFLOW (ret) = 1;
138 ret = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (expr), NULL_TREE, expr);
139 C_MAYBE_CONST_EXPR_INT_OPERANDS (ret) = 1;
144 /* Having checked whether EXPR may appear in an unevaluated part of an
145 integer constant expression and found that it may, remove any
146 C_MAYBE_CONST_EXPR noting this fact and return the resulting
150 remove_c_maybe_const_expr (tree expr)
152 if (TREE_CODE (expr) == C_MAYBE_CONST_EXPR)
153 return C_MAYBE_CONST_EXPR_EXPR (expr);
158 \f/* This is a cache to hold if two types are compatible or not. */
160 struct tagged_tu_seen_cache {
161 const struct tagged_tu_seen_cache * next;
164 /* The return value of tagged_types_tu_compatible_p if we had seen
165 these two types already. */
169 static const struct tagged_tu_seen_cache * tagged_tu_seen_base;
170 static void free_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache *);
172 /* Do `exp = require_complete_type (exp);' to make sure exp
173 does not have an incomplete type. (That includes void types.) */
176 require_complete_type (tree value)
178 tree type = TREE_TYPE (value);
180 if (value == error_mark_node || type == error_mark_node)
181 return error_mark_node;
183 /* First, detect a valid value with a complete type. */
184 if (COMPLETE_TYPE_P (type))
187 c_incomplete_type_error (value, type);
188 return error_mark_node;
191 /* Print an error message for invalid use of an incomplete type.
192 VALUE is the expression that was used (or 0 if that isn't known)
193 and TYPE is the type that was invalid. */
196 c_incomplete_type_error (const_tree value, const_tree type)
198 const char *type_code_string;
200 /* Avoid duplicate error message. */
201 if (TREE_CODE (type) == ERROR_MARK)
204 if (value != 0 && (TREE_CODE (value) == VAR_DECL
205 || TREE_CODE (value) == PARM_DECL))
206 error ("%qD has an incomplete type", value);
210 /* We must print an error message. Be clever about what it says. */
212 switch (TREE_CODE (type))
215 type_code_string = "struct";
219 type_code_string = "union";
223 type_code_string = "enum";
227 error ("invalid use of void expression");
231 if (TYPE_DOMAIN (type))
233 if (TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL)
235 error ("invalid use of flexible array member");
238 type = TREE_TYPE (type);
241 error ("invalid use of array with unspecified bounds");
248 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
249 error ("invalid use of undefined type %<%s %E%>",
250 type_code_string, TYPE_NAME (type));
252 /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
253 error ("invalid use of incomplete typedef %qD", TYPE_NAME (type));
257 /* Given a type, apply default promotions wrt unnamed function
258 arguments and return the new type. */
261 c_type_promotes_to (tree type)
263 if (TYPE_MAIN_VARIANT (type) == float_type_node)
264 return double_type_node;
266 if (c_promoting_integer_type_p (type))
268 /* Preserve unsignedness if not really getting any wider. */
269 if (TYPE_UNSIGNED (type)
270 && (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
271 return unsigned_type_node;
272 return integer_type_node;
278 /* Return true if between two named address spaces, whether there is a superset
279 named address space that encompasses both address spaces. If there is a
280 superset, return which address space is the superset. */
283 addr_space_superset (addr_space_t as1, addr_space_t as2, addr_space_t *common)
290 else if (targetm.addr_space.subset_p (as1, as2))
295 else if (targetm.addr_space.subset_p (as2, as1))
304 /* Return a variant of TYPE which has all the type qualifiers of LIKE
305 as well as those of TYPE. */
308 qualify_type (tree type, tree like)
310 addr_space_t as_type = TYPE_ADDR_SPACE (type);
311 addr_space_t as_like = TYPE_ADDR_SPACE (like);
312 addr_space_t as_common;
314 /* If the two named address spaces are different, determine the common
315 superset address space. If there isn't one, raise an error. */
316 if (!addr_space_superset (as_type, as_like, &as_common))
319 error ("%qT and %qT are in disjoint named address spaces",
323 return c_build_qualified_type (type,
324 TYPE_QUALS_NO_ADDR_SPACE (type)
325 | TYPE_QUALS_NO_ADDR_SPACE (like)
326 | ENCODE_QUAL_ADDR_SPACE (as_common));
329 /* Return true iff the given tree T is a variable length array. */
332 c_vla_type_p (const_tree t)
334 if (TREE_CODE (t) == ARRAY_TYPE
335 && C_TYPE_VARIABLE_SIZE (t))
340 /* Return the composite type of two compatible types.
342 We assume that comptypes has already been done and returned
343 nonzero; if that isn't so, this may crash. In particular, we
344 assume that qualifiers match. */
347 composite_type (tree t1, tree t2)
349 enum tree_code code1;
350 enum tree_code code2;
353 /* Save time if the two types are the same. */
355 if (t1 == t2) return t1;
357 /* If one type is nonsense, use the other. */
358 if (t1 == error_mark_node)
360 if (t2 == error_mark_node)
363 code1 = TREE_CODE (t1);
364 code2 = TREE_CODE (t2);
366 /* Merge the attributes. */
367 attributes = targetm.merge_type_attributes (t1, t2);
369 /* If one is an enumerated type and the other is the compatible
370 integer type, the composite type might be either of the two
371 (DR#013 question 3). For consistency, use the enumerated type as
372 the composite type. */
374 if (code1 == ENUMERAL_TYPE && code2 == INTEGER_TYPE)
376 if (code2 == ENUMERAL_TYPE && code1 == INTEGER_TYPE)
379 gcc_assert (code1 == code2);
384 /* For two pointers, do this recursively on the target type. */
386 tree pointed_to_1 = TREE_TYPE (t1);
387 tree pointed_to_2 = TREE_TYPE (t2);
388 tree target = composite_type (pointed_to_1, pointed_to_2);
389 t1 = build_pointer_type (target);
390 t1 = build_type_attribute_variant (t1, attributes);
391 return qualify_type (t1, t2);
396 tree elt = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
399 tree d1 = TYPE_DOMAIN (t1);
400 tree d2 = TYPE_DOMAIN (t2);
401 bool d1_variable, d2_variable;
402 bool d1_zero, d2_zero;
403 bool t1_complete, t2_complete;
405 /* We should not have any type quals on arrays at all. */
406 gcc_assert (!TYPE_QUALS_NO_ADDR_SPACE (t1)
407 && !TYPE_QUALS_NO_ADDR_SPACE (t2));
409 t1_complete = COMPLETE_TYPE_P (t1);
410 t2_complete = COMPLETE_TYPE_P (t2);
412 d1_zero = d1 == 0 || !TYPE_MAX_VALUE (d1);
413 d2_zero = d2 == 0 || !TYPE_MAX_VALUE (d2);
415 d1_variable = (!d1_zero
416 && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
417 || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
418 d2_variable = (!d2_zero
419 && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
420 || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
421 d1_variable = d1_variable || (d1_zero && c_vla_type_p (t1));
422 d2_variable = d2_variable || (d2_zero && c_vla_type_p (t2));
424 /* Save space: see if the result is identical to one of the args. */
425 if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1)
426 && (d2_variable || d2_zero || !d1_variable))
427 return build_type_attribute_variant (t1, attributes);
428 if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2)
429 && (d1_variable || d1_zero || !d2_variable))
430 return build_type_attribute_variant (t2, attributes);
432 if (elt == TREE_TYPE (t1) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1))
433 return build_type_attribute_variant (t1, attributes);
434 if (elt == TREE_TYPE (t2) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1))
435 return build_type_attribute_variant (t2, attributes);
437 /* Merge the element types, and have a size if either arg has
438 one. We may have qualifiers on the element types. To set
439 up TYPE_MAIN_VARIANT correctly, we need to form the
440 composite of the unqualified types and add the qualifiers
442 quals = TYPE_QUALS (strip_array_types (elt));
443 unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
444 t1 = build_array_type (unqual_elt,
445 TYPE_DOMAIN ((TYPE_DOMAIN (t1)
451 /* Ensure a composite type involving a zero-length array type
452 is a zero-length type not an incomplete type. */
453 if (d1_zero && d2_zero
454 && (t1_complete || t2_complete)
455 && !COMPLETE_TYPE_P (t1))
457 TYPE_SIZE (t1) = bitsize_zero_node;
458 TYPE_SIZE_UNIT (t1) = size_zero_node;
460 t1 = c_build_qualified_type (t1, quals);
461 return build_type_attribute_variant (t1, attributes);
467 if (attributes != NULL)
469 /* Try harder not to create a new aggregate type. */
470 if (attribute_list_equal (TYPE_ATTRIBUTES (t1), attributes))
472 if (attribute_list_equal (TYPE_ATTRIBUTES (t2), attributes))
475 return build_type_attribute_variant (t1, attributes);
478 /* Function types: prefer the one that specified arg types.
479 If both do, merge the arg types. Also merge the return types. */
481 tree valtype = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
482 tree p1 = TYPE_ARG_TYPES (t1);
483 tree p2 = TYPE_ARG_TYPES (t2);
488 /* Save space: see if the result is identical to one of the args. */
489 if (valtype == TREE_TYPE (t1) && !TYPE_ARG_TYPES (t2))
490 return build_type_attribute_variant (t1, attributes);
491 if (valtype == TREE_TYPE (t2) && !TYPE_ARG_TYPES (t1))
492 return build_type_attribute_variant (t2, attributes);
494 /* Simple way if one arg fails to specify argument types. */
495 if (TYPE_ARG_TYPES (t1) == 0)
497 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2));
498 t1 = build_type_attribute_variant (t1, attributes);
499 return qualify_type (t1, t2);
501 if (TYPE_ARG_TYPES (t2) == 0)
503 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1));
504 t1 = build_type_attribute_variant (t1, attributes);
505 return qualify_type (t1, t2);
508 /* If both args specify argument types, we must merge the two
509 lists, argument by argument. */
510 /* Tell global_bindings_p to return false so that variable_size
511 doesn't die on VLAs in parameter types. */
512 c_override_global_bindings_to_false = true;
514 len = list_length (p1);
517 for (i = 0; i < len; i++)
518 newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
523 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n))
525 /* A null type means arg type is not specified.
526 Take whatever the other function type has. */
527 if (TREE_VALUE (p1) == 0)
529 TREE_VALUE (n) = TREE_VALUE (p2);
532 if (TREE_VALUE (p2) == 0)
534 TREE_VALUE (n) = TREE_VALUE (p1);
538 /* Given wait (union {union wait *u; int *i} *)
539 and wait (union wait *),
540 prefer union wait * as type of parm. */
541 if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE
542 && TREE_VALUE (p1) != TREE_VALUE (p2))
545 tree mv2 = TREE_VALUE (p2);
546 if (mv2 && mv2 != error_mark_node
547 && TREE_CODE (mv2) != ARRAY_TYPE)
548 mv2 = TYPE_MAIN_VARIANT (mv2);
549 for (memb = TYPE_FIELDS (TREE_VALUE (p1));
550 memb; memb = DECL_CHAIN (memb))
552 tree mv3 = TREE_TYPE (memb);
553 if (mv3 && mv3 != error_mark_node
554 && TREE_CODE (mv3) != ARRAY_TYPE)
555 mv3 = TYPE_MAIN_VARIANT (mv3);
556 if (comptypes (mv3, mv2))
558 TREE_VALUE (n) = composite_type (TREE_TYPE (memb),
560 pedwarn (input_location, OPT_pedantic,
561 "function types not truly compatible in ISO C");
566 if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE
567 && TREE_VALUE (p2) != TREE_VALUE (p1))
570 tree mv1 = TREE_VALUE (p1);
571 if (mv1 && mv1 != error_mark_node
572 && TREE_CODE (mv1) != ARRAY_TYPE)
573 mv1 = TYPE_MAIN_VARIANT (mv1);
574 for (memb = TYPE_FIELDS (TREE_VALUE (p2));
575 memb; memb = DECL_CHAIN (memb))
577 tree mv3 = TREE_TYPE (memb);
578 if (mv3 && mv3 != error_mark_node
579 && TREE_CODE (mv3) != ARRAY_TYPE)
580 mv3 = TYPE_MAIN_VARIANT (mv3);
581 if (comptypes (mv3, mv1))
583 TREE_VALUE (n) = composite_type (TREE_TYPE (memb),
585 pedwarn (input_location, OPT_pedantic,
586 "function types not truly compatible in ISO C");
591 TREE_VALUE (n) = composite_type (TREE_VALUE (p1), TREE_VALUE (p2));
595 c_override_global_bindings_to_false = false;
596 t1 = build_function_type (valtype, newargs);
597 t1 = qualify_type (t1, t2);
598 /* ... falls through ... */
602 return build_type_attribute_variant (t1, attributes);
607 /* Return the type of a conditional expression between pointers to
608 possibly differently qualified versions of compatible types.
610 We assume that comp_target_types has already been done and returned
611 nonzero; if that isn't so, this may crash. */
614 common_pointer_type (tree t1, tree t2)
617 tree pointed_to_1, mv1;
618 tree pointed_to_2, mv2;
620 unsigned target_quals;
621 addr_space_t as1, as2, as_common;
624 /* Save time if the two types are the same. */
626 if (t1 == t2) return t1;
628 /* If one type is nonsense, use the other. */
629 if (t1 == error_mark_node)
631 if (t2 == error_mark_node)
634 gcc_assert (TREE_CODE (t1) == POINTER_TYPE
635 && TREE_CODE (t2) == POINTER_TYPE);
637 /* Merge the attributes. */
638 attributes = targetm.merge_type_attributes (t1, t2);
640 /* Find the composite type of the target types, and combine the
641 qualifiers of the two types' targets. Do not lose qualifiers on
642 array element types by taking the TYPE_MAIN_VARIANT. */
643 mv1 = pointed_to_1 = TREE_TYPE (t1);
644 mv2 = pointed_to_2 = TREE_TYPE (t2);
645 if (TREE_CODE (mv1) != ARRAY_TYPE)
646 mv1 = TYPE_MAIN_VARIANT (pointed_to_1);
647 if (TREE_CODE (mv2) != ARRAY_TYPE)
648 mv2 = TYPE_MAIN_VARIANT (pointed_to_2);
649 target = composite_type (mv1, mv2);
651 /* For function types do not merge const qualifiers, but drop them
652 if used inconsistently. The middle-end uses these to mark const
653 and noreturn functions. */
654 quals1 = TYPE_QUALS_NO_ADDR_SPACE (pointed_to_1);
655 quals2 = TYPE_QUALS_NO_ADDR_SPACE (pointed_to_2);
657 if (TREE_CODE (pointed_to_1) == FUNCTION_TYPE)
658 target_quals = (quals1 & quals2);
660 target_quals = (quals1 | quals2);
662 /* If the two named address spaces are different, determine the common
663 superset address space. This is guaranteed to exist due to the
664 assumption that comp_target_type returned non-zero. */
665 as1 = TYPE_ADDR_SPACE (pointed_to_1);
666 as2 = TYPE_ADDR_SPACE (pointed_to_2);
667 if (!addr_space_superset (as1, as2, &as_common))
670 target_quals |= ENCODE_QUAL_ADDR_SPACE (as_common);
672 t1 = build_pointer_type (c_build_qualified_type (target, target_quals));
673 return build_type_attribute_variant (t1, attributes);
676 /* Return the common type for two arithmetic types under the usual
677 arithmetic conversions. The default conversions have already been
678 applied, and enumerated types converted to their compatible integer
679 types. The resulting type is unqualified and has no attributes.
681 This is the type for the result of most arithmetic operations
682 if the operands have the given two types. */
685 c_common_type (tree t1, tree t2)
687 enum tree_code code1;
688 enum tree_code code2;
690 /* If one type is nonsense, use the other. */
691 if (t1 == error_mark_node)
693 if (t2 == error_mark_node)
696 if (TYPE_QUALS (t1) != TYPE_UNQUALIFIED)
697 t1 = TYPE_MAIN_VARIANT (t1);
699 if (TYPE_QUALS (t2) != TYPE_UNQUALIFIED)
700 t2 = TYPE_MAIN_VARIANT (t2);
702 if (TYPE_ATTRIBUTES (t1) != NULL_TREE)
703 t1 = build_type_attribute_variant (t1, NULL_TREE);
705 if (TYPE_ATTRIBUTES (t2) != NULL_TREE)
706 t2 = build_type_attribute_variant (t2, NULL_TREE);
708 /* Save time if the two types are the same. */
710 if (t1 == t2) return t1;
712 code1 = TREE_CODE (t1);
713 code2 = TREE_CODE (t2);
715 gcc_assert (code1 == VECTOR_TYPE || code1 == COMPLEX_TYPE
716 || code1 == FIXED_POINT_TYPE || code1 == REAL_TYPE
717 || code1 == INTEGER_TYPE);
718 gcc_assert (code2 == VECTOR_TYPE || code2 == COMPLEX_TYPE
719 || code2 == FIXED_POINT_TYPE || code2 == REAL_TYPE
720 || code2 == INTEGER_TYPE);
722 /* When one operand is a decimal float type, the other operand cannot be
723 a generic float type or a complex type. We also disallow vector types
725 if ((DECIMAL_FLOAT_TYPE_P (t1) || DECIMAL_FLOAT_TYPE_P (t2))
726 && !(DECIMAL_FLOAT_TYPE_P (t1) && DECIMAL_FLOAT_TYPE_P (t2)))
728 if (code1 == VECTOR_TYPE || code2 == VECTOR_TYPE)
730 error ("can%'t mix operands of decimal float and vector types");
731 return error_mark_node;
733 if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
735 error ("can%'t mix operands of decimal float and complex types");
736 return error_mark_node;
738 if (code1 == REAL_TYPE && code2 == REAL_TYPE)
740 error ("can%'t mix operands of decimal float and other float types");
741 return error_mark_node;
745 /* If one type is a vector type, return that type. (How the usual
746 arithmetic conversions apply to the vector types extension is not
747 precisely specified.) */
748 if (code1 == VECTOR_TYPE)
751 if (code2 == VECTOR_TYPE)
754 /* If one type is complex, form the common type of the non-complex
755 components, then make that complex. Use T1 or T2 if it is the
757 if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
759 tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
760 tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
761 tree subtype = c_common_type (subtype1, subtype2);
763 if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
765 else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
768 return build_complex_type (subtype);
771 /* If only one is real, use it as the result. */
773 if (code1 == REAL_TYPE && code2 != REAL_TYPE)
776 if (code2 == REAL_TYPE && code1 != REAL_TYPE)
779 /* If both are real and either are decimal floating point types, use
780 the decimal floating point type with the greater precision. */
782 if (code1 == REAL_TYPE && code2 == REAL_TYPE)
784 if (TYPE_MAIN_VARIANT (t1) == dfloat128_type_node
785 || TYPE_MAIN_VARIANT (t2) == dfloat128_type_node)
786 return dfloat128_type_node;
787 else if (TYPE_MAIN_VARIANT (t1) == dfloat64_type_node
788 || TYPE_MAIN_VARIANT (t2) == dfloat64_type_node)
789 return dfloat64_type_node;
790 else if (TYPE_MAIN_VARIANT (t1) == dfloat32_type_node
791 || TYPE_MAIN_VARIANT (t2) == dfloat32_type_node)
792 return dfloat32_type_node;
795 /* Deal with fixed-point types. */
796 if (code1 == FIXED_POINT_TYPE || code2 == FIXED_POINT_TYPE)
798 unsigned int unsignedp = 0, satp = 0;
799 enum machine_mode m1, m2;
800 unsigned int fbit1, ibit1, fbit2, ibit2, max_fbit, max_ibit;
805 /* If one input type is saturating, the result type is saturating. */
806 if (TYPE_SATURATING (t1) || TYPE_SATURATING (t2))
809 /* If both fixed-point types are unsigned, the result type is unsigned.
810 When mixing fixed-point and integer types, follow the sign of the
812 Otherwise, the result type is signed. */
813 if ((TYPE_UNSIGNED (t1) && TYPE_UNSIGNED (t2)
814 && code1 == FIXED_POINT_TYPE && code2 == FIXED_POINT_TYPE)
815 || (code1 == FIXED_POINT_TYPE && code2 != FIXED_POINT_TYPE
816 && TYPE_UNSIGNED (t1))
817 || (code1 != FIXED_POINT_TYPE && code2 == FIXED_POINT_TYPE
818 && TYPE_UNSIGNED (t2)))
821 /* The result type is signed. */
824 /* If the input type is unsigned, we need to convert to the
826 if (code1 == FIXED_POINT_TYPE && TYPE_UNSIGNED (t1))
828 enum mode_class mclass = (enum mode_class) 0;
829 if (GET_MODE_CLASS (m1) == MODE_UFRACT)
831 else if (GET_MODE_CLASS (m1) == MODE_UACCUM)
835 m1 = mode_for_size (GET_MODE_PRECISION (m1), mclass, 0);
837 if (code2 == FIXED_POINT_TYPE && TYPE_UNSIGNED (t2))
839 enum mode_class mclass = (enum mode_class) 0;
840 if (GET_MODE_CLASS (m2) == MODE_UFRACT)
842 else if (GET_MODE_CLASS (m2) == MODE_UACCUM)
846 m2 = mode_for_size (GET_MODE_PRECISION (m2), mclass, 0);
850 if (code1 == FIXED_POINT_TYPE)
852 fbit1 = GET_MODE_FBIT (m1);
853 ibit1 = GET_MODE_IBIT (m1);
858 /* Signed integers need to subtract one sign bit. */
859 ibit1 = TYPE_PRECISION (t1) - (!TYPE_UNSIGNED (t1));
862 if (code2 == FIXED_POINT_TYPE)
864 fbit2 = GET_MODE_FBIT (m2);
865 ibit2 = GET_MODE_IBIT (m2);
870 /* Signed integers need to subtract one sign bit. */
871 ibit2 = TYPE_PRECISION (t2) - (!TYPE_UNSIGNED (t2));
874 max_ibit = ibit1 >= ibit2 ? ibit1 : ibit2;
875 max_fbit = fbit1 >= fbit2 ? fbit1 : fbit2;
876 return c_common_fixed_point_type_for_size (max_ibit, max_fbit, unsignedp,
880 /* Both real or both integers; use the one with greater precision. */
882 if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
884 else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
887 /* Same precision. Prefer long longs to longs to ints when the
888 same precision, following the C99 rules on integer type rank
889 (which are equivalent to the C90 rules for C90 types). */
891 if (TYPE_MAIN_VARIANT (t1) == long_long_unsigned_type_node
892 || TYPE_MAIN_VARIANT (t2) == long_long_unsigned_type_node)
893 return long_long_unsigned_type_node;
895 if (TYPE_MAIN_VARIANT (t1) == long_long_integer_type_node
896 || TYPE_MAIN_VARIANT (t2) == long_long_integer_type_node)
898 if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
899 return long_long_unsigned_type_node;
901 return long_long_integer_type_node;
904 if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
905 || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
906 return long_unsigned_type_node;
908 if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
909 || TYPE_MAIN_VARIANT (t2) == long_integer_type_node)
911 /* But preserve unsignedness from the other type,
912 since long cannot hold all the values of an unsigned int. */
913 if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
914 return long_unsigned_type_node;
916 return long_integer_type_node;
919 /* Likewise, prefer long double to double even if same size. */
920 if (TYPE_MAIN_VARIANT (t1) == long_double_type_node
921 || TYPE_MAIN_VARIANT (t2) == long_double_type_node)
922 return long_double_type_node;
924 /* Otherwise prefer the unsigned one. */
926 if (TYPE_UNSIGNED (t1))
932 /* Wrapper around c_common_type that is used by c-common.c and other
933 front end optimizations that remove promotions. ENUMERAL_TYPEs
934 are allowed here and are converted to their compatible integer types.
935 BOOLEAN_TYPEs are allowed here and return either boolean_type_node or
936 preferably a non-Boolean type as the common type. */
938 common_type (tree t1, tree t2)
940 if (TREE_CODE (t1) == ENUMERAL_TYPE)
941 t1 = c_common_type_for_size (TYPE_PRECISION (t1), 1);
942 if (TREE_CODE (t2) == ENUMERAL_TYPE)
943 t2 = c_common_type_for_size (TYPE_PRECISION (t2), 1);
945 /* If both types are BOOLEAN_TYPE, then return boolean_type_node. */
946 if (TREE_CODE (t1) == BOOLEAN_TYPE
947 && TREE_CODE (t2) == BOOLEAN_TYPE)
948 return boolean_type_node;
950 /* If either type is BOOLEAN_TYPE, then return the other. */
951 if (TREE_CODE (t1) == BOOLEAN_TYPE)
953 if (TREE_CODE (t2) == BOOLEAN_TYPE)
956 return c_common_type (t1, t2);
959 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
960 or various other operations. Return 2 if they are compatible
961 but a warning may be needed if you use them together. */
964 comptypes (tree type1, tree type2)
966 const struct tagged_tu_seen_cache * tagged_tu_seen_base1 = tagged_tu_seen_base;
969 val = comptypes_internal (type1, type2, NULL, NULL);
970 free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1);
975 /* Like comptypes, but if it returns non-zero because enum and int are
976 compatible, it sets *ENUM_AND_INT_P to true. */
979 comptypes_check_enum_int (tree type1, tree type2, bool *enum_and_int_p)
981 const struct tagged_tu_seen_cache * tagged_tu_seen_base1 = tagged_tu_seen_base;
984 val = comptypes_internal (type1, type2, enum_and_int_p, NULL);
985 free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1);
990 /* Like comptypes, but if it returns nonzero for different types, it
991 sets *DIFFERENT_TYPES_P to true. */
994 comptypes_check_different_types (tree type1, tree type2,
995 bool *different_types_p)
997 const struct tagged_tu_seen_cache * tagged_tu_seen_base1 = tagged_tu_seen_base;
1000 val = comptypes_internal (type1, type2, NULL, different_types_p);
1001 free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1);
1006 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
1007 or various other operations. Return 2 if they are compatible
1008 but a warning may be needed if you use them together. If
1009 ENUM_AND_INT_P is not NULL, and one type is an enum and the other a
1010 compatible integer type, then this sets *ENUM_AND_INT_P to true;
1011 *ENUM_AND_INT_P is never set to false. If DIFFERENT_TYPES_P is not
1012 NULL, and the types are compatible but different enough not to be
1013 permitted in C1X typedef redeclarations, then this sets
1014 *DIFFERENT_TYPES_P to true; *DIFFERENT_TYPES_P is never set to
1015 false, but may or may not be set if the types are incompatible.
1016 This differs from comptypes, in that we don't free the seen
1020 comptypes_internal (const_tree type1, const_tree type2, bool *enum_and_int_p,
1021 bool *different_types_p)
1023 const_tree t1 = type1;
1024 const_tree t2 = type2;
1027 /* Suppress errors caused by previously reported errors. */
1029 if (t1 == t2 || !t1 || !t2
1030 || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK)
1033 /* Enumerated types are compatible with integer types, but this is
1034 not transitive: two enumerated types in the same translation unit
1035 are compatible with each other only if they are the same type. */
1037 if (TREE_CODE (t1) == ENUMERAL_TYPE && TREE_CODE (t2) != ENUMERAL_TYPE)
1039 t1 = c_common_type_for_size (TYPE_PRECISION (t1), TYPE_UNSIGNED (t1));
1040 if (TREE_CODE (t2) != VOID_TYPE)
1042 if (enum_and_int_p != NULL)
1043 *enum_and_int_p = true;
1044 if (different_types_p != NULL)
1045 *different_types_p = true;
1048 else if (TREE_CODE (t2) == ENUMERAL_TYPE && TREE_CODE (t1) != ENUMERAL_TYPE)
1050 t2 = c_common_type_for_size (TYPE_PRECISION (t2), TYPE_UNSIGNED (t2));
1051 if (TREE_CODE (t1) != VOID_TYPE)
1053 if (enum_and_int_p != NULL)
1054 *enum_and_int_p = true;
1055 if (different_types_p != NULL)
1056 *different_types_p = true;
1063 /* Different classes of types can't be compatible. */
1065 if (TREE_CODE (t1) != TREE_CODE (t2))
1068 /* Qualifiers must match. C99 6.7.3p9 */
1070 if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
1073 /* Allow for two different type nodes which have essentially the same
1074 definition. Note that we already checked for equality of the type
1075 qualifiers (just above). */
1077 if (TREE_CODE (t1) != ARRAY_TYPE
1078 && TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
1081 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1082 if (!(attrval = targetm.comp_type_attributes (t1, t2)))
1085 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1088 switch (TREE_CODE (t1))
1091 /* Do not remove mode or aliasing information. */
1092 if (TYPE_MODE (t1) != TYPE_MODE (t2)
1093 || TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2))
1095 val = (TREE_TYPE (t1) == TREE_TYPE (t2)
1096 ? 1 : comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2),
1097 enum_and_int_p, different_types_p));
1101 val = function_types_compatible_p (t1, t2, enum_and_int_p,
1107 tree d1 = TYPE_DOMAIN (t1);
1108 tree d2 = TYPE_DOMAIN (t2);
1109 bool d1_variable, d2_variable;
1110 bool d1_zero, d2_zero;
1113 /* Target types must match incl. qualifiers. */
1114 if (TREE_TYPE (t1) != TREE_TYPE (t2)
1115 && 0 == (val = comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2),
1117 different_types_p)))
1120 if (different_types_p != NULL
1121 && (d1 == 0) != (d2 == 0))
1122 *different_types_p = true;
1123 /* Sizes must match unless one is missing or variable. */
1124 if (d1 == 0 || d2 == 0 || d1 == d2)
1127 d1_zero = !TYPE_MAX_VALUE (d1);
1128 d2_zero = !TYPE_MAX_VALUE (d2);
1130 d1_variable = (!d1_zero
1131 && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
1132 || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
1133 d2_variable = (!d2_zero
1134 && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
1135 || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
1136 d1_variable = d1_variable || (d1_zero && c_vla_type_p (t1));
1137 d2_variable = d2_variable || (d2_zero && c_vla_type_p (t2));
1139 if (different_types_p != NULL
1140 && d1_variable != d2_variable)
1141 *different_types_p = true;
1142 if (d1_variable || d2_variable)
1144 if (d1_zero && d2_zero)
1146 if (d1_zero || d2_zero
1147 || !tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2))
1148 || !tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2)))
1157 if (val != 1 && !same_translation_unit_p (t1, t2))
1159 tree a1 = TYPE_ATTRIBUTES (t1);
1160 tree a2 = TYPE_ATTRIBUTES (t2);
1162 if (! attribute_list_contained (a1, a2)
1163 && ! attribute_list_contained (a2, a1))
1167 return tagged_types_tu_compatible_p (t1, t2, enum_and_int_p,
1169 val = tagged_types_tu_compatible_p (t1, t2, enum_and_int_p,
1175 val = (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1176 && comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2),
1177 enum_and_int_p, different_types_p));
1183 return attrval == 2 && val == 1 ? 2 : val;
1186 /* Return 1 if TTL and TTR are pointers to types that are equivalent, ignoring
1187 their qualifiers, except for named address spaces. If the pointers point to
1188 different named addresses, then we must determine if one address space is a
1189 subset of the other. */
1192 comp_target_types (location_t location, tree ttl, tree ttr)
1195 tree mvl = TREE_TYPE (ttl);
1196 tree mvr = TREE_TYPE (ttr);
1197 addr_space_t asl = TYPE_ADDR_SPACE (mvl);
1198 addr_space_t asr = TYPE_ADDR_SPACE (mvr);
1199 addr_space_t as_common;
1200 bool enum_and_int_p;
1202 /* Fail if pointers point to incompatible address spaces. */
1203 if (!addr_space_superset (asl, asr, &as_common))
1206 /* Do not lose qualifiers on element types of array types that are
1207 pointer targets by taking their TYPE_MAIN_VARIANT. */
1208 if (TREE_CODE (mvl) != ARRAY_TYPE)
1209 mvl = TYPE_MAIN_VARIANT (mvl);
1210 if (TREE_CODE (mvr) != ARRAY_TYPE)
1211 mvr = TYPE_MAIN_VARIANT (mvr);
1212 enum_and_int_p = false;
1213 val = comptypes_check_enum_int (mvl, mvr, &enum_and_int_p);
1216 pedwarn (location, OPT_pedantic, "types are not quite compatible");
1218 if (val == 1 && enum_and_int_p && warn_cxx_compat)
1219 warning_at (location, OPT_Wc___compat,
1220 "pointer target types incompatible in C++");
1225 /* Subroutines of `comptypes'. */
1227 /* Determine whether two trees derive from the same translation unit.
1228 If the CONTEXT chain ends in a null, that tree's context is still
1229 being parsed, so if two trees have context chains ending in null,
1230 they're in the same translation unit. */
1232 same_translation_unit_p (const_tree t1, const_tree t2)
1234 while (t1 && TREE_CODE (t1) != TRANSLATION_UNIT_DECL)
1235 switch (TREE_CODE_CLASS (TREE_CODE (t1)))
1237 case tcc_declaration:
1238 t1 = DECL_CONTEXT (t1); break;
1240 t1 = TYPE_CONTEXT (t1); break;
1241 case tcc_exceptional:
1242 t1 = BLOCK_SUPERCONTEXT (t1); break; /* assume block */
1243 default: gcc_unreachable ();
1246 while (t2 && TREE_CODE (t2) != TRANSLATION_UNIT_DECL)
1247 switch (TREE_CODE_CLASS (TREE_CODE (t2)))
1249 case tcc_declaration:
1250 t2 = DECL_CONTEXT (t2); break;
1252 t2 = TYPE_CONTEXT (t2); break;
1253 case tcc_exceptional:
1254 t2 = BLOCK_SUPERCONTEXT (t2); break; /* assume block */
1255 default: gcc_unreachable ();
1261 /* Allocate the seen two types, assuming that they are compatible. */
1263 static struct tagged_tu_seen_cache *
1264 alloc_tagged_tu_seen_cache (const_tree t1, const_tree t2)
1266 struct tagged_tu_seen_cache *tu = XNEW (struct tagged_tu_seen_cache);
1267 tu->next = tagged_tu_seen_base;
1271 tagged_tu_seen_base = tu;
1273 /* The C standard says that two structures in different translation
1274 units are compatible with each other only if the types of their
1275 fields are compatible (among other things). We assume that they
1276 are compatible until proven otherwise when building the cache.
1277 An example where this can occur is:
1282 If we are comparing this against a similar struct in another TU,
1283 and did not assume they were compatible, we end up with an infinite
1289 /* Free the seen types until we get to TU_TIL. */
1292 free_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache *tu_til)
1294 const struct tagged_tu_seen_cache *tu = tagged_tu_seen_base;
1295 while (tu != tu_til)
1297 const struct tagged_tu_seen_cache *const tu1
1298 = (const struct tagged_tu_seen_cache *) tu;
1300 free (CONST_CAST (struct tagged_tu_seen_cache *, tu1));
1302 tagged_tu_seen_base = tu_til;
1305 /* Return 1 if two 'struct', 'union', or 'enum' types T1 and T2 are
1306 compatible. If the two types are not the same (which has been
1307 checked earlier), this can only happen when multiple translation
1308 units are being compiled. See C99 6.2.7 paragraph 1 for the exact
1309 rules. ENUM_AND_INT_P and DIFFERENT_TYPES_P are as in
1310 comptypes_internal. */
1313 tagged_types_tu_compatible_p (const_tree t1, const_tree t2,
1314 bool *enum_and_int_p, bool *different_types_p)
1317 bool needs_warning = false;
1319 /* We have to verify that the tags of the types are the same. This
1320 is harder than it looks because this may be a typedef, so we have
1321 to go look at the original type. It may even be a typedef of a
1323 In the case of compiler-created builtin structs the TYPE_DECL
1324 may be a dummy, with no DECL_ORIGINAL_TYPE. Don't fault. */
1325 while (TYPE_NAME (t1)
1326 && TREE_CODE (TYPE_NAME (t1)) == TYPE_DECL
1327 && DECL_ORIGINAL_TYPE (TYPE_NAME (t1)))
1328 t1 = DECL_ORIGINAL_TYPE (TYPE_NAME (t1));
1330 while (TYPE_NAME (t2)
1331 && TREE_CODE (TYPE_NAME (t2)) == TYPE_DECL
1332 && DECL_ORIGINAL_TYPE (TYPE_NAME (t2)))
1333 t2 = DECL_ORIGINAL_TYPE (TYPE_NAME (t2));
1335 /* C90 didn't have the requirement that the two tags be the same. */
1336 if (flag_isoc99 && TYPE_NAME (t1) != TYPE_NAME (t2))
1339 /* C90 didn't say what happened if one or both of the types were
1340 incomplete; we choose to follow C99 rules here, which is that they
1342 if (TYPE_SIZE (t1) == NULL
1343 || TYPE_SIZE (t2) == NULL)
1347 const struct tagged_tu_seen_cache * tts_i;
1348 for (tts_i = tagged_tu_seen_base; tts_i != NULL; tts_i = tts_i->next)
1349 if (tts_i->t1 == t1 && tts_i->t2 == t2)
1353 switch (TREE_CODE (t1))
1357 struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2);
1358 /* Speed up the case where the type values are in the same order. */
1359 tree tv1 = TYPE_VALUES (t1);
1360 tree tv2 = TYPE_VALUES (t2);
1367 for (;tv1 && tv2; tv1 = TREE_CHAIN (tv1), tv2 = TREE_CHAIN (tv2))
1369 if (TREE_PURPOSE (tv1) != TREE_PURPOSE (tv2))
1371 if (simple_cst_equal (TREE_VALUE (tv1), TREE_VALUE (tv2)) != 1)
1378 if (tv1 == NULL_TREE && tv2 == NULL_TREE)
1382 if (tv1 == NULL_TREE || tv2 == NULL_TREE)
1388 if (list_length (TYPE_VALUES (t1)) != list_length (TYPE_VALUES (t2)))
1394 for (s1 = TYPE_VALUES (t1); s1; s1 = TREE_CHAIN (s1))
1396 s2 = purpose_member (TREE_PURPOSE (s1), TYPE_VALUES (t2));
1398 || simple_cst_equal (TREE_VALUE (s1), TREE_VALUE (s2)) != 1)
1409 struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2);
1410 if (list_length (TYPE_FIELDS (t1)) != list_length (TYPE_FIELDS (t2)))
1416 /* Speed up the common case where the fields are in the same order. */
1417 for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2); s1 && s2;
1418 s1 = DECL_CHAIN (s1), s2 = DECL_CHAIN (s2))
1422 if (DECL_NAME (s1) != DECL_NAME (s2))
1424 result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2),
1425 enum_and_int_p, different_types_p);
1427 if (result != 1 && !DECL_NAME (s1))
1435 needs_warning = true;
1437 if (TREE_CODE (s1) == FIELD_DECL
1438 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
1439 DECL_FIELD_BIT_OFFSET (s2)) != 1)
1447 tu->val = needs_warning ? 2 : 1;
1451 for (s1 = TYPE_FIELDS (t1); s1; s1 = DECL_CHAIN (s1))
1455 for (s2 = TYPE_FIELDS (t2); s2; s2 = DECL_CHAIN (s2))
1456 if (DECL_NAME (s1) == DECL_NAME (s2))
1460 result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2),
1464 if (result != 1 && !DECL_NAME (s1))
1472 needs_warning = true;
1474 if (TREE_CODE (s1) == FIELD_DECL
1475 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
1476 DECL_FIELD_BIT_OFFSET (s2)) != 1)
1488 tu->val = needs_warning ? 2 : 10;
1494 struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2);
1496 for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2);
1498 s1 = DECL_CHAIN (s1), s2 = DECL_CHAIN (s2))
1501 if (TREE_CODE (s1) != TREE_CODE (s2)
1502 || DECL_NAME (s1) != DECL_NAME (s2))
1504 result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2),
1505 enum_and_int_p, different_types_p);
1509 needs_warning = true;
1511 if (TREE_CODE (s1) == FIELD_DECL
1512 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
1513 DECL_FIELD_BIT_OFFSET (s2)) != 1)
1519 tu->val = needs_warning ? 2 : 1;
1528 /* Return 1 if two function types F1 and F2 are compatible.
1529 If either type specifies no argument types,
1530 the other must specify a fixed number of self-promoting arg types.
1531 Otherwise, if one type specifies only the number of arguments,
1532 the other must specify that number of self-promoting arg types.
1533 Otherwise, the argument types must match.
1534 ENUM_AND_INT_P and DIFFERENT_TYPES_P are as in comptypes_internal. */
1537 function_types_compatible_p (const_tree f1, const_tree f2,
1538 bool *enum_and_int_p, bool *different_types_p)
1541 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1546 ret1 = TREE_TYPE (f1);
1547 ret2 = TREE_TYPE (f2);
1549 /* 'volatile' qualifiers on a function's return type used to mean
1550 the function is noreturn. */
1551 if (TYPE_VOLATILE (ret1) != TYPE_VOLATILE (ret2))
1552 pedwarn (input_location, 0, "function return types not compatible due to %<volatile%>");
1553 if (TYPE_VOLATILE (ret1))
1554 ret1 = build_qualified_type (TYPE_MAIN_VARIANT (ret1),
1555 TYPE_QUALS (ret1) & ~TYPE_QUAL_VOLATILE);
1556 if (TYPE_VOLATILE (ret2))
1557 ret2 = build_qualified_type (TYPE_MAIN_VARIANT (ret2),
1558 TYPE_QUALS (ret2) & ~TYPE_QUAL_VOLATILE);
1559 val = comptypes_internal (ret1, ret2, enum_and_int_p, different_types_p);
1563 args1 = TYPE_ARG_TYPES (f1);
1564 args2 = TYPE_ARG_TYPES (f2);
1566 if (different_types_p != NULL
1567 && (args1 == 0) != (args2 == 0))
1568 *different_types_p = true;
1570 /* An unspecified parmlist matches any specified parmlist
1571 whose argument types don't need default promotions. */
1575 if (!self_promoting_args_p (args2))
1577 /* If one of these types comes from a non-prototype fn definition,
1578 compare that with the other type's arglist.
1579 If they don't match, ask for a warning (but no error). */
1580 if (TYPE_ACTUAL_ARG_TYPES (f1)
1581 && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1),
1582 enum_and_int_p, different_types_p))
1588 if (!self_promoting_args_p (args1))
1590 if (TYPE_ACTUAL_ARG_TYPES (f2)
1591 && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2),
1592 enum_and_int_p, different_types_p))
1597 /* Both types have argument lists: compare them and propagate results. */
1598 val1 = type_lists_compatible_p (args1, args2, enum_and_int_p,
1600 return val1 != 1 ? val1 : val;
1603 /* Check two lists of types for compatibility, returning 0 for
1604 incompatible, 1 for compatible, or 2 for compatible with
1605 warning. ENUM_AND_INT_P and DIFFERENT_TYPES_P are as in
1606 comptypes_internal. */
1609 type_lists_compatible_p (const_tree args1, const_tree args2,
1610 bool *enum_and_int_p, bool *different_types_p)
1612 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1618 tree a1, mv1, a2, mv2;
1619 if (args1 == 0 && args2 == 0)
1621 /* If one list is shorter than the other,
1622 they fail to match. */
1623 if (args1 == 0 || args2 == 0)
1625 mv1 = a1 = TREE_VALUE (args1);
1626 mv2 = a2 = TREE_VALUE (args2);
1627 if (mv1 && mv1 != error_mark_node && TREE_CODE (mv1) != ARRAY_TYPE)
1628 mv1 = TYPE_MAIN_VARIANT (mv1);
1629 if (mv2 && mv2 != error_mark_node && TREE_CODE (mv2) != ARRAY_TYPE)
1630 mv2 = TYPE_MAIN_VARIANT (mv2);
1631 /* A null pointer instead of a type
1632 means there is supposed to be an argument
1633 but nothing is specified about what type it has.
1634 So match anything that self-promotes. */
1635 if (different_types_p != NULL
1636 && (a1 == 0) != (a2 == 0))
1637 *different_types_p = true;
1640 if (c_type_promotes_to (a2) != a2)
1645 if (c_type_promotes_to (a1) != a1)
1648 /* If one of the lists has an error marker, ignore this arg. */
1649 else if (TREE_CODE (a1) == ERROR_MARK
1650 || TREE_CODE (a2) == ERROR_MARK)
1652 else if (!(newval = comptypes_internal (mv1, mv2, enum_and_int_p,
1653 different_types_p)))
1655 if (different_types_p != NULL)
1656 *different_types_p = true;
1657 /* Allow wait (union {union wait *u; int *i} *)
1658 and wait (union wait *) to be compatible. */
1659 if (TREE_CODE (a1) == UNION_TYPE
1660 && (TYPE_NAME (a1) == 0
1661 || TYPE_TRANSPARENT_AGGR (a1))
1662 && TREE_CODE (TYPE_SIZE (a1)) == INTEGER_CST
1663 && tree_int_cst_equal (TYPE_SIZE (a1),
1667 for (memb = TYPE_FIELDS (a1);
1668 memb; memb = DECL_CHAIN (memb))
1670 tree mv3 = TREE_TYPE (memb);
1671 if (mv3 && mv3 != error_mark_node
1672 && TREE_CODE (mv3) != ARRAY_TYPE)
1673 mv3 = TYPE_MAIN_VARIANT (mv3);
1674 if (comptypes_internal (mv3, mv2, enum_and_int_p,
1681 else if (TREE_CODE (a2) == UNION_TYPE
1682 && (TYPE_NAME (a2) == 0
1683 || TYPE_TRANSPARENT_AGGR (a2))
1684 && TREE_CODE (TYPE_SIZE (a2)) == INTEGER_CST
1685 && tree_int_cst_equal (TYPE_SIZE (a2),
1689 for (memb = TYPE_FIELDS (a2);
1690 memb; memb = DECL_CHAIN (memb))
1692 tree mv3 = TREE_TYPE (memb);
1693 if (mv3 && mv3 != error_mark_node
1694 && TREE_CODE (mv3) != ARRAY_TYPE)
1695 mv3 = TYPE_MAIN_VARIANT (mv3);
1696 if (comptypes_internal (mv3, mv1, enum_and_int_p,
1707 /* comptypes said ok, but record if it said to warn. */
1711 args1 = TREE_CHAIN (args1);
1712 args2 = TREE_CHAIN (args2);
1716 /* Compute the size to increment a pointer by. */
1719 c_size_in_bytes (const_tree type)
1721 enum tree_code code = TREE_CODE (type);
1723 if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
1724 return size_one_node;
1726 if (!COMPLETE_OR_VOID_TYPE_P (type))
1728 error ("arithmetic on pointer to an incomplete type");
1729 return size_one_node;
1732 /* Convert in case a char is more than one unit. */
1733 return size_binop_loc (input_location, CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
1734 size_int (TYPE_PRECISION (char_type_node)
1738 /* Return either DECL or its known constant value (if it has one). */
1741 decl_constant_value (tree decl)
1743 if (/* Don't change a variable array bound or initial value to a constant
1744 in a place where a variable is invalid. Note that DECL_INITIAL
1745 isn't valid for a PARM_DECL. */
1746 current_function_decl != 0
1747 && TREE_CODE (decl) != PARM_DECL
1748 && !TREE_THIS_VOLATILE (decl)
1749 && TREE_READONLY (decl)
1750 && DECL_INITIAL (decl) != 0
1751 && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
1752 /* This is invalid if initial value is not constant.
1753 If it has either a function call, a memory reference,
1754 or a variable, then re-evaluating it could give different results. */
1755 && TREE_CONSTANT (DECL_INITIAL (decl))
1756 /* Check for cases where this is sub-optimal, even though valid. */
1757 && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
1758 return DECL_INITIAL (decl);
1762 /* Convert the array expression EXP to a pointer. */
1764 array_to_pointer_conversion (location_t loc, tree exp)
1766 tree orig_exp = exp;
1767 tree type = TREE_TYPE (exp);
1769 tree restype = TREE_TYPE (type);
1772 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
1774 STRIP_TYPE_NOPS (exp);
1776 if (TREE_NO_WARNING (orig_exp))
1777 TREE_NO_WARNING (exp) = 1;
1779 ptrtype = build_pointer_type (restype);
1781 if (TREE_CODE (exp) == INDIRECT_REF)
1782 return convert (ptrtype, TREE_OPERAND (exp, 0));
1784 adr = build_unary_op (loc, ADDR_EXPR, exp, 1);
1785 return convert (ptrtype, adr);
1788 /* Convert the function expression EXP to a pointer. */
1790 function_to_pointer_conversion (location_t loc, tree exp)
1792 tree orig_exp = exp;
1794 gcc_assert (TREE_CODE (TREE_TYPE (exp)) == FUNCTION_TYPE);
1796 STRIP_TYPE_NOPS (exp);
1798 if (TREE_NO_WARNING (orig_exp))
1799 TREE_NO_WARNING (exp) = 1;
1801 return build_unary_op (loc, ADDR_EXPR, exp, 0);
1804 /* Mark EXP as read, not just set, for set but not used -Wunused
1805 warning purposes. */
1808 mark_exp_read (tree exp)
1810 switch (TREE_CODE (exp))
1814 DECL_READ_P (exp) = 1;
1823 mark_exp_read (TREE_OPERAND (exp, 0));
1826 case C_MAYBE_CONST_EXPR:
1827 mark_exp_read (TREE_OPERAND (exp, 1));
1834 /* Perform the default conversion of arrays and functions to pointers.
1835 Return the result of converting EXP. For any other expression, just
1838 LOC is the location of the expression. */
1841 default_function_array_conversion (location_t loc, struct c_expr exp)
1843 tree orig_exp = exp.value;
1844 tree type = TREE_TYPE (exp.value);
1845 enum tree_code code = TREE_CODE (type);
1851 bool not_lvalue = false;
1852 bool lvalue_array_p;
1854 while ((TREE_CODE (exp.value) == NON_LVALUE_EXPR
1855 || CONVERT_EXPR_P (exp.value))
1856 && TREE_TYPE (TREE_OPERAND (exp.value, 0)) == type)
1858 if (TREE_CODE (exp.value) == NON_LVALUE_EXPR)
1860 exp.value = TREE_OPERAND (exp.value, 0);
1863 if (TREE_NO_WARNING (orig_exp))
1864 TREE_NO_WARNING (exp.value) = 1;
1866 lvalue_array_p = !not_lvalue && lvalue_p (exp.value);
1867 if (!flag_isoc99 && !lvalue_array_p)
1869 /* Before C99, non-lvalue arrays do not decay to pointers.
1870 Normally, using such an array would be invalid; but it can
1871 be used correctly inside sizeof or as a statement expression.
1872 Thus, do not give an error here; an error will result later. */
1876 exp.value = array_to_pointer_conversion (loc, exp.value);
1880 exp.value = function_to_pointer_conversion (loc, exp.value);
1890 default_function_array_read_conversion (location_t loc, struct c_expr exp)
1892 mark_exp_read (exp.value);
1893 return default_function_array_conversion (loc, exp);
1896 /* EXP is an expression of integer type. Apply the integer promotions
1897 to it and return the promoted value. */
1900 perform_integral_promotions (tree exp)
1902 tree type = TREE_TYPE (exp);
1903 enum tree_code code = TREE_CODE (type);
1905 gcc_assert (INTEGRAL_TYPE_P (type));
1907 /* Normally convert enums to int,
1908 but convert wide enums to something wider. */
1909 if (code == ENUMERAL_TYPE)
1911 type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
1912 TYPE_PRECISION (integer_type_node)),
1913 ((TYPE_PRECISION (type)
1914 >= TYPE_PRECISION (integer_type_node))
1915 && TYPE_UNSIGNED (type)));
1917 return convert (type, exp);
1920 /* ??? This should no longer be needed now bit-fields have their
1922 if (TREE_CODE (exp) == COMPONENT_REF
1923 && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1))
1924 /* If it's thinner than an int, promote it like a
1925 c_promoting_integer_type_p, otherwise leave it alone. */
1926 && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
1927 TYPE_PRECISION (integer_type_node)))
1928 return convert (integer_type_node, exp);
1930 if (c_promoting_integer_type_p (type))
1932 /* Preserve unsignedness if not really getting any wider. */
1933 if (TYPE_UNSIGNED (type)
1934 && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1935 return convert (unsigned_type_node, exp);
1937 return convert (integer_type_node, exp);
1944 /* Perform default promotions for C data used in expressions.
1945 Enumeral types or short or char are converted to int.
1946 In addition, manifest constants symbols are replaced by their values. */
1949 default_conversion (tree exp)
1952 tree type = TREE_TYPE (exp);
1953 enum tree_code code = TREE_CODE (type);
1956 mark_exp_read (exp);
1958 /* Functions and arrays have been converted during parsing. */
1959 gcc_assert (code != FUNCTION_TYPE);
1960 if (code == ARRAY_TYPE)
1963 /* Constants can be used directly unless they're not loadable. */
1964 if (TREE_CODE (exp) == CONST_DECL)
1965 exp = DECL_INITIAL (exp);
1967 /* Strip no-op conversions. */
1969 STRIP_TYPE_NOPS (exp);
1971 if (TREE_NO_WARNING (orig_exp))
1972 TREE_NO_WARNING (exp) = 1;
1974 if (code == VOID_TYPE)
1976 error ("void value not ignored as it ought to be");
1977 return error_mark_node;
1980 exp = require_complete_type (exp);
1981 if (exp == error_mark_node)
1982 return error_mark_node;
1984 promoted_type = targetm.promoted_type (type);
1986 return convert (promoted_type, exp);
1988 if (INTEGRAL_TYPE_P (type))
1989 return perform_integral_promotions (exp);
1994 /* Look up COMPONENT in a structure or union TYPE.
1996 If the component name is not found, returns NULL_TREE. Otherwise,
1997 the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL
1998 stepping down the chain to the component, which is in the last
1999 TREE_VALUE of the list. Normally the list is of length one, but if
2000 the component is embedded within (nested) anonymous structures or
2001 unions, the list steps down the chain to the component. */
2004 lookup_field (tree type, tree component)
2008 /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
2009 to the field elements. Use a binary search on this array to quickly
2010 find the element. Otherwise, do a linear search. TYPE_LANG_SPECIFIC
2011 will always be set for structures which have many elements. */
2013 if (TYPE_LANG_SPECIFIC (type) && TYPE_LANG_SPECIFIC (type)->s)
2016 tree *field_array = &TYPE_LANG_SPECIFIC (type)->s->elts[0];
2018 field = TYPE_FIELDS (type);
2020 top = TYPE_LANG_SPECIFIC (type)->s->len;
2021 while (top - bot > 1)
2023 half = (top - bot + 1) >> 1;
2024 field = field_array[bot+half];
2026 if (DECL_NAME (field) == NULL_TREE)
2028 /* Step through all anon unions in linear fashion. */
2029 while (DECL_NAME (field_array[bot]) == NULL_TREE)
2031 field = field_array[bot++];
2032 if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
2033 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
2035 tree anon = lookup_field (TREE_TYPE (field), component);
2038 return tree_cons (NULL_TREE, field, anon);
2040 /* The Plan 9 compiler permits referring
2041 directly to an anonymous struct/union field
2042 using a typedef name. */
2043 if (flag_plan9_extensions
2044 && TYPE_NAME (TREE_TYPE (field)) != NULL_TREE
2045 && (TREE_CODE (TYPE_NAME (TREE_TYPE (field)))
2047 && (DECL_NAME (TYPE_NAME (TREE_TYPE (field)))
2053 /* Entire record is only anon unions. */
2057 /* Restart the binary search, with new lower bound. */
2061 if (DECL_NAME (field) == component)
2063 if (DECL_NAME (field) < component)
2069 if (DECL_NAME (field_array[bot]) == component)
2070 field = field_array[bot];
2071 else if (DECL_NAME (field) != component)
2076 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
2078 if (DECL_NAME (field) == NULL_TREE
2079 && (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
2080 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE))
2082 tree anon = lookup_field (TREE_TYPE (field), component);
2085 return tree_cons (NULL_TREE, field, anon);
2087 /* The Plan 9 compiler permits referring directly to an
2088 anonymous struct/union field using a typedef
2090 if (flag_plan9_extensions
2091 && TYPE_NAME (TREE_TYPE (field)) != NULL_TREE
2092 && TREE_CODE (TYPE_NAME (TREE_TYPE (field))) == TYPE_DECL
2093 && (DECL_NAME (TYPE_NAME (TREE_TYPE (field)))
2098 if (DECL_NAME (field) == component)
2102 if (field == NULL_TREE)
2106 return tree_cons (NULL_TREE, field, NULL_TREE);
2109 /* Make an expression to refer to the COMPONENT field of structure or
2110 union value DATUM. COMPONENT is an IDENTIFIER_NODE. LOC is the
2111 location of the COMPONENT_REF. */
2114 build_component_ref (location_t loc, tree datum, tree component)
2116 tree type = TREE_TYPE (datum);
2117 enum tree_code code = TREE_CODE (type);
2120 bool datum_lvalue = lvalue_p (datum);
2122 if (!objc_is_public (datum, component))
2123 return error_mark_node;
2125 /* Detect Objective-C property syntax object.property. */
2126 if (c_dialect_objc ()
2127 && (ref = objc_maybe_build_component_ref (datum, component)))
2130 /* See if there is a field or component with name COMPONENT. */
2132 if (code == RECORD_TYPE || code == UNION_TYPE)
2134 if (!COMPLETE_TYPE_P (type))
2136 c_incomplete_type_error (NULL_TREE, type);
2137 return error_mark_node;
2140 field = lookup_field (type, component);
2144 error_at (loc, "%qT has no member named %qE", type, component);
2145 return error_mark_node;
2148 /* Chain the COMPONENT_REFs if necessary down to the FIELD.
2149 This might be better solved in future the way the C++ front
2150 end does it - by giving the anonymous entities each a
2151 separate name and type, and then have build_component_ref
2152 recursively call itself. We can't do that here. */
2155 tree subdatum = TREE_VALUE (field);
2158 bool use_datum_quals;
2160 if (TREE_TYPE (subdatum) == error_mark_node)
2161 return error_mark_node;
2163 /* If this is an rvalue, it does not have qualifiers in C
2164 standard terms and we must avoid propagating such
2165 qualifiers down to a non-lvalue array that is then
2166 converted to a pointer. */
2167 use_datum_quals = (datum_lvalue
2168 || TREE_CODE (TREE_TYPE (subdatum)) != ARRAY_TYPE);
2170 quals = TYPE_QUALS (strip_array_types (TREE_TYPE (subdatum)));
2171 if (use_datum_quals)
2172 quals |= TYPE_QUALS (TREE_TYPE (datum));
2173 subtype = c_build_qualified_type (TREE_TYPE (subdatum), quals);
2175 ref = build3 (COMPONENT_REF, subtype, datum, subdatum,
2177 SET_EXPR_LOCATION (ref, loc);
2178 if (TREE_READONLY (subdatum)
2179 || (use_datum_quals && TREE_READONLY (datum)))
2180 TREE_READONLY (ref) = 1;
2181 if (TREE_THIS_VOLATILE (subdatum)
2182 || (use_datum_quals && TREE_THIS_VOLATILE (datum)))
2183 TREE_THIS_VOLATILE (ref) = 1;
2185 if (TREE_DEPRECATED (subdatum))
2186 warn_deprecated_use (subdatum, NULL_TREE);
2190 field = TREE_CHAIN (field);
2196 else if (code != ERROR_MARK)
2198 "request for member %qE in something not a structure or union",
2201 return error_mark_node;
2204 /* Given an expression PTR for a pointer, return an expression
2205 for the value pointed to.
2206 ERRORSTRING is the name of the operator to appear in error messages.
2208 LOC is the location to use for the generated tree. */
2211 build_indirect_ref (location_t loc, tree ptr, ref_operator errstring)
2213 tree pointer = default_conversion (ptr);
2214 tree type = TREE_TYPE (pointer);
2217 if (TREE_CODE (type) == POINTER_TYPE)
2219 if (CONVERT_EXPR_P (pointer)
2220 || TREE_CODE (pointer) == VIEW_CONVERT_EXPR)
2222 /* If a warning is issued, mark it to avoid duplicates from
2223 the backend. This only needs to be done at
2224 warn_strict_aliasing > 2. */
2225 if (warn_strict_aliasing > 2)
2226 if (strict_aliasing_warning (TREE_TYPE (TREE_OPERAND (pointer, 0)),
2227 type, TREE_OPERAND (pointer, 0)))
2228 TREE_NO_WARNING (pointer) = 1;
2231 if (TREE_CODE (pointer) == ADDR_EXPR
2232 && (TREE_TYPE (TREE_OPERAND (pointer, 0))
2233 == TREE_TYPE (type)))
2235 ref = TREE_OPERAND (pointer, 0);
2236 protected_set_expr_location (ref, loc);
2241 tree t = TREE_TYPE (type);
2243 ref = build1 (INDIRECT_REF, t, pointer);
2245 if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE)
2247 error_at (loc, "dereferencing pointer to incomplete type");
2248 return error_mark_node;
2250 if (VOID_TYPE_P (t) && c_inhibit_evaluation_warnings == 0)
2251 warning_at (loc, 0, "dereferencing %<void *%> pointer");
2253 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
2254 so that we get the proper error message if the result is used
2255 to assign to. Also, &* is supposed to be a no-op.
2256 And ANSI C seems to specify that the type of the result
2257 should be the const type. */
2258 /* A de-reference of a pointer to const is not a const. It is valid
2259 to change it via some other pointer. */
2260 TREE_READONLY (ref) = TYPE_READONLY (t);
2261 TREE_SIDE_EFFECTS (ref)
2262 = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer);
2263 TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
2264 protected_set_expr_location (ref, loc);
2268 else if (TREE_CODE (pointer) != ERROR_MARK)
2271 case RO_ARRAY_INDEXING:
2273 "invalid type argument of array indexing (have %qT)",
2278 "invalid type argument of unary %<*%> (have %qT)",
2283 "invalid type argument of %<->%> (have %qT)",
2289 return error_mark_node;
2292 /* This handles expressions of the form "a[i]", which denotes
2295 This is logically equivalent in C to *(a+i), but we may do it differently.
2296 If A is a variable or a member, we generate a primitive ARRAY_REF.
2297 This avoids forcing the array out of registers, and can work on
2298 arrays that are not lvalues (for example, members of structures returned
2301 For vector types, allow vector[i] but not i[vector], and create
2302 *(((type*)&vectortype) + i) for the expression.
2304 LOC is the location to use for the returned expression. */
2307 build_array_ref (location_t loc, tree array, tree index)
2310 bool swapped = false;
2311 if (TREE_TYPE (array) == error_mark_node
2312 || TREE_TYPE (index) == error_mark_node)
2313 return error_mark_node;
2315 if (TREE_CODE (TREE_TYPE (array)) != ARRAY_TYPE
2316 && TREE_CODE (TREE_TYPE (array)) != POINTER_TYPE
2317 /* Allow vector[index] but not index[vector]. */
2318 && TREE_CODE (TREE_TYPE (array)) != VECTOR_TYPE)
2321 if (TREE_CODE (TREE_TYPE (index)) != ARRAY_TYPE
2322 && TREE_CODE (TREE_TYPE (index)) != POINTER_TYPE)
2325 "subscripted value is neither array nor pointer nor vector");
2327 return error_mark_node;
2335 if (!INTEGRAL_TYPE_P (TREE_TYPE (index)))
2337 error_at (loc, "array subscript is not an integer");
2338 return error_mark_node;
2341 if (TREE_CODE (TREE_TYPE (TREE_TYPE (array))) == FUNCTION_TYPE)
2343 error_at (loc, "subscripted value is pointer to function");
2344 return error_mark_node;
2347 /* ??? Existing practice has been to warn only when the char
2348 index is syntactically the index, not for char[array]. */
2350 warn_array_subscript_with_type_char (index);
2352 /* Apply default promotions *after* noticing character types. */
2353 index = default_conversion (index);
2355 gcc_assert (TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE);
2357 /* For vector[index], convert the vector to a
2358 pointer of the underlying type. */
2359 if (TREE_CODE (TREE_TYPE (array)) == VECTOR_TYPE)
2361 tree type = TREE_TYPE (array);
2364 if (TREE_CODE (index) == INTEGER_CST)
2365 if (!host_integerp (index, 1)
2366 || ((unsigned HOST_WIDE_INT) tree_low_cst (index, 1)
2367 >= TYPE_VECTOR_SUBPARTS (TREE_TYPE (array))))
2368 warning_at (loc, OPT_Warray_bounds, "index value is out of bound");
2370 c_common_mark_addressable_vec (array);
2371 type = build_qualified_type (TREE_TYPE (type), TYPE_QUALS (type));
2372 type = build_pointer_type (type);
2373 type1 = build_pointer_type (TREE_TYPE (array));
2374 array = build1 (ADDR_EXPR, type1, array);
2375 array = convert (type, array);
2378 if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE)
2382 /* An array that is indexed by a non-constant
2383 cannot be stored in a register; we must be able to do
2384 address arithmetic on its address.
2385 Likewise an array of elements of variable size. */
2386 if (TREE_CODE (index) != INTEGER_CST
2387 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
2388 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
2390 if (!c_mark_addressable (array))
2391 return error_mark_node;
2393 /* An array that is indexed by a constant value which is not within
2394 the array bounds cannot be stored in a register either; because we
2395 would get a crash in store_bit_field/extract_bit_field when trying
2396 to access a non-existent part of the register. */
2397 if (TREE_CODE (index) == INTEGER_CST
2398 && TYPE_DOMAIN (TREE_TYPE (array))
2399 && !int_fits_type_p (index, TYPE_DOMAIN (TREE_TYPE (array))))
2401 if (!c_mark_addressable (array))
2402 return error_mark_node;
2408 while (TREE_CODE (foo) == COMPONENT_REF)
2409 foo = TREE_OPERAND (foo, 0);
2410 if (TREE_CODE (foo) == VAR_DECL && C_DECL_REGISTER (foo))
2411 pedwarn (loc, OPT_pedantic,
2412 "ISO C forbids subscripting %<register%> array");
2413 else if (!flag_isoc99 && !lvalue_p (foo))
2414 pedwarn (loc, OPT_pedantic,
2415 "ISO C90 forbids subscripting non-lvalue array");
2418 type = TREE_TYPE (TREE_TYPE (array));
2419 rval = build4 (ARRAY_REF, type, array, index, NULL_TREE, NULL_TREE);
2420 /* Array ref is const/volatile if the array elements are
2421 or if the array is. */
2422 TREE_READONLY (rval)
2423 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
2424 | TREE_READONLY (array));
2425 TREE_SIDE_EFFECTS (rval)
2426 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
2427 | TREE_SIDE_EFFECTS (array));
2428 TREE_THIS_VOLATILE (rval)
2429 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
2430 /* This was added by rms on 16 Nov 91.
2431 It fixes vol struct foo *a; a->elts[1]
2432 in an inline function.
2433 Hope it doesn't break something else. */
2434 | TREE_THIS_VOLATILE (array));
2435 ret = require_complete_type (rval);
2436 protected_set_expr_location (ret, loc);
2441 tree ar = default_conversion (array);
2443 if (ar == error_mark_node)
2446 gcc_assert (TREE_CODE (TREE_TYPE (ar)) == POINTER_TYPE);
2447 gcc_assert (TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) != FUNCTION_TYPE);
2449 return build_indirect_ref
2450 (loc, build_binary_op (loc, PLUS_EXPR, ar, index, 0),
2455 /* Build an external reference to identifier ID. FUN indicates
2456 whether this will be used for a function call. LOC is the source
2457 location of the identifier. This sets *TYPE to the type of the
2458 identifier, which is not the same as the type of the returned value
2459 for CONST_DECLs defined as enum constants. If the type of the
2460 identifier is not available, *TYPE is set to NULL. */
2462 build_external_ref (location_t loc, tree id, int fun, tree *type)
2465 tree decl = lookup_name (id);
2467 /* In Objective-C, an instance variable (ivar) may be preferred to
2468 whatever lookup_name() found. */
2469 decl = objc_lookup_ivar (decl, id);
2472 if (decl && decl != error_mark_node)
2475 *type = TREE_TYPE (ref);
2478 /* Implicit function declaration. */
2479 ref = implicitly_declare (loc, id);
2480 else if (decl == error_mark_node)
2481 /* Don't complain about something that's already been
2482 complained about. */
2483 return error_mark_node;
2486 undeclared_variable (loc, id);
2487 return error_mark_node;
2490 if (TREE_TYPE (ref) == error_mark_node)
2491 return error_mark_node;
2493 if (TREE_DEPRECATED (ref))
2494 warn_deprecated_use (ref, NULL_TREE);
2496 /* Recursive call does not count as usage. */
2497 if (ref != current_function_decl)
2499 TREE_USED (ref) = 1;
2502 if (TREE_CODE (ref) == FUNCTION_DECL && !in_alignof)
2504 if (!in_sizeof && !in_typeof)
2505 C_DECL_USED (ref) = 1;
2506 else if (DECL_INITIAL (ref) == 0
2507 && DECL_EXTERNAL (ref)
2508 && !TREE_PUBLIC (ref))
2509 record_maybe_used_decl (ref);
2512 if (TREE_CODE (ref) == CONST_DECL)
2514 used_types_insert (TREE_TYPE (ref));
2517 && TREE_CODE (TREE_TYPE (ref)) == ENUMERAL_TYPE
2518 && C_TYPE_DEFINED_IN_STRUCT (TREE_TYPE (ref)))
2520 warning_at (loc, OPT_Wc___compat,
2521 ("enum constant defined in struct or union "
2522 "is not visible in C++"));
2523 inform (DECL_SOURCE_LOCATION (ref), "enum constant defined here");
2526 ref = DECL_INITIAL (ref);
2527 TREE_CONSTANT (ref) = 1;
2529 else if (current_function_decl != 0
2530 && !DECL_FILE_SCOPE_P (current_function_decl)
2531 && (TREE_CODE (ref) == VAR_DECL
2532 || TREE_CODE (ref) == PARM_DECL
2533 || TREE_CODE (ref) == FUNCTION_DECL))
2535 tree context = decl_function_context (ref);
2537 if (context != 0 && context != current_function_decl)
2538 DECL_NONLOCAL (ref) = 1;
2540 /* C99 6.7.4p3: An inline definition of a function with external
2541 linkage ... shall not contain a reference to an identifier with
2542 internal linkage. */
2543 else if (current_function_decl != 0
2544 && DECL_DECLARED_INLINE_P (current_function_decl)
2545 && DECL_EXTERNAL (current_function_decl)
2546 && VAR_OR_FUNCTION_DECL_P (ref)
2547 && (TREE_CODE (ref) != VAR_DECL || TREE_STATIC (ref))
2548 && ! TREE_PUBLIC (ref)
2549 && DECL_CONTEXT (ref) != current_function_decl)
2550 record_inline_static (loc, current_function_decl, ref,
2556 /* Record details of decls possibly used inside sizeof or typeof. */
2557 struct maybe_used_decl
2561 /* The level seen at (in_sizeof + in_typeof). */
2563 /* The next one at this level or above, or NULL. */
2564 struct maybe_used_decl *next;
2567 static struct maybe_used_decl *maybe_used_decls;
2569 /* Record that DECL, an undefined static function reference seen
2570 inside sizeof or typeof, might be used if the operand of sizeof is
2571 a VLA type or the operand of typeof is a variably modified
2575 record_maybe_used_decl (tree decl)
2577 struct maybe_used_decl *t = XOBNEW (&parser_obstack, struct maybe_used_decl);
2579 t->level = in_sizeof + in_typeof;
2580 t->next = maybe_used_decls;
2581 maybe_used_decls = t;
2584 /* Pop the stack of decls possibly used inside sizeof or typeof. If
2585 USED is false, just discard them. If it is true, mark them used
2586 (if no longer inside sizeof or typeof) or move them to the next
2587 level up (if still inside sizeof or typeof). */
2590 pop_maybe_used (bool used)
2592 struct maybe_used_decl *p = maybe_used_decls;
2593 int cur_level = in_sizeof + in_typeof;
2594 while (p && p->level > cur_level)
2599 C_DECL_USED (p->decl) = 1;
2601 p->level = cur_level;
2605 if (!used || cur_level == 0)
2606 maybe_used_decls = p;
2609 /* Return the result of sizeof applied to EXPR. */
2612 c_expr_sizeof_expr (location_t loc, struct c_expr expr)
2615 if (expr.value == error_mark_node)
2617 ret.value = error_mark_node;
2618 ret.original_code = ERROR_MARK;
2619 ret.original_type = NULL;
2620 pop_maybe_used (false);
2624 bool expr_const_operands = true;
2625 tree folded_expr = c_fully_fold (expr.value, require_constant_value,
2626 &expr_const_operands);
2627 ret.value = c_sizeof (loc, TREE_TYPE (folded_expr));
2628 ret.original_code = ERROR_MARK;
2629 ret.original_type = NULL;
2630 if (c_vla_type_p (TREE_TYPE (folded_expr)))
2632 /* sizeof is evaluated when given a vla (C99 6.5.3.4p2). */
2633 ret.value = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (ret.value),
2634 folded_expr, ret.value);
2635 C_MAYBE_CONST_EXPR_NON_CONST (ret.value) = !expr_const_operands;
2636 SET_EXPR_LOCATION (ret.value, loc);
2638 pop_maybe_used (C_TYPE_VARIABLE_SIZE (TREE_TYPE (folded_expr)));
2643 /* Return the result of sizeof applied to T, a structure for the type
2644 name passed to sizeof (rather than the type itself). LOC is the
2645 location of the original expression. */
2648 c_expr_sizeof_type (location_t loc, struct c_type_name *t)
2652 tree type_expr = NULL_TREE;
2653 bool type_expr_const = true;
2654 type = groktypename (t, &type_expr, &type_expr_const);
2655 ret.value = c_sizeof (loc, type);
2656 ret.original_code = ERROR_MARK;
2657 ret.original_type = NULL;
2658 if ((type_expr || TREE_CODE (ret.value) == INTEGER_CST)
2659 && c_vla_type_p (type))
2661 /* If the type is a [*] array, it is a VLA but is represented as
2662 having a size of zero. In such a case we must ensure that
2663 the result of sizeof does not get folded to a constant by
2664 c_fully_fold, because if the size is evaluated the result is
2665 not constant and so constraints on zero or negative size
2666 arrays must not be applied when this sizeof call is inside
2667 another array declarator. */
2669 type_expr = integer_zero_node;
2670 ret.value = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (ret.value),
2671 type_expr, ret.value);
2672 C_MAYBE_CONST_EXPR_NON_CONST (ret.value) = !type_expr_const;
2674 pop_maybe_used (type != error_mark_node
2675 ? C_TYPE_VARIABLE_SIZE (type) : false);
2679 /* Build a function call to function FUNCTION with parameters PARAMS.
2680 The function call is at LOC.
2681 PARAMS is a list--a chain of TREE_LIST nodes--in which the
2682 TREE_VALUE of each node is a parameter-expression.
2683 FUNCTION's data type may be a function type or a pointer-to-function. */
2686 build_function_call (location_t loc, tree function, tree params)
2691 vec = VEC_alloc (tree, gc, list_length (params));
2692 for (; params; params = TREE_CHAIN (params))
2693 VEC_quick_push (tree, vec, TREE_VALUE (params));
2694 ret = build_function_call_vec (loc, function, vec, NULL);
2695 VEC_free (tree, gc, vec);
2699 /* Build a function call to function FUNCTION with parameters PARAMS.
2700 ORIGTYPES, if not NULL, is a vector of types; each element is
2701 either NULL or the original type of the corresponding element in
2702 PARAMS. The original type may differ from TREE_TYPE of the
2703 parameter for enums. FUNCTION's data type may be a function type
2704 or pointer-to-function. This function changes the elements of
2708 build_function_call_vec (location_t loc, tree function, VEC(tree,gc) *params,
2709 VEC(tree,gc) *origtypes)
2711 tree fntype, fundecl = 0;
2712 tree name = NULL_TREE, result;
2718 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
2719 STRIP_TYPE_NOPS (function);
2721 /* Convert anything with function type to a pointer-to-function. */
2722 if (TREE_CODE (function) == FUNCTION_DECL)
2724 /* Implement type-directed function overloading for builtins.
2725 resolve_overloaded_builtin and targetm.resolve_overloaded_builtin
2726 handle all the type checking. The result is a complete expression
2727 that implements this function call. */
2728 tem = resolve_overloaded_builtin (loc, function, params);
2732 name = DECL_NAME (function);
2735 if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE)
2736 function = function_to_pointer_conversion (loc, function);
2738 /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
2739 expressions, like those used for ObjC messenger dispatches. */
2740 if (!VEC_empty (tree, params))
2741 function = objc_rewrite_function_call (function,
2742 VEC_index (tree, params, 0));
2744 function = c_fully_fold (function, false, NULL);
2746 fntype = TREE_TYPE (function);
2748 if (TREE_CODE (fntype) == ERROR_MARK)
2749 return error_mark_node;
2751 if (!(TREE_CODE (fntype) == POINTER_TYPE
2752 && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
2754 error_at (loc, "called object %qE is not a function", function);
2755 return error_mark_node;
2758 if (fundecl && TREE_THIS_VOLATILE (fundecl))
2759 current_function_returns_abnormally = 1;
2761 /* fntype now gets the type of function pointed to. */
2762 fntype = TREE_TYPE (fntype);
2764 /* Convert the parameters to the types declared in the
2765 function prototype, or apply default promotions. */
2767 nargs = convert_arguments (TYPE_ARG_TYPES (fntype), params, origtypes,
2770 return error_mark_node;
2772 /* Check that the function is called through a compatible prototype.
2773 If it is not, replace the call by a trap, wrapped up in a compound
2774 expression if necessary. This has the nice side-effect to prevent
2775 the tree-inliner from generating invalid assignment trees which may
2776 blow up in the RTL expander later. */
2777 if (CONVERT_EXPR_P (function)
2778 && TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR
2779 && TREE_CODE (tem = TREE_OPERAND (tem, 0)) == FUNCTION_DECL
2780 && !comptypes (fntype, TREE_TYPE (tem)))
2782 tree return_type = TREE_TYPE (fntype);
2783 tree trap = build_function_call (loc, built_in_decls[BUILT_IN_TRAP],
2787 /* This situation leads to run-time undefined behavior. We can't,
2788 therefore, simply error unless we can prove that all possible
2789 executions of the program must execute the code. */
2790 if (warning_at (loc, 0, "function called through a non-compatible type"))
2791 /* We can, however, treat "undefined" any way we please.
2792 Call abort to encourage the user to fix the program. */
2793 inform (loc, "if this code is reached, the program will abort");
2794 /* Before the abort, allow the function arguments to exit or
2796 for (i = 0; i < nargs; i++)
2797 trap = build2 (COMPOUND_EXPR, void_type_node,
2798 VEC_index (tree, params, i), trap);
2800 if (VOID_TYPE_P (return_type))
2802 if (TYPE_QUALS (return_type) != TYPE_UNQUALIFIED)
2804 "function with qualified void return type called");
2811 if (AGGREGATE_TYPE_P (return_type))
2812 rhs = build_compound_literal (loc, return_type,
2813 build_constructor (return_type, 0),
2816 rhs = build_zero_cst (return_type);
2818 return require_complete_type (build2 (COMPOUND_EXPR, return_type,
2823 argarray = VEC_address (tree, params);
2825 /* Check that arguments to builtin functions match the expectations. */
2827 && DECL_BUILT_IN (fundecl)
2828 && DECL_BUILT_IN_CLASS (fundecl) == BUILT_IN_NORMAL
2829 && !check_builtin_function_arguments (fundecl, nargs, argarray))
2830 return error_mark_node;
2832 /* Check that the arguments to the function are valid. */
2833 check_function_arguments (TYPE_ATTRIBUTES (fntype), nargs, argarray,
2834 TYPE_ARG_TYPES (fntype));
2836 if (name != NULL_TREE
2837 && !strncmp (IDENTIFIER_POINTER (name), "__builtin_", 10))
2839 if (require_constant_value)
2841 fold_build_call_array_initializer_loc (loc, TREE_TYPE (fntype),
2842 function, nargs, argarray);
2844 result = fold_build_call_array_loc (loc, TREE_TYPE (fntype),
2845 function, nargs, argarray);
2846 if (TREE_CODE (result) == NOP_EXPR
2847 && TREE_CODE (TREE_OPERAND (result, 0)) == INTEGER_CST)
2848 STRIP_TYPE_NOPS (result);
2851 result = build_call_array_loc (loc, TREE_TYPE (fntype),
2852 function, nargs, argarray);
2854 if (VOID_TYPE_P (TREE_TYPE (result)))
2856 if (TYPE_QUALS (TREE_TYPE (result)) != TYPE_UNQUALIFIED)
2858 "function with qualified void return type called");
2861 return require_complete_type (result);
2864 /* Convert the argument expressions in the vector VALUES
2865 to the types in the list TYPELIST.
2867 If TYPELIST is exhausted, or when an element has NULL as its type,
2868 perform the default conversions.
2870 ORIGTYPES is the original types of the expressions in VALUES. This
2871 holds the type of enum values which have been converted to integral
2872 types. It may be NULL.
2874 FUNCTION is a tree for the called function. It is used only for
2875 error messages, where it is formatted with %qE.
2877 This is also where warnings about wrong number of args are generated.
2879 Returns the actual number of arguments processed (which may be less
2880 than the length of VALUES in some error situations), or -1 on
2884 convert_arguments (tree typelist, VEC(tree,gc) *values,
2885 VEC(tree,gc) *origtypes, tree function, tree fundecl)
2888 unsigned int parmnum;
2889 bool error_args = false;
2890 const bool type_generic = fundecl
2891 && lookup_attribute ("type generic", TYPE_ATTRIBUTES(TREE_TYPE (fundecl)));
2892 bool type_generic_remove_excess_precision = false;
2895 /* Change pointer to function to the function itself for
2897 if (TREE_CODE (function) == ADDR_EXPR
2898 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
2899 function = TREE_OPERAND (function, 0);
2901 /* Handle an ObjC selector specially for diagnostics. */
2902 selector = objc_message_selector ();
2904 /* For type-generic built-in functions, determine whether excess
2905 precision should be removed (classification) or not
2908 && DECL_BUILT_IN (fundecl)
2909 && DECL_BUILT_IN_CLASS (fundecl) == BUILT_IN_NORMAL)
2911 switch (DECL_FUNCTION_CODE (fundecl))
2913 case BUILT_IN_ISFINITE:
2914 case BUILT_IN_ISINF:
2915 case BUILT_IN_ISINF_SIGN:
2916 case BUILT_IN_ISNAN:
2917 case BUILT_IN_ISNORMAL:
2918 case BUILT_IN_FPCLASSIFY:
2919 type_generic_remove_excess_precision = true;
2923 type_generic_remove_excess_precision = false;
2928 /* Scan the given expressions and types, producing individual
2929 converted arguments. */
2931 for (typetail = typelist, parmnum = 0;
2932 VEC_iterate (tree, values, parmnum, val);
2935 tree type = typetail ? TREE_VALUE (typetail) : 0;
2936 tree valtype = TREE_TYPE (val);
2937 tree rname = function;
2938 int argnum = parmnum + 1;
2939 const char *invalid_func_diag;
2940 bool excess_precision = false;
2944 if (type == void_type_node)
2947 error_at (input_location,
2948 "too many arguments to method %qE", selector);
2950 error_at (input_location,
2951 "too many arguments to function %qE", function);
2953 if (fundecl && !DECL_BUILT_IN (fundecl))
2954 inform (DECL_SOURCE_LOCATION (fundecl), "declared here");
2958 if (selector && argnum > 2)
2964 npc = null_pointer_constant_p (val);
2966 /* If there is excess precision and a prototype, convert once to
2967 the required type rather than converting via the semantic
2968 type. Likewise without a prototype a float value represented
2969 as long double should be converted once to double. But for
2970 type-generic classification functions excess precision must
2972 if (TREE_CODE (val) == EXCESS_PRECISION_EXPR
2973 && (type || !type_generic || !type_generic_remove_excess_precision))
2975 val = TREE_OPERAND (val, 0);
2976 excess_precision = true;
2978 val = c_fully_fold (val, false, NULL);
2979 STRIP_TYPE_NOPS (val);
2981 val = require_complete_type (val);
2985 /* Formal parm type is specified by a function prototype. */
2987 if (type == error_mark_node || !COMPLETE_TYPE_P (type))
2989 error ("type of formal parameter %d is incomplete", parmnum + 1);
2996 /* Optionally warn about conversions that
2997 differ from the default conversions. */
2998 if (warn_traditional_conversion || warn_traditional)
3000 unsigned int formal_prec = TYPE_PRECISION (type);
3002 if (INTEGRAL_TYPE_P (type)
3003 && TREE_CODE (valtype) == REAL_TYPE)
3004 warning (0, "passing argument %d of %qE as integer "
3005 "rather than floating due to prototype",
3007 if (INTEGRAL_TYPE_P (type)
3008 && TREE_CODE (valtype) == COMPLEX_TYPE)
3009 warning (0, "passing argument %d of %qE as integer "
3010 "rather than complex due to prototype",
3012 else if (TREE_CODE (type) == COMPLEX_TYPE
3013 && TREE_CODE (valtype) == REAL_TYPE)
3014 warning (0, "passing argument %d of %qE as complex "
3015 "rather than floating due to prototype",
3017 else if (TREE_CODE (type) == REAL_TYPE
3018 && INTEGRAL_TYPE_P (valtype))
3019 warning (0, "passing argument %d of %qE as floating "
3020 "rather than integer due to prototype",
3022 else if (TREE_CODE (type) == COMPLEX_TYPE
3023 && INTEGRAL_TYPE_P (valtype))
3024 warning (0, "passing argument %d of %qE as complex "
3025 "rather than integer due to prototype",
3027 else if (TREE_CODE (type) == REAL_TYPE
3028 && TREE_CODE (valtype) == COMPLEX_TYPE)
3029 warning (0, "passing argument %d of %qE as floating "
3030 "rather than complex due to prototype",
3032 /* ??? At some point, messages should be written about
3033 conversions between complex types, but that's too messy
3035 else if (TREE_CODE (type) == REAL_TYPE
3036 && TREE_CODE (valtype) == REAL_TYPE)
3038 /* Warn if any argument is passed as `float',
3039 since without a prototype it would be `double'. */
3040 if (formal_prec == TYPE_PRECISION (float_type_node)
3041 && type != dfloat32_type_node)
3042 warning (0, "passing argument %d of %qE as %<float%> "
3043 "rather than %<double%> due to prototype",
3046 /* Warn if mismatch between argument and prototype
3047 for decimal float types. Warn of conversions with
3048 binary float types and of precision narrowing due to
3050 else if (type != valtype
3051 && (type == dfloat32_type_node
3052 || type == dfloat64_type_node
3053 || type == dfloat128_type_node
3054 || valtype == dfloat32_type_node
3055 || valtype == dfloat64_type_node
3056 || valtype == dfloat128_type_node)
3058 <= TYPE_PRECISION (valtype)
3059 || (type == dfloat128_type_node
3061 != dfloat64_type_node
3063 != dfloat32_type_node)))
3064 || (type == dfloat64_type_node
3066 != dfloat32_type_node))))
3067 warning (0, "passing argument %d of %qE as %qT "
3068 "rather than %qT due to prototype",
3069 argnum, rname, type, valtype);
3072 /* Detect integer changing in width or signedness.
3073 These warnings are only activated with
3074 -Wtraditional-conversion, not with -Wtraditional. */
3075 else if (warn_traditional_conversion && INTEGRAL_TYPE_P (type)
3076 && INTEGRAL_TYPE_P (valtype))
3078 tree would_have_been = default_conversion (val);
3079 tree type1 = TREE_TYPE (would_have_been);
3081 if (TREE_CODE (type) == ENUMERAL_TYPE
3082 && (TYPE_MAIN_VARIANT (type)
3083 == TYPE_MAIN_VARIANT (valtype)))
3084 /* No warning if function asks for enum
3085 and the actual arg is that enum type. */
3087 else if (formal_prec != TYPE_PRECISION (type1))
3088 warning (OPT_Wtraditional_conversion,
3089 "passing argument %d of %qE "
3090 "with different width due to prototype",
3092 else if (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (type1))
3094 /* Don't complain if the formal parameter type
3095 is an enum, because we can't tell now whether
3096 the value was an enum--even the same enum. */
3097 else if (TREE_CODE (type) == ENUMERAL_TYPE)
3099 else if (TREE_CODE (val) == INTEGER_CST
3100 && int_fits_type_p (val, type))
3101 /* Change in signedness doesn't matter
3102 if a constant value is unaffected. */
3104 /* If the value is extended from a narrower
3105 unsigned type, it doesn't matter whether we
3106 pass it as signed or unsigned; the value
3107 certainly is the same either way. */
3108 else if (TYPE_PRECISION (valtype) < TYPE_PRECISION (type)
3109 && TYPE_UNSIGNED (valtype))
3111 else if (TYPE_UNSIGNED (type))
3112 warning (OPT_Wtraditional_conversion,
3113 "passing argument %d of %qE "
3114 "as unsigned due to prototype",
3117 warning (OPT_Wtraditional_conversion,
3118 "passing argument %d of %qE "
3119 "as signed due to prototype", argnum, rname);
3123 /* Possibly restore an EXCESS_PRECISION_EXPR for the
3124 sake of better warnings from convert_and_check. */
3125 if (excess_precision)
3126 val = build1 (EXCESS_PRECISION_EXPR, valtype, val);
3127 origtype = (origtypes == NULL
3129 : VEC_index (tree, origtypes, parmnum));
3130 parmval = convert_for_assignment (input_location, type, val,
3131 origtype, ic_argpass, npc,
3135 if (targetm.calls.promote_prototypes (fundecl ? TREE_TYPE (fundecl) : 0)
3136 && INTEGRAL_TYPE_P (type)
3137 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
3138 parmval = default_conversion (parmval);
3141 else if (TREE_CODE (valtype) == REAL_TYPE
3142 && (TYPE_PRECISION (valtype)
3143 < TYPE_PRECISION (double_type_node))
3144 && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (valtype)))
3150 /* Convert `float' to `double'. */
3151 if (warn_double_promotion && !c_inhibit_evaluation_warnings)
3152 warning (OPT_Wdouble_promotion,
3153 "implicit conversion from %qT to %qT when passing "
3154 "argument to function",
3155 valtype, double_type_node);
3156 parmval = convert (double_type_node, val);
3159 else if (excess_precision && !type_generic)
3160 /* A "double" argument with excess precision being passed
3161 without a prototype or in variable arguments. */
3162 parmval = convert (valtype, val);
3163 else if ((invalid_func_diag =
3164 targetm.calls.invalid_arg_for_unprototyped_fn (typelist, fundecl, val)))
3166 error (invalid_func_diag);
3170 /* Convert `short' and `char' to full-size `int'. */
3171 parmval = default_conversion (val);
3173 VEC_replace (tree, values, parmnum, parmval);
3174 if (parmval == error_mark_node)
3178 typetail = TREE_CHAIN (typetail);
3181 gcc_assert (parmnum == VEC_length (tree, values));
3183 if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
3185 error_at (input_location,
3186 "too few arguments to function %qE", function);
3187 if (fundecl && !DECL_BUILT_IN (fundecl))
3188 inform (DECL_SOURCE_LOCATION (fundecl), "declared here");
3192 return error_args ? -1 : (int) parmnum;
3195 /* This is the entry point used by the parser to build unary operators
3196 in the input. CODE, a tree_code, specifies the unary operator, and
3197 ARG is the operand. For unary plus, the C parser currently uses
3198 CONVERT_EXPR for code.
3200 LOC is the location to use for the tree generated.
3204 parser_build_unary_op (location_t loc, enum tree_code code, struct c_expr arg)
3206 struct c_expr result;
3208 result.value = build_unary_op (loc, code, arg.value, 0);
3209 result.original_code = code;
3210 result.original_type = NULL;
3212 if (TREE_OVERFLOW_P (result.value) && !TREE_OVERFLOW_P (arg.value))
3213 overflow_warning (loc, result.value);
3218 /* This is the entry point used by the parser to build binary operators
3219 in the input. CODE, a tree_code, specifies the binary operator, and
3220 ARG1 and ARG2 are the operands. In addition to constructing the
3221 expression, we check for operands that were written with other binary
3222 operators in a way that is likely to confuse the user.
3224 LOCATION is the location of the binary operator. */
3227 parser_build_binary_op (location_t location, enum tree_code code,
3228 struct c_expr arg1, struct c_expr arg2)
3230 struct c_expr result;
3232 enum tree_code code1 = arg1.original_code;
3233 enum tree_code code2 = arg2.original_code;
3234 tree type1 = (arg1.original_type
3235 ? arg1.original_type
3236 : TREE_TYPE (arg1.value));
3237 tree type2 = (arg2.original_type
3238 ? arg2.original_type
3239 : TREE_TYPE (arg2.value));
3241 result.value = build_binary_op (location, code,
3242 arg1.value, arg2.value, 1);
3243 result.original_code = code;
3244 result.original_type = NULL;
3246 if (TREE_CODE (result.value) == ERROR_MARK)
3249 if (location != UNKNOWN_LOCATION)
3250 protected_set_expr_location (result.value, location);
3252 /* Check for cases such as x+y<<z which users are likely
3254 if (warn_parentheses)
3255 warn_about_parentheses (code, code1, arg1.value, code2, arg2.value);
3257 if (warn_logical_op)
3258 warn_logical_operator (input_location, code, TREE_TYPE (result.value),
3259 code1, arg1.value, code2, arg2.value);
3261 /* Warn about comparisons against string literals, with the exception
3262 of testing for equality or inequality of a string literal with NULL. */
3263 if (code == EQ_EXPR || code == NE_EXPR)
3265 if ((code1 == STRING_CST && !integer_zerop (arg2.value))
3266 || (code2 == STRING_CST && !integer_zerop (arg1.value)))
3267 warning_at (location, OPT_Waddress,
3268 "comparison with string literal results in unspecified behavior");
3270 else if (TREE_CODE_CLASS (code) == tcc_comparison
3271 && (code1 == STRING_CST || code2 == STRING_CST))
3272 warning_at (location, OPT_Waddress,
3273 "comparison with string literal results in unspecified behavior");
3275 if (TREE_OVERFLOW_P (result.value)
3276 && !TREE_OVERFLOW_P (arg1.value)
3277 && !TREE_OVERFLOW_P (arg2.value))
3278 overflow_warning (location, result.value);
3280 /* Warn about comparisons of different enum types. */
3281 if (warn_enum_compare
3282 && TREE_CODE_CLASS (code) == tcc_comparison
3283 && TREE_CODE (type1) == ENUMERAL_TYPE
3284 && TREE_CODE (type2) == ENUMERAL_TYPE
3285 && TYPE_MAIN_VARIANT (type1) != TYPE_MAIN_VARIANT (type2))
3286 warning_at (location, OPT_Wenum_compare,
3287 "comparison between %qT and %qT",
3293 /* Return a tree for the difference of pointers OP0 and OP1.
3294 The resulting tree has type int. */
3297 pointer_diff (location_t loc, tree op0, tree op1)
3299 tree restype = ptrdiff_type_node;
3300 tree result, inttype;
3302 addr_space_t as0 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op0)));
3303 addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op1)));
3304 tree target_type = TREE_TYPE (TREE_TYPE (op0));
3305 tree con0, con1, lit0, lit1;
3306 tree orig_op1 = op1;
3308 /* If the operands point into different address spaces, we need to
3309 explicitly convert them to pointers into the common address space
3310 before we can subtract the numerical address values. */
3313 addr_space_t as_common;
3316 /* Determine the common superset address space. This is guaranteed
3317 to exist because the caller verified that comp_target_types
3318 returned non-zero. */
3319 if (!addr_space_superset (as0, as1, &as_common))
3322 common_type = common_pointer_type (TREE_TYPE (op0), TREE_TYPE (op1));
3323 op0 = convert (common_type, op0);
3324 op1 = convert (common_type, op1);
3327 /* Determine integer type to perform computations in. This will usually
3328 be the same as the result type (ptrdiff_t), but may need to be a wider
3329 type if pointers for the address space are wider than ptrdiff_t. */
3330 if (TYPE_PRECISION (restype) < TYPE_PRECISION (TREE_TYPE (op0)))
3331 inttype = lang_hooks.types.type_for_size
3332 (TYPE_PRECISION (TREE_TYPE (op0)), 0);
3337 if (TREE_CODE (target_type) == VOID_TYPE)
3338 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3339 "pointer of type %<void *%> used in subtraction");
3340 if (TREE_CODE (target_type) == FUNCTION_TYPE)
3341 pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3342 "pointer to a function used in subtraction");
3344 /* If the conversion to ptrdiff_type does anything like widening or
3345 converting a partial to an integral mode, we get a convert_expression
3346 that is in the way to do any simplifications.
3347 (fold-const.c doesn't know that the extra bits won't be needed.
3348 split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a
3349 different mode in place.)
3350 So first try to find a common term here 'by hand'; we want to cover
3351 at least the cases that occur in legal static initializers. */
3352 if (CONVERT_EXPR_P (op0)
3353 && (TYPE_PRECISION (TREE_TYPE (op0))
3354 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))))
3355 con0 = TREE_OPERAND (op0, 0);
3358 if (CONVERT_EXPR_P (op1)
3359 && (TYPE_PRECISION (TREE_TYPE (op1))
3360 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0)))))
3361 con1 = TREE_OPERAND (op1, 0);
3365 if (TREE_CODE (con0) == PLUS_EXPR)
3367 lit0 = TREE_OPERAND (con0, 1);
3368 con0 = TREE_OPERAND (con0, 0);
3371 lit0 = integer_zero_node;
3373 if (TREE_CODE (con1) == PLUS_EXPR)
3375 lit1 = TREE_OPERAND (con1, 1);
3376 con1 = TREE_OPERAND (con1, 0);
3379 lit1 = integer_zero_node;
3381 if (operand_equal_p (con0, con1, 0))
3388 /* First do the subtraction as integers;
3389 then drop through to build the divide operator.
3390 Do not do default conversions on the minus operator
3391 in case restype is a short type. */
3393 op0 = build_binary_op (loc,
3394 MINUS_EXPR, convert (inttype, op0),
3395 convert (inttype, op1), 0);
3396 /* This generates an error if op1 is pointer to incomplete type. */
3397 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1))))
3398 error_at (loc, "arithmetic on pointer to an incomplete type");
3400 /* This generates an error if op0 is pointer to incomplete type. */
3401 op1 = c_size_in_bytes (target_type);
3403 /* Divide by the size, in easiest possible way. */
3404 result = fold_build2_loc (loc, EXACT_DIV_EXPR, inttype,
3405 op0, convert (inttype, op1));
3407 /* Convert to final result type if necessary. */
3408 return convert (restype, result);
3411 /* Construct and perhaps optimize a tree representation
3412 for a unary operation. CODE, a tree_code, specifies the operation
3413 and XARG is the operand.
3414 For any CODE other than ADDR_EXPR, FLAG nonzero suppresses
3415 the default promotions (such as from short to int).
3416 For ADDR_EXPR, the default promotions are not applied; FLAG nonzero
3417 allows non-lvalues; this is only used to handle conversion of non-lvalue
3418 arrays to pointers in C99.
3420 LOCATION is the location of the operator. */
3423 build_unary_op (location_t location,
3424 enum tree_code code, tree xarg, int flag)
3426 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
3429 enum tree_code typecode;
3431 tree ret = error_mark_node;
3432 tree eptype = NULL_TREE;
3433 int noconvert = flag;
3434 const char *invalid_op_diag;
3437 int_operands = EXPR_INT_CONST_OPERANDS (xarg);
3439 arg = remove_c_maybe_const_expr (arg);
3441 if (code != ADDR_EXPR)
3442 arg = require_complete_type (arg);
3444 typecode = TREE_CODE (TREE_TYPE (arg));
3445 if (typecode == ERROR_MARK)
3446 return error_mark_node;
3447 if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE)
3448 typecode = INTEGER_TYPE;
3450 if ((invalid_op_diag
3451 = targetm.invalid_unary_op (code, TREE_TYPE (xarg))))
3453 error_at (location, invalid_op_diag);
3454 return error_mark_node;
3457 if (TREE_CODE (arg) == EXCESS_PRECISION_EXPR)
3459 eptype = TREE_TYPE (arg);
3460 arg = TREE_OPERAND (arg, 0);
3466 /* This is used for unary plus, because a CONVERT_EXPR
3467 is enough to prevent anybody from looking inside for
3468 associativity, but won't generate any code. */
3469 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
3470 || typecode == FIXED_POINT_TYPE || typecode == COMPLEX_TYPE
3471 || typecode == VECTOR_TYPE))
3473 error_at (location, "wrong type argument to unary plus");
3474 return error_mark_node;
3476 else if (!noconvert)
3477 arg = default_conversion (arg);
3478 arg = non_lvalue_loc (location, arg);
3482 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
3483 || typecode == FIXED_POINT_TYPE || typecode == COMPLEX_TYPE
3484 || typecode == VECTOR_TYPE))
3486 error_at (location, "wrong type argument to unary minus");
3487 return error_mark_node;
3489 else if (!noconvert)
3490 arg = default_conversion (arg);
3494 /* ~ works on integer types and non float vectors. */
3495 if (typecode == INTEGER_TYPE
3496 || (typecode == VECTOR_TYPE
3497 && !VECTOR_FLOAT_TYPE_P (TREE_TYPE (arg))))
3500 arg = default_conversion (arg);
3502 else if (typecode == COMPLEX_TYPE)
3505 pedwarn (location, OPT_pedantic,
3506 "ISO C does not support %<~%> for complex conjugation");
3508 arg = default_conversion (arg);
3512 error_at (location, "wrong type argument to bit-complement");
3513 return error_mark_node;
3518 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE))
3520 error_at (location, "wrong type argument to abs");
3521 return error_mark_node;
3523 else if (!noconvert)
3524 arg = default_conversion (arg);
3528 /* Conjugating a real value is a no-op, but allow it anyway. */
3529 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
3530 || typecode == COMPLEX_TYPE))
3532 error_at (location, "wrong type argument to conjugation");
3533 return error_mark_node;
3535 else if (!noconvert)
3536 arg = default_conversion (arg);
3539 case TRUTH_NOT_EXPR:
3540 if (typecode != INTEGER_TYPE && typecode != FIXED_POINT_TYPE
3541 && typecode != REAL_TYPE && typecode != POINTER_TYPE
3542 && typecode != COMPLEX_TYPE)
3545 "wrong type argument to unary exclamation mark");
3546 return error_mark_node;
3548 arg = c_objc_common_truthvalue_conversion (location, arg);
3549 ret = invert_truthvalue_loc (location, arg);
3550 /* If the TRUTH_NOT_EXPR has been folded, reset the location. */
3551 if (EXPR_P (ret) && EXPR_HAS_LOCATION (ret))
3552 location = EXPR_LOCATION (ret);
3553 goto return_build_unary_op;
3557 ret = build_real_imag_expr (location, code, arg);
3558 if (ret == error_mark_node)
3559 return error_mark_node;
3560 if (eptype && TREE_CODE (eptype) == COMPLEX_TYPE)
3561 eptype = TREE_TYPE (eptype);
3562 goto return_build_unary_op;
3564 case PREINCREMENT_EXPR:
3565 case POSTINCREMENT_EXPR:
3566 case PREDECREMENT_EXPR:
3567 case POSTDECREMENT_EXPR:
3569 if (TREE_CODE (arg) == C_MAYBE_CONST_EXPR)
3571 tree inner = build_unary_op (location, code,
3572 C_MAYBE_CONST_EXPR_EXPR (arg), flag);
3573 if (inner == error_mark_node)
3574 return error_mark_node;
3575 ret = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (inner),
3576 C_MAYBE_CONST_EXPR_PRE (arg), inner);
3577 gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (arg));
3578 C_MAYBE_CONST_EXPR_NON_CONST (ret) = 1;
3579 goto return_build_unary_op;
3582 /* Complain about anything that is not a true lvalue. In
3583 Objective-C, skip this check for property_refs. */
3584 if (!objc_is_property_ref (arg)
3585 && !lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
3586 || code == POSTINCREMENT_EXPR)
3589 return error_mark_node;
3591 if (warn_cxx_compat && TREE_CODE (TREE_TYPE (arg)) == ENUMERAL_TYPE)
3593 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
3594 warning_at (location, OPT_Wc___compat,
3595 "increment of enumeration value is invalid in C++");
3597 warning_at (location, OPT_Wc___compat,
3598 "decrement of enumeration value is invalid in C++");
3601 /* Ensure the argument is fully folded inside any SAVE_EXPR. */
3602 arg = c_fully_fold (arg, false, NULL);
3604 /* Increment or decrement the real part of the value,
3605 and don't change the imaginary part. */
3606 if (typecode == COMPLEX_TYPE)
3610 pedwarn (location, OPT_pedantic,
3611 "ISO C does not support %<++%> and %<--%> on complex types");
3613 arg = stabilize_reference (arg);
3614 real = build_unary_op (EXPR_LOCATION (arg), REALPART_EXPR, arg, 1);
3615 imag = build_unary_op (EXPR_LOCATION (arg), IMAGPART_EXPR, arg, 1);
3616 real = build_unary_op (EXPR_LOCATION (arg), code, real, 1);
3617 if (real == error_mark_node || imag == error_mark_node)
3618 return error_mark_node;
3619 ret = build2 (COMPLEX_EXPR, TREE_TYPE (arg),
3621 goto return_build_unary_op;
3624 /* Report invalid types. */
3626 if (typecode != POINTER_TYPE && typecode != FIXED_POINT_TYPE
3627 && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
3629 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
3630 error_at (location, "wrong type argument to increment");
3632 error_at (location, "wrong type argument to decrement");
3634 return error_mark_node;
3640 argtype = TREE_TYPE (arg);
3642 /* Compute the increment. */
3644 if (typecode == POINTER_TYPE)
3646 /* If pointer target is an undefined struct,
3647 we just cannot know how to do the arithmetic. */
3648 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (argtype)))
3650 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
3652 "increment of pointer to unknown structure");
3655 "decrement of pointer to unknown structure");
3657 else if (TREE_CODE (TREE_TYPE (argtype)) == FUNCTION_TYPE
3658 || TREE_CODE (TREE_TYPE (argtype)) == VOID_TYPE)
3660 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
3661 pedwarn (location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3662 "wrong type argument to increment");
3664 pedwarn (location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3665 "wrong type argument to decrement");
3668 inc = c_size_in_bytes (TREE_TYPE (argtype));
3669 inc = fold_convert_loc (location, sizetype, inc);
3671 else if (FRACT_MODE_P (TYPE_MODE (argtype)))
3673 /* For signed fract types, we invert ++ to -- or
3674 -- to ++, and change inc from 1 to -1, because
3675 it is not possible to represent 1 in signed fract constants.
3676 For unsigned fract types, the result always overflows and
3677 we get an undefined (original) or the maximum value. */
3678 if (code == PREINCREMENT_EXPR)
3679 code = PREDECREMENT_EXPR;
3680 else if (code == PREDECREMENT_EXPR)
3681 code = PREINCREMENT_EXPR;
3682 else if (code == POSTINCREMENT_EXPR)
3683 code = POSTDECREMENT_EXPR;
3684 else /* code == POSTDECREMENT_EXPR */
3685 code = POSTINCREMENT_EXPR;
3687 inc = integer_minus_one_node;
3688 inc = convert (argtype, inc);
3692 inc = integer_one_node;
3693 inc = convert (argtype, inc);
3696 /* If 'arg' is an Objective-C PROPERTY_REF expression, then we
3697 need to ask Objective-C to build the increment or decrement
3698 expression for it. */
3699 if (objc_is_property_ref (arg))
3700 return objc_build_incr_expr_for_property_ref (location, code,
3703 /* Report a read-only lvalue. */
3704 if (TYPE_READONLY (argtype))
3706 readonly_error (arg,
3707 ((code == PREINCREMENT_EXPR
3708 || code == POSTINCREMENT_EXPR)
3709 ? lv_increment : lv_decrement));
3710 return error_mark_node;
3712 else if (TREE_READONLY (arg))
3713 readonly_warning (arg,
3714 ((code == PREINCREMENT_EXPR
3715 || code == POSTINCREMENT_EXPR)
3716 ? lv_increment : lv_decrement));
3718 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
3719 val = boolean_increment (code, arg);
3721 val = build2 (code, TREE_TYPE (arg), arg, inc);
3722 TREE_SIDE_EFFECTS (val) = 1;
3723 if (TREE_CODE (val) != code)
3724 TREE_NO_WARNING (val) = 1;
3726 goto return_build_unary_op;
3730 /* Note that this operation never does default_conversion. */
3732 /* The operand of unary '&' must be an lvalue (which excludes
3733 expressions of type void), or, in C99, the result of a [] or
3734 unary '*' operator. */
3735 if (VOID_TYPE_P (TREE_TYPE (arg))
3736 && TYPE_QUALS (TREE_TYPE (arg)) == TYPE_UNQUALIFIED
3737 && (TREE_CODE (arg) != INDIRECT_REF
3739 pedwarn (location, 0, "taking address of expression of type %<void%>");
3741 /* Let &* cancel out to simplify resulting code. */
3742 if (TREE_CODE (arg) == INDIRECT_REF)
3744 /* Don't let this be an lvalue. */
3745 if (lvalue_p (TREE_OPERAND (arg, 0)))
3746 return non_lvalue_loc (location, TREE_OPERAND (arg, 0));
3747 ret = TREE_OPERAND (arg, 0);
3748 goto return_build_unary_op;
3751 /* For &x[y], return x+y */
3752 if (TREE_CODE (arg) == ARRAY_REF)
3754 tree op0 = TREE_OPERAND (arg, 0);
3755 if (!c_mark_addressable (op0))
3756 return error_mark_node;
3757 return build_binary_op (location, PLUS_EXPR,
3758 (TREE_CODE (TREE_TYPE (op0)) == ARRAY_TYPE
3759 ? array_to_pointer_conversion (location,
3762 TREE_OPERAND (arg, 1), 1);
3765 /* Anything not already handled and not a true memory reference
3766 or a non-lvalue array is an error. */
3767 else if (typecode != FUNCTION_TYPE && !flag
3768 && !lvalue_or_else (arg, lv_addressof))
3769 return error_mark_node;
3771 /* Move address operations inside C_MAYBE_CONST_EXPR to simplify
3773 if (TREE_CODE (arg) == C_MAYBE_CONST_EXPR)
3775 tree inner = build_unary_op (location, code,
3776 C_MAYBE_CONST_EXPR_EXPR (arg), flag);
3777 ret = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (inner),
3778 C_MAYBE_CONST_EXPR_PRE (arg), inner);
3779 gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (arg));
3780 C_MAYBE_CONST_EXPR_NON_CONST (ret)
3781 = C_MAYBE_CONST_EXPR_NON_CONST (arg);
3782 goto return_build_unary_op;
3785 /* Ordinary case; arg is a COMPONENT_REF or a decl. */
3786 argtype = TREE_TYPE (arg);
3788 /* If the lvalue is const or volatile, merge that into the type
3789 to which the address will point. This should only be needed
3790 for function types. */
3791 if ((DECL_P (arg) || REFERENCE_CLASS_P (arg))
3792 && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg)))
3794 int orig_quals = TYPE_QUALS (strip_array_types (argtype));
3795 int quals = orig_quals;
3797 if (TREE_READONLY (arg))
3798 quals |= TYPE_QUAL_CONST;
3799 if (TREE_THIS_VOLATILE (arg))
3800 quals |= TYPE_QUAL_VOLATILE;
3802 gcc_assert (quals == orig_quals
3803 || TREE_CODE (argtype) == FUNCTION_TYPE);
3805 argtype = c_build_qualified_type (argtype, quals);
3808 if (!c_mark_addressable (arg))
3809 return error_mark_node;
3811 gcc_assert (TREE_CODE (arg) != COMPONENT_REF
3812 || !DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)));
3814 argtype = build_pointer_type (argtype);
3816 /* ??? Cope with user tricks that amount to offsetof. Delete this
3817 when we have proper support for integer constant expressions. */
3818 val = get_base_address (arg);
3819 if (val && TREE_CODE (val) == INDIRECT_REF
3820 && TREE_CONSTANT (TREE_OPERAND (val, 0)))
3822 tree op0 = fold_convert_loc (location, sizetype,
3823 fold_offsetof (arg, val)), op1;
3825 op1 = fold_convert_loc (location, argtype, TREE_OPERAND (val, 0));
3826 ret = fold_build2_loc (location, POINTER_PLUS_EXPR, argtype, op1, op0);
3827 goto return_build_unary_op;
3830 val = build1 (ADDR_EXPR, argtype, arg);
3833 goto return_build_unary_op;
3840 argtype = TREE_TYPE (arg);
3841 if (TREE_CODE (arg) == INTEGER_CST)
3842 ret = (require_constant_value
3843 ? fold_build1_initializer_loc (location, code, argtype, arg)
3844 : fold_build1_loc (location, code, argtype, arg));
3846 ret = build1 (code, argtype, arg);
3847 return_build_unary_op:
3848 gcc_assert (ret != error_mark_node);
3849 if (TREE_CODE (ret) == INTEGER_CST && !TREE_OVERFLOW (ret)
3850 && !(TREE_CODE (xarg) == INTEGER_CST && !TREE_OVERFLOW (xarg)))
3851 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
3852 else if (TREE_CODE (ret) != INTEGER_CST && int_operands)
3853 ret = note_integer_operands (ret);
3855 ret = build1 (EXCESS_PRECISION_EXPR, eptype, ret);
3856 protected_set_expr_location (ret, location);
3860 /* Return nonzero if REF is an lvalue valid for this language.
3861 Lvalues can be assigned, unless their type has TYPE_READONLY.
3862 Lvalues can have their address taken, unless they have C_DECL_REGISTER. */
3865 lvalue_p (const_tree ref)
3867 const enum tree_code code = TREE_CODE (ref);
3874 return lvalue_p (TREE_OPERAND (ref, 0));
3876 case C_MAYBE_CONST_EXPR:
3877 return lvalue_p (TREE_OPERAND (ref, 1));
3879 case COMPOUND_LITERAL_EXPR:
3889 return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
3890 && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
3893 return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
3900 /* Give an error for storing in something that is 'const'. */
3903 readonly_error (tree arg, enum lvalue_use use)
3905 gcc_assert (use == lv_assign || use == lv_increment || use == lv_decrement
3907 /* Using this macro rather than (for example) arrays of messages
3908 ensures that all the format strings are checked at compile
3910 #define READONLY_MSG(A, I, D, AS) (use == lv_assign ? (A) \
3911 : (use == lv_increment ? (I) \
3912 : (use == lv_decrement ? (D) : (AS))))
3913 if (TREE_CODE (arg) == COMPONENT_REF)
3915 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
3916 readonly_error (TREE_OPERAND (arg, 0), use);
3918 error (READONLY_MSG (G_("assignment of read-only member %qD"),
3919 G_("increment of read-only member %qD"),
3920 G_("decrement of read-only member %qD"),
3921 G_("read-only member %qD used as %<asm%> output")),
3922 TREE_OPERAND (arg, 1));
3924 else if (TREE_CODE (arg) == VAR_DECL)
3925 error (READONLY_MSG (G_("assignment of read-only variable %qD"),
3926 G_("increment of read-only variable %qD"),
3927 G_("decrement of read-only variable %qD"),
3928 G_("read-only variable %qD used as %<asm%> output")),
3931 error (READONLY_MSG (G_("assignment of read-only location %qE"),
3932 G_("increment of read-only location %qE"),
3933 G_("decrement of read-only location %qE"),
3934 G_("read-only location %qE used as %<asm%> output")),
3938 /* Give a warning for storing in something that is read-only in GCC
3939 terms but not const in ISO C terms. */
3942 readonly_warning (tree arg, enum lvalue_use use)
3947 warning (0, "assignment of read-only location %qE", arg);
3950 warning (0, "increment of read-only location %qE", arg);
3953 warning (0, "decrement of read-only location %qE", arg);
3962 /* Return nonzero if REF is an lvalue valid for this language;
3963 otherwise, print an error message and return zero. USE says
3964 how the lvalue is being used and so selects the error message. */
3967 lvalue_or_else (const_tree ref, enum lvalue_use use)
3969 int win = lvalue_p (ref);
3977 /* Mark EXP saying that we need to be able to take the
3978 address of it; it should not be allocated in a register.
3979 Returns true if successful. */
3982 c_mark_addressable (tree exp)
3987 switch (TREE_CODE (x))
3990 if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
3993 ("cannot take address of bit-field %qD", TREE_OPERAND (x, 1));
3997 /* ... fall through ... */
4003 x = TREE_OPERAND (x, 0);
4006 case COMPOUND_LITERAL_EXPR:
4008 TREE_ADDRESSABLE (x) = 1;
4015 if (C_DECL_REGISTER (x)
4016 && DECL_NONLOCAL (x))
4018 if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x))
4021 ("global register variable %qD used in nested function", x);
4024 pedwarn (input_location, 0, "register variable %qD used in nested function", x);
4026 else if (C_DECL_REGISTER (x))
4028 if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x))
4029 error ("address of global register variable %qD requested", x);
4031 error ("address of register variable %qD requested", x);
4037 TREE_ADDRESSABLE (x) = 1;
4044 /* Convert EXPR to TYPE, warning about conversion problems with
4045 constants. SEMANTIC_TYPE is the type this conversion would use
4046 without excess precision. If SEMANTIC_TYPE is NULL, this function
4047 is equivalent to convert_and_check. This function is a wrapper that
4048 handles conversions that may be different than
4049 the usual ones because of excess precision. */
4052 ep_convert_and_check (tree type, tree expr, tree semantic_type)
4054 if (TREE_TYPE (expr) == type)
4058 return convert_and_check (type, expr);
4060 if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
4061 && TREE_TYPE (expr) != semantic_type)
4063 /* For integers, we need to check the real conversion, not
4064 the conversion to the excess precision type. */
4065 expr = convert_and_check (semantic_type, expr);
4067 /* Result type is the excess precision type, which should be
4068 large enough, so do not check. */
4069 return convert (type, expr);
4072 /* Build and return a conditional expression IFEXP ? OP1 : OP2. If
4073 IFEXP_BCP then the condition is a call to __builtin_constant_p, and
4074 if folded to an integer constant then the unselected half may
4075 contain arbitrary operations not normally permitted in constant
4076 expressions. Set the location of the expression to LOC. */
4079 build_conditional_expr (location_t colon_loc, tree ifexp, bool ifexp_bcp,
4080 tree op1, tree op1_original_type, tree op2,
4081 tree op2_original_type)
4085 enum tree_code code1;
4086 enum tree_code code2;
4087 tree result_type = NULL;
4088 tree semantic_result_type = NULL;
4089 tree orig_op1 = op1, orig_op2 = op2;
4090 bool int_const, op1_int_operands, op2_int_operands, int_operands;
4091 bool ifexp_int_operands;
4094 op1_int_operands = EXPR_INT_CONST_OPERANDS (orig_op1);
4095 if (op1_int_operands)
4096 op1 = remove_c_maybe_const_expr (op1);
4097 op2_int_operands = EXPR_INT_CONST_OPERANDS (orig_op2);
4098 if (op2_int_operands)
4099 op2 = remove_c_maybe_const_expr (op2);
4100 ifexp_int_operands = EXPR_INT_CONST_OPERANDS (ifexp);
4101 if (ifexp_int_operands)
4102 ifexp = remove_c_maybe_const_expr (ifexp);
4104 /* Promote both alternatives. */
4106 if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
4107 op1 = default_conversion (op1);
4108 if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
4109 op2 = default_conversion (op2);
4111 if (TREE_CODE (ifexp) == ERROR_MARK
4112 || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
4113 || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
4114 return error_mark_node;
4116 type1 = TREE_TYPE (op1);
4117 code1 = TREE_CODE (type1);
4118 type2 = TREE_TYPE (op2);
4119 code2 = TREE_CODE (type2);
4121 /* C90 does not permit non-lvalue arrays in conditional expressions.
4122 In C99 they will be pointers by now. */
4123 if (code1 == ARRAY_TYPE || code2 == ARRAY_TYPE)
4125 error_at (colon_loc, "non-lvalue array in conditional expression");
4126 return error_mark_node;
4129 if ((TREE_CODE (op1) == EXCESS_PRECISION_EXPR
4130 || TREE_CODE (op2) == EXCESS_PRECISION_EXPR)
4131 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
4132 || code1 == COMPLEX_TYPE)
4133 && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
4134 || code2 == COMPLEX_TYPE))
4136 semantic_result_type = c_common_type (type1, type2);
4137 if (TREE_CODE (op1) == EXCESS_PRECISION_EXPR)
4139 op1 = TREE_OPERAND (op1, 0);
4140 type1 = TREE_TYPE (op1);
4141 gcc_assert (TREE_CODE (type1) == code1);
4143 if (TREE_CODE (op2) == EXCESS_PRECISION_EXPR)
4145 op2 = TREE_OPERAND (op2, 0);
4146 type2 = TREE_TYPE (op2);
4147 gcc_assert (TREE_CODE (type2) == code2);
4151 if (warn_cxx_compat)
4153 tree t1 = op1_original_type ? op1_original_type : TREE_TYPE (orig_op1);
4154 tree t2 = op2_original_type ? op2_original_type : TREE_TYPE (orig_op2);
4156 if (TREE_CODE (t1) == ENUMERAL_TYPE
4157 && TREE_CODE (t2) == ENUMERAL_TYPE
4158 && TYPE_MAIN_VARIANT (t1) != TYPE_MAIN_VARIANT (t2))
4159 warning_at (colon_loc, OPT_Wc___compat,
4160 ("different enum types in conditional is "
4161 "invalid in C++: %qT vs %qT"),
4165 /* Quickly detect the usual case where op1 and op2 have the same type
4167 if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
4170 result_type = type1;
4172 result_type = TYPE_MAIN_VARIANT (type1);
4174 else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE
4175 || code1 == COMPLEX_TYPE)
4176 && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
4177 || code2 == COMPLEX_TYPE))
4179 result_type = c_common_type (type1, type2);
4180 do_warn_double_promotion (result_type, type1, type2,
4181 "implicit conversion from %qT to %qT to "
4182 "match other result of conditional",
4185 /* If -Wsign-compare, warn here if type1 and type2 have
4186 different signedness. We'll promote the signed to unsigned
4187 and later code won't know it used to be different.
4188 Do this check on the original types, so that explicit casts
4189 will be considered, but default promotions won't. */
4190 if (c_inhibit_evaluation_warnings == 0)
4192 int unsigned_op1 = TYPE_UNSIGNED (TREE_TYPE (orig_op1));
4193 int unsigned_op2 = TYPE_UNSIGNED (TREE_TYPE (orig_op2));
4195 if (unsigned_op1 ^ unsigned_op2)
4199 /* Do not warn if the result type is signed, since the
4200 signed type will only be chosen if it can represent
4201 all the values of the unsigned type. */
4202 if (!TYPE_UNSIGNED (result_type))
4206 bool op1_maybe_const = true;
4207 bool op2_maybe_const = true;
4209 /* Do not warn if the signed quantity is an
4210 unsuffixed integer literal (or some static
4211 constant expression involving such literals) and
4212 it is non-negative. This warning requires the
4213 operands to be folded for best results, so do
4214 that folding in this case even without
4215 warn_sign_compare to avoid warning options
4216 possibly affecting code generation. */
4217 c_inhibit_evaluation_warnings
4218 += (ifexp == truthvalue_false_node);
4219 op1 = c_fully_fold (op1, require_constant_value,
4221 c_inhibit_evaluation_warnings
4222 -= (ifexp == truthvalue_false_node);
4224 c_inhibit_evaluation_warnings
4225 += (ifexp == truthvalue_true_node);
4226 op2 = c_fully_fold (op2, require_constant_value,
4228 c_inhibit_evaluation_warnings
4229 -= (ifexp == truthvalue_true_node);
4231 if (warn_sign_compare)
4234 && tree_expr_nonnegative_warnv_p (op1, &ovf))
4236 && tree_expr_nonnegative_warnv_p (op2, &ovf)))
4239 warning_at (colon_loc, OPT_Wsign_compare,
4240 ("signed and unsigned type in "
4241 "conditional expression"));
4243 if (!op1_maybe_const || TREE_CODE (op1) != INTEGER_CST)
4244 op1 = c_wrap_maybe_const (op1, !op1_maybe_const);
4245 if (!op2_maybe_const || TREE_CODE (op2) != INTEGER_CST)
4246 op2 = c_wrap_maybe_const (op2, !op2_maybe_const);
4251 else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
4253 if (code1 != VOID_TYPE || code2 != VOID_TYPE)
4254 pedwarn (colon_loc, OPT_pedantic,
4255 "ISO C forbids conditional expr with only one void side");
4256 result_type = void_type_node;
4258 else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
4260 addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (type1));
4261 addr_space_t as2 = TYPE_ADDR_SPACE (TREE_TYPE (type2));
4262 addr_space_t as_common;
4264 if (comp_target_types (colon_loc, type1, type2))
4265 result_type = common_pointer_type (type1, type2);
4266 else if (null_pointer_constant_p (orig_op1))
4267 result_type = type2;
4268 else if (null_pointer_constant_p (orig_op2))
4269 result_type = type1;
4270 else if (!addr_space_superset (as1, as2, &as_common))
4272 error_at (colon_loc, "pointers to disjoint address spaces "
4273 "used in conditional expression");
4274 return error_mark_node;
4276 else if (VOID_TYPE_P (TREE_TYPE (type1)))
4278 if (TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
4279 pedwarn (colon_loc, OPT_pedantic,
4280 "ISO C forbids conditional expr between "
4281 "%<void *%> and function pointer");
4282 result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
4283 TREE_TYPE (type2)));
4285 else if (VOID_TYPE_P (TREE_TYPE (type2)))
4287 if (TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
4288 pedwarn (colon_loc, OPT_pedantic,
4289 "ISO C forbids conditional expr between "
4290 "%<void *%> and function pointer");
4291 result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
4292 TREE_TYPE (type1)));
4294 /* Objective-C pointer comparisons are a bit more lenient. */
4295 else if (objc_have_common_type (type1, type2, -3, NULL_TREE))
4296 result_type = objc_common_type (type1, type2);
4299 int qual = ENCODE_QUAL_ADDR_SPACE (as_common);
4301 pedwarn (colon_loc, 0,
4302 "pointer type mismatch in conditional expression");
4303 result_type = build_pointer_type
4304 (build_qualified_type (void_type_node, qual));
4307 else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
4309 if (!null_pointer_constant_p (orig_op2))
4310 pedwarn (colon_loc, 0,
4311 "pointer/integer type mismatch in conditional expression");
4314 op2 = null_pointer_node;
4316 result_type = type1;
4318 else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
4320 if (!null_pointer_constant_p (orig_op1))
4321 pedwarn (colon_loc, 0,
4322 "pointer/integer type mismatch in conditional expression");
4325 op1 = null_pointer_node;
4327 result_type = type2;
4332 if (flag_cond_mismatch)
4333 result_type = void_type_node;
4336 error_at (colon_loc, "type mismatch in conditional expression");
4337 return error_mark_node;
4341 /* Merge const and volatile flags of the incoming types. */
4343 = build_type_variant (result_type,
4344 TYPE_READONLY (type1) || TYPE_READONLY (type2),
4345 TYPE_VOLATILE (type1) || TYPE_VOLATILE (type2));
4347 op1 = ep_convert_and_check (result_type, op1, semantic_result_type);
4348 op2 = ep_convert_and_check (result_type, op2, semantic_result_type);
4350 if (ifexp_bcp && ifexp == truthvalue_true_node)
4352 op2_int_operands = true;
4353 op1 = c_fully_fold (op1, require_constant_value, NULL);
4355 if (ifexp_bcp && ifexp == truthvalue_false_node)
4357 op1_int_operands = true;
4358 op2 = c_fully_fold (op2, require_constant_value, NULL);
4360 int_const = int_operands = (ifexp_int_operands
4362 && op2_int_operands);
4365 int_const = ((ifexp == truthvalue_true_node
4366 && TREE_CODE (orig_op1) == INTEGER_CST
4367 && !TREE_OVERFLOW (orig_op1))
4368 || (ifexp == truthvalue_false_node
4369 && TREE_CODE (orig_op2) == INTEGER_CST
4370 && !TREE_OVERFLOW (orig_op2)));
4372 if (int_const || (ifexp_bcp && TREE_CODE (ifexp) == INTEGER_CST))
4373 ret = fold_build3_loc (colon_loc, COND_EXPR, result_type, ifexp, op1, op2);
4376 ret = build3 (COND_EXPR, result_type, ifexp, op1, op2);
4378 ret = note_integer_operands (ret);
4380 if (semantic_result_type)
4381 ret = build1 (EXCESS_PRECISION_EXPR, semantic_result_type, ret);
4383 protected_set_expr_location (ret, colon_loc);
4387 /* Return a compound expression that performs two expressions and
4388 returns the value of the second of them.
4390 LOC is the location of the COMPOUND_EXPR. */
4393 build_compound_expr (location_t loc, tree expr1, tree expr2)
4395 bool expr1_int_operands, expr2_int_operands;
4396 tree eptype = NULL_TREE;
4399 expr1_int_operands = EXPR_INT_CONST_OPERANDS (expr1);
4400 if (expr1_int_operands)
4401 expr1 = remove_c_maybe_const_expr (expr1);
4402 expr2_int_operands = EXPR_INT_CONST_OPERANDS (expr2);
4403 if (expr2_int_operands)
4404 expr2 = remove_c_maybe_const_expr (expr2);
4406 if (TREE_CODE (expr1) == EXCESS_PRECISION_EXPR)
4407 expr1 = TREE_OPERAND (expr1, 0);
4408 if (TREE_CODE (expr2) == EXCESS_PRECISION_EXPR)
4410 eptype = TREE_TYPE (expr2);
4411 expr2 = TREE_OPERAND (expr2, 0);
4414 if (!TREE_SIDE_EFFECTS (expr1))
4416 /* The left-hand operand of a comma expression is like an expression
4417 statement: with -Wunused, we should warn if it doesn't have
4418 any side-effects, unless it was explicitly cast to (void). */
4419 if (warn_unused_value)
4421 if (VOID_TYPE_P (TREE_TYPE (expr1))
4422 && CONVERT_EXPR_P (expr1))
4424 else if (VOID_TYPE_P (TREE_TYPE (expr1))
4425 && TREE_CODE (expr1) == COMPOUND_EXPR
4426 && CONVERT_EXPR_P (TREE_OPERAND (expr1, 1)))
4427 ; /* (void) a, (void) b, c */
4429 warning_at (loc, OPT_Wunused_value,
4430 "left-hand operand of comma expression has no effect");
4434 /* With -Wunused, we should also warn if the left-hand operand does have
4435 side-effects, but computes a value which is not used. For example, in
4436 `foo() + bar(), baz()' the result of the `+' operator is not used,
4437 so we should issue a warning. */
4438 else if (warn_unused_value)
4439 warn_if_unused_value (expr1, loc);
4441 if (expr2 == error_mark_node)
4442 return error_mark_node;
4444 ret = build2 (COMPOUND_EXPR, TREE_TYPE (expr2), expr1, expr2);
4447 && expr1_int_operands
4448 && expr2_int_operands)
4449 ret = note_integer_operands (ret);
4452 ret = build1 (EXCESS_PRECISION_EXPR, eptype, ret);
4454 protected_set_expr_location (ret, loc);
4458 /* Issue -Wcast-qual warnings when appropriate. TYPE is the type to
4459 which we are casting. OTYPE is the type of the expression being
4460 cast. Both TYPE and OTYPE are pointer types. LOC is the location
4461 of the cast. -Wcast-qual appeared on the command line. Named
4462 address space qualifiers are not handled here, because they result
4463 in different warnings. */
4466 handle_warn_cast_qual (location_t loc, tree type, tree otype)
4468 tree in_type = type;
4469 tree in_otype = otype;
4474 /* Check that the qualifiers on IN_TYPE are a superset of the
4475 qualifiers of IN_OTYPE. The outermost level of POINTER_TYPE
4476 nodes is uninteresting and we stop as soon as we hit a
4477 non-POINTER_TYPE node on either type. */
4480 in_otype = TREE_TYPE (in_otype);
4481 in_type = TREE_TYPE (in_type);
4483 /* GNU C allows cv-qualified function types. 'const' means the
4484 function is very pure, 'volatile' means it can't return. We
4485 need to warn when such qualifiers are added, not when they're
4487 if (TREE_CODE (in_otype) == FUNCTION_TYPE
4488 && TREE_CODE (in_type) == FUNCTION_TYPE)
4489 added |= (TYPE_QUALS_NO_ADDR_SPACE (in_type)
4490 & ~TYPE_QUALS_NO_ADDR_SPACE (in_otype));
4492 discarded |= (TYPE_QUALS_NO_ADDR_SPACE (in_otype)
4493 & ~TYPE_QUALS_NO_ADDR_SPACE (in_type));
4495 while (TREE_CODE (in_type) == POINTER_TYPE
4496 && TREE_CODE (in_otype) == POINTER_TYPE);
4499 warning_at (loc, OPT_Wcast_qual,
4500 "cast adds %q#v qualifier to function type", added);
4503 /* There are qualifiers present in IN_OTYPE that are not present
4505 warning_at (loc, OPT_Wcast_qual,
4506 "cast discards %q#v qualifier from pointer target type",
4509 if (added || discarded)
4512 /* A cast from **T to const **T is unsafe, because it can cause a
4513 const value to be changed with no additional warning. We only
4514 issue this warning if T is the same on both sides, and we only
4515 issue the warning if there are the same number of pointers on
4516 both sides, as otherwise the cast is clearly unsafe anyhow. A
4517 cast is unsafe when a qualifier is added at one level and const
4518 is not present at all outer levels.
4520 To issue this warning, we check at each level whether the cast
4521 adds new qualifiers not already seen. We don't need to special
4522 case function types, as they won't have the same
4523 TYPE_MAIN_VARIANT. */
4525 if (TYPE_MAIN_VARIANT (in_type) != TYPE_MAIN_VARIANT (in_otype))
4527 if (TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE)
4532 is_const = TYPE_READONLY (TREE_TYPE (in_type));
4535 in_type = TREE_TYPE (in_type);
4536 in_otype = TREE_TYPE (in_otype);
4537 if ((TYPE_QUALS (in_type) &~ TYPE_QUALS (in_otype)) != 0
4540 warning_at (loc, OPT_Wcast_qual,
4541 "to be safe all intermediate pointers in cast from "
4542 "%qT to %qT must be %<const%> qualified",
4547 is_const = TYPE_READONLY (in_type);
4549 while (TREE_CODE (in_type) == POINTER_TYPE);
4552 /* Build an expression representing a cast to type TYPE of expression EXPR.
4553 LOC is the location of the cast-- typically the open paren of the cast. */
4556 build_c_cast (location_t loc, tree type, tree expr)
4560 if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
4561 expr = TREE_OPERAND (expr, 0);
4565 if (type == error_mark_node || expr == error_mark_node)
4566 return error_mark_node;
4568 /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
4569 only in <protocol> qualifications. But when constructing cast expressions,
4570 the protocols do matter and must be kept around. */
4571 if (objc_is_object_ptr (type) && objc_is_object_ptr (TREE_TYPE (expr)))
4572 return build1 (NOP_EXPR, type, expr);
4574 type = TYPE_MAIN_VARIANT (type);
4576 if (TREE_CODE (type) == ARRAY_TYPE)
4578 error_at (loc, "cast specifies array type");
4579 return error_mark_node;
4582 if (TREE_CODE (type) == FUNCTION_TYPE)
4584 error_at (loc, "cast specifies function type");
4585 return error_mark_node;
4588 if (!VOID_TYPE_P (type))
4590 value = require_complete_type (value);
4591 if (value == error_mark_node)
4592 return error_mark_node;
4595 if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
4597 if (TREE_CODE (type) == RECORD_TYPE
4598 || TREE_CODE (type) == UNION_TYPE)
4599 pedwarn (loc, OPT_pedantic,
4600 "ISO C forbids casting nonscalar to the same type");
4602 else if (TREE_CODE (type) == UNION_TYPE)
4606 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
4607 if (TREE_TYPE (field) != error_mark_node
4608 && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
4609 TYPE_MAIN_VARIANT (TREE_TYPE (value))))
4615 bool maybe_const = true;
4617 pedwarn (loc, OPT_pedantic, "ISO C forbids casts to union type");
4618 t = c_fully_fold (value, false, &maybe_const);
4619 t = build_constructor_single (type, field, t);
4621 t = c_wrap_maybe_const (t, true);
4622 t = digest_init (loc, type, t,
4623 NULL_TREE, false, true, 0);
4624 TREE_CONSTANT (t) = TREE_CONSTANT (value);
4627 error_at (loc, "cast to union type from type not present in union");
4628 return error_mark_node;
4634 if (type == void_type_node)
4636 tree t = build1 (CONVERT_EXPR, type, value);
4637 SET_EXPR_LOCATION (t, loc);
4641 otype = TREE_TYPE (value);
4643 /* Optionally warn about potentially worrisome casts. */
4645 && TREE_CODE (type) == POINTER_TYPE
4646 && TREE_CODE (otype) == POINTER_TYPE)
4647 handle_warn_cast_qual (loc, type, otype);
4649 /* Warn about conversions between pointers to disjoint
4651 if (TREE_CODE (type) == POINTER_TYPE
4652 && TREE_CODE (otype) == POINTER_TYPE
4653 && !null_pointer_constant_p (value))
4655 addr_space_t as_to = TYPE_ADDR_SPACE (TREE_TYPE (type));
4656 addr_space_t as_from = TYPE_ADDR_SPACE (TREE_TYPE (otype));
4657 addr_space_t as_common;
4659 if (!addr_space_superset (as_to, as_from, &as_common))
4661 if (ADDR_SPACE_GENERIC_P (as_from))
4662 warning_at (loc, 0, "cast to %s address space pointer "
4663 "from disjoint generic address space pointer",
4664 c_addr_space_name (as_to));
4666 else if (ADDR_SPACE_GENERIC_P (as_to))
4667 warning_at (loc, 0, "cast to generic address space pointer "
4668 "from disjoint %s address space pointer",
4669 c_addr_space_name (as_from));
4672 warning_at (loc, 0, "cast to %s address space pointer "
4673 "from disjoint %s address space pointer",
4674 c_addr_space_name (as_to),
4675 c_addr_space_name (as_from));
4679 /* Warn about possible alignment problems. */
4680 if (STRICT_ALIGNMENT
4681 && TREE_CODE (type) == POINTER_TYPE
4682 && TREE_CODE (otype) == POINTER_TYPE
4683 && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
4684 && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
4685 /* Don't warn about opaque types, where the actual alignment
4686 restriction is unknown. */
4687 && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
4688 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
4689 && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
4690 && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
4691 warning_at (loc, OPT_Wcast_align,
4692 "cast increases required alignment of target type");
4694 if (TREE_CODE (type) == INTEGER_TYPE
4695 && TREE_CODE (otype) == POINTER_TYPE
4696 && TYPE_PRECISION (type) != TYPE_PRECISION (otype))
4697 /* Unlike conversion of integers to pointers, where the
4698 warning is disabled for converting constants because
4699 of cases such as SIG_*, warn about converting constant
4700 pointers to integers. In some cases it may cause unwanted
4701 sign extension, and a warning is appropriate. */
4702 warning_at (loc, OPT_Wpointer_to_int_cast,
4703 "cast from pointer to integer of different size");
4705 if (TREE_CODE (value) == CALL_EXPR
4706 && TREE_CODE (type) != TREE_CODE (otype))
4707 warning_at (loc, OPT_Wbad_function_cast,
4708 "cast from function call of type %qT "
4709 "to non-matching type %qT", otype, type);
4711 if (TREE_CODE (type) == POINTER_TYPE
4712 && TREE_CODE (otype) == INTEGER_TYPE
4713 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
4714 /* Don't warn about converting any constant. */
4715 && !TREE_CONSTANT (value))
4717 OPT_Wint_to_pointer_cast, "cast to pointer from integer "
4718 "of different size");
4720 if (warn_strict_aliasing <= 2)
4721 strict_aliasing_warning (otype, type, expr);
4723 /* If pedantic, warn for conversions between function and object
4724 pointer types, except for converting a null pointer constant
4725 to function pointer type. */
4727 && TREE_CODE (type) == POINTER_TYPE
4728 && TREE_CODE (otype) == POINTER_TYPE
4729 && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE
4730 && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE)
4731 pedwarn (loc, OPT_pedantic, "ISO C forbids "
4732 "conversion of function pointer to object pointer type");
4735 && TREE_CODE (type) == POINTER_TYPE
4736 && TREE_CODE (otype) == POINTER_TYPE
4737 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
4738 && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
4739 && !null_pointer_constant_p (value))
4740 pedwarn (loc, OPT_pedantic, "ISO C forbids "
4741 "conversion of object pointer to function pointer type");
4744 value = convert (type, value);
4746 /* Ignore any integer overflow caused by the cast. */
4747 if (TREE_CODE (value) == INTEGER_CST && !FLOAT_TYPE_P (otype))
4749 if (CONSTANT_CLASS_P (ovalue) && TREE_OVERFLOW (ovalue))
4751 if (!TREE_OVERFLOW (value))
4753 /* Avoid clobbering a shared constant. */
4754 value = copy_node (value);
4755 TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
4758 else if (TREE_OVERFLOW (value))
4759 /* Reset VALUE's overflow flags, ensuring constant sharing. */
4760 value = build_int_cst_wide (TREE_TYPE (value),
4761 TREE_INT_CST_LOW (value),
4762 TREE_INT_CST_HIGH (value));
4766 /* Don't let a cast be an lvalue. */
4768 value = non_lvalue_loc (loc, value);
4770 /* Don't allow the results of casting to floating-point or complex
4771 types be confused with actual constants, or casts involving
4772 integer and pointer types other than direct integer-to-integer
4773 and integer-to-pointer be confused with integer constant
4774 expressions and null pointer constants. */
4775 if (TREE_CODE (value) == REAL_CST
4776 || TREE_CODE (value) == COMPLEX_CST
4777 || (TREE_CODE (value) == INTEGER_CST
4778 && !((TREE_CODE (expr) == INTEGER_CST
4779 && INTEGRAL_TYPE_P (TREE_TYPE (expr)))
4780 || TREE_CODE (expr) == REAL_CST
4781 || TREE_CODE (expr) == COMPLEX_CST)))
4782 value = build1 (NOP_EXPR, type, value);
4784 if (CAN_HAVE_LOCATION_P (value))
4785 SET_EXPR_LOCATION (value, loc);
4789 /* Interpret a cast of expression EXPR to type TYPE. LOC is the
4790 location of the open paren of the cast, or the position of the cast
4793 c_cast_expr (location_t loc, struct c_type_name *type_name, tree expr)
4796 tree type_expr = NULL_TREE;
4797 bool type_expr_const = true;
4799 int saved_wsp = warn_strict_prototypes;
4801 /* This avoids warnings about unprototyped casts on
4802 integers. E.g. "#define SIG_DFL (void(*)())0". */
4803 if (TREE_CODE (expr) == INTEGER_CST)
4804 warn_strict_prototypes = 0;
4805 type = groktypename (type_name, &type_expr, &type_expr_const);
4806 warn_strict_prototypes = saved_wsp;
4808 ret = build_c_cast (loc, type, expr);
4811 ret = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (ret), type_expr, ret);
4812 C_MAYBE_CONST_EXPR_NON_CONST (ret) = !type_expr_const;
4813 SET_EXPR_LOCATION (ret, loc);
4816 if (CAN_HAVE_LOCATION_P (ret) && !EXPR_HAS_LOCATION (ret))
4817 SET_EXPR_LOCATION (ret, loc);
4819 /* C++ does not permits types to be defined in a cast, but it
4820 allows references to incomplete types. */
4821 if (warn_cxx_compat && type_name->specs->typespec_kind == ctsk_tagdef)
4822 warning_at (loc, OPT_Wc___compat,
4823 "defining a type in a cast is invalid in C++");
4828 /* Build an assignment expression of lvalue LHS from value RHS.
4829 If LHS_ORIGTYPE is not NULL, it is the original type of LHS, which
4830 may differ from TREE_TYPE (LHS) for an enum bitfield.
4831 MODIFYCODE is the code for a binary operator that we use
4832 to combine the old value of LHS with RHS to get the new value.
4833 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
4834 If RHS_ORIGTYPE is not NULL_TREE, it is the original type of RHS,
4835 which may differ from TREE_TYPE (RHS) for an enum value.
4837 LOCATION is the location of the MODIFYCODE operator.
4838 RHS_LOC is the location of the RHS. */
4841 build_modify_expr (location_t location, tree lhs, tree lhs_origtype,
4842 enum tree_code modifycode,
4843 location_t rhs_loc, tree rhs, tree rhs_origtype)
4847 tree rhs_semantic_type = NULL_TREE;
4848 tree lhstype = TREE_TYPE (lhs);
4849 tree olhstype = lhstype;
4852 /* Types that aren't fully specified cannot be used in assignments. */
4853 lhs = require_complete_type (lhs);
4855 /* Avoid duplicate error messages from operands that had errors. */
4856 if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
4857 return error_mark_node;
4859 /* For ObjC properties, defer this check. */
4860 if (!objc_is_property_ref (lhs) && !lvalue_or_else (lhs, lv_assign))
4861 return error_mark_node;
4863 if (TREE_CODE (rhs) == EXCESS_PRECISION_EXPR)
4865 rhs_semantic_type = TREE_TYPE (rhs);
4866 rhs = TREE_OPERAND (rhs, 0);
4871 if (TREE_CODE (lhs) == C_MAYBE_CONST_EXPR)
4873 tree inner = build_modify_expr (location, C_MAYBE_CONST_EXPR_EXPR (lhs),
4874 lhs_origtype, modifycode, rhs_loc, rhs,
4876 if (inner == error_mark_node)
4877 return error_mark_node;
4878 result = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (inner),
4879 C_MAYBE_CONST_EXPR_PRE (lhs), inner);
4880 gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (lhs));
4881 C_MAYBE_CONST_EXPR_NON_CONST (result) = 1;
4882 protected_set_expr_location (result, location);
4886 /* If a binary op has been requested, combine the old LHS value with the RHS
4887 producing the value we should actually store into the LHS. */
4889 if (modifycode != NOP_EXPR)
4891 lhs = c_fully_fold (lhs, false, NULL);
4892 lhs = stabilize_reference (lhs);
4893 newrhs = build_binary_op (location,
4894 modifycode, lhs, rhs, 1);
4896 /* The original type of the right hand side is no longer
4898 rhs_origtype = NULL_TREE;
4901 if (c_dialect_objc ())
4903 /* Check if we are modifying an Objective-C property reference;
4904 if so, we need to generate setter calls. */
4905 result = objc_maybe_build_modify_expr (lhs, newrhs);
4909 /* Else, do the check that we postponed for Objective-C. */
4910 if (!lvalue_or_else (lhs, lv_assign))
4911 return error_mark_node;
4914 /* Give an error for storing in something that is 'const'. */
4916 if (TYPE_READONLY (lhstype)
4917 || ((TREE_CODE (lhstype) == RECORD_TYPE
4918 || TREE_CODE (lhstype) == UNION_TYPE)
4919 && C_TYPE_FIELDS_READONLY (lhstype)))
4921 readonly_error (lhs, lv_assign);
4922 return error_mark_node;
4924 else if (TREE_READONLY (lhs))
4925 readonly_warning (lhs, lv_assign);
4927 /* If storing into a structure or union member,
4928 it has probably been given type `int'.
4929 Compute the type that would go with
4930 the actual amount of storage the member occupies. */
4932 if (TREE_CODE (lhs) == COMPONENT_REF
4933 && (TREE_CODE (lhstype) == INTEGER_TYPE
4934 || TREE_CODE (lhstype) == BOOLEAN_TYPE
4935 || TREE_CODE (lhstype) == REAL_TYPE
4936 || TREE_CODE (lhstype) == ENUMERAL_TYPE))
4937 lhstype = TREE_TYPE (get_unwidened (lhs, 0));
4939 /* If storing in a field that is in actuality a short or narrower than one,
4940 we must store in the field in its actual type. */
4942 if (lhstype != TREE_TYPE (lhs))
4944 lhs = copy_node (lhs);
4945 TREE_TYPE (lhs) = lhstype;
4948 /* Issue -Wc++-compat warnings about an assignment to an enum type
4949 when LHS does not have its original type. This happens for,
4950 e.g., an enum bitfield in a struct. */
4952 && lhs_origtype != NULL_TREE
4953 && lhs_origtype != lhstype
4954 && TREE_CODE (lhs_origtype) == ENUMERAL_TYPE)
4956 tree checktype = (rhs_origtype != NULL_TREE
4959 if (checktype != error_mark_node
4960 && TYPE_MAIN_VARIANT (checktype) != TYPE_MAIN_VARIANT (lhs_origtype))
4961 warning_at (location, OPT_Wc___compat,
4962 "enum conversion in assignment is invalid in C++");
4965 /* Convert new value to destination type. Fold it first, then
4966 restore any excess precision information, for the sake of
4967 conversion warnings. */
4969 npc = null_pointer_constant_p (newrhs);
4970 newrhs = c_fully_fold (newrhs, false, NULL);
4971 if (rhs_semantic_type)
4972 newrhs = build1 (EXCESS_PRECISION_EXPR, rhs_semantic_type, newrhs);
4973 newrhs = convert_for_assignment (location, lhstype, newrhs, rhs_origtype,
4974 ic_assign, npc, NULL_TREE, NULL_TREE, 0);
4975 if (TREE_CODE (newrhs) == ERROR_MARK)
4976 return error_mark_node;
4978 /* Emit ObjC write barrier, if necessary. */
4979 if (c_dialect_objc () && flag_objc_gc)
4981 result = objc_generate_write_barrier (lhs, modifycode, newrhs);
4984 protected_set_expr_location (result, location);
4989 /* Scan operands. */
4991 result = build2 (MODIFY_EXPR, lhstype, lhs, newrhs);
4992 TREE_SIDE_EFFECTS (result) = 1;
4993 protected_set_expr_location (result, location);
4995 /* If we got the LHS in a different type for storing in,
4996 convert the result back to the nominal type of LHS
4997 so that the value we return always has the same type
4998 as the LHS argument. */
5000 if (olhstype == TREE_TYPE (result))
5003 result = convert_for_assignment (location, olhstype, result, rhs_origtype,
5004 ic_assign, false, NULL_TREE, NULL_TREE, 0);
5005 protected_set_expr_location (result, location);
5009 /* Return whether STRUCT_TYPE has an anonymous field with type TYPE.
5010 This is used to implement -fplan9-extensions. */
5013 find_anonymous_field_with_type (tree struct_type, tree type)
5018 gcc_assert (TREE_CODE (struct_type) == RECORD_TYPE
5019 || TREE_CODE (struct_type) == UNION_TYPE);
5021 for (field = TYPE_FIELDS (struct_type);
5023 field = TREE_CHAIN (field))
5025 if (DECL_NAME (field) == NULL
5026 && comptypes (type, TYPE_MAIN_VARIANT (TREE_TYPE (field))))
5032 else if (DECL_NAME (field) == NULL
5033 && (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
5034 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
5035 && find_anonymous_field_with_type (TREE_TYPE (field), type))
5045 /* RHS is an expression whose type is pointer to struct. If there is
5046 an anonymous field in RHS with type TYPE, then return a pointer to
5047 that field in RHS. This is used with -fplan9-extensions. This
5048 returns NULL if no conversion could be found. */
5051 convert_to_anonymous_field (location_t location, tree type, tree rhs)
5053 tree rhs_struct_type, lhs_main_type;
5054 tree field, found_field;
5055 bool found_sub_field;
5058 gcc_assert (POINTER_TYPE_P (TREE_TYPE (rhs)));
5059 rhs_struct_type = TREE_TYPE (TREE_TYPE (rhs));
5060 gcc_assert (TREE_CODE (rhs_struct_type) == RECORD_TYPE
5061 || TREE_CODE (rhs_struct_type) == UNION_TYPE);
5063 gcc_assert (POINTER_TYPE_P (type));
5064 lhs_main_type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
5066 found_field = NULL_TREE;
5067 found_sub_field = false;
5068 for (field = TYPE_FIELDS (rhs_struct_type);
5070 field = TREE_CHAIN (field))
5072 if (DECL_NAME (field) != NULL_TREE
5073 || (TREE_CODE (TREE_TYPE (field)) != RECORD_TYPE
5074 && TREE_CODE (TREE_TYPE (field)) != UNION_TYPE))
5076 if (comptypes (lhs_main_type, TYPE_MAIN_VARIANT (TREE_TYPE (field))))
5078 if (found_field != NULL_TREE)
5080 found_field = field;
5082 else if (find_anonymous_field_with_type (TREE_TYPE (field),
5085 if (found_field != NULL_TREE)
5087 found_field = field;
5088 found_sub_field = true;
5092 if (found_field == NULL_TREE)
5095 ret = fold_build3_loc (location, COMPONENT_REF, TREE_TYPE (found_field),
5096 build_fold_indirect_ref (rhs), found_field,
5098 ret = build_fold_addr_expr_loc (location, ret);
5100 if (found_sub_field)
5102 ret = convert_to_anonymous_field (location, type, ret);
5103 gcc_assert (ret != NULL_TREE);
5109 /* Convert value RHS to type TYPE as preparation for an assignment to
5110 an lvalue of type TYPE. If ORIGTYPE is not NULL_TREE, it is the
5111 original type of RHS; this differs from TREE_TYPE (RHS) for enum
5112 types. NULL_POINTER_CONSTANT says whether RHS was a null pointer
5113 constant before any folding.
5114 The real work of conversion is done by `convert'.
5115 The purpose of this function is to generate error messages
5116 for assignments that are not allowed in C.
5117 ERRTYPE says whether it is argument passing, assignment,
5118 initialization or return.
5120 LOCATION is the location of the RHS.
5121 FUNCTION is a tree for the function being called.
5122 PARMNUM is the number of the argument, for printing in error messages. */
5125 convert_for_assignment (location_t location, tree type, tree rhs,
5126 tree origtype, enum impl_conv errtype,
5127 bool null_pointer_constant, tree fundecl,
5128 tree function, int parmnum)
5130 enum tree_code codel = TREE_CODE (type);
5131 tree orig_rhs = rhs;
5133 enum tree_code coder;
5134 tree rname = NULL_TREE;
5135 bool objc_ok = false;
5137 if (errtype == ic_argpass)
5140 /* Change pointer to function to the function itself for
5142 if (TREE_CODE (function) == ADDR_EXPR
5143 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
5144 function = TREE_OPERAND (function, 0);
5146 /* Handle an ObjC selector specially for diagnostics. */
5147 selector = objc_message_selector ();
5149 if (selector && parmnum > 2)
5156 /* This macro is used to emit diagnostics to ensure that all format
5157 strings are complete sentences, visible to gettext and checked at
5159 #define WARN_FOR_ASSIGNMENT(LOCATION, OPT, AR, AS, IN, RE) \
5164 if (pedwarn (LOCATION, OPT, AR, parmnum, rname)) \
5165 inform ((fundecl && !DECL_IS_BUILTIN (fundecl)) \
5166 ? DECL_SOURCE_LOCATION (fundecl) : LOCATION, \
5167 "expected %qT but argument is of type %qT", \
5171 pedwarn (LOCATION, OPT, AS); \
5174 pedwarn_init (LOCATION, OPT, IN); \
5177 pedwarn (LOCATION, OPT, RE); \
5180 gcc_unreachable (); \
5184 /* This macro is used to emit diagnostics to ensure that all format
5185 strings are complete sentences, visible to gettext and checked at
5186 compile time. It is the same as WARN_FOR_ASSIGNMENT but with an
5187 extra parameter to enumerate qualifiers. */
5189 #define WARN_FOR_QUALIFIERS(LOCATION, OPT, AR, AS, IN, RE, QUALS) \
5194 if (pedwarn (LOCATION, OPT, AR, parmnum, rname, QUALS)) \
5195 inform ((fundecl && !DECL_IS_BUILTIN (fundecl)) \
5196 ? DECL_SOURCE_LOCATION (fundecl) : LOCATION, \
5197 "expected %qT but argument is of type %qT", \
5201 pedwarn (LOCATION, OPT, AS, QUALS); \
5204 pedwarn (LOCATION, OPT, IN, QUALS); \
5207 pedwarn (LOCATION, OPT, RE, QUALS); \
5210 gcc_unreachable (); \
5214 if (TREE_CODE (rhs) == EXCESS_PRECISION_EXPR)
5215 rhs = TREE_OPERAND (rhs, 0);
5217 rhstype = TREE_TYPE (rhs);
5218 coder = TREE_CODE (rhstype);
5220 if (coder == ERROR_MARK)
5221 return error_mark_node;
5223 if (c_dialect_objc ())
5246 objc_ok = objc_compare_types (type, rhstype, parmno, rname);
5249 if (warn_cxx_compat)
5251 tree checktype = origtype != NULL_TREE ? origtype : rhstype;
5252 if (checktype != error_mark_node
5253 && TREE_CODE (type) == ENUMERAL_TYPE
5254 && TYPE_MAIN_VARIANT (checktype) != TYPE_MAIN_VARIANT (type))
5256 WARN_FOR_ASSIGNMENT (input_location, OPT_Wc___compat,
5257 G_("enum conversion when passing argument "
5258 "%d of %qE is invalid in C++"),
5259 G_("enum conversion in assignment is "
5261 G_("enum conversion in initialization is "
5263 G_("enum conversion in return is "
5268 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
5271 if (coder == VOID_TYPE)
5273 /* Except for passing an argument to an unprototyped function,
5274 this is a constraint violation. When passing an argument to
5275 an unprototyped function, it is compile-time undefined;
5276 making it a constraint in that case was rejected in
5278 error_at (location, "void value not ignored as it ought to be");
5279 return error_mark_node;
5281 rhs = require_complete_type (rhs);
5282 if (rhs == error_mark_node)
5283 return error_mark_node;
5284 /* A type converts to a reference to it.
5285 This code doesn't fully support references, it's just for the
5286 special case of va_start and va_copy. */
5287 if (codel == REFERENCE_TYPE
5288 && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1)
5290 if (!lvalue_p (rhs))
5292 error_at (location, "cannot pass rvalue to reference parameter");
5293 return error_mark_node;
5295 if (!c_mark_addressable (rhs))
5296 return error_mark_node;
5297 rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
5298 SET_EXPR_LOCATION (rhs, location);
5300 /* We already know that these two types are compatible, but they
5301 may not be exactly identical. In fact, `TREE_TYPE (type)' is
5302 likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
5303 likely to be va_list, a typedef to __builtin_va_list, which
5304 is different enough that it will cause problems later. */
5305 if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
5307 rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
5308 SET_EXPR_LOCATION (rhs, location);
5311 rhs = build1 (NOP_EXPR, type, rhs);
5312 SET_EXPR_LOCATION (rhs, location);
5315 /* Some types can interconvert without explicit casts. */
5316 else if (codel == VECTOR_TYPE && coder == VECTOR_TYPE
5317 && vector_types_convertible_p (type, TREE_TYPE (rhs), true))
5318 return convert (type, rhs);
5319 /* Arithmetic types all interconvert, and enum is treated like int. */
5320 else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
5321 || codel == FIXED_POINT_TYPE
5322 || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
5323 || codel == BOOLEAN_TYPE)
5324 && (coder == INTEGER_TYPE || coder == REAL_TYPE
5325 || coder == FIXED_POINT_TYPE
5326 || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE
5327 || coder == BOOLEAN_TYPE))
5330 bool save = in_late_binary_op;
5331 if (codel == BOOLEAN_TYPE)
5332 in_late_binary_op = true;
5333 ret = convert_and_check (type, orig_rhs);
5334 if (codel == BOOLEAN_TYPE)
5335 in_late_binary_op = save;
5339 /* Aggregates in different TUs might need conversion. */
5340 if ((codel == RECORD_TYPE || codel == UNION_TYPE)
5342 && comptypes (type, rhstype))
5343 return convert_and_check (type, rhs);
5345 /* Conversion to a transparent union or record from its member types.
5346 This applies only to function arguments. */
5347 if (((codel == UNION_TYPE || codel == RECORD_TYPE)
5348 && TYPE_TRANSPARENT_AGGR (type))
5349 && errtype == ic_argpass)
5351 tree memb, marginal_memb = NULL_TREE;
5353 for (memb = TYPE_FIELDS (type); memb ; memb = DECL_CHAIN (memb))
5355 tree memb_type = TREE_TYPE (memb);
5357 if (comptypes (TYPE_MAIN_VARIANT (memb_type),
5358 TYPE_MAIN_VARIANT (rhstype)))
5361 if (TREE_CODE (memb_type) != POINTER_TYPE)
5364 if (coder == POINTER_TYPE)
5366 tree ttl = TREE_TYPE (memb_type);
5367 tree ttr = TREE_TYPE (rhstype);
5369 /* Any non-function converts to a [const][volatile] void *
5370 and vice versa; otherwise, targets must be the same.
5371 Meanwhile, the lhs target must have all the qualifiers of
5373 if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
5374 || comp_target_types (location, memb_type, rhstype))
5376 /* If this type won't generate any warnings, use it. */
5377 if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
5378 || ((TREE_CODE (ttr) == FUNCTION_TYPE
5379 && TREE_CODE (ttl) == FUNCTION_TYPE)
5380 ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
5381 == TYPE_QUALS (ttr))
5382 : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
5383 == TYPE_QUALS (ttl))))
5386 /* Keep looking for a better type, but remember this one. */
5388 marginal_memb = memb;
5392 /* Can convert integer zero to any pointer type. */
5393 if (null_pointer_constant)
5395 rhs = null_pointer_node;
5400 if (memb || marginal_memb)
5404 /* We have only a marginally acceptable member type;
5405 it needs a warning. */
5406 tree ttl = TREE_TYPE (TREE_TYPE (marginal_memb));
5407 tree ttr = TREE_TYPE (rhstype);
5409 /* Const and volatile mean something different for function
5410 types, so the usual warnings are not appropriate. */
5411 if (TREE_CODE (ttr) == FUNCTION_TYPE
5412 && TREE_CODE (ttl) == FUNCTION_TYPE)
5414 /* Because const and volatile on functions are
5415 restrictions that say the function will not do
5416 certain things, it is okay to use a const or volatile
5417 function where an ordinary one is wanted, but not
5419 if (TYPE_QUALS_NO_ADDR_SPACE (ttl)
5420 & ~TYPE_QUALS_NO_ADDR_SPACE (ttr))
5421 WARN_FOR_QUALIFIERS (location, 0,
5422 G_("passing argument %d of %qE "
5423 "makes %q#v qualified function "
5424 "pointer from unqualified"),
5425 G_("assignment makes %q#v qualified "
5426 "function pointer from "
5428 G_("initialization makes %q#v qualified "
5429 "function pointer from "
5431 G_("return makes %q#v qualified function "
5432 "pointer from unqualified"),
5433 TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr));
5435 else if (TYPE_QUALS_NO_ADDR_SPACE (ttr)
5436 & ~TYPE_QUALS_NO_ADDR_SPACE (ttl))
5437 WARN_FOR_QUALIFIERS (location, 0,
5438 G_("passing argument %d of %qE discards "
5439 "%qv qualifier from pointer target type"),
5440 G_("assignment discards %qv qualifier "
5441 "from pointer target type"),
5442 G_("initialization discards %qv qualifier "
5443 "from pointer target type"),
5444 G_("return discards %qv qualifier from "
5445 "pointer target type"),
5446 TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl));
5448 memb = marginal_memb;
5451 if (!fundecl || !DECL_IN_SYSTEM_HEADER (fundecl))
5452 pedwarn (location, OPT_pedantic,
5453 "ISO C prohibits argument conversion to union type");
5455 rhs = fold_convert_loc (location, TREE_TYPE (memb), rhs);
5456 return build_constructor_single (type, memb, rhs);
5460 /* Conversions among pointers */
5461 else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
5462 && (coder == codel))
5464 tree ttl = TREE_TYPE (type);
5465 tree ttr = TREE_TYPE (rhstype);
5468 bool is_opaque_pointer;
5469 int target_cmp = 0; /* Cache comp_target_types () result. */
5473 if (TREE_CODE (mvl) != ARRAY_TYPE)
5474 mvl = TYPE_MAIN_VARIANT (mvl);
5475 if (TREE_CODE (mvr) != ARRAY_TYPE)
5476 mvr = TYPE_MAIN_VARIANT (mvr);
5477 /* Opaque pointers are treated like void pointers. */
5478 is_opaque_pointer = vector_targets_convertible_p (ttl, ttr);
5480 /* The Plan 9 compiler permits a pointer to a struct to be
5481 automatically converted into a pointer to an anonymous field
5482 within the struct. */
5483 if (flag_plan9_extensions
5484 && (TREE_CODE (mvl) == RECORD_TYPE || TREE_CODE(mvl) == UNION_TYPE)
5485 && (TREE_CODE (mvr) == RECORD_TYPE || TREE_CODE(mvr) == UNION_TYPE)
5488 tree new_rhs = convert_to_anonymous_field (location, type, rhs);
5489 if (new_rhs != NULL_TREE)
5492 rhstype = TREE_TYPE (rhs);
5493 coder = TREE_CODE (rhstype);
5494 ttr = TREE_TYPE (rhstype);
5495 mvr = TYPE_MAIN_VARIANT (ttr);
5499 /* C++ does not allow the implicit conversion void* -> T*. However,
5500 for the purpose of reducing the number of false positives, we
5501 tolerate the special case of
5505 where NULL is typically defined in C to be '(void *) 0'. */
5506 if (VOID_TYPE_P (ttr) && rhs != null_pointer_node && !VOID_TYPE_P (ttl))
5507 warning_at (location, OPT_Wc___compat,
5508 "request for implicit conversion "
5509 "from %qT to %qT not permitted in C++", rhstype, type);
5511 /* See if the pointers point to incompatible address spaces. */
5512 asl = TYPE_ADDR_SPACE (ttl);
5513 asr = TYPE_ADDR_SPACE (ttr);
5514 if (!null_pointer_constant_p (rhs)
5515 && asr != asl && !targetm.addr_space.subset_p (asr, asl))
5520 error_at (location, "passing argument %d of %qE from pointer to "
5521 "non-enclosed address space", parmnum, rname);
5524 error_at (location, "assignment from pointer to "
5525 "non-enclosed address space");
5528 error_at (location, "initialization from pointer to "
5529 "non-enclosed address space");
5532 error_at (location, "return from pointer to "
5533 "non-enclosed address space");
5538 return error_mark_node;
5541 /* Check if the right-hand side has a format attribute but the
5542 left-hand side doesn't. */
5543 if (warn_missing_format_attribute
5544 && check_missing_format_attribute (type, rhstype))
5549 warning_at (location, OPT_Wmissing_format_attribute,
5550 "argument %d of %qE might be "
5551 "a candidate for a format attribute",
5555 warning_at (location, OPT_Wmissing_format_attribute,
5556 "assignment left-hand side might be "
5557 "a candidate for a format attribute");
5560 warning_at (location, OPT_Wmissing_format_attribute,
5561 "initialization left-hand side might be "
5562 "a candidate for a format attribute");
5565 warning_at (location, OPT_Wmissing_format_attribute,
5566 "return type might be "
5567 "a candidate for a format attribute");
5574 /* Any non-function converts to a [const][volatile] void *
5575 and vice versa; otherwise, targets must be the same.
5576 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
5577 if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
5578 || (target_cmp = comp_target_types (location, type, rhstype))
5579 || is_opaque_pointer
5580 || (c_common_unsigned_type (mvl)
5581 == c_common_unsigned_type (mvr)))
5584 && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
5587 && !null_pointer_constant
5588 && TREE_CODE (ttl) == FUNCTION_TYPE)))
5589 WARN_FOR_ASSIGNMENT (location, OPT_pedantic,
5590 G_("ISO C forbids passing argument %d of "
5591 "%qE between function pointer "
5593 G_("ISO C forbids assignment between "
5594 "function pointer and %<void *%>"),
5595 G_("ISO C forbids initialization between "
5596 "function pointer and %<void *%>"),
5597 G_("ISO C forbids return between function "
5598 "pointer and %<void *%>"));
5599 /* Const and volatile mean something different for function types,
5600 so the usual warnings are not appropriate. */
5601 else if (TREE_CODE (ttr) != FUNCTION_TYPE
5602 && TREE_CODE (ttl) != FUNCTION_TYPE)
5604 if (TYPE_QUALS_NO_ADDR_SPACE (ttr)
5605 & ~TYPE_QUALS_NO_ADDR_SPACE (ttl))
5607 WARN_FOR_QUALIFIERS (location, 0,
5608 G_("passing argument %d of %qE discards "
5609 "%qv qualifier from pointer target type"),
5610 G_("assignment discards %qv qualifier "
5611 "from pointer target type"),
5612 G_("initialization discards %qv qualifier "
5613 "from pointer target type"),
5614 G_("return discards %qv qualifier from "
5615 "pointer target type"),
5616 TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl));
5618 /* If this is not a case of ignoring a mismatch in signedness,
5620 else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
5623 /* If there is a mismatch, do warn. */
5624 else if (warn_pointer_sign)
5625 WARN_FOR_ASSIGNMENT (location, OPT_Wpointer_sign,
5626 G_("pointer targets in passing argument "
5627 "%d of %qE differ in signedness"),
5628 G_("pointer targets in assignment "
5629 "differ in signedness"),
5630 G_("pointer targets in initialization "
5631 "differ in signedness"),
5632 G_("pointer targets in return differ "
5635 else if (TREE_CODE (ttl) == FUNCTION_TYPE
5636 && TREE_CODE (ttr) == FUNCTION_TYPE)
5638 /* Because const and volatile on functions are restrictions
5639 that say the function will not do certain things,
5640 it is okay to use a const or volatile function
5641 where an ordinary one is wanted, but not vice-versa. */
5642 if (TYPE_QUALS_NO_ADDR_SPACE (ttl)
5643 & ~TYPE_QUALS_NO_ADDR_SPACE (ttr))
5644 WARN_FOR_QUALIFIERS (location, 0,
5645 G_("passing argument %d of %qE makes "
5646 "%q#v qualified function pointer "
5647 "from unqualified"),
5648 G_("assignment makes %q#v qualified function "
5649 "pointer from unqualified"),
5650 G_("initialization makes %q#v qualified "
5651 "function pointer from unqualified"),
5652 G_("return makes %q#v qualified function "
5653 "pointer from unqualified"),
5654 TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr));
5658 /* Avoid warning about the volatile ObjC EH puts on decls. */
5660 WARN_FOR_ASSIGNMENT (location, 0,
5661 G_("passing argument %d of %qE from "
5662 "incompatible pointer type"),
5663 G_("assignment from incompatible pointer type"),
5664 G_("initialization from incompatible "
5666 G_("return from incompatible pointer type"));
5668 return convert (type, rhs);
5670 else if (codel == POINTER_TYPE && coder == ARRAY_TYPE)
5672 /* ??? This should not be an error when inlining calls to
5673 unprototyped functions. */
5674 error_at (location, "invalid use of non-lvalue array");
5675 return error_mark_node;
5677 else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
5679 /* An explicit constant 0 can convert to a pointer,
5680 or one that results from arithmetic, even including
5681 a cast to integer type. */
5682 if (!null_pointer_constant)
5683 WARN_FOR_ASSIGNMENT (location, 0,
5684 G_("passing argument %d of %qE makes "
5685 "pointer from integer without a cast"),
5686 G_("assignment makes pointer from integer "
5688 G_("initialization makes pointer from "
5689 "integer without a cast"),
5690 G_("return makes pointer from integer "
5693 return convert (type, rhs);
5695 else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
5697 WARN_FOR_ASSIGNMENT (location, 0,
5698 G_("passing argument %d of %qE makes integer "
5699 "from pointer without a cast"),
5700 G_("assignment makes integer from pointer "
5702 G_("initialization makes integer from pointer "
5704 G_("return makes integer from pointer "
5706 return convert (type, rhs);
5708 else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
5711 bool save = in_late_binary_op;
5712 in_late_binary_op = true;
5713 ret = convert (type, rhs);
5714 in_late_binary_op = save;
5721 error_at (location, "incompatible type for argument %d of %qE", parmnum, rname);
5722 inform ((fundecl && !DECL_IS_BUILTIN (fundecl))
5723 ? DECL_SOURCE_LOCATION (fundecl) : input_location,
5724 "expected %qT but argument is of type %qT", type, rhstype);
5727 error_at (location, "incompatible types when assigning to type %qT from "
5728 "type %qT", type, rhstype);
5732 "incompatible types when initializing type %qT using type %qT",
5737 "incompatible types when returning type %qT but %qT was "
5738 "expected", rhstype, type);
5744 return error_mark_node;
5747 /* If VALUE is a compound expr all of whose expressions are constant, then
5748 return its value. Otherwise, return error_mark_node.
5750 This is for handling COMPOUND_EXPRs as initializer elements
5751 which is allowed with a warning when -pedantic is specified. */
5754 valid_compound_expr_initializer (tree value, tree endtype)
5756 if (TREE_CODE (value) == COMPOUND_EXPR)
5758 if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
5760 return error_mark_node;
5761 return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
5764 else if (!initializer_constant_valid_p (value, endtype))
5765 return error_mark_node;
5770 /* Perform appropriate conversions on the initial value of a variable,
5771 store it in the declaration DECL,
5772 and print any error messages that are appropriate.
5773 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
5774 If the init is invalid, store an ERROR_MARK.
5776 INIT_LOC is the location of the initial value. */
5779 store_init_value (location_t init_loc, tree decl, tree init, tree origtype)
5784 /* If variable's type was invalidly declared, just ignore it. */
5786 type = TREE_TYPE (decl);
5787 if (TREE_CODE (type) == ERROR_MARK)
5790 /* Digest the specified initializer into an expression. */
5793 npc = null_pointer_constant_p (init);
5794 value = digest_init (init_loc, type, init, origtype, npc,
5795 true, TREE_STATIC (decl));
5797 /* Store the expression if valid; else report error. */
5799 if (!in_system_header
5800 && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && !TREE_STATIC (decl))
5801 warning (OPT_Wtraditional, "traditional C rejects automatic "
5802 "aggregate initialization");
5804 DECL_INITIAL (decl) = value;
5806 /* ANSI wants warnings about out-of-range constant initializers. */
5807 STRIP_TYPE_NOPS (value);
5808 if (TREE_STATIC (decl))
5809 constant_expression_warning (value);
5811 /* Check if we need to set array size from compound literal size. */
5812 if (TREE_CODE (type) == ARRAY_TYPE
5813 && TYPE_DOMAIN (type) == 0
5814 && value != error_mark_node)
5816 tree inside_init = init;
5818 STRIP_TYPE_NOPS (inside_init);
5819 inside_init = fold (inside_init);
5821 if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
5823 tree cldecl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
5825 if (TYPE_DOMAIN (TREE_TYPE (cldecl)))
5827 /* For int foo[] = (int [3]){1}; we need to set array size
5828 now since later on array initializer will be just the
5829 brace enclosed list of the compound literal. */
5830 type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
5831 TREE_TYPE (decl) = type;
5832 TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (cldecl));
5834 layout_decl (cldecl, 0);
5840 /* Methods for storing and printing names for error messages. */
5842 /* Implement a spelling stack that allows components of a name to be pushed
5843 and popped. Each element on the stack is this structure. */
5850 unsigned HOST_WIDE_INT i;
5855 #define SPELLING_STRING 1
5856 #define SPELLING_MEMBER 2
5857 #define SPELLING_BOUNDS 3
5859 static struct spelling *spelling; /* Next stack element (unused). */
5860 static struct spelling *spelling_base; /* Spelling stack base. */
5861 static int spelling_size; /* Size of the spelling stack. */
5863 /* Macros to save and restore the spelling stack around push_... functions.
5864 Alternative to SAVE_SPELLING_STACK. */
5866 #define SPELLING_DEPTH() (spelling - spelling_base)
5867 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
5869 /* Push an element on the spelling stack with type KIND and assign VALUE
5872 #define PUSH_SPELLING(KIND, VALUE, MEMBER) \
5874 int depth = SPELLING_DEPTH (); \
5876 if (depth >= spelling_size) \
5878 spelling_size += 10; \
5879 spelling_base = XRESIZEVEC (struct spelling, spelling_base, \
5881 RESTORE_SPELLING_DEPTH (depth); \
5884 spelling->kind = (KIND); \
5885 spelling->MEMBER = (VALUE); \
5889 /* Push STRING on the stack. Printed literally. */
5892 push_string (const char *string)
5894 PUSH_SPELLING (SPELLING_STRING, string, u.s);
5897 /* Push a member name on the stack. Printed as '.' STRING. */
5900 push_member_name (tree decl)
5902 const char *const string
5904 ? identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl)))
5905 : _("<anonymous>"));
5906 PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
5909 /* Push an array bounds on the stack. Printed as [BOUNDS]. */
5912 push_array_bounds (unsigned HOST_WIDE_INT bounds)
5914 PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
5917 /* Compute the maximum size in bytes of the printed spelling. */
5920 spelling_length (void)
5925 for (p = spelling_base; p < spelling; p++)
5927 if (p->kind == SPELLING_BOUNDS)
5930 size += strlen (p->u.s) + 1;
5936 /* Print the spelling to BUFFER and return it. */
5939 print_spelling (char *buffer)
5944 for (p = spelling_base; p < spelling; p++)
5945 if (p->kind == SPELLING_BOUNDS)
5947 sprintf (d, "[" HOST_WIDE_INT_PRINT_UNSIGNED "]", p->u.i);
5953 if (p->kind == SPELLING_MEMBER)
5955 for (s = p->u.s; (*d = *s++); d++)
5962 /* Issue an error message for a bad initializer component.
5963 GMSGID identifies the message.
5964 The component name is taken from the spelling stack. */
5967 error_init (const char *gmsgid)
5971 /* The gmsgid may be a format string with %< and %>. */
5973 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
5975 error ("(near initialization for %qs)", ofwhat);
5978 /* Issue a pedantic warning for a bad initializer component. OPT is
5979 the option OPT_* (from options.h) controlling this warning or 0 if
5980 it is unconditionally given. GMSGID identifies the message. The
5981 component name is taken from the spelling stack. */
5984 pedwarn_init (location_t location, int opt, const char *gmsgid)
5988 /* The gmsgid may be a format string with %< and %>. */
5989 pedwarn (location, opt, gmsgid);
5990 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
5992 pedwarn (location, opt, "(near initialization for %qs)", ofwhat);
5995 /* Issue a warning for a bad initializer component.
5997 OPT is the OPT_W* value corresponding to the warning option that
5998 controls this warning. GMSGID identifies the message. The
5999 component name is taken from the spelling stack. */
6002 warning_init (int opt, const char *gmsgid)
6006 /* The gmsgid may be a format string with %< and %>. */
6007 warning (opt, gmsgid);
6008 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
6010 warning (opt, "(near initialization for %qs)", ofwhat);
6013 /* If TYPE is an array type and EXPR is a parenthesized string
6014 constant, warn if pedantic that EXPR is being used to initialize an
6015 object of type TYPE. */
6018 maybe_warn_string_init (tree type, struct c_expr expr)
6021 && TREE_CODE (type) == ARRAY_TYPE
6022 && TREE_CODE (expr.value) == STRING_CST
6023 && expr.original_code != STRING_CST)
6024 pedwarn_init (input_location, OPT_pedantic,
6025 "array initialized from parenthesized string constant");
6028 /* Digest the parser output INIT as an initializer for type TYPE.
6029 Return a C expression of type TYPE to represent the initial value.
6031 If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
6033 NULL_POINTER_CONSTANT is true if INIT is a null pointer constant.
6035 If INIT is a string constant, STRICT_STRING is true if it is
6036 unparenthesized or we should not warn here for it being parenthesized.
6037 For other types of INIT, STRICT_STRING is not used.
6039 INIT_LOC is the location of the INIT.
6041 REQUIRE_CONSTANT requests an error if non-constant initializers or
6042 elements are seen. */
6045 digest_init (location_t init_loc, tree type, tree init, tree origtype,
6046 bool null_pointer_constant, bool strict_string,
6047 int require_constant)
6049 enum tree_code code = TREE_CODE (type);
6050 tree inside_init = init;
6051 tree semantic_type = NULL_TREE;
6052 bool maybe_const = true;
6054 if (type == error_mark_node
6056 || init == error_mark_node
6057 || TREE_TYPE (init) == error_mark_node)
6058 return error_mark_node;
6060 STRIP_TYPE_NOPS (inside_init);
6062 if (TREE_CODE (inside_init) == EXCESS_PRECISION_EXPR)
6064 semantic_type = TREE_TYPE (inside_init);
6065 inside_init = TREE_OPERAND (inside_init, 0);
6067 inside_init = c_fully_fold (inside_init, require_constant, &maybe_const);
6068 inside_init = decl_constant_value_for_optimization (inside_init);
6070 /* Initialization of an array of chars from a string constant
6071 optionally enclosed in braces. */
6073 if (code == ARRAY_TYPE && inside_init
6074 && TREE_CODE (inside_init) == STRING_CST)
6076 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
6077 /* Note that an array could be both an array of character type
6078 and an array of wchar_t if wchar_t is signed char or unsigned
6080 bool char_array = (typ1 == char_type_node
6081 || typ1 == signed_char_type_node
6082 || typ1 == unsigned_char_type_node);
6083 bool wchar_array = !!comptypes (typ1, wchar_type_node);
6084 bool char16_array = !!comptypes (typ1, char16_type_node);
6085 bool char32_array = !!comptypes (typ1, char32_type_node);
6087 if (char_array || wchar_array || char16_array || char32_array)
6090 tree typ2 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)));
6091 expr.value = inside_init;
6092 expr.original_code = (strict_string ? STRING_CST : ERROR_MARK);
6093 expr.original_type = NULL;
6094 maybe_warn_string_init (type, expr);
6096 if (TYPE_DOMAIN (type) && !TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
6097 pedwarn_init (init_loc, OPT_pedantic,
6098 "initialization of a flexible array member");
6100 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
6101 TYPE_MAIN_VARIANT (type)))
6106 if (typ2 != char_type_node)
6108 error_init ("char-array initialized from wide string");
6109 return error_mark_node;
6114 if (typ2 == char_type_node)
6116 error_init ("wide character array initialized from non-wide "
6118 return error_mark_node;
6120 else if (!comptypes(typ1, typ2))
6122 error_init ("wide character array initialized from "
6123 "incompatible wide string");
6124 return error_mark_node;
6128 TREE_TYPE (inside_init) = type;
6129 if (TYPE_DOMAIN (type) != 0
6130 && TYPE_SIZE (type) != 0
6131 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
6133 unsigned HOST_WIDE_INT len = TREE_STRING_LENGTH (inside_init);
6135 /* Subtract the size of a single (possibly wide) character
6136 because it's ok to ignore the terminating null char
6137 that is counted in the length of the constant. */
6138 if (0 > compare_tree_int (TYPE_SIZE_UNIT (type),
6140 - (TYPE_PRECISION (typ1)
6142 pedwarn_init (init_loc, 0,
6143 ("initializer-string for array of chars "
6145 else if (warn_cxx_compat
6146 && 0 > compare_tree_int (TYPE_SIZE_UNIT (type), len))
6147 warning_at (init_loc, OPT_Wc___compat,
6148 ("initializer-string for array chars "
6149 "is too long for C++"));
6154 else if (INTEGRAL_TYPE_P (typ1))
6156 error_init ("array of inappropriate type initialized "
6157 "from string constant");
6158 return error_mark_node;
6162 /* Build a VECTOR_CST from a *constant* vector constructor. If the
6163 vector constructor is not constant (e.g. {1,2,3,foo()}) then punt
6164 below and handle as a constructor. */
6165 if (code == VECTOR_TYPE
6166 && TREE_CODE (TREE_TYPE (inside_init)) == VECTOR_TYPE
6167 && vector_types_convertible_p (TREE_TYPE (inside_init), type, true)
6168 && TREE_CONSTANT (inside_init))
6170 if (TREE_CODE (inside_init) == VECTOR_CST
6171 && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
6172 TYPE_MAIN_VARIANT (type)))
6175 if (TREE_CODE (inside_init) == CONSTRUCTOR)
6177 unsigned HOST_WIDE_INT ix;
6179 bool constant_p = true;
6181 /* Iterate through elements and check if all constructor
6182 elements are *_CSTs. */
6183 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (inside_init), ix, value)
6184 if (!CONSTANT_CLASS_P (value))
6191 return build_vector_from_ctor (type,
6192 CONSTRUCTOR_ELTS (inside_init));
6196 if (warn_sequence_point)
6197 verify_sequence_points (inside_init);
6199 /* Any type can be initialized
6200 from an expression of the same type, optionally with braces. */
6202 if (inside_init && TREE_TYPE (inside_init) != 0
6203 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
6204 TYPE_MAIN_VARIANT (type))
6205 || (code == ARRAY_TYPE
6206 && comptypes (TREE_TYPE (inside_init), type))
6207 || (code == VECTOR_TYPE
6208 && comptypes (TREE_TYPE (inside_init), type))
6209 || (code == POINTER_TYPE
6210 && TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
6211 && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
6212 TREE_TYPE (type)))))
6214 if (code == POINTER_TYPE)
6216 if (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE)
6218 if (TREE_CODE (inside_init) == STRING_CST
6219 || TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
6220 inside_init = array_to_pointer_conversion
6221 (init_loc, inside_init);
6224 error_init ("invalid use of non-lvalue array");
6225 return error_mark_node;
6230 if (code == VECTOR_TYPE)
6231 /* Although the types are compatible, we may require a
6233 inside_init = convert (type, inside_init);
6235 if (require_constant
6236 && (code == VECTOR_TYPE || !flag_isoc99)
6237 && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
6239 /* As an extension, allow initializing objects with static storage
6240 duration with compound literals (which are then treated just as
6241 the brace enclosed list they contain). Also allow this for
6242 vectors, as we can only assign them with compound literals. */
6243 tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
6244 inside_init = DECL_INITIAL (decl);
6247 if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
6248 && TREE_CODE (inside_init) != CONSTRUCTOR)
6250 error_init ("array initialized from non-constant array expression");
6251 return error_mark_node;
6254 /* Compound expressions can only occur here if -pedantic or
6255 -pedantic-errors is specified. In the later case, we always want
6256 an error. In the former case, we simply want a warning. */
6257 if (require_constant && pedantic
6258 && TREE_CODE (inside_init) == COMPOUND_EXPR)
6261 = valid_compound_expr_initializer (inside_init,
6262 TREE_TYPE (inside_init));
6263 if (inside_init == error_mark_node)
6264 error_init ("initializer element is not constant");
6266 pedwarn_init (init_loc, OPT_pedantic,
6267 "initializer element is not constant");
6268 if (flag_pedantic_errors)
6269 inside_init = error_mark_node;
6271 else if (require_constant
6272 && !initializer_constant_valid_p (inside_init,
6273 TREE_TYPE (inside_init)))
6275 error_init ("initializer element is not constant");
6276 inside_init = error_mark_node;
6278 else if (require_constant && !maybe_const)
6279 pedwarn_init (init_loc, 0,
6280 "initializer element is not a constant expression");
6282 /* Added to enable additional -Wmissing-format-attribute warnings. */
6283 if (TREE_CODE (TREE_TYPE (inside_init)) == POINTER_TYPE)
6284 inside_init = convert_for_assignment (init_loc, type, inside_init,
6286 ic_init, null_pointer_constant,
6287 NULL_TREE, NULL_TREE, 0);
6291 /* Handle scalar types, including conversions. */
6293 if (code == INTEGER_TYPE || code == REAL_TYPE || code == FIXED_POINT_TYPE
6294 || code == POINTER_TYPE || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE
6295 || code == COMPLEX_TYPE || code == VECTOR_TYPE)
6297 if (TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE
6298 && (TREE_CODE (init) == STRING_CST
6299 || TREE_CODE (init) == COMPOUND_LITERAL_EXPR))
6300 inside_init = init = array_to_pointer_conversion (init_loc, init);
6302 inside_init = build1 (EXCESS_PRECISION_EXPR, semantic_type,
6305 = convert_for_assignment (init_loc, type, inside_init, origtype,
6306 ic_init, null_pointer_constant,
6307 NULL_TREE, NULL_TREE, 0);
6309 /* Check to see if we have already given an error message. */
6310 if (inside_init == error_mark_node)
6312 else if (require_constant && !TREE_CONSTANT (inside_init))
6314 error_init ("initializer element is not constant");
6315 inside_init = error_mark_node;
6317 else if (require_constant
6318 && !initializer_constant_valid_p (inside_init,
6319 TREE_TYPE (inside_init)))
6321 error_init ("initializer element is not computable at load time");
6322 inside_init = error_mark_node;
6324 else if (require_constant && !maybe_const)
6325 pedwarn_init (init_loc, 0,
6326 "initializer element is not a constant expression");
6331 /* Come here only for records and arrays. */
6333 if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
6335 error_init ("variable-sized object may not be initialized");
6336 return error_mark_node;
6339 error_init ("invalid initializer");
6340 return error_mark_node;
6343 /* Handle initializers that use braces. */
6345 /* Type of object we are accumulating a constructor for.
6346 This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */
6347 static tree constructor_type;
6349 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
6351 static tree constructor_fields;
6353 /* For an ARRAY_TYPE, this is the specified index
6354 at which to store the next element we get. */
6355 static tree constructor_index;
6357 /* For an ARRAY_TYPE, this is the maximum index. */
6358 static tree constructor_max_index;
6360 /* For a RECORD_TYPE, this is the first field not yet written out. */
6361 static tree constructor_unfilled_fields;
6363 /* For an ARRAY_TYPE, this is the index of the first element
6364 not yet written out. */
6365 static tree constructor_unfilled_index;
6367 /* In a RECORD_TYPE, the byte index of the next consecutive field.
6368 This is so we can generate gaps between fields, when appropriate. */
6369 static tree constructor_bit_index;
6371 /* If we are saving up the elements rather than allocating them,
6372 this is the list of elements so far (in reverse order,
6373 most recent first). */
6374 static VEC(constructor_elt,gc) *constructor_elements;
6376 /* 1 if constructor should be incrementally stored into a constructor chain,
6377 0 if all the elements should be kept in AVL tree. */
6378 static int constructor_incremental;
6380 /* 1 if so far this constructor's elements are all compile-time constants. */
6381 static int constructor_constant;
6383 /* 1 if so far this constructor's elements are all valid address constants. */
6384 static int constructor_simple;
6386 /* 1 if this constructor has an element that cannot be part of a
6387 constant expression. */
6388 static int constructor_nonconst;
6390 /* 1 if this constructor is erroneous so far. */
6391 static int constructor_erroneous;
6393 /* Structure for managing pending initializer elements, organized as an
6398 struct init_node *left, *right;
6399 struct init_node *parent;
6406 /* Tree of pending elements at this constructor level.
6407 These are elements encountered out of order
6408 which belong at places we haven't reached yet in actually
6410 Will never hold tree nodes across GC runs. */
6411 static struct init_node *constructor_pending_elts;
6413 /* The SPELLING_DEPTH of this constructor. */
6414 static int constructor_depth;
6416 /* DECL node for which an initializer is being read.
6417 0 means we are reading a constructor expression
6418 such as (struct foo) {...}. */
6419 static tree constructor_decl;
6421 /* Nonzero if this is an initializer for a top-level decl. */
6422 static int constructor_top_level;
6424 /* Nonzero if there were any member designators in this initializer. */
6425 static int constructor_designated;
6427 /* Nesting depth of designator list. */
6428 static int designator_depth;
6430 /* Nonzero if there were diagnosed errors in this designator list. */
6431 static int designator_erroneous;
6434 /* This stack has a level for each implicit or explicit level of
6435 structuring in the initializer, including the outermost one. It
6436 saves the values of most of the variables above. */
6438 struct constructor_range_stack;
6440 struct constructor_stack
6442 struct constructor_stack *next;
6447 tree unfilled_index;
6448 tree unfilled_fields;
6450 VEC(constructor_elt,gc) *elements;
6451 struct init_node *pending_elts;
6454 /* If value nonzero, this value should replace the entire
6455 constructor at this level. */
6456 struct c_expr replacement_value;
6457 struct constructor_range_stack *range_stack;
6468 static struct constructor_stack *constructor_stack;
6470 /* This stack represents designators from some range designator up to
6471 the last designator in the list. */
6473 struct constructor_range_stack
6475 struct constructor_range_stack *next, *prev;
6476 struct constructor_stack *stack;
6483 static struct constructor_range_stack *constructor_range_stack;
6485 /* This stack records separate initializers that are nested.
6486 Nested initializers can't happen in ANSI C, but GNU C allows them
6487 in cases like { ... (struct foo) { ... } ... }. */
6489 struct initializer_stack
6491 struct initializer_stack *next;
6493 struct constructor_stack *constructor_stack;
6494 struct constructor_range_stack *constructor_range_stack;
6495 VEC(constructor_elt,gc) *elements;
6496 struct spelling *spelling;
6497 struct spelling *spelling_base;
6500 char require_constant_value;
6501 char require_constant_elements;
6504 static struct initializer_stack *initializer_stack;
6506 /* Prepare to parse and output the initializer for variable DECL. */
6509 start_init (tree decl, tree asmspec_tree ATTRIBUTE_UNUSED, int top_level)
6512 struct initializer_stack *p = XNEW (struct initializer_stack);
6514 p->decl = constructor_decl;
6515 p->require_constant_value = require_constant_value;
6516 p->require_constant_elements = require_constant_elements;
6517 p->constructor_stack = constructor_stack;
6518 p->constructor_range_stack = constructor_range_stack;
6519 p->elements = constructor_elements;
6520 p->spelling = spelling;
6521 p->spelling_base = spelling_base;
6522 p->spelling_size = spelling_size;
6523 p->top_level = constructor_top_level;
6524 p->next = initializer_stack;
6525 initializer_stack = p;
6527 constructor_decl = decl;
6528 constructor_designated = 0;
6529 constructor_top_level = top_level;
6531 if (decl != 0 && decl != error_mark_node)
6533 require_constant_value = TREE_STATIC (decl);
6534 require_constant_elements
6535 = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
6536 /* For a scalar, you can always use any value to initialize,
6537 even within braces. */
6538 && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
6539 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
6540 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
6541 || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
6542 locus = identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl)));
6546 require_constant_value = 0;
6547 require_constant_elements = 0;
6548 locus = _("(anonymous)");
6551 constructor_stack = 0;
6552 constructor_range_stack = 0;
6554 missing_braces_mentioned = 0;
6558 RESTORE_SPELLING_DEPTH (0);
6561 push_string (locus);
6567 struct initializer_stack *p = initializer_stack;
6569 /* Free the whole constructor stack of this initializer. */
6570 while (constructor_stack)
6572 struct constructor_stack *q = constructor_stack;
6573 constructor_stack = q->next;
6577 gcc_assert (!constructor_range_stack);
6579 /* Pop back to the data of the outer initializer (if any). */
6580 free (spelling_base);
6582 constructor_decl = p->decl;
6583 require_constant_value = p->require_constant_value;
6584 require_constant_elements = p->require_constant_elements;
6585 constructor_stack = p->constructor_stack;
6586 constructor_range_stack = p->constructor_range_stack;
6587 constructor_elements = p->elements;
6588 spelling = p->spelling;
6589 spelling_base = p->spelling_base;
6590 spelling_size = p->spelling_size;
6591 constructor_top_level = p->top_level;
6592 initializer_stack = p->next;
6596 /* Call here when we see the initializer is surrounded by braces.
6597 This is instead of a call to push_init_level;
6598 it is matched by a call to pop_init_level.
6600 TYPE is the type to initialize, for a constructor expression.
6601 For an initializer for a decl, TYPE is zero. */
6604 really_start_incremental_init (tree type)
6606 struct constructor_stack *p = XNEW (struct constructor_stack);
6609 type = TREE_TYPE (constructor_decl);
6611 if (TREE_CODE (type) == VECTOR_TYPE
6612 && TYPE_VECTOR_OPAQUE (type))
6613 error ("opaque vector types cannot be initialized");
6615 p->type = constructor_type;
6616 p->fields = constructor_fields;
6617 p->index = constructor_index;
6618 p->max_index = constructor_max_index;
6619 p->unfilled_index = constructor_unfilled_index;
6620 p->unfilled_fields = constructor_unfilled_fields;
6621 p->bit_index = constructor_bit_index;
6622 p->elements = constructor_elements;
6623 p->constant = constructor_constant;
6624 p->simple = constructor_simple;
6625 p->nonconst = constructor_nonconst;
6626 p->erroneous = constructor_erroneous;
6627 p->pending_elts = constructor_pending_elts;
6628 p->depth = constructor_depth;
6629 p->replacement_value.value = 0;
6630 p->replacement_value.original_code = ERROR_MARK;
6631 p->replacement_value.original_type = NULL;
6635 p->incremental = constructor_incremental;
6636 p->designated = constructor_designated;
6638 constructor_stack = p;
6640 constructor_constant = 1;
6641 constructor_simple = 1;
6642 constructor_nonconst = 0;
6643 constructor_depth = SPELLING_DEPTH ();
6644 constructor_elements = 0;
6645 constructor_pending_elts = 0;
6646 constructor_type = type;
6647 constructor_incremental = 1;
6648 constructor_designated = 0;
6649 designator_depth = 0;
6650 designator_erroneous = 0;
6652 if (TREE_CODE (constructor_type) == RECORD_TYPE
6653 || TREE_CODE (constructor_type) == UNION_TYPE)
6655 constructor_fields = TYPE_FIELDS (constructor_type);
6656 /* Skip any nameless bit fields at the beginning. */
6657 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
6658 && DECL_NAME (constructor_fields) == 0)
6659 constructor_fields = DECL_CHAIN (constructor_fields);
6661 constructor_unfilled_fields = constructor_fields;
6662 constructor_bit_index = bitsize_zero_node;
6664 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6666 if (TYPE_DOMAIN (constructor_type))
6668 constructor_max_index
6669 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
6671 /* Detect non-empty initializations of zero-length arrays. */
6672 if (constructor_max_index == NULL_TREE
6673 && TYPE_SIZE (constructor_type))
6674 constructor_max_index = integer_minus_one_node;
6676 /* constructor_max_index needs to be an INTEGER_CST. Attempts
6677 to initialize VLAs will cause a proper error; avoid tree
6678 checking errors as well by setting a safe value. */
6679 if (constructor_max_index
6680 && TREE_CODE (constructor_max_index) != INTEGER_CST)
6681 constructor_max_index = integer_minus_one_node;
6684 = convert (bitsizetype,
6685 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
6689 constructor_index = bitsize_zero_node;
6690 constructor_max_index = NULL_TREE;
6693 constructor_unfilled_index = constructor_index;
6695 else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
6697 /* Vectors are like simple fixed-size arrays. */
6698 constructor_max_index =
6699 build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
6700 constructor_index = bitsize_zero_node;
6701 constructor_unfilled_index = constructor_index;
6705 /* Handle the case of int x = {5}; */
6706 constructor_fields = constructor_type;
6707 constructor_unfilled_fields = constructor_type;
6711 /* Push down into a subobject, for initialization.
6712 If this is for an explicit set of braces, IMPLICIT is 0.
6713 If it is because the next element belongs at a lower level,
6714 IMPLICIT is 1 (or 2 if the push is because of designator list). */
6717 push_init_level (int implicit, struct obstack * braced_init_obstack)
6719 struct constructor_stack *p;
6720 tree value = NULL_TREE;
6722 /* If we've exhausted any levels that didn't have braces,
6723 pop them now. If implicit == 1, this will have been done in
6724 process_init_element; do not repeat it here because in the case
6725 of excess initializers for an empty aggregate this leads to an
6726 infinite cycle of popping a level and immediately recreating
6730 while (constructor_stack->implicit)
6732 if ((TREE_CODE (constructor_type) == RECORD_TYPE
6733 || TREE_CODE (constructor_type) == UNION_TYPE)
6734 && constructor_fields == 0)
6735 process_init_element (pop_init_level (1, braced_init_obstack),
6736 true, braced_init_obstack);
6737 else if (TREE_CODE (constructor_type) == ARRAY_TYPE
6738 && constructor_max_index
6739 && tree_int_cst_lt (constructor_max_index,
6741 process_init_element (pop_init_level (1, braced_init_obstack),
6742 true, braced_init_obstack);
6748 /* Unless this is an explicit brace, we need to preserve previous
6752 if ((TREE_CODE (constructor_type) == RECORD_TYPE
6753 || TREE_CODE (constructor_type) == UNION_TYPE)
6754 && constructor_fields)
6755 value = find_init_member (constructor_fields, braced_init_obstack);
6756 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6757 value = find_init_member (constructor_index, braced_init_obstack);
6760 p = XNEW (struct constructor_stack);
6761 p->type = constructor_type;
6762 p->fields = constructor_fields;
6763 p->index = constructor_index;
6764 p->max_index = constructor_max_index;
6765 p->unfilled_index = constructor_unfilled_index;
6766 p->unfilled_fields = constructor_unfilled_fields;
6767 p->bit_index = constructor_bit_index;
6768 p->elements = constructor_elements;
6769 p->constant = constructor_constant;
6770 p->simple = constructor_simple;
6771 p->nonconst = constructor_nonconst;
6772 p->erroneous = constructor_erroneous;
6773 p->pending_elts = constructor_pending_elts;
6774 p->depth = constructor_depth;
6775 p->replacement_value.value = 0;
6776 p->replacement_value.original_code = ERROR_MARK;
6777 p->replacement_value.original_type = NULL;
6778 p->implicit = implicit;
6780 p->incremental = constructor_incremental;
6781 p->designated = constructor_designated;
6782 p->next = constructor_stack;
6784 constructor_stack = p;
6786 constructor_constant = 1;
6787 constructor_simple = 1;
6788 constructor_nonconst = 0;
6789 constructor_depth = SPELLING_DEPTH ();
6790 constructor_elements = 0;
6791 constructor_incremental = 1;
6792 constructor_designated = 0;
6793 constructor_pending_elts = 0;
6796 p->range_stack = constructor_range_stack;
6797 constructor_range_stack = 0;
6798 designator_depth = 0;
6799 designator_erroneous = 0;
6802 /* Don't die if an entire brace-pair level is superfluous
6803 in the containing level. */
6804 if (constructor_type == 0)
6806 else if (TREE_CODE (constructor_type) == RECORD_TYPE
6807 || TREE_CODE (constructor_type) == UNION_TYPE)
6809 /* Don't die if there are extra init elts at the end. */
6810 if (constructor_fields == 0)
6811 constructor_type = 0;
6814 constructor_type = TREE_TYPE (constructor_fields);
6815 push_member_name (constructor_fields);
6816 constructor_depth++;
6819 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6821 constructor_type = TREE_TYPE (constructor_type);
6822 push_array_bounds (tree_low_cst (constructor_index, 1));
6823 constructor_depth++;
6826 if (constructor_type == 0)
6828 error_init ("extra brace group at end of initializer");
6829 constructor_fields = 0;
6830 constructor_unfilled_fields = 0;
6834 if (value && TREE_CODE (value) == CONSTRUCTOR)
6836 constructor_constant = TREE_CONSTANT (value);
6837 constructor_simple = TREE_STATIC (value);
6838 constructor_nonconst = CONSTRUCTOR_NON_CONST (value);
6839 constructor_elements = CONSTRUCTOR_ELTS (value);
6840 if (!VEC_empty (constructor_elt, constructor_elements)
6841 && (TREE_CODE (constructor_type) == RECORD_TYPE
6842 || TREE_CODE (constructor_type) == ARRAY_TYPE))
6843 set_nonincremental_init (braced_init_obstack);
6846 if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
6848 missing_braces_mentioned = 1;
6849 warning_init (OPT_Wmissing_braces, "missing braces around initializer");
6852 if (TREE_CODE (constructor_type) == RECORD_TYPE
6853 || TREE_CODE (constructor_type) == UNION_TYPE)
6855 constructor_fields = TYPE_FIELDS (constructor_type);
6856 /* Skip any nameless bit fields at the beginning. */
6857 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
6858 && DECL_NAME (constructor_fields) == 0)
6859 constructor_fields = DECL_CHAIN (constructor_fields);
6861 constructor_unfilled_fields = constructor_fields;
6862 constructor_bit_index = bitsize_zero_node;
6864 else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
6866 /* Vectors are like simple fixed-size arrays. */
6867 constructor_max_index =
6868 build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
6869 constructor_index = convert (bitsizetype, integer_zero_node);
6870 constructor_unfilled_index = constructor_index;
6872 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6874 if (TYPE_DOMAIN (constructor_type))
6876 constructor_max_index
6877 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
6879 /* Detect non-empty initializations of zero-length arrays. */
6880 if (constructor_max_index == NULL_TREE
6881 && TYPE_SIZE (constructor_type))
6882 constructor_max_index = integer_minus_one_node;
6884 /* constructor_max_index needs to be an INTEGER_CST. Attempts
6885 to initialize VLAs will cause a proper error; avoid tree
6886 checking errors as well by setting a safe value. */
6887 if (constructor_max_index
6888 && TREE_CODE (constructor_max_index) != INTEGER_CST)
6889 constructor_max_index = integer_minus_one_node;
6892 = convert (bitsizetype,
6893 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
6896 constructor_index = bitsize_zero_node;
6898 constructor_unfilled_index = constructor_index;
6899 if (value && TREE_CODE (value) == STRING_CST)
6901 /* We need to split the char/wchar array into individual
6902 characters, so that we don't have to special case it
6904 set_nonincremental_init_from_string (value, braced_init_obstack);
6909 if (constructor_type != error_mark_node)
6910 warning_init (0, "braces around scalar initializer");
6911 constructor_fields = constructor_type;
6912 constructor_unfilled_fields = constructor_type;
6916 /* At the end of an implicit or explicit brace level,
6917 finish up that level of constructor. If a single expression
6918 with redundant braces initialized that level, return the
6919 c_expr structure for that expression. Otherwise, the original_code
6920 element is set to ERROR_MARK.
6921 If we were outputting the elements as they are read, return 0 as the value
6922 from inner levels (process_init_element ignores that),
6923 but return error_mark_node as the value from the outermost level
6924 (that's what we want to put in DECL_INITIAL).
6925 Otherwise, return a CONSTRUCTOR expression as the value. */
6928 pop_init_level (int implicit, struct obstack * braced_init_obstack)
6930 struct constructor_stack *p;
6933 ret.original_code = ERROR_MARK;
6934 ret.original_type = NULL;
6938 /* When we come to an explicit close brace,
6939 pop any inner levels that didn't have explicit braces. */
6940 while (constructor_stack->implicit)
6942 process_init_element (pop_init_level (1, braced_init_obstack),
6943 true, braced_init_obstack);
6945 gcc_assert (!constructor_range_stack);
6948 /* Now output all pending elements. */
6949 constructor_incremental = 1;
6950 output_pending_init_elements (1, braced_init_obstack);
6952 p = constructor_stack;
6954 /* Error for initializing a flexible array member, or a zero-length
6955 array member in an inappropriate context. */
6956 if (constructor_type && constructor_fields
6957 && TREE_CODE (constructor_type) == ARRAY_TYPE
6958 && TYPE_DOMAIN (constructor_type)
6959 && !TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
6961 /* Silently discard empty initializations. The parser will
6962 already have pedwarned for empty brackets. */
6963 if (integer_zerop (constructor_unfilled_index))
6964 constructor_type = NULL_TREE;
6967 gcc_assert (!TYPE_SIZE (constructor_type));
6969 if (constructor_depth > 2)
6970 error_init ("initialization of flexible array member in a nested context");
6972 pedwarn_init (input_location, OPT_pedantic,
6973 "initialization of a flexible array member");
6975 /* We have already issued an error message for the existence
6976 of a flexible array member not at the end of the structure.
6977 Discard the initializer so that we do not die later. */
6978 if (DECL_CHAIN (constructor_fields) != NULL_TREE)
6979 constructor_type = NULL_TREE;
6983 /* Warn when some struct elements are implicitly initialized to zero. */
6984 if (warn_missing_field_initializers
6986 && TREE_CODE (constructor_type) == RECORD_TYPE
6987 && constructor_unfilled_fields)
6989 /* Do not warn for flexible array members or zero-length arrays. */
6990 while (constructor_unfilled_fields
6991 && (!DECL_SIZE (constructor_unfilled_fields)
6992 || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
6993 constructor_unfilled_fields = DECL_CHAIN (constructor_unfilled_fields);
6995 /* Do not warn if this level of the initializer uses member
6996 designators; it is likely to be deliberate. */
6997 if (constructor_unfilled_fields && !constructor_designated)
6999 push_member_name (constructor_unfilled_fields);
7000 warning_init (OPT_Wmissing_field_initializers,
7001 "missing initializer");
7002 RESTORE_SPELLING_DEPTH (constructor_depth);
7006 /* Pad out the end of the structure. */
7007 if (p->replacement_value.value)
7008 /* If this closes a superfluous brace pair,
7009 just pass out the element between them. */
7010 ret = p->replacement_value;
7011 else if (constructor_type == 0)
7013 else if (TREE_CODE (constructor_type) != RECORD_TYPE
7014 && TREE_CODE (constructor_type) != UNION_TYPE
7015 && TREE_CODE (constructor_type) != ARRAY_TYPE
7016 && TREE_CODE (constructor_type) != VECTOR_TYPE)
7018 /* A nonincremental scalar initializer--just return
7019 the element, after verifying there is just one. */
7020 if (VEC_empty (constructor_elt,constructor_elements))
7022 if (!constructor_erroneous)
7023 error_init ("empty scalar initializer");
7024 ret.value = error_mark_node;
7026 else if (VEC_length (constructor_elt,constructor_elements) != 1)
7028 error_init ("extra elements in scalar initializer");
7029 ret.value = VEC_index (constructor_elt,constructor_elements,0)->value;
7032 ret.value = VEC_index (constructor_elt,constructor_elements,0)->value;
7036 if (constructor_erroneous)
7037 ret.value = error_mark_node;
7040 ret.value = build_constructor (constructor_type,
7041 constructor_elements);
7042 if (constructor_constant)
7043 TREE_CONSTANT (ret.value) = 1;
7044 if (constructor_constant && constructor_simple)
7045 TREE_STATIC (ret.value) = 1;
7046 if (constructor_nonconst)
7047 CONSTRUCTOR_NON_CONST (ret.value) = 1;
7051 if (ret.value && TREE_CODE (ret.value) != CONSTRUCTOR)
7053 if (constructor_nonconst)
7054 ret.original_code = C_MAYBE_CONST_EXPR;
7055 else if (ret.original_code == C_MAYBE_CONST_EXPR)
7056 ret.original_code = ERROR_MARK;
7059 constructor_type = p->type;
7060 constructor_fields = p->fields;
7061 constructor_index = p->index;
7062 constructor_max_index = p->max_index;
7063 constructor_unfilled_index = p->unfilled_index;
7064 constructor_unfilled_fields = p->unfilled_fields;
7065 constructor_bit_index = p->bit_index;
7066 constructor_elements = p->elements;
7067 constructor_constant = p->constant;
7068 constructor_simple = p->simple;
7069 constructor_nonconst = p->nonconst;
7070 constructor_erroneous = p->erroneous;
7071 constructor_incremental = p->incremental;
7072 constructor_designated = p->designated;
7073 constructor_pending_elts = p->pending_elts;
7074 constructor_depth = p->depth;
7076 constructor_range_stack = p->range_stack;
7077 RESTORE_SPELLING_DEPTH (constructor_depth);
7079 constructor_stack = p->next;
7082 if (ret.value == 0 && constructor_stack == 0)
7083 ret.value = error_mark_node;
7087 /* Common handling for both array range and field name designators.
7088 ARRAY argument is nonzero for array ranges. Returns zero for success. */
7091 set_designator (int array, struct obstack * braced_init_obstack)
7094 enum tree_code subcode;
7096 /* Don't die if an entire brace-pair level is superfluous
7097 in the containing level. */
7098 if (constructor_type == 0)
7101 /* If there were errors in this designator list already, bail out
7103 if (designator_erroneous)
7106 if (!designator_depth)
7108 gcc_assert (!constructor_range_stack);
7110 /* Designator list starts at the level of closest explicit
7112 while (constructor_stack->implicit)
7114 process_init_element (pop_init_level (1, braced_init_obstack),
7115 true, braced_init_obstack);
7117 constructor_designated = 1;
7121 switch (TREE_CODE (constructor_type))
7125 subtype = TREE_TYPE (constructor_fields);
7126 if (subtype != error_mark_node)
7127 subtype = TYPE_MAIN_VARIANT (subtype);
7130 subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
7136 subcode = TREE_CODE (subtype);
7137 if (array && subcode != ARRAY_TYPE)
7139 error_init ("array index in non-array initializer");
7142 else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
7144 error_init ("field name not in record or union initializer");
7148 constructor_designated = 1;
7149 push_init_level (2, braced_init_obstack);
7153 /* If there are range designators in designator list, push a new designator
7154 to constructor_range_stack. RANGE_END is end of such stack range or
7155 NULL_TREE if there is no range designator at this level. */
7158 push_range_stack (tree range_end, struct obstack * braced_init_obstack)
7160 struct constructor_range_stack *p;
7162 p = (struct constructor_range_stack *)
7163 obstack_alloc (braced_init_obstack,
7164 sizeof (struct constructor_range_stack));
7165 p->prev = constructor_range_stack;
7167 p->fields = constructor_fields;
7168 p->range_start = constructor_index;
7169 p->index = constructor_index;
7170 p->stack = constructor_stack;
7171 p->range_end = range_end;
7172 if (constructor_range_stack)
7173 constructor_range_stack->next = p;
7174 constructor_range_stack = p;
7177 /* Within an array initializer, specify the next index to be initialized.
7178 FIRST is that index. If LAST is nonzero, then initialize a range
7179 of indices, running from FIRST through LAST. */
7182 set_init_index (tree first, tree last,
7183 struct obstack * braced_init_obstack)
7185 if (set_designator (1, braced_init_obstack))
7188 designator_erroneous = 1;
7190 if (!INTEGRAL_TYPE_P (TREE_TYPE (first))
7191 || (last && !INTEGRAL_TYPE_P (TREE_TYPE (last))))
7193 error_init ("array index in initializer not of integer type");
7197 if (TREE_CODE (first) != INTEGER_CST)
7199 first = c_fully_fold (first, false, NULL);
7200 if (TREE_CODE (first) == INTEGER_CST)
7201 pedwarn_init (input_location, OPT_pedantic,
7202 "array index in initializer is not "
7203 "an integer constant expression");
7206 if (last && TREE_CODE (last) != INTEGER_CST)
7208 last = c_fully_fold (last, false, NULL);
7209 if (TREE_CODE (last) == INTEGER_CST)
7210 pedwarn_init (input_location, OPT_pedantic,
7211 "array index in initializer is not "
7212 "an integer constant expression");
7215 if (TREE_CODE (first) != INTEGER_CST)
7216 error_init ("nonconstant array index in initializer");
7217 else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
7218 error_init ("nonconstant array index in initializer");
7219 else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
7220 error_init ("array index in non-array initializer");
7221 else if (tree_int_cst_sgn (first) == -1)
7222 error_init ("array index in initializer exceeds array bounds");
7223 else if (constructor_max_index
7224 && tree_int_cst_lt (constructor_max_index, first))
7225 error_init ("array index in initializer exceeds array bounds");
7228 constant_expression_warning (first);
7230 constant_expression_warning (last);
7231 constructor_index = convert (bitsizetype, first);
7235 if (tree_int_cst_equal (first, last))
7237 else if (tree_int_cst_lt (last, first))
7239 error_init ("empty index range in initializer");
7244 last = convert (bitsizetype, last);
7245 if (constructor_max_index != 0
7246 && tree_int_cst_lt (constructor_max_index, last))
7248 error_init ("array index range in initializer exceeds array bounds");
7255 designator_erroneous = 0;
7256 if (constructor_range_stack || last)
7257 push_range_stack (last, braced_init_obstack);
7261 /* Within a struct initializer, specify the next field to be initialized. */
7264 set_init_label (tree fieldname, struct obstack * braced_init_obstack)
7268 if (set_designator (0, braced_init_obstack))
7271 designator_erroneous = 1;
7273 if (TREE_CODE (constructor_type) != RECORD_TYPE
7274 && TREE_CODE (constructor_type) != UNION_TYPE)
7276 error_init ("field name not in record or union initializer");
7280 field = lookup_field (constructor_type, fieldname);
7283 error ("unknown field %qE specified in initializer", fieldname);
7287 constructor_fields = TREE_VALUE (field);
7289 designator_erroneous = 0;
7290 if (constructor_range_stack)
7291 push_range_stack (NULL_TREE, braced_init_obstack);
7292 field = TREE_CHAIN (field);
7295 if (set_designator (0, braced_init_obstack))
7299 while (field != NULL_TREE);
7302 /* Add a new initializer to the tree of pending initializers. PURPOSE
7303 identifies the initializer, either array index or field in a structure.
7304 VALUE is the value of that index or field. If ORIGTYPE is not
7305 NULL_TREE, it is the original type of VALUE.
7307 IMPLICIT is true if value comes from pop_init_level (1),
7308 the new initializer has been merged with the existing one
7309 and thus no warnings should be emitted about overriding an
7310 existing initializer. */
7313 add_pending_init (tree purpose, tree value, tree origtype, bool implicit,
7314 struct obstack * braced_init_obstack)
7316 struct init_node *p, **q, *r;
7318 q = &constructor_pending_elts;
7321 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
7326 if (tree_int_cst_lt (purpose, p->purpose))
7328 else if (tree_int_cst_lt (p->purpose, purpose))
7334 if (TREE_SIDE_EFFECTS (p->value))
7335 warning_init (0, "initialized field with side-effects overwritten");
7336 else if (warn_override_init)
7337 warning_init (OPT_Woverride_init, "initialized field overwritten");
7340 p->origtype = origtype;
7349 bitpos = bit_position (purpose);
7353 if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
7355 else if (p->purpose != purpose)
7361 if (TREE_SIDE_EFFECTS (p->value))
7362 warning_init (0, "initialized field with side-effects overwritten");
7363 else if (warn_override_init)
7364 warning_init (OPT_Woverride_init, "initialized field overwritten");
7367 p->origtype = origtype;
7373 r = (struct init_node *) obstack_alloc (braced_init_obstack,
7374 sizeof (struct init_node));
7375 r->purpose = purpose;
7377 r->origtype = origtype;
7387 struct init_node *s;
7391 if (p->balance == 0)
7393 else if (p->balance < 0)
7400 p->left->parent = p;
7417 constructor_pending_elts = r;
7422 struct init_node *t = r->right;
7426 r->right->parent = r;
7431 p->left->parent = p;
7434 p->balance = t->balance < 0;
7435 r->balance = -(t->balance > 0);
7450 constructor_pending_elts = t;
7456 /* p->balance == +1; growth of left side balances the node. */
7461 else /* r == p->right */
7463 if (p->balance == 0)
7464 /* Growth propagation from right side. */
7466 else if (p->balance > 0)
7473 p->right->parent = p;
7490 constructor_pending_elts = r;
7492 else /* r->balance == -1 */
7495 struct init_node *t = r->left;
7499 r->left->parent = r;
7504 p->right->parent = p;
7507 r->balance = (t->balance < 0);
7508 p->balance = -(t->balance > 0);
7523 constructor_pending_elts = t;
7529 /* p->balance == -1; growth of right side balances the node. */
7540 /* Build AVL tree from a sorted chain. */
7543 set_nonincremental_init (struct obstack * braced_init_obstack)
7545 unsigned HOST_WIDE_INT ix;
7548 if (TREE_CODE (constructor_type) != RECORD_TYPE
7549 && TREE_CODE (constructor_type) != ARRAY_TYPE)
7552 FOR_EACH_CONSTRUCTOR_ELT (constructor_elements, ix, index, value)
7554 add_pending_init (index, value, NULL_TREE, false,
7555 braced_init_obstack);
7557 constructor_elements = 0;
7558 if (TREE_CODE (constructor_type) == RECORD_TYPE)
7560 constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
7561 /* Skip any nameless bit fields at the beginning. */
7562 while (constructor_unfilled_fields != 0
7563 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
7564 && DECL_NAME (constructor_unfilled_fields) == 0)
7565 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
7568 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
7570 if (TYPE_DOMAIN (constructor_type))
7571 constructor_unfilled_index
7572 = convert (bitsizetype,
7573 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
7575 constructor_unfilled_index = bitsize_zero_node;
7577 constructor_incremental = 0;
7580 /* Build AVL tree from a string constant. */
7583 set_nonincremental_init_from_string (tree str,
7584 struct obstack * braced_init_obstack)
7586 tree value, purpose, type;
7587 HOST_WIDE_INT val[2];
7588 const char *p, *end;
7589 int byte, wchar_bytes, charwidth, bitpos;
7591 gcc_assert (TREE_CODE (constructor_type) == ARRAY_TYPE);
7593 wchar_bytes = TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str))) / BITS_PER_UNIT;
7594 charwidth = TYPE_PRECISION (char_type_node);
7595 type = TREE_TYPE (constructor_type);
7596 p = TREE_STRING_POINTER (str);
7597 end = p + TREE_STRING_LENGTH (str);
7599 for (purpose = bitsize_zero_node;
7600 p < end && !tree_int_cst_lt (constructor_max_index, purpose);
7601 purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
7603 if (wchar_bytes == 1)
7605 val[1] = (unsigned char) *p++;
7612 for (byte = 0; byte < wchar_bytes; byte++)
7614 if (BYTES_BIG_ENDIAN)
7615 bitpos = (wchar_bytes - byte - 1) * charwidth;
7617 bitpos = byte * charwidth;
7618 val[bitpos < HOST_BITS_PER_WIDE_INT]
7619 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
7620 << (bitpos % HOST_BITS_PER_WIDE_INT);
7624 if (!TYPE_UNSIGNED (type))
7626 bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
7627 if (bitpos < HOST_BITS_PER_WIDE_INT)
7629 if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
7631 val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
7635 else if (bitpos == HOST_BITS_PER_WIDE_INT)
7640 else if (val[0] & (((HOST_WIDE_INT) 1)
7641 << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
7642 val[0] |= ((HOST_WIDE_INT) -1)
7643 << (bitpos - HOST_BITS_PER_WIDE_INT);
7646 value = build_int_cst_wide (type, val[1], val[0]);
7647 add_pending_init (purpose, value, NULL_TREE, false,
7648 braced_init_obstack);
7651 constructor_incremental = 0;
7654 /* Return value of FIELD in pending initializer or zero if the field was
7655 not initialized yet. */
7658 find_init_member (tree field, struct obstack * braced_init_obstack)
7660 struct init_node *p;
7662 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
7664 if (constructor_incremental
7665 && tree_int_cst_lt (field, constructor_unfilled_index))
7666 set_nonincremental_init (braced_init_obstack);
7668 p = constructor_pending_elts;
7671 if (tree_int_cst_lt (field, p->purpose))
7673 else if (tree_int_cst_lt (p->purpose, field))
7679 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
7681 tree bitpos = bit_position (field);
7683 if (constructor_incremental
7684 && (!constructor_unfilled_fields
7685 || tree_int_cst_lt (bitpos,
7686 bit_position (constructor_unfilled_fields))))
7687 set_nonincremental_init (braced_init_obstack);
7689 p = constructor_pending_elts;
7692 if (field == p->purpose)
7694 else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
7700 else if (TREE_CODE (constructor_type) == UNION_TYPE)
7702 if (!VEC_empty (constructor_elt, constructor_elements)
7703 && (VEC_last (constructor_elt, constructor_elements)->index
7705 return VEC_last (constructor_elt, constructor_elements)->value;
7710 /* "Output" the next constructor element.
7711 At top level, really output it to assembler code now.
7712 Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
7713 If ORIGTYPE is not NULL_TREE, it is the original type of VALUE.
7714 TYPE is the data type that the containing data type wants here.
7715 FIELD is the field (a FIELD_DECL) or the index that this element fills.
7716 If VALUE is a string constant, STRICT_STRING is true if it is
7717 unparenthesized or we should not warn here for it being parenthesized.
7718 For other types of VALUE, STRICT_STRING is not used.
7720 PENDING if non-nil means output pending elements that belong
7721 right after this element. (PENDING is normally 1;
7722 it is 0 while outputting pending elements, to avoid recursion.)
7724 IMPLICIT is true if value comes from pop_init_level (1),
7725 the new initializer has been merged with the existing one
7726 and thus no warnings should be emitted about overriding an
7727 existing initializer. */
7730 output_init_element (tree value, tree origtype, bool strict_string, tree type,
7731 tree field, int pending, bool implicit,
7732 struct obstack * braced_init_obstack)
7734 tree semantic_type = NULL_TREE;
7735 constructor_elt *celt;
7736 bool maybe_const = true;
7739 if (type == error_mark_node || value == error_mark_node)
7741 constructor_erroneous = 1;
7744 if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
7745 && (TREE_CODE (value) == STRING_CST
7746 || TREE_CODE (value) == COMPOUND_LITERAL_EXPR)
7747 && !(TREE_CODE (value) == STRING_CST
7748 && TREE_CODE (type) == ARRAY_TYPE
7749 && INTEGRAL_TYPE_P (TREE_TYPE (type)))
7750 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
7751 TYPE_MAIN_VARIANT (type)))
7752 value = array_to_pointer_conversion (input_location, value);
7754 if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR
7755 && require_constant_value && !flag_isoc99 && pending)
7757 /* As an extension, allow initializing objects with static storage
7758 duration with compound literals (which are then treated just as
7759 the brace enclosed list they contain). */
7760 tree decl = COMPOUND_LITERAL_EXPR_DECL (value);
7761 value = DECL_INITIAL (decl);
7764 npc = null_pointer_constant_p (value);
7765 if (TREE_CODE (value) == EXCESS_PRECISION_EXPR)
7767 semantic_type = TREE_TYPE (value);
7768 value = TREE_OPERAND (value, 0);
7770 value = c_fully_fold (value, require_constant_value, &maybe_const);
7772 if (value == error_mark_node)
7773 constructor_erroneous = 1;
7774 else if (!TREE_CONSTANT (value))
7775 constructor_constant = 0;
7776 else if (!initializer_constant_valid_p (value, TREE_TYPE (value))
7777 || ((TREE_CODE (constructor_type) == RECORD_TYPE
7778 || TREE_CODE (constructor_type) == UNION_TYPE)
7779 && DECL_C_BIT_FIELD (field)
7780 && TREE_CODE (value) != INTEGER_CST))
7781 constructor_simple = 0;
7783 constructor_nonconst = 1;
7785 if (!initializer_constant_valid_p (value, TREE_TYPE (value)))
7787 if (require_constant_value)
7789 error_init ("initializer element is not constant");
7790 value = error_mark_node;
7792 else if (require_constant_elements)
7793 pedwarn (input_location, 0,
7794 "initializer element is not computable at load time");
7796 else if (!maybe_const
7797 && (require_constant_value || require_constant_elements))
7798 pedwarn_init (input_location, 0,
7799 "initializer element is not a constant expression");
7801 /* Issue -Wc++-compat warnings about initializing a bitfield with
7804 && field != NULL_TREE
7805 && TREE_CODE (field) == FIELD_DECL
7806 && DECL_BIT_FIELD_TYPE (field) != NULL_TREE
7807 && (TYPE_MAIN_VARIANT (DECL_BIT_FIELD_TYPE (field))
7808 != TYPE_MAIN_VARIANT (type))
7809 && TREE_CODE (DECL_BIT_FIELD_TYPE (field)) == ENUMERAL_TYPE)
7811 tree checktype = origtype != NULL_TREE ? origtype : TREE_TYPE (value);
7812 if (checktype != error_mark_node
7813 && (TYPE_MAIN_VARIANT (checktype)
7814 != TYPE_MAIN_VARIANT (DECL_BIT_FIELD_TYPE (field))))
7815 warning_init (OPT_Wc___compat,
7816 "enum conversion in initialization is invalid in C++");
7819 /* If this field is empty (and not at the end of structure),
7820 don't do anything other than checking the initializer. */
7822 && (TREE_TYPE (field) == error_mark_node
7823 || (COMPLETE_TYPE_P (TREE_TYPE (field))
7824 && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
7825 && (TREE_CODE (constructor_type) == ARRAY_TYPE
7826 || DECL_CHAIN (field)))))
7830 value = build1 (EXCESS_PRECISION_EXPR, semantic_type, value);
7831 value = digest_init (input_location, type, value, origtype, npc,
7832 strict_string, require_constant_value);
7833 if (value == error_mark_node)
7835 constructor_erroneous = 1;
7838 if (require_constant_value || require_constant_elements)
7839 constant_expression_warning (value);
7841 /* If this element doesn't come next in sequence,
7842 put it on constructor_pending_elts. */
7843 if (TREE_CODE (constructor_type) == ARRAY_TYPE
7844 && (!constructor_incremental
7845 || !tree_int_cst_equal (field, constructor_unfilled_index)))
7847 if (constructor_incremental
7848 && tree_int_cst_lt (field, constructor_unfilled_index))
7849 set_nonincremental_init (braced_init_obstack);
7851 add_pending_init (field, value, origtype, implicit,
7852 braced_init_obstack);
7855 else if (TREE_CODE (constructor_type) == RECORD_TYPE
7856 && (!constructor_incremental
7857 || field != constructor_unfilled_fields))
7859 /* We do this for records but not for unions. In a union,
7860 no matter which field is specified, it can be initialized
7861 right away since it starts at the beginning of the union. */
7862 if (constructor_incremental)
7864 if (!constructor_unfilled_fields)
7865 set_nonincremental_init (braced_init_obstack);
7868 tree bitpos, unfillpos;
7870 bitpos = bit_position (field);
7871 unfillpos = bit_position (constructor_unfilled_fields);
7873 if (tree_int_cst_lt (bitpos, unfillpos))
7874 set_nonincremental_init (braced_init_obstack);
7878 add_pending_init (field, value, origtype, implicit,
7879 braced_init_obstack);
7882 else if (TREE_CODE (constructor_type) == UNION_TYPE
7883 && !VEC_empty (constructor_elt, constructor_elements))
7887 if (TREE_SIDE_EFFECTS (VEC_last (constructor_elt,
7888 constructor_elements)->value))
7890 "initialized field with side-effects overwritten");
7891 else if (warn_override_init)
7892 warning_init (OPT_Woverride_init, "initialized field overwritten");
7895 /* We can have just one union field set. */
7896 constructor_elements = 0;
7899 /* Otherwise, output this element either to
7900 constructor_elements or to the assembler file. */
7902 celt = VEC_safe_push (constructor_elt, gc, constructor_elements, NULL);
7903 celt->index = field;
7904 celt->value = value;
7906 /* Advance the variable that indicates sequential elements output. */
7907 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
7908 constructor_unfilled_index
7909 = size_binop_loc (input_location, PLUS_EXPR, constructor_unfilled_index,
7911 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
7913 constructor_unfilled_fields
7914 = DECL_CHAIN (constructor_unfilled_fields);
7916 /* Skip any nameless bit fields. */
7917 while (constructor_unfilled_fields != 0
7918 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
7919 && DECL_NAME (constructor_unfilled_fields) == 0)
7920 constructor_unfilled_fields =
7921 DECL_CHAIN (constructor_unfilled_fields);
7923 else if (TREE_CODE (constructor_type) == UNION_TYPE)
7924 constructor_unfilled_fields = 0;
7926 /* Now output any pending elements which have become next. */
7928 output_pending_init_elements (0, braced_init_obstack);
7931 /* Output any pending elements which have become next.
7932 As we output elements, constructor_unfilled_{fields,index}
7933 advances, which may cause other elements to become next;
7934 if so, they too are output.
7936 If ALL is 0, we return when there are
7937 no more pending elements to output now.
7939 If ALL is 1, we output space as necessary so that
7940 we can output all the pending elements. */
7942 output_pending_init_elements (int all, struct obstack * braced_init_obstack)
7944 struct init_node *elt = constructor_pending_elts;
7949 /* Look through the whole pending tree.
7950 If we find an element that should be output now,
7951 output it. Otherwise, set NEXT to the element
7952 that comes first among those still pending. */
7957 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
7959 if (tree_int_cst_equal (elt->purpose,
7960 constructor_unfilled_index))
7961 output_init_element (elt->value, elt->origtype, true,
7962 TREE_TYPE (constructor_type),
7963 constructor_unfilled_index, 0, false,
7964 braced_init_obstack);
7965 else if (tree_int_cst_lt (constructor_unfilled_index,
7968 /* Advance to the next smaller node. */
7973 /* We have reached the smallest node bigger than the
7974 current unfilled index. Fill the space first. */
7975 next = elt->purpose;
7981 /* Advance to the next bigger node. */
7986 /* We have reached the biggest node in a subtree. Find
7987 the parent of it, which is the next bigger node. */
7988 while (elt->parent && elt->parent->right == elt)
7991 if (elt && tree_int_cst_lt (constructor_unfilled_index,
7994 next = elt->purpose;
8000 else if (TREE_CODE (constructor_type) == RECORD_TYPE
8001 || TREE_CODE (constructor_type) == UNION_TYPE)
8003 tree ctor_unfilled_bitpos, elt_bitpos;
8005 /* If the current record is complete we are done. */
8006 if (constructor_unfilled_fields == 0)
8009 ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
8010 elt_bitpos = bit_position (elt->purpose);
8011 /* We can't compare fields here because there might be empty
8012 fields in between. */
8013 if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
8015 constructor_unfilled_fields = elt->purpose;
8016 output_init_element (elt->value, elt->origtype, true,
8017 TREE_TYPE (elt->purpose),
8018 elt->purpose, 0, false,
8019 braced_init_obstack);
8021 else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
8023 /* Advance to the next smaller node. */
8028 /* We have reached the smallest node bigger than the
8029 current unfilled field. Fill the space first. */
8030 next = elt->purpose;
8036 /* Advance to the next bigger node. */
8041 /* We have reached the biggest node in a subtree. Find
8042 the parent of it, which is the next bigger node. */
8043 while (elt->parent && elt->parent->right == elt)
8047 && (tree_int_cst_lt (ctor_unfilled_bitpos,
8048 bit_position (elt->purpose))))
8050 next = elt->purpose;
8058 /* Ordinarily return, but not if we want to output all
8059 and there are elements left. */
8060 if (!(all && next != 0))
8063 /* If it's not incremental, just skip over the gap, so that after
8064 jumping to retry we will output the next successive element. */
8065 if (TREE_CODE (constructor_type) == RECORD_TYPE
8066 || TREE_CODE (constructor_type) == UNION_TYPE)
8067 constructor_unfilled_fields = next;
8068 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
8069 constructor_unfilled_index = next;
8071 /* ELT now points to the node in the pending tree with the next
8072 initializer to output. */
8076 /* Add one non-braced element to the current constructor level.
8077 This adjusts the current position within the constructor's type.
8078 This may also start or terminate implicit levels
8079 to handle a partly-braced initializer.
8081 Once this has found the correct level for the new element,
8082 it calls output_init_element.
8084 IMPLICIT is true if value comes from pop_init_level (1),
8085 the new initializer has been merged with the existing one
8086 and thus no warnings should be emitted about overriding an
8087 existing initializer. */
8090 process_init_element (struct c_expr value, bool implicit,
8091 struct obstack * braced_init_obstack)
8093 tree orig_value = value.value;
8094 int string_flag = orig_value != 0 && TREE_CODE (orig_value) == STRING_CST;
8095 bool strict_string = value.original_code == STRING_CST;
8097 designator_depth = 0;
8098 designator_erroneous = 0;
8100 /* Handle superfluous braces around string cst as in
8101 char x[] = {"foo"}; */
8104 && TREE_CODE (constructor_type) == ARRAY_TYPE
8105 && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type))
8106 && integer_zerop (constructor_unfilled_index))
8108 if (constructor_stack->replacement_value.value)
8109 error_init ("excess elements in char array initializer");
8110 constructor_stack->replacement_value = value;
8114 if (constructor_stack->replacement_value.value != 0)
8116 error_init ("excess elements in struct initializer");
8120 /* Ignore elements of a brace group if it is entirely superfluous
8121 and has already been diagnosed. */
8122 if (constructor_type == 0)
8125 /* If we've exhausted any levels that didn't have braces,
8127 while (constructor_stack->implicit)
8129 if ((TREE_CODE (constructor_type) == RECORD_TYPE
8130 || TREE_CODE (constructor_type) == UNION_TYPE)
8131 && constructor_fields == 0)
8132 process_init_element (pop_init_level (1, braced_init_obstack),
8133 true, braced_init_obstack);
8134 else if ((TREE_CODE (constructor_type) == ARRAY_TYPE
8135 || TREE_CODE (constructor_type) == VECTOR_TYPE)
8136 && (constructor_max_index == 0
8137 || tree_int_cst_lt (constructor_max_index,
8138 constructor_index)))
8139 process_init_element (pop_init_level (1, braced_init_obstack),
8140 true, braced_init_obstack);
8145 /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */
8146 if (constructor_range_stack)
8148 /* If value is a compound literal and we'll be just using its
8149 content, don't put it into a SAVE_EXPR. */
8150 if (TREE_CODE (value.value) != COMPOUND_LITERAL_EXPR
8151 || !require_constant_value
8154 tree semantic_type = NULL_TREE;
8155 if (TREE_CODE (value.value) == EXCESS_PRECISION_EXPR)
8157 semantic_type = TREE_TYPE (value.value);
8158 value.value = TREE_OPERAND (value.value, 0);
8160 value.value = c_save_expr (value.value);
8162 value.value = build1 (EXCESS_PRECISION_EXPR, semantic_type,
8169 if (TREE_CODE (constructor_type) == RECORD_TYPE)
8172 enum tree_code fieldcode;
8174 if (constructor_fields == 0)
8176 pedwarn_init (input_location, 0,
8177 "excess elements in struct initializer");
8181 fieldtype = TREE_TYPE (constructor_fields);
8182 if (fieldtype != error_mark_node)
8183 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
8184 fieldcode = TREE_CODE (fieldtype);
8186 /* Error for non-static initialization of a flexible array member. */
8187 if (fieldcode == ARRAY_TYPE
8188 && !require_constant_value
8189 && TYPE_SIZE (fieldtype) == NULL_TREE
8190 && DECL_CHAIN (constructor_fields) == NULL_TREE)
8192 error_init ("non-static initialization of a flexible array member");
8196 /* Accept a string constant to initialize a subarray. */
8197 if (value.value != 0
8198 && fieldcode == ARRAY_TYPE
8199 && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
8201 value.value = orig_value;
8202 /* Otherwise, if we have come to a subaggregate,
8203 and we don't have an element of its type, push into it. */
8204 else if (value.value != 0
8205 && value.value != error_mark_node
8206 && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
8207 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
8208 || fieldcode == UNION_TYPE || fieldcode == VECTOR_TYPE))
8210 push_init_level (1, braced_init_obstack);
8216 push_member_name (constructor_fields);
8217 output_init_element (value.value, value.original_type,
8218 strict_string, fieldtype,
8219 constructor_fields, 1, implicit,
8220 braced_init_obstack);
8221 RESTORE_SPELLING_DEPTH (constructor_depth);
8224 /* Do the bookkeeping for an element that was
8225 directly output as a constructor. */
8227 /* For a record, keep track of end position of last field. */
8228 if (DECL_SIZE (constructor_fields))
8229 constructor_bit_index
8230 = size_binop_loc (input_location, PLUS_EXPR,
8231 bit_position (constructor_fields),
8232 DECL_SIZE (constructor_fields));
8234 /* If the current field was the first one not yet written out,
8235 it isn't now, so update. */
8236 if (constructor_unfilled_fields == constructor_fields)
8238 constructor_unfilled_fields = DECL_CHAIN (constructor_fields);
8239 /* Skip any nameless bit fields. */
8240 while (constructor_unfilled_fields != 0
8241 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
8242 && DECL_NAME (constructor_unfilled_fields) == 0)
8243 constructor_unfilled_fields =
8244 DECL_CHAIN (constructor_unfilled_fields);
8248 constructor_fields = DECL_CHAIN (constructor_fields);
8249 /* Skip any nameless bit fields at the beginning. */
8250 while (constructor_fields != 0
8251 && DECL_C_BIT_FIELD (constructor_fields)
8252 && DECL_NAME (constructor_fields) == 0)
8253 constructor_fields = DECL_CHAIN (constructor_fields);
8255 else if (TREE_CODE (constructor_type) == UNION_TYPE)
8258 enum tree_code fieldcode;
8260 if (constructor_fields == 0)
8262 pedwarn_init (input_location, 0,
8263 "excess elements in union initializer");
8267 fieldtype = TREE_TYPE (constructor_fields);
8268 if (fieldtype != error_mark_node)
8269 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
8270 fieldcode = TREE_CODE (fieldtype);
8272 /* Warn that traditional C rejects initialization of unions.
8273 We skip the warning if the value is zero. This is done
8274 under the assumption that the zero initializer in user
8275 code appears conditioned on e.g. __STDC__ to avoid
8276 "missing initializer" warnings and relies on default
8277 initialization to zero in the traditional C case.
8278 We also skip the warning if the initializer is designated,
8279 again on the assumption that this must be conditional on
8280 __STDC__ anyway (and we've already complained about the
8281 member-designator already). */
8282 if (!in_system_header && !constructor_designated
8283 && !(value.value && (integer_zerop (value.value)
8284 || real_zerop (value.value))))
8285 warning (OPT_Wtraditional, "traditional C rejects initialization "
8288 /* Accept a string constant to initialize a subarray. */
8289 if (value.value != 0
8290 && fieldcode == ARRAY_TYPE
8291 && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
8293 value.value = orig_value;
8294 /* Otherwise, if we have come to a subaggregate,
8295 and we don't have an element of its type, push into it. */
8296 else if (value.value != 0
8297 && value.value != error_mark_node
8298 && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
8299 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
8300 || fieldcode == UNION_TYPE || fieldcode == VECTOR_TYPE))
8302 push_init_level (1, braced_init_obstack);
8308 push_member_name (constructor_fields);
8309 output_init_element (value.value, value.original_type,
8310 strict_string, fieldtype,
8311 constructor_fields, 1, implicit,
8312 braced_init_obstack);
8313 RESTORE_SPELLING_DEPTH (constructor_depth);
8316 /* Do the bookkeeping for an element that was
8317 directly output as a constructor. */
8319 constructor_bit_index = DECL_SIZE (constructor_fields);
8320 constructor_unfilled_fields = DECL_CHAIN (constructor_fields);
8323 constructor_fields = 0;
8325 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
8327 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
8328 enum tree_code eltcode = TREE_CODE (elttype);
8330 /* Accept a string constant to initialize a subarray. */
8331 if (value.value != 0
8332 && eltcode == ARRAY_TYPE
8333 && INTEGRAL_TYPE_P (TREE_TYPE (elttype))
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)) != elttype
8341 && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
8342 || eltcode == UNION_TYPE || eltcode == VECTOR_TYPE))
8344 push_init_level (1, braced_init_obstack);
8348 if (constructor_max_index != 0
8349 && (tree_int_cst_lt (constructor_max_index, constructor_index)
8350 || integer_all_onesp (constructor_max_index)))
8352 pedwarn_init (input_location, 0,
8353 "excess elements in array initializer");
8357 /* Now output the actual element. */
8360 push_array_bounds (tree_low_cst (constructor_index, 1));
8361 output_init_element (value.value, value.original_type,
8362 strict_string, elttype,
8363 constructor_index, 1, implicit,
8364 braced_init_obstack);
8365 RESTORE_SPELLING_DEPTH (constructor_depth);
8369 = size_binop_loc (input_location, PLUS_EXPR,
8370 constructor_index, bitsize_one_node);
8373 /* If we are doing the bookkeeping for an element that was
8374 directly output as a constructor, we must update
8375 constructor_unfilled_index. */
8376 constructor_unfilled_index = constructor_index;
8378 else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
8380 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
8382 /* Do a basic check of initializer size. Note that vectors
8383 always have a fixed size derived from their type. */
8384 if (tree_int_cst_lt (constructor_max_index, constructor_index))
8386 pedwarn_init (input_location, 0,
8387 "excess elements in vector initializer");
8391 /* Now output the actual element. */
8394 if (TREE_CODE (value.value) == VECTOR_CST)
8395 elttype = TYPE_MAIN_VARIANT (constructor_type);
8396 output_init_element (value.value, value.original_type,
8397 strict_string, elttype,
8398 constructor_index, 1, implicit,
8399 braced_init_obstack);
8403 = size_binop_loc (input_location,
8404 PLUS_EXPR, constructor_index, bitsize_one_node);
8407 /* If we are doing the bookkeeping for an element that was
8408 directly output as a constructor, we must update
8409 constructor_unfilled_index. */
8410 constructor_unfilled_index = constructor_index;
8413 /* Handle the sole element allowed in a braced initializer
8414 for a scalar variable. */
8415 else if (constructor_type != error_mark_node
8416 && constructor_fields == 0)
8418 pedwarn_init (input_location, 0,
8419 "excess elements in scalar initializer");
8425 output_init_element (value.value, value.original_type,
8426 strict_string, constructor_type,
8427 NULL_TREE, 1, implicit,
8428 braced_init_obstack);
8429 constructor_fields = 0;
8432 /* Handle range initializers either at this level or anywhere higher
8433 in the designator stack. */
8434 if (constructor_range_stack)
8436 struct constructor_range_stack *p, *range_stack;
8439 range_stack = constructor_range_stack;
8440 constructor_range_stack = 0;
8441 while (constructor_stack != range_stack->stack)
8443 gcc_assert (constructor_stack->implicit);
8444 process_init_element (pop_init_level (1,
8445 braced_init_obstack),
8446 true, braced_init_obstack);
8448 for (p = range_stack;
8449 !p->range_end || tree_int_cst_equal (p->index, p->range_end);
8452 gcc_assert (constructor_stack->implicit);
8453 process_init_element (pop_init_level (1, braced_init_obstack),
8454 true, braced_init_obstack);
8457 p->index = size_binop_loc (input_location,
8458 PLUS_EXPR, p->index, bitsize_one_node);
8459 if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
8464 constructor_index = p->index;
8465 constructor_fields = p->fields;
8466 if (finish && p->range_end && p->index == p->range_start)
8474 push_init_level (2, braced_init_obstack);
8475 p->stack = constructor_stack;
8476 if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
8477 p->index = p->range_start;
8481 constructor_range_stack = range_stack;
8488 constructor_range_stack = 0;
8491 /* Build a complete asm-statement, whose components are a CV_QUALIFIER
8492 (guaranteed to be 'volatile' or null) and ARGS (represented using
8493 an ASM_EXPR node). */
8495 build_asm_stmt (tree cv_qualifier, tree args)
8497 if (!ASM_VOLATILE_P (args) && cv_qualifier)
8498 ASM_VOLATILE_P (args) = 1;
8499 return add_stmt (args);
8502 /* Build an asm-expr, whose components are a STRING, some OUTPUTS,
8503 some INPUTS, and some CLOBBERS. The latter three may be NULL.
8504 SIMPLE indicates whether there was anything at all after the
8505 string in the asm expression -- asm("blah") and asm("blah" : )
8506 are subtly different. We use a ASM_EXPR node to represent this. */
8508 build_asm_expr (location_t loc, tree string, tree outputs, tree inputs,
8509 tree clobbers, tree labels, bool simple)
8514 const char *constraint;
8515 const char **oconstraints;
8516 bool allows_mem, allows_reg, is_inout;
8517 int ninputs, noutputs;
8519 ninputs = list_length (inputs);
8520 noutputs = list_length (outputs);
8521 oconstraints = (const char **) alloca (noutputs * sizeof (const char *));
8523 string = resolve_asm_operand_names (string, outputs, inputs, labels);
8525 /* Remove output conversions that change the type but not the mode. */
8526 for (i = 0, tail = outputs; tail; ++i, tail = TREE_CHAIN (tail))
8528 tree output = TREE_VALUE (tail);
8530 /* ??? Really, this should not be here. Users should be using a
8531 proper lvalue, dammit. But there's a long history of using casts
8532 in the output operands. In cases like longlong.h, this becomes a
8533 primitive form of typechecking -- if the cast can be removed, then
8534 the output operand had a type of the proper width; otherwise we'll
8535 get an error. Gross, but ... */
8536 STRIP_NOPS (output);
8538 if (!lvalue_or_else (output, lv_asm))
8539 output = error_mark_node;
8541 if (output != error_mark_node
8542 && (TREE_READONLY (output)
8543 || TYPE_READONLY (TREE_TYPE (output))
8544 || ((TREE_CODE (TREE_TYPE (output)) == RECORD_TYPE
8545 || TREE_CODE (TREE_TYPE (output)) == UNION_TYPE)
8546 && C_TYPE_FIELDS_READONLY (TREE_TYPE (output)))))
8547 readonly_error (output, lv_asm);
8549 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
8550 oconstraints[i] = constraint;
8552 if (parse_output_constraint (&constraint, i, ninputs, noutputs,
8553 &allows_mem, &allows_reg, &is_inout))
8555 /* If the operand is going to end up in memory,
8556 mark it addressable. */
8557 if (!allows_reg && !c_mark_addressable (output))
8558 output = error_mark_node;
8561 output = error_mark_node;
8563 TREE_VALUE (tail) = output;
8566 for (i = 0, tail = inputs; tail; ++i, tail = TREE_CHAIN (tail))
8570 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
8571 input = TREE_VALUE (tail);
8573 if (parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
8574 oconstraints, &allows_mem, &allows_reg))
8576 /* If the operand is going to end up in memory,
8577 mark it addressable. */
8578 if (!allows_reg && allows_mem)
8580 /* Strip the nops as we allow this case. FIXME, this really
8581 should be rejected or made deprecated. */
8583 if (!c_mark_addressable (input))
8584 input = error_mark_node;
8588 input = error_mark_node;
8590 TREE_VALUE (tail) = input;
8593 /* ASMs with labels cannot have outputs. This should have been
8594 enforced by the parser. */
8595 gcc_assert (outputs == NULL || labels == NULL);
8597 args = build_stmt (loc, ASM_EXPR, string, outputs, inputs, clobbers, labels);
8599 /* asm statements without outputs, including simple ones, are treated
8601 ASM_INPUT_P (args) = simple;
8602 ASM_VOLATILE_P (args) = (noutputs == 0);
8607 /* Generate a goto statement to LABEL. LOC is the location of the
8611 c_finish_goto_label (location_t loc, tree label)
8613 tree decl = lookup_label_for_goto (loc, label);
8616 TREE_USED (decl) = 1;
8618 tree t = build1 (GOTO_EXPR, void_type_node, decl);
8619 SET_EXPR_LOCATION (t, loc);
8620 return add_stmt (t);
8624 /* Generate a computed goto statement to EXPR. LOC is the location of
8628 c_finish_goto_ptr (location_t loc, tree expr)
8631 pedwarn (loc, OPT_pedantic, "ISO C forbids %<goto *expr;%>");
8632 expr = c_fully_fold (expr, false, NULL);
8633 expr = convert (ptr_type_node, expr);
8634 t = build1 (GOTO_EXPR, void_type_node, expr);
8635 SET_EXPR_LOCATION (t, loc);
8636 return add_stmt (t);
8639 /* Generate a C `return' statement. RETVAL is the expression for what
8640 to return, or a null pointer for `return;' with no value. LOC is
8641 the location of the return statement. If ORIGTYPE is not NULL_TREE, it
8642 is the original type of RETVAL. */
8645 c_finish_return (location_t loc, tree retval, tree origtype)
8647 tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl)), ret_stmt;
8648 bool no_warning = false;
8651 if (TREE_THIS_VOLATILE (current_function_decl))
8653 "function declared %<noreturn%> has a %<return%> statement");
8657 tree semantic_type = NULL_TREE;
8658 npc = null_pointer_constant_p (retval);
8659 if (TREE_CODE (retval) == EXCESS_PRECISION_EXPR)
8661 semantic_type = TREE_TYPE (retval);
8662 retval = TREE_OPERAND (retval, 0);
8664 retval = c_fully_fold (retval, false, NULL);
8666 retval = build1 (EXCESS_PRECISION_EXPR, semantic_type, retval);
8671 current_function_returns_null = 1;
8672 if ((warn_return_type || flag_isoc99)
8673 && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
8675 pedwarn_c99 (loc, flag_isoc99 ? 0 : OPT_Wreturn_type,
8676 "%<return%> with no value, in "
8677 "function returning non-void");
8681 else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
8683 current_function_returns_null = 1;
8684 if (TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
8686 "%<return%> with a value, in function returning void");
8688 pedwarn (loc, OPT_pedantic, "ISO C forbids "
8689 "%<return%> with expression, in function returning void");
8693 tree t = convert_for_assignment (loc, valtype, retval, origtype,
8695 npc, NULL_TREE, NULL_TREE, 0);
8696 tree res = DECL_RESULT (current_function_decl);
8699 current_function_returns_value = 1;
8700 if (t == error_mark_node)
8703 inner = t = convert (TREE_TYPE (res), t);
8705 /* Strip any conversions, additions, and subtractions, and see if
8706 we are returning the address of a local variable. Warn if so. */
8709 switch (TREE_CODE (inner))
8712 case NON_LVALUE_EXPR:
8714 case POINTER_PLUS_EXPR:
8715 inner = TREE_OPERAND (inner, 0);
8719 /* If the second operand of the MINUS_EXPR has a pointer
8720 type (or is converted from it), this may be valid, so
8721 don't give a warning. */
8723 tree op1 = TREE_OPERAND (inner, 1);
8725 while (!POINTER_TYPE_P (TREE_TYPE (op1))
8726 && (CONVERT_EXPR_P (op1)
8727 || TREE_CODE (op1) == NON_LVALUE_EXPR))
8728 op1 = TREE_OPERAND (op1, 0);
8730 if (POINTER_TYPE_P (TREE_TYPE (op1)))
8733 inner = TREE_OPERAND (inner, 0);
8738 inner = TREE_OPERAND (inner, 0);
8740 while (REFERENCE_CLASS_P (inner)
8741 && TREE_CODE (inner) != INDIRECT_REF)
8742 inner = TREE_OPERAND (inner, 0);
8745 && !DECL_EXTERNAL (inner)
8746 && !TREE_STATIC (inner)
8747 && DECL_CONTEXT (inner) == current_function_decl)
8749 0, "function returns address of local variable");
8759 retval = build2 (MODIFY_EXPR, TREE_TYPE (res), res, t);
8760 SET_EXPR_LOCATION (retval, loc);
8762 if (warn_sequence_point)
8763 verify_sequence_points (retval);
8766 ret_stmt = build_stmt (loc, RETURN_EXPR, retval);
8767 TREE_NO_WARNING (ret_stmt) |= no_warning;
8768 return add_stmt (ret_stmt);
8772 /* The SWITCH_EXPR being built. */
8775 /* The original type of the testing expression, i.e. before the
8776 default conversion is applied. */
8779 /* A splay-tree mapping the low element of a case range to the high
8780 element, or NULL_TREE if there is no high element. Used to
8781 determine whether or not a new case label duplicates an old case
8782 label. We need a tree, rather than simply a hash table, because
8783 of the GNU case range extension. */
8786 /* The bindings at the point of the switch. This is used for
8787 warnings crossing decls when branching to a case label. */
8788 struct c_spot_bindings *bindings;
8790 /* The next node on the stack. */
8791 struct c_switch *next;
8794 /* A stack of the currently active switch statements. The innermost
8795 switch statement is on the top of the stack. There is no need to
8796 mark the stack for garbage collection because it is only active
8797 during the processing of the body of a function, and we never
8798 collect at that point. */
8800 struct c_switch *c_switch_stack;
8802 /* Start a C switch statement, testing expression EXP. Return the new
8803 SWITCH_EXPR. SWITCH_LOC is the location of the `switch'.
8804 SWITCH_COND_LOC is the location of the switch's condition. */
8807 c_start_case (location_t switch_loc,
8808 location_t switch_cond_loc,
8811 tree orig_type = error_mark_node;
8812 struct c_switch *cs;
8814 if (exp != error_mark_node)
8816 orig_type = TREE_TYPE (exp);
8818 if (!INTEGRAL_TYPE_P (orig_type))
8820 if (orig_type != error_mark_node)
8822 error_at (switch_cond_loc, "switch quantity not an integer");
8823 orig_type = error_mark_node;
8825 exp = integer_zero_node;
8829 tree type = TYPE_MAIN_VARIANT (orig_type);
8831 if (!in_system_header
8832 && (type == long_integer_type_node
8833 || type == long_unsigned_type_node))
8834 warning_at (switch_cond_loc,
8835 OPT_Wtraditional, "%<long%> switch expression not "
8836 "converted to %<int%> in ISO C");
8838 exp = c_fully_fold (exp, false, NULL);
8839 exp = default_conversion (exp);
8841 if (warn_sequence_point)
8842 verify_sequence_points (exp);
8846 /* Add this new SWITCH_EXPR to the stack. */
8847 cs = XNEW (struct c_switch);
8848 cs->switch_expr = build3 (SWITCH_EXPR, orig_type, exp, NULL_TREE, NULL_TREE);
8849 SET_EXPR_LOCATION (cs->switch_expr, switch_loc);
8850 cs->orig_type = orig_type;
8851 cs->cases = splay_tree_new (case_compare, NULL, NULL);
8852 cs->bindings = c_get_switch_bindings ();
8853 cs->next = c_switch_stack;
8854 c_switch_stack = cs;
8856 return add_stmt (cs->switch_expr);
8859 /* Process a case label at location LOC. */
8862 do_case (location_t loc, tree low_value, tree high_value)
8864 tree label = NULL_TREE;
8866 if (low_value && TREE_CODE (low_value) != INTEGER_CST)
8868 low_value = c_fully_fold (low_value, false, NULL);
8869 if (TREE_CODE (low_value) == INTEGER_CST)
8870 pedwarn (input_location, OPT_pedantic,
8871 "case label is not an integer constant expression");
8874 if (high_value && TREE_CODE (high_value) != INTEGER_CST)
8876 high_value = c_fully_fold (high_value, false, NULL);
8877 if (TREE_CODE (high_value) == INTEGER_CST)
8878 pedwarn (input_location, OPT_pedantic,
8879 "case label is not an integer constant expression");
8882 if (c_switch_stack == NULL)
8885 error_at (loc, "case label not within a switch statement");
8887 error_at (loc, "%<default%> label not within a switch statement");
8891 if (c_check_switch_jump_warnings (c_switch_stack->bindings,
8892 EXPR_LOCATION (c_switch_stack->switch_expr),
8896 label = c_add_case_label (loc, c_switch_stack->cases,
8897 SWITCH_COND (c_switch_stack->switch_expr),
8898 c_switch_stack->orig_type,
8899 low_value, high_value);
8900 if (label == error_mark_node)
8905 /* Finish the switch statement. */
8908 c_finish_case (tree body)
8910 struct c_switch *cs = c_switch_stack;
8911 location_t switch_location;
8913 SWITCH_BODY (cs->switch_expr) = body;
8915 /* Emit warnings as needed. */
8916 switch_location = EXPR_LOCATION (cs->switch_expr);
8917 c_do_switch_warnings (cs->cases, switch_location,
8918 TREE_TYPE (cs->switch_expr),
8919 SWITCH_COND (cs->switch_expr));
8921 /* Pop the stack. */
8922 c_switch_stack = cs->next;
8923 splay_tree_delete (cs->cases);
8924 c_release_switch_bindings (cs->bindings);
8928 /* Emit an if statement. IF_LOCUS is the location of the 'if'. COND,
8929 THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK
8930 may be null. NESTED_IF is true if THEN_BLOCK contains another IF
8931 statement, and was not surrounded with parenthesis. */
8934 c_finish_if_stmt (location_t if_locus, tree cond, tree then_block,
8935 tree else_block, bool nested_if)
8939 /* Diagnose an ambiguous else if if-then-else is nested inside if-then. */
8940 if (warn_parentheses && nested_if && else_block == NULL)
8942 tree inner_if = then_block;
8944 /* We know from the grammar productions that there is an IF nested
8945 within THEN_BLOCK. Due to labels and c99 conditional declarations,
8946 it might not be exactly THEN_BLOCK, but should be the last
8947 non-container statement within. */
8949 switch (TREE_CODE (inner_if))
8954 inner_if = BIND_EXPR_BODY (inner_if);
8956 case STATEMENT_LIST:
8957 inner_if = expr_last (then_block);
8959 case TRY_FINALLY_EXPR:
8960 case TRY_CATCH_EXPR:
8961 inner_if = TREE_OPERAND (inner_if, 0);
8968 if (COND_EXPR_ELSE (inner_if))
8969 warning_at (if_locus, OPT_Wparentheses,
8970 "suggest explicit braces to avoid ambiguous %<else%>");
8973 stmt = build3 (COND_EXPR, void_type_node, cond, then_block, else_block);
8974 SET_EXPR_LOCATION (stmt, if_locus);
8978 /* Emit a general-purpose loop construct. START_LOCUS is the location of
8979 the beginning of the loop. COND is the loop condition. COND_IS_FIRST
8980 is false for DO loops. INCR is the FOR increment expression. BODY is
8981 the statement controlled by the loop. BLAB is the break label. CLAB is
8982 the continue label. Everything is allowed to be NULL. */
8985 c_finish_loop (location_t start_locus, tree cond, tree incr, tree body,
8986 tree blab, tree clab, bool cond_is_first)
8988 tree entry = NULL, exit = NULL, t;
8990 /* If the condition is zero don't generate a loop construct. */
8991 if (cond && integer_zerop (cond))
8995 t = build_and_jump (&blab);
8996 SET_EXPR_LOCATION (t, start_locus);
9002 tree top = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
9004 /* If we have an exit condition, then we build an IF with gotos either
9005 out of the loop, or to the top of it. If there's no exit condition,
9006 then we just build a jump back to the top. */
9007 exit = build_and_jump (&LABEL_EXPR_LABEL (top));
9009 if (cond && !integer_nonzerop (cond))
9011 /* Canonicalize the loop condition to the end. This means
9012 generating a branch to the loop condition. Reuse the
9013 continue label, if possible. */
9018 entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
9019 t = build_and_jump (&LABEL_EXPR_LABEL (entry));
9022 t = build1 (GOTO_EXPR, void_type_node, clab);
9023 SET_EXPR_LOCATION (t, start_locus);
9027 t = build_and_jump (&blab);
9029 exit = fold_build3_loc (start_locus,
9030 COND_EXPR, void_type_node, cond, exit, t);
9032 exit = fold_build3_loc (input_location,
9033 COND_EXPR, void_type_node, cond, exit, t);
9042 add_stmt (build1 (LABEL_EXPR, void_type_node, clab));
9050 add_stmt (build1 (LABEL_EXPR, void_type_node, blab));
9054 c_finish_bc_stmt (location_t loc, tree *label_p, bool is_break)
9057 tree label = *label_p;
9059 /* In switch statements break is sometimes stylistically used after
9060 a return statement. This can lead to spurious warnings about
9061 control reaching the end of a non-void function when it is
9062 inlined. Note that we are calling block_may_fallthru with
9063 language specific tree nodes; this works because
9064 block_may_fallthru returns true when given something it does not
9066 skip = !block_may_fallthru (cur_stmt_list);
9071 *label_p = label = create_artificial_label (loc);
9073 else if (TREE_CODE (label) == LABEL_DECL)
9075 else switch (TREE_INT_CST_LOW (label))
9079 error_at (loc, "break statement not within loop or switch");
9081 error_at (loc, "continue statement not within a loop");
9085 gcc_assert (is_break);
9086 error_at (loc, "break statement used with OpenMP for loop");
9097 add_stmt (build_predict_expr (PRED_CONTINUE, NOT_TAKEN));
9099 return add_stmt (build1 (GOTO_EXPR, void_type_node, label));
9102 /* A helper routine for c_process_expr_stmt and c_finish_stmt_expr. */
9105 emit_side_effect_warnings (location_t loc, tree expr)
9107 if (expr == error_mark_node)
9109 else if (!TREE_SIDE_EFFECTS (expr))
9111 if (!VOID_TYPE_P (TREE_TYPE (expr)) && !TREE_NO_WARNING (expr))
9112 warning_at (loc, OPT_Wunused_value, "statement with no effect");
9115 warn_if_unused_value (expr, loc);
9118 /* Process an expression as if it were a complete statement. Emit
9119 diagnostics, but do not call ADD_STMT. LOC is the location of the
9123 c_process_expr_stmt (location_t loc, tree expr)
9130 expr = c_fully_fold (expr, false, NULL);
9132 if (warn_sequence_point)
9133 verify_sequence_points (expr);
9135 if (TREE_TYPE (expr) != error_mark_node
9136 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
9137 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
9138 error_at (loc, "expression statement has incomplete type");
9140 /* If we're not processing a statement expression, warn about unused values.
9141 Warnings for statement expressions will be emitted later, once we figure
9142 out which is the result. */
9143 if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
9144 && warn_unused_value)
9145 emit_side_effect_warnings (loc, expr);
9148 while (TREE_CODE (exprv) == COMPOUND_EXPR)
9149 exprv = TREE_OPERAND (exprv, 1);
9150 if (DECL_P (exprv) || handled_component_p (exprv))
9151 mark_exp_read (exprv);
9153 /* If the expression is not of a type to which we cannot assign a line
9154 number, wrap the thing in a no-op NOP_EXPR. */
9155 if (DECL_P (expr) || CONSTANT_CLASS_P (expr))
9157 expr = build1 (NOP_EXPR, TREE_TYPE (expr), expr);
9158 SET_EXPR_LOCATION (expr, loc);
9164 /* Emit an expression as a statement. LOC is the location of the
9168 c_finish_expr_stmt (location_t loc, tree expr)
9171 return add_stmt (c_process_expr_stmt (loc, expr));
9176 /* Do the opposite and emit a statement as an expression. To begin,
9177 create a new binding level and return it. */
9180 c_begin_stmt_expr (void)
9184 /* We must force a BLOCK for this level so that, if it is not expanded
9185 later, there is a way to turn off the entire subtree of blocks that
9186 are contained in it. */
9188 ret = c_begin_compound_stmt (true);
9190 c_bindings_start_stmt_expr (c_switch_stack == NULL
9192 : c_switch_stack->bindings);
9194 /* Mark the current statement list as belonging to a statement list. */
9195 STATEMENT_LIST_STMT_EXPR (ret) = 1;
9200 /* LOC is the location of the compound statement to which this body
9204 c_finish_stmt_expr (location_t loc, tree body)
9206 tree last, type, tmp, val;
9209 body = c_end_compound_stmt (loc, body, true);
9211 c_bindings_end_stmt_expr (c_switch_stack == NULL
9213 : c_switch_stack->bindings);
9215 /* Locate the last statement in BODY. See c_end_compound_stmt
9216 about always returning a BIND_EXPR. */
9217 last_p = &BIND_EXPR_BODY (body);
9218 last = BIND_EXPR_BODY (body);
9221 if (TREE_CODE (last) == STATEMENT_LIST)
9223 tree_stmt_iterator i;
9225 /* This can happen with degenerate cases like ({ }). No value. */
9226 if (!TREE_SIDE_EFFECTS (last))
9229 /* If we're supposed to generate side effects warnings, process
9230 all of the statements except the last. */
9231 if (warn_unused_value)
9233 for (i = tsi_start (last); !tsi_one_before_end_p (i); tsi_next (&i))
9236 tree t = tsi_stmt (i);
9238 tloc = EXPR_HAS_LOCATION (t) ? EXPR_LOCATION (t) : loc;
9239 emit_side_effect_warnings (tloc, t);
9243 i = tsi_last (last);
9244 last_p = tsi_stmt_ptr (i);
9248 /* If the end of the list is exception related, then the list was split
9249 by a call to push_cleanup. Continue searching. */
9250 if (TREE_CODE (last) == TRY_FINALLY_EXPR
9251 || TREE_CODE (last) == TRY_CATCH_EXPR)
9253 last_p = &TREE_OPERAND (last, 0);
9255 goto continue_searching;
9258 if (last == error_mark_node)
9261 /* In the case that the BIND_EXPR is not necessary, return the
9262 expression out from inside it. */
9263 if (last == BIND_EXPR_BODY (body)
9264 && BIND_EXPR_VARS (body) == NULL)
9266 /* Even if this looks constant, do not allow it in a constant
9268 last = c_wrap_maybe_const (last, true);
9269 /* Do not warn if the return value of a statement expression is
9271 TREE_NO_WARNING (last) = 1;
9275 /* Extract the type of said expression. */
9276 type = TREE_TYPE (last);
9278 /* If we're not returning a value at all, then the BIND_EXPR that
9279 we already have is a fine expression to return. */
9280 if (!type || VOID_TYPE_P (type))
9283 /* Now that we've located the expression containing the value, it seems
9284 silly to make voidify_wrapper_expr repeat the process. Create a
9285 temporary of the appropriate type and stick it in a TARGET_EXPR. */
9286 tmp = create_tmp_var_raw (type, NULL);
9288 /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt. This avoids
9289 tree_expr_nonnegative_p giving up immediately. */
9291 if (TREE_CODE (val) == NOP_EXPR
9292 && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0)))
9293 val = TREE_OPERAND (val, 0);
9295 *last_p = build2 (MODIFY_EXPR, void_type_node, tmp, val);
9296 SET_EXPR_LOCATION (*last_p, EXPR_LOCATION (last));
9299 tree t = build4 (TARGET_EXPR, type, tmp, body, NULL_TREE, NULL_TREE);
9300 SET_EXPR_LOCATION (t, loc);
9305 /* Begin and end compound statements. This is as simple as pushing
9306 and popping new statement lists from the tree. */
9309 c_begin_compound_stmt (bool do_scope)
9311 tree stmt = push_stmt_list ();
9317 /* End a compound statement. STMT is the statement. LOC is the
9318 location of the compound statement-- this is usually the location
9319 of the opening brace. */
9322 c_end_compound_stmt (location_t loc, tree stmt, bool do_scope)
9328 if (c_dialect_objc ())
9329 objc_clear_super_receiver ();
9330 block = pop_scope ();
9333 stmt = pop_stmt_list (stmt);
9334 stmt = c_build_bind_expr (loc, block, stmt);
9336 /* If this compound statement is nested immediately inside a statement
9337 expression, then force a BIND_EXPR to be created. Otherwise we'll
9338 do the wrong thing for ({ { 1; } }) or ({ 1; { } }). In particular,
9339 STATEMENT_LISTs merge, and thus we can lose track of what statement
9342 && STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
9343 && TREE_CODE (stmt) != BIND_EXPR)
9345 stmt = build3 (BIND_EXPR, void_type_node, NULL, stmt, NULL);
9346 TREE_SIDE_EFFECTS (stmt) = 1;
9347 SET_EXPR_LOCATION (stmt, loc);
9353 /* Queue a cleanup. CLEANUP is an expression/statement to be executed
9354 when the current scope is exited. EH_ONLY is true when this is not
9355 meant to apply to normal control flow transfer. */
9358 push_cleanup (tree decl, tree cleanup, bool eh_only)
9360 enum tree_code code;
9364 code = eh_only ? TRY_CATCH_EXPR : TRY_FINALLY_EXPR;
9365 stmt = build_stmt (DECL_SOURCE_LOCATION (decl), code, NULL, cleanup);
9367 stmt_expr = STATEMENT_LIST_STMT_EXPR (cur_stmt_list);
9368 list = push_stmt_list ();
9369 TREE_OPERAND (stmt, 0) = list;
9370 STATEMENT_LIST_STMT_EXPR (list) = stmt_expr;
9373 /* Build a binary-operation expression without default conversions.
9374 CODE is the kind of expression to build.
9375 LOCATION is the operator's location.
9376 This function differs from `build' in several ways:
9377 the data type of the result is computed and recorded in it,
9378 warnings are generated if arg data types are invalid,
9379 special handling for addition and subtraction of pointers is known,
9380 and some optimization is done (operations on narrow ints
9381 are done in the narrower type when that gives the same result).
9382 Constant folding is also done before the result is returned.
9384 Note that the operands will never have enumeral types, or function
9385 or array types, because either they will have the default conversions
9386 performed or they have both just been converted to some other type in which
9387 the arithmetic is to be done. */
9390 build_binary_op (location_t location, enum tree_code code,
9391 tree orig_op0, tree orig_op1, int convert_p)
9393 tree type0, type1, orig_type0, orig_type1;
9395 enum tree_code code0, code1;
9397 tree ret = error_mark_node;
9398 const char *invalid_op_diag;
9399 bool op0_int_operands, op1_int_operands;
9400 bool int_const, int_const_or_overflow, int_operands;
9402 /* Expression code to give to the expression when it is built.
9403 Normally this is CODE, which is what the caller asked for,
9404 but in some special cases we change it. */
9405 enum tree_code resultcode = code;
9407 /* Data type in which the computation is to be performed.
9408 In the simplest cases this is the common type of the arguments. */
9409 tree result_type = NULL;
9411 /* When the computation is in excess precision, the type of the
9412 final EXCESS_PRECISION_EXPR. */
9413 tree semantic_result_type = NULL;
9415 /* Nonzero means operands have already been type-converted
9416 in whatever way is necessary.
9417 Zero means they need to be converted to RESULT_TYPE. */
9420 /* Nonzero means create the expression with this type, rather than
9422 tree build_type = 0;
9424 /* Nonzero means after finally constructing the expression
9425 convert it to this type. */
9426 tree final_type = 0;
9428 /* Nonzero if this is an operation like MIN or MAX which can
9429 safely be computed in short if both args are promoted shorts.
9430 Also implies COMMON.
9431 -1 indicates a bitwise operation; this makes a difference
9432 in the exact conditions for when it is safe to do the operation
9433 in a narrower mode. */
9436 /* Nonzero if this is a comparison operation;
9437 if both args are promoted shorts, compare the original shorts.
9438 Also implies COMMON. */
9439 int short_compare = 0;
9441 /* Nonzero if this is a right-shift operation, which can be computed on the
9442 original short and then promoted if the operand is a promoted short. */
9443 int short_shift = 0;
9445 /* Nonzero means set RESULT_TYPE to the common type of the args. */
9448 /* True means types are compatible as far as ObjC is concerned. */
9451 /* True means this is an arithmetic operation that may need excess
9453 bool may_need_excess_precision;
9455 /* True means this is a boolean operation that converts both its
9456 operands to truth-values. */
9457 bool boolean_op = false;
9459 if (location == UNKNOWN_LOCATION)
9460 location = input_location;
9465 op0_int_operands = EXPR_INT_CONST_OPERANDS (orig_op0);
9466 if (op0_int_operands)
9467 op0 = remove_c_maybe_const_expr (op0);
9468 op1_int_operands = EXPR_INT_CONST_OPERANDS (orig_op1);
9469 if (op1_int_operands)
9470 op1 = remove_c_maybe_const_expr (op1);
9471 int_operands = (op0_int_operands && op1_int_operands);
9474 int_const_or_overflow = (TREE_CODE (orig_op0) == INTEGER_CST
9475 && TREE_CODE (orig_op1) == INTEGER_CST);
9476 int_const = (int_const_or_overflow
9477 && !TREE_OVERFLOW (orig_op0)
9478 && !TREE_OVERFLOW (orig_op1));
9481 int_const = int_const_or_overflow = false;
9485 op0 = default_conversion (op0);
9486 op1 = default_conversion (op1);
9489 orig_type0 = type0 = TREE_TYPE (op0);
9490 orig_type1 = type1 = TREE_TYPE (op1);
9492 /* The expression codes of the data types of the arguments tell us
9493 whether the arguments are integers, floating, pointers, etc. */
9494 code0 = TREE_CODE (type0);
9495 code1 = TREE_CODE (type1);
9497 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
9498 STRIP_TYPE_NOPS (op0);
9499 STRIP_TYPE_NOPS (op1);
9501 /* If an error was already reported for one of the arguments,
9502 avoid reporting another error. */
9504 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
9505 return error_mark_node;
9507 if ((invalid_op_diag
9508 = targetm.invalid_binary_op (code, type0, type1)))
9510 error_at (location, invalid_op_diag);
9511 return error_mark_node;
9519 case TRUNC_DIV_EXPR:
9521 case FLOOR_DIV_EXPR:
9522 case ROUND_DIV_EXPR:
9523 case EXACT_DIV_EXPR:
9524 may_need_excess_precision = true;
9527 may_need_excess_precision = false;
9530 if (TREE_CODE (op0) == EXCESS_PRECISION_EXPR)
9532 op0 = TREE_OPERAND (op0, 0);
9533 type0 = TREE_TYPE (op0);
9535 else if (may_need_excess_precision
9536 && (eptype = excess_precision_type (type0)) != NULL_TREE)
9539 op0 = convert (eptype, op0);
9541 if (TREE_CODE (op1) == EXCESS_PRECISION_EXPR)
9543 op1 = TREE_OPERAND (op1, 0);
9544 type1 = TREE_TYPE (op1);
9546 else if (may_need_excess_precision
9547 && (eptype = excess_precision_type (type1)) != NULL_TREE)
9550 op1 = convert (eptype, op1);
9553 objc_ok = objc_compare_types (type0, type1, -3, NULL_TREE);
9558 /* Handle the pointer + int case. */
9559 if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
9561 ret = pointer_int_sum (location, PLUS_EXPR, op0, op1);
9562 goto return_build_binary_op;
9564 else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
9566 ret = pointer_int_sum (location, PLUS_EXPR, op1, op0);
9567 goto return_build_binary_op;
9574 /* Subtraction of two similar pointers.
9575 We must subtract them as integers, then divide by object size. */
9576 if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
9577 && comp_target_types (location, type0, type1))
9579 ret = pointer_diff (location, op0, op1);
9580 goto return_build_binary_op;
9582 /* Handle pointer minus int. Just like pointer plus int. */
9583 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
9585 ret = pointer_int_sum (location, MINUS_EXPR, op0, op1);
9586 goto return_build_binary_op;
9596 case TRUNC_DIV_EXPR:
9598 case FLOOR_DIV_EXPR:
9599 case ROUND_DIV_EXPR:
9600 case EXACT_DIV_EXPR:
9601 warn_for_div_by_zero (location, op1);
9603 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
9604 || code0 == FIXED_POINT_TYPE
9605 || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
9606 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
9607 || code1 == FIXED_POINT_TYPE
9608 || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
9610 enum tree_code tcode0 = code0, tcode1 = code1;
9612 if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
9613 tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
9614 if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)
9615 tcode1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
9617 if (!((tcode0 == INTEGER_TYPE && tcode1 == INTEGER_TYPE)
9618 || (tcode0 == FIXED_POINT_TYPE && tcode1 == FIXED_POINT_TYPE)))
9619 resultcode = RDIV_EXPR;
9621 /* Although it would be tempting to shorten always here, that
9622 loses on some targets, since the modulo instruction is
9623 undefined if the quotient can't be represented in the
9624 computation mode. We shorten only if unsigned or if
9625 dividing by something we know != -1. */
9626 shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
9627 || (TREE_CODE (op1) == INTEGER_CST
9628 && !integer_all_onesp (op1)));
9636 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
9638 /* Allow vector types which are not floating point types. */
9639 else if (code0 == VECTOR_TYPE
9640 && code1 == VECTOR_TYPE
9641 && !VECTOR_FLOAT_TYPE_P (type0)
9642 && !VECTOR_FLOAT_TYPE_P (type1))
9646 case TRUNC_MOD_EXPR:
9647 case FLOOR_MOD_EXPR:
9648 warn_for_div_by_zero (location, op1);
9650 if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
9651 && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE
9652 && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE)
9654 else if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
9656 /* Although it would be tempting to shorten always here, that loses
9657 on some targets, since the modulo instruction is undefined if the
9658 quotient can't be represented in the computation mode. We shorten
9659 only if unsigned or if dividing by something we know != -1. */
9660 shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
9661 || (TREE_CODE (op1) == INTEGER_CST
9662 && !integer_all_onesp (op1)));
9667 case TRUTH_ANDIF_EXPR:
9668 case TRUTH_ORIF_EXPR:
9669 case TRUTH_AND_EXPR:
9671 case TRUTH_XOR_EXPR:
9672 if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
9673 || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
9674 || code0 == FIXED_POINT_TYPE)
9675 && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
9676 || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
9677 || code1 == FIXED_POINT_TYPE))
9679 /* Result of these operations is always an int,
9680 but that does not mean the operands should be
9681 converted to ints! */
9682 result_type = integer_type_node;
9683 op0 = c_common_truthvalue_conversion (location, op0);
9684 op1 = c_common_truthvalue_conversion (location, op1);
9688 if (code == TRUTH_ANDIF_EXPR)
9690 int_const_or_overflow = (int_operands
9691 && TREE_CODE (orig_op0) == INTEGER_CST
9692 && (op0 == truthvalue_false_node
9693 || TREE_CODE (orig_op1) == INTEGER_CST));
9694 int_const = (int_const_or_overflow
9695 && !TREE_OVERFLOW (orig_op0)
9696 && (op0 == truthvalue_false_node
9697 || !TREE_OVERFLOW (orig_op1)));
9699 else if (code == TRUTH_ORIF_EXPR)
9701 int_const_or_overflow = (int_operands
9702 && TREE_CODE (orig_op0) == INTEGER_CST
9703 && (op0 == truthvalue_true_node
9704 || TREE_CODE (orig_op1) == INTEGER_CST));
9705 int_const = (int_const_or_overflow
9706 && !TREE_OVERFLOW (orig_op0)
9707 && (op0 == truthvalue_true_node
9708 || !TREE_OVERFLOW (orig_op1)));
9712 /* Shift operations: result has same type as first operand;
9713 always convert second operand to int.
9714 Also set SHORT_SHIFT if shifting rightward. */
9717 if (code0 == VECTOR_TYPE && code1 == INTEGER_TYPE
9718 && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE)
9720 result_type = type0;
9723 else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
9724 && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE
9725 && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE
9726 && TYPE_VECTOR_SUBPARTS (type0) == TYPE_VECTOR_SUBPARTS (type1))
9728 result_type = type0;
9731 else if ((code0 == INTEGER_TYPE || code0 == FIXED_POINT_TYPE)
9732 && code1 == INTEGER_TYPE)
9734 if (TREE_CODE (op1) == INTEGER_CST)
9736 if (tree_int_cst_sgn (op1) < 0)
9739 if (c_inhibit_evaluation_warnings == 0)
9740 warning (0, "right shift count is negative");
9744 if (!integer_zerop (op1))
9747 if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
9750 if (c_inhibit_evaluation_warnings == 0)
9751 warning (0, "right shift count >= width of type");
9756 /* Use the type of the value to be shifted. */
9757 result_type = type0;
9758 /* Convert the non vector shift-count to an integer, regardless
9759 of size of value being shifted. */
9760 if (TREE_CODE (TREE_TYPE (op1)) != VECTOR_TYPE
9761 && TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
9762 op1 = convert (integer_type_node, op1);
9763 /* Avoid converting op1 to result_type later. */
9769 if (code0 == VECTOR_TYPE && code1 == INTEGER_TYPE
9770 && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE)
9772 result_type = type0;
9775 else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
9776 && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE
9777 && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE
9778 && TYPE_VECTOR_SUBPARTS (type0) == TYPE_VECTOR_SUBPARTS (type1))
9780 result_type = type0;
9783 else if ((code0 == INTEGER_TYPE || code0 == FIXED_POINT_TYPE)
9784 && code1 == INTEGER_TYPE)
9786 if (TREE_CODE (op1) == INTEGER_CST)
9788 if (tree_int_cst_sgn (op1) < 0)
9791 if (c_inhibit_evaluation_warnings == 0)
9792 warning (0, "left shift count is negative");
9795 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
9798 if (c_inhibit_evaluation_warnings == 0)
9799 warning (0, "left shift count >= width of type");
9803 /* Use the type of the value to be shifted. */
9804 result_type = type0;
9805 /* Convert the non vector shift-count to an integer, regardless
9806 of size of value being shifted. */
9807 if (TREE_CODE (TREE_TYPE (op1)) != VECTOR_TYPE
9808 && TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
9809 op1 = convert (integer_type_node, op1);
9810 /* Avoid converting op1 to result_type later. */
9817 if (FLOAT_TYPE_P (type0) || FLOAT_TYPE_P (type1))
9818 warning_at (location,
9820 "comparing floating point with == or != is unsafe");
9821 /* Result of comparison is always int,
9822 but don't convert the args to int! */
9823 build_type = integer_type_node;
9824 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
9825 || code0 == FIXED_POINT_TYPE || code0 == COMPLEX_TYPE)
9826 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
9827 || code1 == FIXED_POINT_TYPE || code1 == COMPLEX_TYPE))
9829 else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1))
9831 if (TREE_CODE (op0) == ADDR_EXPR
9832 && decl_with_nonnull_addr_p (TREE_OPERAND (op0, 0)))
9834 if (code == EQ_EXPR)
9835 warning_at (location,
9837 "the comparison will always evaluate as %<false%> "
9838 "for the address of %qD will never be NULL",
9839 TREE_OPERAND (op0, 0));
9841 warning_at (location,
9843 "the comparison will always evaluate as %<true%> "
9844 "for the address of %qD will never be NULL",
9845 TREE_OPERAND (op0, 0));
9847 result_type = type0;
9849 else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0))
9851 if (TREE_CODE (op1) == ADDR_EXPR
9852 && decl_with_nonnull_addr_p (TREE_OPERAND (op1, 0)))
9854 if (code == EQ_EXPR)
9855 warning_at (location,
9857 "the comparison will always evaluate as %<false%> "
9858 "for the address of %qD will never be NULL",
9859 TREE_OPERAND (op1, 0));
9861 warning_at (location,
9863 "the comparison will always evaluate as %<true%> "
9864 "for the address of %qD will never be NULL",
9865 TREE_OPERAND (op1, 0));
9867 result_type = type1;
9869 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
9871 tree tt0 = TREE_TYPE (type0);
9872 tree tt1 = TREE_TYPE (type1);
9873 addr_space_t as0 = TYPE_ADDR_SPACE (tt0);
9874 addr_space_t as1 = TYPE_ADDR_SPACE (tt1);
9875 addr_space_t as_common = ADDR_SPACE_GENERIC;
9877 /* Anything compares with void *. void * compares with anything.
9878 Otherwise, the targets must be compatible
9879 and both must be object or both incomplete. */
9880 if (comp_target_types (location, type0, type1))
9881 result_type = common_pointer_type (type0, type1);
9882 else if (!addr_space_superset (as0, as1, &as_common))
9884 error_at (location, "comparison of pointers to "
9885 "disjoint address spaces");
9886 return error_mark_node;
9888 else if (VOID_TYPE_P (tt0))
9890 if (pedantic && TREE_CODE (tt1) == FUNCTION_TYPE)
9891 pedwarn (location, OPT_pedantic, "ISO C forbids "
9892 "comparison of %<void *%> with function pointer");
9894 else if (VOID_TYPE_P (tt1))
9896 if (pedantic && TREE_CODE (tt0) == FUNCTION_TYPE)
9897 pedwarn (location, OPT_pedantic, "ISO C forbids "
9898 "comparison of %<void *%> with function pointer");
9901 /* Avoid warning about the volatile ObjC EH puts on decls. */
9903 pedwarn (location, 0,
9904 "comparison of distinct pointer types lacks a cast");
9906 if (result_type == NULL_TREE)
9908 int qual = ENCODE_QUAL_ADDR_SPACE (as_common);
9909 result_type = build_pointer_type
9910 (build_qualified_type (void_type_node, qual));
9913 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
9915 result_type = type0;
9916 pedwarn (location, 0, "comparison between pointer and integer");
9918 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
9920 result_type = type1;
9921 pedwarn (location, 0, "comparison between pointer and integer");
9929 build_type = integer_type_node;
9930 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
9931 || code0 == FIXED_POINT_TYPE)
9932 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
9933 || code1 == FIXED_POINT_TYPE))
9935 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
9937 addr_space_t as0 = TYPE_ADDR_SPACE (TREE_TYPE (type0));
9938 addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (type1));
9939 addr_space_t as_common;
9941 if (comp_target_types (location, type0, type1))
9943 result_type = common_pointer_type (type0, type1);
9944 if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
9945 != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
9946 pedwarn (location, 0,
9947 "comparison of complete and incomplete pointers");
9948 else if (TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
9949 pedwarn (location, OPT_pedantic, "ISO C forbids "
9950 "ordered comparisons of pointers to functions");
9951 else if (null_pointer_constant_p (orig_op0)
9952 || null_pointer_constant_p (orig_op1))
9953 warning_at (location, OPT_Wextra,
9954 "ordered comparison of pointer with null pointer");
9957 else if (!addr_space_superset (as0, as1, &as_common))
9959 error_at (location, "comparison of pointers to "
9960 "disjoint address spaces");
9961 return error_mark_node;
9965 int qual = ENCODE_QUAL_ADDR_SPACE (as_common);
9966 result_type = build_pointer_type
9967 (build_qualified_type (void_type_node, qual));
9968 pedwarn (location, 0,
9969 "comparison of distinct pointer types lacks a cast");
9972 else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1))
9974 result_type = type0;
9976 pedwarn (location, OPT_pedantic,
9977 "ordered comparison of pointer with integer zero");
9978 else if (extra_warnings)
9979 warning_at (location, OPT_Wextra,
9980 "ordered comparison of pointer with integer zero");
9982 else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0))
9984 result_type = type1;
9986 pedwarn (location, OPT_pedantic,
9987 "ordered comparison of pointer with integer zero");
9988 else if (extra_warnings)
9989 warning_at (location, OPT_Wextra,
9990 "ordered comparison of pointer with integer zero");
9992 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
9994 result_type = type0;
9995 pedwarn (location, 0, "comparison between pointer and integer");
9997 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
9999 result_type = type1;
10000 pedwarn (location, 0, "comparison between pointer and integer");
10005 gcc_unreachable ();
10008 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
10009 return error_mark_node;
10011 if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
10012 && (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1))
10013 || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0),
10014 TREE_TYPE (type1))))
10016 binary_op_error (location, code, type0, type1);
10017 return error_mark_node;
10020 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
10021 || code0 == FIXED_POINT_TYPE || code0 == VECTOR_TYPE)
10023 (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
10024 || code1 == FIXED_POINT_TYPE || code1 == VECTOR_TYPE))
10026 bool first_complex = (code0 == COMPLEX_TYPE);
10027 bool second_complex = (code1 == COMPLEX_TYPE);
10028 int none_complex = (!first_complex && !second_complex);
10030 if (shorten || common || short_compare)
10032 result_type = c_common_type (type0, type1);
10033 do_warn_double_promotion (result_type, type0, type1,
10034 "implicit conversion from %qT to %qT "
10035 "to match other operand of binary "
10038 if (result_type == error_mark_node)
10039 return error_mark_node;
10042 if (first_complex != second_complex
10043 && (code == PLUS_EXPR
10044 || code == MINUS_EXPR
10045 || code == MULT_EXPR
10046 || (code == TRUNC_DIV_EXPR && first_complex))
10047 && TREE_CODE (TREE_TYPE (result_type)) == REAL_TYPE
10048 && flag_signed_zeros)
10050 /* An operation on mixed real/complex operands must be
10051 handled specially, but the language-independent code can
10052 more easily optimize the plain complex arithmetic if
10053 -fno-signed-zeros. */
10054 tree real_type = TREE_TYPE (result_type);
10056 if (type0 != orig_type0 || type1 != orig_type1)
10058 gcc_assert (may_need_excess_precision && common);
10059 semantic_result_type = c_common_type (orig_type0, orig_type1);
10063 if (TREE_TYPE (op0) != result_type)
10064 op0 = convert_and_check (result_type, op0);
10065 if (TREE_TYPE (op1) != real_type)
10066 op1 = convert_and_check (real_type, op1);
10070 if (TREE_TYPE (op0) != real_type)
10071 op0 = convert_and_check (real_type, op0);
10072 if (TREE_TYPE (op1) != result_type)
10073 op1 = convert_and_check (result_type, op1);
10075 if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK)
10076 return error_mark_node;
10079 op0 = c_save_expr (op0);
10080 real = build_unary_op (EXPR_LOCATION (orig_op0), REALPART_EXPR,
10082 imag = build_unary_op (EXPR_LOCATION (orig_op0), IMAGPART_EXPR,
10087 case TRUNC_DIV_EXPR:
10088 imag = build2 (resultcode, real_type, imag, op1);
10089 /* Fall through. */
10092 real = build2 (resultcode, real_type, real, op1);
10100 op1 = c_save_expr (op1);
10101 real = build_unary_op (EXPR_LOCATION (orig_op1), REALPART_EXPR,
10103 imag = build_unary_op (EXPR_LOCATION (orig_op1), IMAGPART_EXPR,
10108 imag = build2 (resultcode, real_type, op0, imag);
10109 /* Fall through. */
10111 real = build2 (resultcode, real_type, op0, real);
10114 real = build2 (resultcode, real_type, op0, real);
10115 imag = build1 (NEGATE_EXPR, real_type, imag);
10121 ret = build2 (COMPLEX_EXPR, result_type, real, imag);
10122 goto return_build_binary_op;
10125 /* For certain operations (which identify themselves by shorten != 0)
10126 if both args were extended from the same smaller type,
10127 do the arithmetic in that type and then extend.
10129 shorten !=0 and !=1 indicates a bitwise operation.
10130 For them, this optimization is safe only if
10131 both args are zero-extended or both are sign-extended.
10132 Otherwise, we might change the result.
10133 Eg, (short)-1 | (unsigned short)-1 is (int)-1
10134 but calculated in (unsigned short) it would be (unsigned short)-1. */
10136 if (shorten && none_complex)
10138 final_type = result_type;
10139 result_type = shorten_binary_op (result_type, op0, op1,
10143 /* Shifts can be shortened if shifting right. */
10148 tree arg0 = get_narrower (op0, &unsigned_arg);
10150 final_type = result_type;
10152 if (arg0 == op0 && final_type == TREE_TYPE (op0))
10153 unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0));
10155 if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
10156 && tree_int_cst_sgn (op1) > 0
10157 /* We can shorten only if the shift count is less than the
10158 number of bits in the smaller type size. */
10159 && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
10160 /* We cannot drop an unsigned shift after sign-extension. */
10161 && (!TYPE_UNSIGNED (final_type) || unsigned_arg))
10163 /* Do an unsigned shift if the operand was zero-extended. */
10165 = c_common_signed_or_unsigned_type (unsigned_arg,
10167 /* Convert value-to-be-shifted to that type. */
10168 if (TREE_TYPE (op0) != result_type)
10169 op0 = convert (result_type, op0);
10174 /* Comparison operations are shortened too but differently.
10175 They identify themselves by setting short_compare = 1. */
10179 /* Don't write &op0, etc., because that would prevent op0
10180 from being kept in a register.
10181 Instead, make copies of the our local variables and
10182 pass the copies by reference, then copy them back afterward. */
10183 tree xop0 = op0, xop1 = op1, xresult_type = result_type;
10184 enum tree_code xresultcode = resultcode;
10186 = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
10191 goto return_build_binary_op;
10194 op0 = xop0, op1 = xop1;
10196 resultcode = xresultcode;
10198 if (c_inhibit_evaluation_warnings == 0)
10200 bool op0_maybe_const = true;
10201 bool op1_maybe_const = true;
10202 tree orig_op0_folded, orig_op1_folded;
10204 if (in_late_binary_op)
10206 orig_op0_folded = orig_op0;
10207 orig_op1_folded = orig_op1;
10211 /* Fold for the sake of possible warnings, as in
10212 build_conditional_expr. This requires the
10213 "original" values to be folded, not just op0 and
10215 c_inhibit_evaluation_warnings++;
10216 op0 = c_fully_fold (op0, require_constant_value,
10218 op1 = c_fully_fold (op1, require_constant_value,
10220 c_inhibit_evaluation_warnings--;
10221 orig_op0_folded = c_fully_fold (orig_op0,
10222 require_constant_value,
10224 orig_op1_folded = c_fully_fold (orig_op1,
10225 require_constant_value,
10229 if (warn_sign_compare)
10230 warn_for_sign_compare (location, orig_op0_folded,
10231 orig_op1_folded, op0, op1,
10232 result_type, resultcode);
10233 if (!in_late_binary_op)
10235 if (!op0_maybe_const || TREE_CODE (op0) != INTEGER_CST)
10236 op0 = c_wrap_maybe_const (op0, !op0_maybe_const);
10237 if (!op1_maybe_const || TREE_CODE (op1) != INTEGER_CST)
10238 op1 = c_wrap_maybe_const (op1, !op1_maybe_const);
10244 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
10245 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
10246 Then the expression will be built.
10247 It will be given type FINAL_TYPE if that is nonzero;
10248 otherwise, it will be given type RESULT_TYPE. */
10252 binary_op_error (location, code, TREE_TYPE (op0), TREE_TYPE (op1));
10253 return error_mark_node;
10256 if (build_type == NULL_TREE)
10258 build_type = result_type;
10259 if ((type0 != orig_type0 || type1 != orig_type1)
10262 gcc_assert (may_need_excess_precision && common);
10263 semantic_result_type = c_common_type (orig_type0, orig_type1);
10269 op0 = ep_convert_and_check (result_type, op0, semantic_result_type);
10270 op1 = ep_convert_and_check (result_type, op1, semantic_result_type);
10272 /* This can happen if one operand has a vector type, and the other
10273 has a different type. */
10274 if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK)
10275 return error_mark_node;
10278 /* Treat expressions in initializers specially as they can't trap. */
10279 if (int_const_or_overflow)
10280 ret = (require_constant_value
10281 ? fold_build2_initializer_loc (location, resultcode, build_type,
10283 : fold_build2_loc (location, resultcode, build_type, op0, op1));
10285 ret = build2 (resultcode, build_type, op0, op1);
10286 if (final_type != 0)
10287 ret = convert (final_type, ret);
10289 return_build_binary_op:
10290 gcc_assert (ret != error_mark_node);
10291 if (TREE_CODE (ret) == INTEGER_CST && !TREE_OVERFLOW (ret) && !int_const)
10292 ret = (int_operands
10293 ? note_integer_operands (ret)
10294 : build1 (NOP_EXPR, TREE_TYPE (ret), ret));
10295 else if (TREE_CODE (ret) != INTEGER_CST && int_operands
10296 && !in_late_binary_op)
10297 ret = note_integer_operands (ret);
10298 if (semantic_result_type)
10299 ret = build1 (EXCESS_PRECISION_EXPR, semantic_result_type, ret);
10300 protected_set_expr_location (ret, location);
10305 /* Convert EXPR to be a truth-value, validating its type for this
10306 purpose. LOCATION is the source location for the expression. */
10309 c_objc_common_truthvalue_conversion (location_t location, tree expr)
10311 bool int_const, int_operands;
10313 switch (TREE_CODE (TREE_TYPE (expr)))
10316 error_at (location, "used array that cannot be converted to pointer where scalar is required");
10317 return error_mark_node;
10320 error_at (location, "used struct type value where scalar is required");
10321 return error_mark_node;
10324 error_at (location, "used union type value where scalar is required");
10325 return error_mark_node;
10327 case FUNCTION_TYPE:
10328 gcc_unreachable ();
10334 int_const = (TREE_CODE (expr) == INTEGER_CST && !TREE_OVERFLOW (expr));
10335 int_operands = EXPR_INT_CONST_OPERANDS (expr);
10337 expr = remove_c_maybe_const_expr (expr);
10339 /* ??? Should we also give an error for void and vectors rather than
10340 leaving those to give errors later? */
10341 expr = c_common_truthvalue_conversion (location, expr);
10343 if (TREE_CODE (expr) == INTEGER_CST && int_operands && !int_const)
10345 if (TREE_OVERFLOW (expr))
10348 return note_integer_operands (expr);
10350 if (TREE_CODE (expr) == INTEGER_CST && !int_const)
10351 return build1 (NOP_EXPR, TREE_TYPE (expr), expr);
10356 /* Convert EXPR to a contained DECL, updating *TC, *TI and *SE as
10360 c_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, bool *se)
10362 if (TREE_CODE (expr) == COMPOUND_LITERAL_EXPR)
10364 tree decl = COMPOUND_LITERAL_EXPR_DECL (expr);
10365 /* Executing a compound literal inside a function reinitializes
10367 if (!TREE_STATIC (decl))
10375 /* Like c_begin_compound_stmt, except force the retention of the BLOCK. */
10378 c_begin_omp_parallel (void)
10382 keep_next_level ();
10383 block = c_begin_compound_stmt (true);
10388 /* Generate OMP_PARALLEL, with CLAUSES and BLOCK as its compound
10389 statement. LOC is the location of the OMP_PARALLEL. */
10392 c_finish_omp_parallel (location_t loc, tree clauses, tree block)
10396 block = c_end_compound_stmt (loc, block, true);
10398 stmt = make_node (OMP_PARALLEL);
10399 TREE_TYPE (stmt) = void_type_node;
10400 OMP_PARALLEL_CLAUSES (stmt) = clauses;
10401 OMP_PARALLEL_BODY (stmt) = block;
10402 SET_EXPR_LOCATION (stmt, loc);
10404 return add_stmt (stmt);
10407 /* Like c_begin_compound_stmt, except force the retention of the BLOCK. */
10410 c_begin_omp_task (void)
10414 keep_next_level ();
10415 block = c_begin_compound_stmt (true);
10420 /* Generate OMP_TASK, with CLAUSES and BLOCK as its compound
10421 statement. LOC is the location of the #pragma. */
10424 c_finish_omp_task (location_t loc, tree clauses, tree block)
10428 block = c_end_compound_stmt (loc, block, true);
10430 stmt = make_node (OMP_TASK);
10431 TREE_TYPE (stmt) = void_type_node;
10432 OMP_TASK_CLAUSES (stmt) = clauses;
10433 OMP_TASK_BODY (stmt) = block;
10434 SET_EXPR_LOCATION (stmt, loc);
10436 return add_stmt (stmt);
10439 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
10440 Remove any elements from the list that are invalid. */
10443 c_finish_omp_clauses (tree clauses)
10445 bitmap_head generic_head, firstprivate_head, lastprivate_head;
10446 tree c, t, *pc = &clauses;
10449 bitmap_obstack_initialize (NULL);
10450 bitmap_initialize (&generic_head, &bitmap_default_obstack);
10451 bitmap_initialize (&firstprivate_head, &bitmap_default_obstack);
10452 bitmap_initialize (&lastprivate_head, &bitmap_default_obstack);
10454 for (pc = &clauses, c = clauses; c ; c = *pc)
10456 bool remove = false;
10457 bool need_complete = false;
10458 bool need_implicitly_determined = false;
10460 switch (OMP_CLAUSE_CODE (c))
10462 case OMP_CLAUSE_SHARED:
10464 need_implicitly_determined = true;
10465 goto check_dup_generic;
10467 case OMP_CLAUSE_PRIVATE:
10469 need_complete = true;
10470 need_implicitly_determined = true;
10471 goto check_dup_generic;
10473 case OMP_CLAUSE_REDUCTION:
10474 name = "reduction";
10475 need_implicitly_determined = true;
10476 t = OMP_CLAUSE_DECL (c);
10477 if (AGGREGATE_TYPE_P (TREE_TYPE (t))
10478 || POINTER_TYPE_P (TREE_TYPE (t)))
10480 error_at (OMP_CLAUSE_LOCATION (c),
10481 "%qE has invalid type for %<reduction%>", t);
10484 else if (FLOAT_TYPE_P (TREE_TYPE (t)))
10486 enum tree_code r_code = OMP_CLAUSE_REDUCTION_CODE (c);
10487 const char *r_name = NULL;
10504 case TRUTH_ANDIF_EXPR:
10507 case TRUTH_ORIF_EXPR:
10511 gcc_unreachable ();
10515 error_at (OMP_CLAUSE_LOCATION (c),
10516 "%qE has invalid type for %<reduction(%s)%>",
10521 goto check_dup_generic;
10523 case OMP_CLAUSE_COPYPRIVATE:
10524 name = "copyprivate";
10525 goto check_dup_generic;
10527 case OMP_CLAUSE_COPYIN:
10529 t = OMP_CLAUSE_DECL (c);
10530 if (TREE_CODE (t) != VAR_DECL || !DECL_THREAD_LOCAL_P (t))
10532 error_at (OMP_CLAUSE_LOCATION (c),
10533 "%qE must be %<threadprivate%> for %<copyin%>", t);
10536 goto check_dup_generic;
10539 t = OMP_CLAUSE_DECL (c);
10540 if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
10542 error_at (OMP_CLAUSE_LOCATION (c),
10543 "%qE is not a variable in clause %qs", t, name);
10546 else if (bitmap_bit_p (&generic_head, DECL_UID (t))
10547 || bitmap_bit_p (&firstprivate_head, DECL_UID (t))
10548 || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
10550 error_at (OMP_CLAUSE_LOCATION (c),
10551 "%qE appears more than once in data clauses", t);
10555 bitmap_set_bit (&generic_head, DECL_UID (t));
10558 case OMP_CLAUSE_FIRSTPRIVATE:
10559 name = "firstprivate";
10560 t = OMP_CLAUSE_DECL (c);
10561 need_complete = true;
10562 need_implicitly_determined = true;
10563 if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
10565 error_at (OMP_CLAUSE_LOCATION (c),
10566 "%qE is not a variable in clause %<firstprivate%>", t);
10569 else if (bitmap_bit_p (&generic_head, DECL_UID (t))
10570 || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
10572 error_at (OMP_CLAUSE_LOCATION (c),
10573 "%qE appears more than once in data clauses", t);
10577 bitmap_set_bit (&firstprivate_head, DECL_UID (t));
10580 case OMP_CLAUSE_LASTPRIVATE:
10581 name = "lastprivate";
10582 t = OMP_CLAUSE_DECL (c);
10583 need_complete = true;
10584 need_implicitly_determined = true;
10585 if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
10587 error_at (OMP_CLAUSE_LOCATION (c),
10588 "%qE is not a variable in clause %<lastprivate%>", t);
10591 else if (bitmap_bit_p (&generic_head, DECL_UID (t))
10592 || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
10594 error_at (OMP_CLAUSE_LOCATION (c),
10595 "%qE appears more than once in data clauses", t);
10599 bitmap_set_bit (&lastprivate_head, DECL_UID (t));
10602 case OMP_CLAUSE_IF:
10603 case OMP_CLAUSE_NUM_THREADS:
10604 case OMP_CLAUSE_SCHEDULE:
10605 case OMP_CLAUSE_NOWAIT:
10606 case OMP_CLAUSE_ORDERED:
10607 case OMP_CLAUSE_DEFAULT:
10608 case OMP_CLAUSE_UNTIED:
10609 case OMP_CLAUSE_COLLAPSE:
10610 pc = &OMP_CLAUSE_CHAIN (c);
10614 gcc_unreachable ();
10619 t = OMP_CLAUSE_DECL (c);
10623 t = require_complete_type (t);
10624 if (t == error_mark_node)
10628 if (need_implicitly_determined)
10630 const char *share_name = NULL;
10632 if (TREE_CODE (t) == VAR_DECL && DECL_THREAD_LOCAL_P (t))
10633 share_name = "threadprivate";
10634 else switch (c_omp_predetermined_sharing (t))
10636 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
10638 case OMP_CLAUSE_DEFAULT_SHARED:
10639 share_name = "shared";
10641 case OMP_CLAUSE_DEFAULT_PRIVATE:
10642 share_name = "private";
10645 gcc_unreachable ();
10649 error_at (OMP_CLAUSE_LOCATION (c),
10650 "%qE is predetermined %qs for %qs",
10651 t, share_name, name);
10658 *pc = OMP_CLAUSE_CHAIN (c);
10660 pc = &OMP_CLAUSE_CHAIN (c);
10663 bitmap_obstack_release (NULL);
10667 /* Make a variant type in the proper way for C/C++, propagating qualifiers
10668 down to the element type of an array. */
10671 c_build_qualified_type (tree type, int type_quals)
10673 if (type == error_mark_node)
10676 if (TREE_CODE (type) == ARRAY_TYPE)
10679 tree element_type = c_build_qualified_type (TREE_TYPE (type),
10682 /* See if we already have an identically qualified type. */
10683 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
10685 if (TYPE_QUALS (strip_array_types (t)) == type_quals
10686 && TYPE_NAME (t) == TYPE_NAME (type)
10687 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
10688 && attribute_list_equal (TYPE_ATTRIBUTES (t),
10689 TYPE_ATTRIBUTES (type)))
10694 tree domain = TYPE_DOMAIN (type);
10696 t = build_variant_type_copy (type);
10697 TREE_TYPE (t) = element_type;
10699 if (TYPE_STRUCTURAL_EQUALITY_P (element_type)
10700 || (domain && TYPE_STRUCTURAL_EQUALITY_P (domain)))
10701 SET_TYPE_STRUCTURAL_EQUALITY (t);
10702 else if (TYPE_CANONICAL (element_type) != element_type
10703 || (domain && TYPE_CANONICAL (domain) != domain))
10705 tree unqualified_canon
10706 = build_array_type (TYPE_CANONICAL (element_type),
10707 domain? TYPE_CANONICAL (domain)
10710 = c_build_qualified_type (unqualified_canon, type_quals);
10713 TYPE_CANONICAL (t) = t;
10718 /* A restrict-qualified pointer type must be a pointer to object or
10719 incomplete type. Note that the use of POINTER_TYPE_P also allows
10720 REFERENCE_TYPEs, which is appropriate for C++. */
10721 if ((type_quals & TYPE_QUAL_RESTRICT)
10722 && (!POINTER_TYPE_P (type)
10723 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
10725 error ("invalid use of %<restrict%>");
10726 type_quals &= ~TYPE_QUAL_RESTRICT;
10729 return build_qualified_type (type, type_quals);
10732 /* Build a VA_ARG_EXPR for the C parser. */
10735 c_build_va_arg (location_t loc, tree expr, tree type)
10737 if (warn_cxx_compat && TREE_CODE (type) == ENUMERAL_TYPE)
10738 warning_at (loc, OPT_Wc___compat,
10739 "C++ requires promoted type, not enum type, in %<va_arg%>");
10740 return build_va_arg (loc, expr, type);