1 /* Build expressions with type checking for C compiler.
2 Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
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"
34 #include "langhooks.h"
44 #include "tree-iterator.h"
45 #include "tree-gimple.h"
47 /* Places where an lvalue, or modifiable lvalue, may be required.
48 Used to select diagnostic messages in lvalue_or_else and
58 /* Possible cases of implicit bad conversions. Used to select
59 diagnostic messages in convert_for_assignment. */
68 /* The level of nesting inside "__alignof__". */
71 /* The level of nesting inside "sizeof". */
74 /* The level of nesting inside "typeof". */
77 /* Nonzero if we've already printed a "missing braces around initializer"
78 message within this initializer. */
79 static int missing_braces_mentioned;
81 static int require_constant_value;
82 static int require_constant_elements;
84 static tree qualify_type (tree, tree);
85 static int tagged_types_tu_compatible_p (tree, tree);
86 static int comp_target_types (tree, tree, int);
87 static int function_types_compatible_p (tree, tree);
88 static int type_lists_compatible_p (tree, tree);
89 static tree decl_constant_value_for_broken_optimization (tree);
90 static tree default_function_array_conversion (tree);
91 static tree lookup_field (tree, tree);
92 static tree convert_arguments (tree, tree, tree, tree);
93 static tree pointer_diff (tree, tree);
94 static tree convert_for_assignment (tree, tree, enum impl_conv, tree, tree,
96 static tree valid_compound_expr_initializer (tree, tree);
97 static void push_string (const char *);
98 static void push_member_name (tree);
99 static void push_array_bounds (int);
100 static int spelling_length (void);
101 static char *print_spelling (char *);
102 static void warning_init (const char *);
103 static tree digest_init (tree, tree, bool, int);
104 static void output_init_element (tree, bool, tree, tree, int);
105 static void output_pending_init_elements (int);
106 static int set_designator (int);
107 static void push_range_stack (tree);
108 static void add_pending_init (tree, tree);
109 static void set_nonincremental_init (void);
110 static void set_nonincremental_init_from_string (tree);
111 static tree find_init_member (tree);
112 static int lvalue_or_else (tree, enum lvalue_use);
113 static void readonly_error (tree, enum lvalue_use);
115 /* Do `exp = require_complete_type (exp);' to make sure exp
116 does not have an incomplete type. (That includes void types.) */
119 require_complete_type (tree value)
121 tree type = TREE_TYPE (value);
123 if (value == error_mark_node || type == error_mark_node)
124 return error_mark_node;
126 /* First, detect a valid value with a complete type. */
127 if (COMPLETE_TYPE_P (type))
130 c_incomplete_type_error (value, type);
131 return error_mark_node;
134 /* Print an error message for invalid use of an incomplete type.
135 VALUE is the expression that was used (or 0 if that isn't known)
136 and TYPE is the type that was invalid. */
139 c_incomplete_type_error (tree value, tree type)
141 const char *type_code_string;
143 /* Avoid duplicate error message. */
144 if (TREE_CODE (type) == ERROR_MARK)
147 if (value != 0 && (TREE_CODE (value) == VAR_DECL
148 || TREE_CODE (value) == PARM_DECL))
149 error ("%qs has an incomplete type",
150 IDENTIFIER_POINTER (DECL_NAME (value)));
154 /* We must print an error message. Be clever about what it says. */
156 switch (TREE_CODE (type))
159 type_code_string = "struct";
163 type_code_string = "union";
167 type_code_string = "enum";
171 error ("invalid use of void expression");
175 if (TYPE_DOMAIN (type))
177 if (TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL)
179 error ("invalid use of flexible array member");
182 type = TREE_TYPE (type);
185 error ("invalid use of array with unspecified bounds");
192 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
193 error ("invalid use of undefined type %<%s %s%>",
194 type_code_string, IDENTIFIER_POINTER (TYPE_NAME (type)));
196 /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
197 error ("invalid use of incomplete typedef %qs",
198 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
202 /* Given a type, apply default promotions wrt unnamed function
203 arguments and return the new type. */
206 c_type_promotes_to (tree type)
208 if (TYPE_MAIN_VARIANT (type) == float_type_node)
209 return double_type_node;
211 if (c_promoting_integer_type_p (type))
213 /* Preserve unsignedness if not really getting any wider. */
214 if (TYPE_UNSIGNED (type)
215 && (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
216 return unsigned_type_node;
217 return integer_type_node;
223 /* Return a variant of TYPE which has all the type qualifiers of LIKE
224 as well as those of TYPE. */
227 qualify_type (tree type, tree like)
229 return c_build_qualified_type (type,
230 TYPE_QUALS (type) | TYPE_QUALS (like));
233 /* Return the composite type of two compatible types.
235 We assume that comptypes has already been done and returned
236 nonzero; if that isn't so, this may crash. In particular, we
237 assume that qualifiers match. */
240 composite_type (tree t1, tree t2)
242 enum tree_code code1;
243 enum tree_code code2;
246 /* Save time if the two types are the same. */
248 if (t1 == t2) return t1;
250 /* If one type is nonsense, use the other. */
251 if (t1 == error_mark_node)
253 if (t2 == error_mark_node)
256 code1 = TREE_CODE (t1);
257 code2 = TREE_CODE (t2);
259 /* Merge the attributes. */
260 attributes = targetm.merge_type_attributes (t1, t2);
262 /* If one is an enumerated type and the other is the compatible
263 integer type, the composite type might be either of the two
264 (DR#013 question 3). For consistency, use the enumerated type as
265 the composite type. */
267 if (code1 == ENUMERAL_TYPE && code2 == INTEGER_TYPE)
269 if (code2 == ENUMERAL_TYPE && code1 == INTEGER_TYPE)
272 gcc_assert (code1 == code2);
277 /* For two pointers, do this recursively on the target type. */
279 tree pointed_to_1 = TREE_TYPE (t1);
280 tree pointed_to_2 = TREE_TYPE (t2);
281 tree target = composite_type (pointed_to_1, pointed_to_2);
282 t1 = build_pointer_type (target);
283 t1 = build_type_attribute_variant (t1, attributes);
284 return qualify_type (t1, t2);
289 tree elt = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
291 /* We should not have any type quals on arrays at all. */
292 gcc_assert (!TYPE_QUALS (t1) && !TYPE_QUALS (t2));
294 /* Save space: see if the result is identical to one of the args. */
295 if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
296 return build_type_attribute_variant (t1, attributes);
297 if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
298 return build_type_attribute_variant (t2, attributes);
300 if (elt == TREE_TYPE (t1) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1))
301 return build_type_attribute_variant (t1, attributes);
302 if (elt == TREE_TYPE (t2) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1))
303 return build_type_attribute_variant (t2, attributes);
305 /* Merge the element types, and have a size if either arg has one. */
306 t1 = build_array_type (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
307 return build_type_attribute_variant (t1, attributes);
311 /* Function types: prefer the one that specified arg types.
312 If both do, merge the arg types. Also merge the return types. */
314 tree valtype = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
315 tree p1 = TYPE_ARG_TYPES (t1);
316 tree p2 = TYPE_ARG_TYPES (t2);
321 /* Save space: see if the result is identical to one of the args. */
322 if (valtype == TREE_TYPE (t1) && !TYPE_ARG_TYPES (t2))
323 return build_type_attribute_variant (t1, attributes);
324 if (valtype == TREE_TYPE (t2) && !TYPE_ARG_TYPES (t1))
325 return build_type_attribute_variant (t2, attributes);
327 /* Simple way if one arg fails to specify argument types. */
328 if (TYPE_ARG_TYPES (t1) == 0)
330 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2));
331 t1 = build_type_attribute_variant (t1, attributes);
332 return qualify_type (t1, t2);
334 if (TYPE_ARG_TYPES (t2) == 0)
336 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1));
337 t1 = build_type_attribute_variant (t1, attributes);
338 return qualify_type (t1, t2);
341 /* If both args specify argument types, we must merge the two
342 lists, argument by argument. */
343 /* Tell global_bindings_p to return false so that variable_size
344 doesn't abort on VLAs in parameter types. */
345 c_override_global_bindings_to_false = true;
347 len = list_length (p1);
350 for (i = 0; i < len; i++)
351 newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
356 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n))
358 /* A null type means arg type is not specified.
359 Take whatever the other function type has. */
360 if (TREE_VALUE (p1) == 0)
362 TREE_VALUE (n) = TREE_VALUE (p2);
365 if (TREE_VALUE (p2) == 0)
367 TREE_VALUE (n) = TREE_VALUE (p1);
371 /* Given wait (union {union wait *u; int *i} *)
372 and wait (union wait *),
373 prefer union wait * as type of parm. */
374 if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE
375 && TREE_VALUE (p1) != TREE_VALUE (p2))
378 for (memb = TYPE_FIELDS (TREE_VALUE (p1));
379 memb; memb = TREE_CHAIN (memb))
380 if (comptypes (TREE_TYPE (memb), TREE_VALUE (p2)))
382 TREE_VALUE (n) = TREE_VALUE (p2);
384 pedwarn ("function types not truly compatible in ISO C");
388 if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE
389 && TREE_VALUE (p2) != TREE_VALUE (p1))
392 for (memb = TYPE_FIELDS (TREE_VALUE (p2));
393 memb; memb = TREE_CHAIN (memb))
394 if (comptypes (TREE_TYPE (memb), TREE_VALUE (p1)))
396 TREE_VALUE (n) = TREE_VALUE (p1);
398 pedwarn ("function types not truly compatible in ISO C");
402 TREE_VALUE (n) = composite_type (TREE_VALUE (p1), TREE_VALUE (p2));
406 c_override_global_bindings_to_false = false;
407 t1 = build_function_type (valtype, newargs);
408 t1 = qualify_type (t1, t2);
409 /* ... falls through ... */
413 return build_type_attribute_variant (t1, attributes);
418 /* Return the type of a conditional expression between pointers to
419 possibly differently qualified versions of compatible types.
421 We assume that comp_target_types has already been done and returned
422 nonzero; if that isn't so, this may crash. */
425 common_pointer_type (tree t1, tree t2)
432 /* Save time if the two types are the same. */
434 if (t1 == t2) return t1;
436 /* If one type is nonsense, use the other. */
437 if (t1 == error_mark_node)
439 if (t2 == error_mark_node)
442 gcc_assert (TREE_CODE (t1) == POINTER_TYPE
443 && TREE_CODE (t2) == POINTER_TYPE);
445 /* Merge the attributes. */
446 attributes = targetm.merge_type_attributes (t1, t2);
448 /* Find the composite type of the target types, and combine the
449 qualifiers of the two types' targets. */
450 pointed_to_1 = TREE_TYPE (t1);
451 pointed_to_2 = TREE_TYPE (t2);
452 target = composite_type (TYPE_MAIN_VARIANT (pointed_to_1),
453 TYPE_MAIN_VARIANT (pointed_to_2));
454 t1 = build_pointer_type (c_build_qualified_type
456 TYPE_QUALS (pointed_to_1) |
457 TYPE_QUALS (pointed_to_2)));
458 return build_type_attribute_variant (t1, attributes);
461 /* Return the common type for two arithmetic types under the usual
462 arithmetic conversions. The default conversions have already been
463 applied, and enumerated types converted to their compatible integer
464 types. The resulting type is unqualified and has no attributes.
466 This is the type for the result of most arithmetic operations
467 if the operands have the given two types. */
470 common_type (tree t1, tree t2)
472 enum tree_code code1;
473 enum tree_code code2;
475 /* If one type is nonsense, use the other. */
476 if (t1 == error_mark_node)
478 if (t2 == error_mark_node)
481 if (TYPE_QUALS (t1) != TYPE_UNQUALIFIED)
482 t1 = TYPE_MAIN_VARIANT (t1);
484 if (TYPE_QUALS (t2) != TYPE_UNQUALIFIED)
485 t2 = TYPE_MAIN_VARIANT (t2);
487 if (TYPE_ATTRIBUTES (t1) != NULL_TREE)
488 t1 = build_type_attribute_variant (t1, NULL_TREE);
490 if (TYPE_ATTRIBUTES (t2) != NULL_TREE)
491 t2 = build_type_attribute_variant (t2, NULL_TREE);
493 /* Save time if the two types are the same. */
495 if (t1 == t2) return t1;
497 code1 = TREE_CODE (t1);
498 code2 = TREE_CODE (t2);
500 gcc_assert (code1 == VECTOR_TYPE || code1 == COMPLEX_TYPE
501 || code1 == REAL_TYPE || code1 == INTEGER_TYPE);
502 gcc_assert (code2 == VECTOR_TYPE || code2 == COMPLEX_TYPE
503 || code2 == REAL_TYPE || code2 == INTEGER_TYPE);
505 /* If one type is a vector type, return that type. (How the usual
506 arithmetic conversions apply to the vector types extension is not
507 precisely specified.) */
508 if (code1 == VECTOR_TYPE)
511 if (code2 == VECTOR_TYPE)
514 /* If one type is complex, form the common type of the non-complex
515 components, then make that complex. Use T1 or T2 if it is the
517 if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
519 tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
520 tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
521 tree subtype = common_type (subtype1, subtype2);
523 if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
525 else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
528 return build_complex_type (subtype);
531 /* If only one is real, use it as the result. */
533 if (code1 == REAL_TYPE && code2 != REAL_TYPE)
536 if (code2 == REAL_TYPE && code1 != REAL_TYPE)
539 /* Both real or both integers; use the one with greater precision. */
541 if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
543 else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
546 /* Same precision. Prefer long longs to longs to ints when the
547 same precision, following the C99 rules on integer type rank
548 (which are equivalent to the C90 rules for C90 types). */
550 if (TYPE_MAIN_VARIANT (t1) == long_long_unsigned_type_node
551 || TYPE_MAIN_VARIANT (t2) == long_long_unsigned_type_node)
552 return long_long_unsigned_type_node;
554 if (TYPE_MAIN_VARIANT (t1) == long_long_integer_type_node
555 || TYPE_MAIN_VARIANT (t2) == long_long_integer_type_node)
557 if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
558 return long_long_unsigned_type_node;
560 return long_long_integer_type_node;
563 if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
564 || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
565 return long_unsigned_type_node;
567 if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
568 || TYPE_MAIN_VARIANT (t2) == long_integer_type_node)
570 /* But preserve unsignedness from the other type,
571 since long cannot hold all the values of an unsigned int. */
572 if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
573 return long_unsigned_type_node;
575 return long_integer_type_node;
578 /* Likewise, prefer long double to double even if same size. */
579 if (TYPE_MAIN_VARIANT (t1) == long_double_type_node
580 || TYPE_MAIN_VARIANT (t2) == long_double_type_node)
581 return long_double_type_node;
583 /* Otherwise prefer the unsigned one. */
585 if (TYPE_UNSIGNED (t1))
591 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
592 or various other operations. Return 2 if they are compatible
593 but a warning may be needed if you use them together. */
596 comptypes (tree type1, tree type2)
602 /* Suppress errors caused by previously reported errors. */
604 if (t1 == t2 || !t1 || !t2
605 || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK)
608 /* If either type is the internal version of sizetype, return the
610 if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1)
611 && TYPE_ORIG_SIZE_TYPE (t1))
612 t1 = TYPE_ORIG_SIZE_TYPE (t1);
614 if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2)
615 && TYPE_ORIG_SIZE_TYPE (t2))
616 t2 = TYPE_ORIG_SIZE_TYPE (t2);
619 /* Enumerated types are compatible with integer types, but this is
620 not transitive: two enumerated types in the same translation unit
621 are compatible with each other only if they are the same type. */
623 if (TREE_CODE (t1) == ENUMERAL_TYPE && TREE_CODE (t2) != ENUMERAL_TYPE)
624 t1 = c_common_type_for_size (TYPE_PRECISION (t1), TYPE_UNSIGNED (t1));
625 else if (TREE_CODE (t2) == ENUMERAL_TYPE && TREE_CODE (t1) != ENUMERAL_TYPE)
626 t2 = c_common_type_for_size (TYPE_PRECISION (t2), TYPE_UNSIGNED (t2));
631 /* Different classes of types can't be compatible. */
633 if (TREE_CODE (t1) != TREE_CODE (t2))
636 /* Qualifiers must match. C99 6.7.3p9 */
638 if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
641 /* Allow for two different type nodes which have essentially the same
642 definition. Note that we already checked for equality of the type
643 qualifiers (just above). */
645 if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
648 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
649 if (!(attrval = targetm.comp_type_attributes (t1, t2)))
652 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
655 switch (TREE_CODE (t1))
658 /* We must give ObjC the first crack at comparing pointers, since
659 protocol qualifiers may be involved. */
660 if (c_dialect_objc () && (val = objc_comptypes (t1, t2, 0)) >= 0)
662 /* Do not remove mode or aliasing information. */
663 if (TYPE_MODE (t1) != TYPE_MODE (t2)
664 || TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2))
666 val = (TREE_TYPE (t1) == TREE_TYPE (t2)
667 ? 1 : comptypes (TREE_TYPE (t1), TREE_TYPE (t2)));
671 val = function_types_compatible_p (t1, t2);
676 tree d1 = TYPE_DOMAIN (t1);
677 tree d2 = TYPE_DOMAIN (t2);
678 bool d1_variable, d2_variable;
679 bool d1_zero, d2_zero;
682 /* Target types must match incl. qualifiers. */
683 if (TREE_TYPE (t1) != TREE_TYPE (t2)
684 && 0 == (val = comptypes (TREE_TYPE (t1), TREE_TYPE (t2))))
687 /* Sizes must match unless one is missing or variable. */
688 if (d1 == 0 || d2 == 0 || d1 == d2)
691 d1_zero = !TYPE_MAX_VALUE (d1);
692 d2_zero = !TYPE_MAX_VALUE (d2);
694 d1_variable = (!d1_zero
695 && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
696 || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
697 d2_variable = (!d2_zero
698 && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
699 || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
701 if (d1_variable || d2_variable)
703 if (d1_zero && d2_zero)
705 if (d1_zero || d2_zero
706 || !tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2))
707 || !tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2)))
714 /* We are dealing with two distinct structs. In assorted Objective-C
715 corner cases, however, these can still be deemed equivalent. */
716 if (c_dialect_objc () && objc_comptypes (t1, t2, 0) == 1)
721 if (val != 1 && !same_translation_unit_p (t1, t2))
722 val = tagged_types_tu_compatible_p (t1, t2);
726 val = TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
727 && comptypes (TREE_TYPE (t1), TREE_TYPE (t2));
733 return attrval == 2 && val == 1 ? 2 : val;
736 /* Return 1 if TTL and TTR are pointers to types that are equivalent,
737 ignoring their qualifiers. REFLEXIVE is only used by ObjC - set it
738 to 1 or 0 depending if the check of the pointer types is meant to
739 be reflexive or not (typically, assignments are not reflexive,
740 while comparisons are reflexive).
744 comp_target_types (tree ttl, tree ttr, int reflexive)
748 /* Give objc_comptypes a crack at letting these types through. */
749 if ((val = objc_comptypes (ttl, ttr, reflexive)) >= 0)
752 val = comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ttl)),
753 TYPE_MAIN_VARIANT (TREE_TYPE (ttr)));
755 if (val == 2 && pedantic)
756 pedwarn ("types are not quite compatible");
760 /* Subroutines of `comptypes'. */
762 /* Determine whether two trees derive from the same translation unit.
763 If the CONTEXT chain ends in a null, that tree's context is still
764 being parsed, so if two trees have context chains ending in null,
765 they're in the same translation unit. */
767 same_translation_unit_p (tree t1, tree t2)
769 while (t1 && TREE_CODE (t1) != TRANSLATION_UNIT_DECL)
770 switch (TREE_CODE_CLASS (TREE_CODE (t1)))
772 case tcc_declaration:
773 t1 = DECL_CONTEXT (t1); break;
775 t1 = TYPE_CONTEXT (t1); break;
776 case tcc_exceptional:
777 t1 = BLOCK_SUPERCONTEXT (t1); break; /* assume block */
778 default: gcc_unreachable ();
781 while (t2 && TREE_CODE (t2) != TRANSLATION_UNIT_DECL)
782 switch (TREE_CODE_CLASS (TREE_CODE (t2)))
784 case tcc_declaration:
785 t2 = DECL_CONTEXT (t2); break;
787 t2 = TYPE_CONTEXT (t2); break;
788 case tcc_exceptional:
789 t2 = BLOCK_SUPERCONTEXT (t2); break; /* assume block */
790 default: gcc_unreachable ();
796 /* The C standard says that two structures in different translation
797 units are compatible with each other only if the types of their
798 fields are compatible (among other things). So, consider two copies
799 of this structure: */
801 struct tagged_tu_seen {
802 const struct tagged_tu_seen * next;
807 /* Can they be compatible with each other? We choose to break the
808 recursion by allowing those types to be compatible. */
810 static const struct tagged_tu_seen * tagged_tu_seen_base;
812 /* Return 1 if two 'struct', 'union', or 'enum' types T1 and T2 are
813 compatible. If the two types are not the same (which has been
814 checked earlier), this can only happen when multiple translation
815 units are being compiled. See C99 6.2.7 paragraph 1 for the exact
819 tagged_types_tu_compatible_p (tree t1, tree t2)
822 bool needs_warning = false;
824 /* We have to verify that the tags of the types are the same. This
825 is harder than it looks because this may be a typedef, so we have
826 to go look at the original type. It may even be a typedef of a
828 In the case of compiler-created builtin structs the TYPE_DECL
829 may be a dummy, with no DECL_ORIGINAL_TYPE. Don't fault. */
830 while (TYPE_NAME (t1)
831 && TREE_CODE (TYPE_NAME (t1)) == TYPE_DECL
832 && DECL_ORIGINAL_TYPE (TYPE_NAME (t1)))
833 t1 = DECL_ORIGINAL_TYPE (TYPE_NAME (t1));
835 while (TYPE_NAME (t2)
836 && TREE_CODE (TYPE_NAME (t2)) == TYPE_DECL
837 && DECL_ORIGINAL_TYPE (TYPE_NAME (t2)))
838 t2 = DECL_ORIGINAL_TYPE (TYPE_NAME (t2));
840 /* C90 didn't have the requirement that the two tags be the same. */
841 if (flag_isoc99 && TYPE_NAME (t1) != TYPE_NAME (t2))
844 /* C90 didn't say what happened if one or both of the types were
845 incomplete; we choose to follow C99 rules here, which is that they
847 if (TYPE_SIZE (t1) == NULL
848 || TYPE_SIZE (t2) == NULL)
852 const struct tagged_tu_seen * tts_i;
853 for (tts_i = tagged_tu_seen_base; tts_i != NULL; tts_i = tts_i->next)
854 if (tts_i->t1 == t1 && tts_i->t2 == t2)
858 switch (TREE_CODE (t1))
863 /* Speed up the case where the type values are in the same order. */
864 tree tv1 = TYPE_VALUES (t1);
865 tree tv2 = TYPE_VALUES (t2);
870 for (;tv1 && tv2; tv1 = TREE_CHAIN (tv1), tv2 = TREE_CHAIN (tv2))
872 if (TREE_PURPOSE (tv1) != TREE_PURPOSE (tv2))
874 if (simple_cst_equal (TREE_VALUE (tv1), TREE_VALUE (tv2)) != 1)
878 if (tv1 == NULL_TREE && tv2 == NULL_TREE)
880 if (tv1 == NULL_TREE || tv2 == NULL_TREE)
883 if (list_length (TYPE_VALUES (t1)) != list_length (TYPE_VALUES (t2)))
886 for (s1 = TYPE_VALUES (t1); s1; s1 = TREE_CHAIN (s1))
888 s2 = purpose_member (TREE_PURPOSE (s1), TYPE_VALUES (t2));
890 || simple_cst_equal (TREE_VALUE (s1), TREE_VALUE (s2)) != 1)
898 if (list_length (TYPE_FIELDS (t1)) != list_length (TYPE_FIELDS (t2)))
901 for (s1 = TYPE_FIELDS (t1); s1; s1 = TREE_CHAIN (s1))
904 struct tagged_tu_seen tts;
906 tts.next = tagged_tu_seen_base;
909 tagged_tu_seen_base = &tts;
911 if (DECL_NAME (s1) != NULL)
912 for (s2 = TYPE_FIELDS (t2); s2; s2 = TREE_CHAIN (s2))
913 if (DECL_NAME (s1) == DECL_NAME (s2))
916 result = comptypes (TREE_TYPE (s1), TREE_TYPE (s2));
920 needs_warning = true;
922 if (TREE_CODE (s1) == FIELD_DECL
923 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
924 DECL_FIELD_BIT_OFFSET (s2)) != 1)
930 tagged_tu_seen_base = tts.next;
934 return needs_warning ? 2 : 1;
939 struct tagged_tu_seen tts;
941 tts.next = tagged_tu_seen_base;
944 tagged_tu_seen_base = &tts;
946 for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2);
948 s1 = TREE_CHAIN (s1), s2 = TREE_CHAIN (s2))
951 if (TREE_CODE (s1) != TREE_CODE (s2)
952 || DECL_NAME (s1) != DECL_NAME (s2))
954 result = comptypes (TREE_TYPE (s1), TREE_TYPE (s2));
958 needs_warning = true;
960 if (TREE_CODE (s1) == FIELD_DECL
961 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
962 DECL_FIELD_BIT_OFFSET (s2)) != 1)
965 tagged_tu_seen_base = tts.next;
968 return needs_warning ? 2 : 1;
976 /* Return 1 if two function types F1 and F2 are compatible.
977 If either type specifies no argument types,
978 the other must specify a fixed number of self-promoting arg types.
979 Otherwise, if one type specifies only the number of arguments,
980 the other must specify that number of self-promoting arg types.
981 Otherwise, the argument types must match. */
984 function_types_compatible_p (tree f1, tree f2)
987 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
992 ret1 = TREE_TYPE (f1);
993 ret2 = TREE_TYPE (f2);
995 /* 'volatile' qualifiers on a function's return type used to mean
996 the function is noreturn. */
997 if (TYPE_VOLATILE (ret1) != TYPE_VOLATILE (ret2))
998 pedwarn ("function return types not compatible due to %<volatile%>");
999 if (TYPE_VOLATILE (ret1))
1000 ret1 = build_qualified_type (TYPE_MAIN_VARIANT (ret1),
1001 TYPE_QUALS (ret1) & ~TYPE_QUAL_VOLATILE);
1002 if (TYPE_VOLATILE (ret2))
1003 ret2 = build_qualified_type (TYPE_MAIN_VARIANT (ret2),
1004 TYPE_QUALS (ret2) & ~TYPE_QUAL_VOLATILE);
1005 val = comptypes (ret1, ret2);
1009 args1 = TYPE_ARG_TYPES (f1);
1010 args2 = TYPE_ARG_TYPES (f2);
1012 /* An unspecified parmlist matches any specified parmlist
1013 whose argument types don't need default promotions. */
1017 if (!self_promoting_args_p (args2))
1019 /* If one of these types comes from a non-prototype fn definition,
1020 compare that with the other type's arglist.
1021 If they don't match, ask for a warning (but no error). */
1022 if (TYPE_ACTUAL_ARG_TYPES (f1)
1023 && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1)))
1029 if (!self_promoting_args_p (args1))
1031 if (TYPE_ACTUAL_ARG_TYPES (f2)
1032 && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2)))
1037 /* Both types have argument lists: compare them and propagate results. */
1038 val1 = type_lists_compatible_p (args1, args2);
1039 return val1 != 1 ? val1 : val;
1042 /* Check two lists of types for compatibility,
1043 returning 0 for incompatible, 1 for compatible,
1044 or 2 for compatible with warning. */
1047 type_lists_compatible_p (tree args1, tree args2)
1049 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
1055 if (args1 == 0 && args2 == 0)
1057 /* If one list is shorter than the other,
1058 they fail to match. */
1059 if (args1 == 0 || args2 == 0)
1061 /* A null pointer instead of a type
1062 means there is supposed to be an argument
1063 but nothing is specified about what type it has.
1064 So match anything that self-promotes. */
1065 if (TREE_VALUE (args1) == 0)
1067 if (c_type_promotes_to (TREE_VALUE (args2)) != TREE_VALUE (args2))
1070 else if (TREE_VALUE (args2) == 0)
1072 if (c_type_promotes_to (TREE_VALUE (args1)) != TREE_VALUE (args1))
1075 /* If one of the lists has an error marker, ignore this arg. */
1076 else if (TREE_CODE (TREE_VALUE (args1)) == ERROR_MARK
1077 || TREE_CODE (TREE_VALUE (args2)) == ERROR_MARK)
1079 else if (!(newval = comptypes (TYPE_MAIN_VARIANT (TREE_VALUE (args1)),
1080 TYPE_MAIN_VARIANT (TREE_VALUE (args2)))))
1082 /* Allow wait (union {union wait *u; int *i} *)
1083 and wait (union wait *) to be compatible. */
1084 if (TREE_CODE (TREE_VALUE (args1)) == UNION_TYPE
1085 && (TYPE_NAME (TREE_VALUE (args1)) == 0
1086 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args1)))
1087 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args1))) == INTEGER_CST
1088 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args1)),
1089 TYPE_SIZE (TREE_VALUE (args2))))
1092 for (memb = TYPE_FIELDS (TREE_VALUE (args1));
1093 memb; memb = TREE_CHAIN (memb))
1094 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args2)))
1099 else if (TREE_CODE (TREE_VALUE (args2)) == UNION_TYPE
1100 && (TYPE_NAME (TREE_VALUE (args2)) == 0
1101 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args2)))
1102 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args2))) == INTEGER_CST
1103 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args2)),
1104 TYPE_SIZE (TREE_VALUE (args1))))
1107 for (memb = TYPE_FIELDS (TREE_VALUE (args2));
1108 memb; memb = TREE_CHAIN (memb))
1109 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args1)))
1118 /* comptypes said ok, but record if it said to warn. */
1122 args1 = TREE_CHAIN (args1);
1123 args2 = TREE_CHAIN (args2);
1127 /* Compute the size to increment a pointer by. */
1130 c_size_in_bytes (tree type)
1132 enum tree_code code = TREE_CODE (type);
1134 if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
1135 return size_one_node;
1137 if (!COMPLETE_OR_VOID_TYPE_P (type))
1139 error ("arithmetic on pointer to an incomplete type");
1140 return size_one_node;
1143 /* Convert in case a char is more than one unit. */
1144 return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
1145 size_int (TYPE_PRECISION (char_type_node)
1149 /* Return either DECL or its known constant value (if it has one). */
1152 decl_constant_value (tree decl)
1154 if (/* Don't change a variable array bound or initial value to a constant
1155 in a place where a variable is invalid. Note that DECL_INITIAL
1156 isn't valid for a PARM_DECL. */
1157 current_function_decl != 0
1158 && TREE_CODE (decl) != PARM_DECL
1159 && !TREE_THIS_VOLATILE (decl)
1160 && TREE_READONLY (decl)
1161 && DECL_INITIAL (decl) != 0
1162 && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
1163 /* This is invalid if initial value is not constant.
1164 If it has either a function call, a memory reference,
1165 or a variable, then re-evaluating it could give different results. */
1166 && TREE_CONSTANT (DECL_INITIAL (decl))
1167 /* Check for cases where this is sub-optimal, even though valid. */
1168 && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
1169 return DECL_INITIAL (decl);
1173 /* Return either DECL or its known constant value (if it has one), but
1174 return DECL if pedantic or DECL has mode BLKmode. This is for
1175 bug-compatibility with the old behavior of decl_constant_value
1176 (before GCC 3.0); every use of this function is a bug and it should
1177 be removed before GCC 3.1. It is not appropriate to use pedantic
1178 in a way that affects optimization, and BLKmode is probably not the
1179 right test for avoiding misoptimizations either. */
1182 decl_constant_value_for_broken_optimization (tree decl)
1184 if (pedantic || DECL_MODE (decl) == BLKmode)
1187 return decl_constant_value (decl);
1191 /* Perform the default conversion of arrays and functions to pointers.
1192 Return the result of converting EXP. For any other expression, just
1196 default_function_array_conversion (tree exp)
1199 tree type = TREE_TYPE (exp);
1200 enum tree_code code = TREE_CODE (type);
1203 /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
1206 Do not use STRIP_NOPS here! It will remove conversions from pointer
1207 to integer and cause infinite recursion. */
1209 while (TREE_CODE (exp) == NON_LVALUE_EXPR
1210 || (TREE_CODE (exp) == NOP_EXPR
1211 && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
1213 if (TREE_CODE (exp) == NON_LVALUE_EXPR)
1215 exp = TREE_OPERAND (exp, 0);
1218 if (TREE_NO_WARNING (orig_exp))
1219 TREE_NO_WARNING (exp) = 1;
1221 if (code == FUNCTION_TYPE)
1223 return build_unary_op (ADDR_EXPR, exp, 0);
1225 if (code == ARRAY_TYPE)
1228 tree restype = TREE_TYPE (type);
1234 if (REFERENCE_CLASS_P (exp) || DECL_P (exp))
1236 constp = TREE_READONLY (exp);
1237 volatilep = TREE_THIS_VOLATILE (exp);
1240 if (TYPE_QUALS (type) || constp || volatilep)
1242 = c_build_qualified_type (restype,
1244 | (constp * TYPE_QUAL_CONST)
1245 | (volatilep * TYPE_QUAL_VOLATILE));
1247 if (TREE_CODE (exp) == INDIRECT_REF)
1248 return convert (build_pointer_type (restype),
1249 TREE_OPERAND (exp, 0));
1251 if (TREE_CODE (exp) == COMPOUND_EXPR)
1253 tree op1 = default_conversion (TREE_OPERAND (exp, 1));
1254 return build2 (COMPOUND_EXPR, TREE_TYPE (op1),
1255 TREE_OPERAND (exp, 0), op1);
1258 lvalue_array_p = !not_lvalue && lvalue_p (exp);
1259 if (!flag_isoc99 && !lvalue_array_p)
1261 /* Before C99, non-lvalue arrays do not decay to pointers.
1262 Normally, using such an array would be invalid; but it can
1263 be used correctly inside sizeof or as a statement expression.
1264 Thus, do not give an error here; an error will result later. */
1268 ptrtype = build_pointer_type (restype);
1270 if (TREE_CODE (exp) == VAR_DECL)
1272 /* We are making an ADDR_EXPR of ptrtype. This is a valid
1273 ADDR_EXPR because it's the best way of representing what
1274 happens in C when we take the address of an array and place
1275 it in a pointer to the element type. */
1276 adr = build1 (ADDR_EXPR, ptrtype, exp);
1277 if (!c_mark_addressable (exp))
1278 return error_mark_node;
1279 TREE_SIDE_EFFECTS (adr) = 0; /* Default would be, same as EXP. */
1282 /* This way is better for a COMPONENT_REF since it can
1283 simplify the offset for a component. */
1284 adr = build_unary_op (ADDR_EXPR, exp, 1);
1285 return convert (ptrtype, adr);
1290 /* Perform default promotions for C data used in expressions.
1291 Arrays and functions are converted to pointers;
1292 enumeral types or short or char, to int.
1293 In addition, manifest constants symbols are replaced by their values. */
1296 default_conversion (tree exp)
1299 tree type = TREE_TYPE (exp);
1300 enum tree_code code = TREE_CODE (type);
1302 if (code == FUNCTION_TYPE || code == ARRAY_TYPE)
1303 return default_function_array_conversion (exp);
1305 /* Constants can be used directly unless they're not loadable. */
1306 if (TREE_CODE (exp) == CONST_DECL)
1307 exp = DECL_INITIAL (exp);
1309 /* Replace a nonvolatile const static variable with its value unless
1310 it is an array, in which case we must be sure that taking the
1311 address of the array produces consistent results. */
1312 else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE)
1314 exp = decl_constant_value_for_broken_optimization (exp);
1315 type = TREE_TYPE (exp);
1318 /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
1321 Do not use STRIP_NOPS here! It will remove conversions from pointer
1322 to integer and cause infinite recursion. */
1324 while (TREE_CODE (exp) == NON_LVALUE_EXPR
1325 || (TREE_CODE (exp) == NOP_EXPR
1326 && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
1327 exp = TREE_OPERAND (exp, 0);
1329 if (TREE_NO_WARNING (orig_exp))
1330 TREE_NO_WARNING (exp) = 1;
1332 /* Normally convert enums to int,
1333 but convert wide enums to something wider. */
1334 if (code == ENUMERAL_TYPE)
1336 type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
1337 TYPE_PRECISION (integer_type_node)),
1338 ((TYPE_PRECISION (type)
1339 >= TYPE_PRECISION (integer_type_node))
1340 && TYPE_UNSIGNED (type)));
1342 return convert (type, exp);
1345 if (TREE_CODE (exp) == COMPONENT_REF
1346 && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1))
1347 /* If it's thinner than an int, promote it like a
1348 c_promoting_integer_type_p, otherwise leave it alone. */
1349 && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
1350 TYPE_PRECISION (integer_type_node)))
1351 return convert (integer_type_node, exp);
1353 if (c_promoting_integer_type_p (type))
1355 /* Preserve unsignedness if not really getting any wider. */
1356 if (TYPE_UNSIGNED (type)
1357 && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1358 return convert (unsigned_type_node, exp);
1360 return convert (integer_type_node, exp);
1363 if (code == VOID_TYPE)
1365 error ("void value not ignored as it ought to be");
1366 return error_mark_node;
1371 /* Look up COMPONENT in a structure or union DECL.
1373 If the component name is not found, returns NULL_TREE. Otherwise,
1374 the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL
1375 stepping down the chain to the component, which is in the last
1376 TREE_VALUE of the list. Normally the list is of length one, but if
1377 the component is embedded within (nested) anonymous structures or
1378 unions, the list steps down the chain to the component. */
1381 lookup_field (tree decl, tree component)
1383 tree type = TREE_TYPE (decl);
1386 /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
1387 to the field elements. Use a binary search on this array to quickly
1388 find the element. Otherwise, do a linear search. TYPE_LANG_SPECIFIC
1389 will always be set for structures which have many elements. */
1391 if (TYPE_LANG_SPECIFIC (type))
1394 tree *field_array = &TYPE_LANG_SPECIFIC (type)->s->elts[0];
1396 field = TYPE_FIELDS (type);
1398 top = TYPE_LANG_SPECIFIC (type)->s->len;
1399 while (top - bot > 1)
1401 half = (top - bot + 1) >> 1;
1402 field = field_array[bot+half];
1404 if (DECL_NAME (field) == NULL_TREE)
1406 /* Step through all anon unions in linear fashion. */
1407 while (DECL_NAME (field_array[bot]) == NULL_TREE)
1409 field = field_array[bot++];
1410 if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1411 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
1413 tree anon = lookup_field (field, component);
1416 return tree_cons (NULL_TREE, field, anon);
1420 /* Entire record is only anon unions. */
1424 /* Restart the binary search, with new lower bound. */
1428 if (DECL_NAME (field) == component)
1430 if (DECL_NAME (field) < component)
1436 if (DECL_NAME (field_array[bot]) == component)
1437 field = field_array[bot];
1438 else if (DECL_NAME (field) != component)
1443 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1445 if (DECL_NAME (field) == NULL_TREE
1446 && (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1447 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE))
1449 tree anon = lookup_field (field, component);
1452 return tree_cons (NULL_TREE, field, anon);
1455 if (DECL_NAME (field) == component)
1459 if (field == NULL_TREE)
1463 return tree_cons (NULL_TREE, field, NULL_TREE);
1466 /* Make an expression to refer to the COMPONENT field of
1467 structure or union value DATUM. COMPONENT is an IDENTIFIER_NODE. */
1470 build_component_ref (tree datum, tree component)
1472 tree type = TREE_TYPE (datum);
1473 enum tree_code code = TREE_CODE (type);
1477 if (!objc_is_public (datum, component))
1478 return error_mark_node;
1480 /* See if there is a field or component with name COMPONENT. */
1482 if (code == RECORD_TYPE || code == UNION_TYPE)
1484 if (!COMPLETE_TYPE_P (type))
1486 c_incomplete_type_error (NULL_TREE, type);
1487 return error_mark_node;
1490 field = lookup_field (datum, component);
1494 error ("%qT has no member named %qs", type,
1495 IDENTIFIER_POINTER (component));
1496 return error_mark_node;
1499 /* Chain the COMPONENT_REFs if necessary down to the FIELD.
1500 This might be better solved in future the way the C++ front
1501 end does it - by giving the anonymous entities each a
1502 separate name and type, and then have build_component_ref
1503 recursively call itself. We can't do that here. */
1506 tree subdatum = TREE_VALUE (field);
1508 if (TREE_TYPE (subdatum) == error_mark_node)
1509 return error_mark_node;
1511 ref = build3 (COMPONENT_REF, TREE_TYPE (subdatum), datum, subdatum,
1513 if (TREE_READONLY (datum) || TREE_READONLY (subdatum))
1514 TREE_READONLY (ref) = 1;
1515 if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (subdatum))
1516 TREE_THIS_VOLATILE (ref) = 1;
1518 if (TREE_DEPRECATED (subdatum))
1519 warn_deprecated_use (subdatum);
1523 field = TREE_CHAIN (field);
1529 else if (code != ERROR_MARK)
1530 error ("request for member %qs in something not a structure or union",
1531 IDENTIFIER_POINTER (component));
1533 return error_mark_node;
1536 /* Given an expression PTR for a pointer, return an expression
1537 for the value pointed to.
1538 ERRORSTRING is the name of the operator to appear in error messages. */
1541 build_indirect_ref (tree ptr, const char *errorstring)
1543 tree pointer = default_conversion (ptr);
1544 tree type = TREE_TYPE (pointer);
1546 if (TREE_CODE (type) == POINTER_TYPE)
1548 if (TREE_CODE (pointer) == ADDR_EXPR
1549 && (TREE_TYPE (TREE_OPERAND (pointer, 0))
1550 == TREE_TYPE (type)))
1551 return TREE_OPERAND (pointer, 0);
1554 tree t = TREE_TYPE (type);
1555 tree ref = build1 (INDIRECT_REF, TYPE_MAIN_VARIANT (t), pointer);
1557 if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE)
1559 error ("dereferencing pointer to incomplete type");
1560 return error_mark_node;
1562 if (VOID_TYPE_P (t) && skip_evaluation == 0)
1563 warning ("dereferencing %<void *%> pointer");
1565 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
1566 so that we get the proper error message if the result is used
1567 to assign to. Also, &* is supposed to be a no-op.
1568 And ANSI C seems to specify that the type of the result
1569 should be the const type. */
1570 /* A de-reference of a pointer to const is not a const. It is valid
1571 to change it via some other pointer. */
1572 TREE_READONLY (ref) = TYPE_READONLY (t);
1573 TREE_SIDE_EFFECTS (ref)
1574 = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer);
1575 TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
1579 else if (TREE_CODE (pointer) != ERROR_MARK)
1580 error ("invalid type argument of %qs", errorstring);
1581 return error_mark_node;
1584 /* This handles expressions of the form "a[i]", which denotes
1587 This is logically equivalent in C to *(a+i), but we may do it differently.
1588 If A is a variable or a member, we generate a primitive ARRAY_REF.
1589 This avoids forcing the array out of registers, and can work on
1590 arrays that are not lvalues (for example, members of structures returned
1594 build_array_ref (tree array, tree index)
1598 error ("subscript missing in array reference");
1599 return error_mark_node;
1602 if (TREE_TYPE (array) == error_mark_node
1603 || TREE_TYPE (index) == error_mark_node)
1604 return error_mark_node;
1606 if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE)
1610 /* Subscripting with type char is likely to lose
1611 on a machine where chars are signed.
1612 So warn on any machine, but optionally.
1613 Don't warn for unsigned char since that type is safe.
1614 Don't warn for signed char because anyone who uses that
1615 must have done so deliberately. */
1616 if (warn_char_subscripts
1617 && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1618 warning ("array subscript has type %<char%>");
1620 /* Apply default promotions *after* noticing character types. */
1621 index = default_conversion (index);
1623 /* Require integer *after* promotion, for sake of enums. */
1624 if (TREE_CODE (TREE_TYPE (index)) != INTEGER_TYPE)
1626 error ("array subscript is not an integer");
1627 return error_mark_node;
1630 /* An array that is indexed by a non-constant
1631 cannot be stored in a register; we must be able to do
1632 address arithmetic on its address.
1633 Likewise an array of elements of variable size. */
1634 if (TREE_CODE (index) != INTEGER_CST
1635 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
1636 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
1638 if (!c_mark_addressable (array))
1639 return error_mark_node;
1641 /* An array that is indexed by a constant value which is not within
1642 the array bounds cannot be stored in a register either; because we
1643 would get a crash in store_bit_field/extract_bit_field when trying
1644 to access a non-existent part of the register. */
1645 if (TREE_CODE (index) == INTEGER_CST
1646 && TYPE_DOMAIN (TREE_TYPE (array))
1647 && !int_fits_type_p (index, TYPE_DOMAIN (TREE_TYPE (array))))
1649 if (!c_mark_addressable (array))
1650 return error_mark_node;
1656 while (TREE_CODE (foo) == COMPONENT_REF)
1657 foo = TREE_OPERAND (foo, 0);
1658 if (TREE_CODE (foo) == VAR_DECL && C_DECL_REGISTER (foo))
1659 pedwarn ("ISO C forbids subscripting %<register%> array");
1660 else if (!flag_isoc99 && !lvalue_p (foo))
1661 pedwarn ("ISO C90 forbids subscripting non-lvalue array");
1664 type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array)));
1665 rval = build4 (ARRAY_REF, type, array, index, NULL_TREE, NULL_TREE);
1666 /* Array ref is const/volatile if the array elements are
1667 or if the array is. */
1668 TREE_READONLY (rval)
1669 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
1670 | TREE_READONLY (array));
1671 TREE_SIDE_EFFECTS (rval)
1672 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1673 | TREE_SIDE_EFFECTS (array));
1674 TREE_THIS_VOLATILE (rval)
1675 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1676 /* This was added by rms on 16 Nov 91.
1677 It fixes vol struct foo *a; a->elts[1]
1678 in an inline function.
1679 Hope it doesn't break something else. */
1680 | TREE_THIS_VOLATILE (array));
1681 return require_complete_type (fold (rval));
1685 tree ar = default_conversion (array);
1686 tree ind = default_conversion (index);
1688 /* Do the same warning check as above, but only on the part that's
1689 syntactically the index and only if it is also semantically
1691 if (warn_char_subscripts
1692 && TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE
1693 && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1694 warning ("subscript has type %<char%>");
1696 /* Put the integer in IND to simplify error checking. */
1697 if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
1704 if (ar == error_mark_node)
1707 if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE
1708 || TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) == FUNCTION_TYPE)
1710 error ("subscripted value is neither array nor pointer");
1711 return error_mark_node;
1713 if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
1715 error ("array subscript is not an integer");
1716 return error_mark_node;
1719 return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, ind, 0),
1724 /* Build an external reference to identifier ID. FUN indicates
1725 whether this will be used for a function call. */
1727 build_external_ref (tree id, int fun)
1730 tree decl = lookup_name (id);
1732 /* In Objective-C, an instance variable (ivar) may be preferred to
1733 whatever lookup_name() found. */
1734 decl = objc_lookup_ivar (decl, id);
1736 if (decl && decl != error_mark_node)
1739 /* Implicit function declaration. */
1740 ref = implicitly_declare (id);
1741 else if (decl == error_mark_node)
1742 /* Don't complain about something that's already been
1743 complained about. */
1744 return error_mark_node;
1747 undeclared_variable (id);
1748 return error_mark_node;
1751 if (TREE_TYPE (ref) == error_mark_node)
1752 return error_mark_node;
1754 if (TREE_DEPRECATED (ref))
1755 warn_deprecated_use (ref);
1757 if (!skip_evaluation)
1758 assemble_external (ref);
1759 TREE_USED (ref) = 1;
1761 if (TREE_CODE (ref) == FUNCTION_DECL && !in_alignof)
1763 if (!in_sizeof && !in_typeof)
1764 C_DECL_USED (ref) = 1;
1765 else if (DECL_INITIAL (ref) == 0
1766 && DECL_EXTERNAL (ref)
1767 && !TREE_PUBLIC (ref))
1768 record_maybe_used_decl (ref);
1771 if (TREE_CODE (ref) == CONST_DECL)
1773 ref = DECL_INITIAL (ref);
1774 TREE_CONSTANT (ref) = 1;
1775 TREE_INVARIANT (ref) = 1;
1777 else if (current_function_decl != 0
1778 && !DECL_FILE_SCOPE_P (current_function_decl)
1779 && (TREE_CODE (ref) == VAR_DECL
1780 || TREE_CODE (ref) == PARM_DECL
1781 || TREE_CODE (ref) == FUNCTION_DECL))
1783 tree context = decl_function_context (ref);
1785 if (context != 0 && context != current_function_decl)
1786 DECL_NONLOCAL (ref) = 1;
1792 /* Record details of decls possibly used inside sizeof or typeof. */
1793 struct maybe_used_decl
1797 /* The level seen at (in_sizeof + in_typeof). */
1799 /* The next one at this level or above, or NULL. */
1800 struct maybe_used_decl *next;
1803 static struct maybe_used_decl *maybe_used_decls;
1805 /* Record that DECL, an undefined static function reference seen
1806 inside sizeof or typeof, might be used if the operand of sizeof is
1807 a VLA type or the operand of typeof is a variably modified
1811 record_maybe_used_decl (tree decl)
1813 struct maybe_used_decl *t = XOBNEW (&parser_obstack, struct maybe_used_decl);
1815 t->level = in_sizeof + in_typeof;
1816 t->next = maybe_used_decls;
1817 maybe_used_decls = t;
1820 /* Pop the stack of decls possibly used inside sizeof or typeof. If
1821 USED is false, just discard them. If it is true, mark them used
1822 (if no longer inside sizeof or typeof) or move them to the next
1823 level up (if still inside sizeof or typeof). */
1826 pop_maybe_used (bool used)
1828 struct maybe_used_decl *p = maybe_used_decls;
1829 int cur_level = in_sizeof + in_typeof;
1830 while (p && p->level > cur_level)
1835 C_DECL_USED (p->decl) = 1;
1837 p->level = cur_level;
1841 if (!used || cur_level == 0)
1842 maybe_used_decls = p;
1845 /* Return the result of sizeof applied to EXPR. */
1848 c_expr_sizeof_expr (struct c_expr expr)
1851 if (expr.value == error_mark_node)
1853 ret.value = error_mark_node;
1854 ret.original_code = ERROR_MARK;
1855 pop_maybe_used (false);
1859 ret.value = c_sizeof (TREE_TYPE (expr.value));
1860 ret.original_code = ERROR_MARK;
1861 pop_maybe_used (C_TYPE_VARIABLE_SIZE (TREE_TYPE (expr.value)));
1866 /* Return the result of sizeof applied to T, a structure for the type
1867 name passed to sizeof (rather than the type itself). */
1870 c_expr_sizeof_type (struct c_type_name *t)
1874 type = groktypename (t);
1875 ret.value = c_sizeof (type);
1876 ret.original_code = ERROR_MARK;
1877 pop_maybe_used (C_TYPE_VARIABLE_SIZE (type));
1881 /* Build a function call to function FUNCTION with parameters PARAMS.
1882 PARAMS is a list--a chain of TREE_LIST nodes--in which the
1883 TREE_VALUE of each node is a parameter-expression.
1884 FUNCTION's data type may be a function type or a pointer-to-function. */
1887 build_function_call (tree function, tree params)
1889 tree fntype, fundecl = 0;
1890 tree coerced_params;
1891 tree name = NULL_TREE, result;
1894 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
1895 STRIP_TYPE_NOPS (function);
1897 /* Convert anything with function type to a pointer-to-function. */
1898 if (TREE_CODE (function) == FUNCTION_DECL)
1900 name = DECL_NAME (function);
1902 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
1903 (because calling an inline function does not mean the function
1904 needs to be separately compiled). */
1905 fntype = build_type_variant (TREE_TYPE (function),
1906 TREE_READONLY (function),
1907 TREE_THIS_VOLATILE (function));
1909 function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
1912 function = default_conversion (function);
1914 fntype = TREE_TYPE (function);
1916 if (TREE_CODE (fntype) == ERROR_MARK)
1917 return error_mark_node;
1919 if (!(TREE_CODE (fntype) == POINTER_TYPE
1920 && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
1922 error ("called object %qE is not a function", function);
1923 return error_mark_node;
1926 if (fundecl && TREE_THIS_VOLATILE (fundecl))
1927 current_function_returns_abnormally = 1;
1929 /* fntype now gets the type of function pointed to. */
1930 fntype = TREE_TYPE (fntype);
1932 /* Check that the function is called through a compatible prototype.
1933 If it is not, replace the call by a trap, wrapped up in a compound
1934 expression if necessary. This has the nice side-effect to prevent
1935 the tree-inliner from generating invalid assignment trees which may
1936 blow up in the RTL expander later.
1938 ??? This doesn't work for Objective-C because objc_comptypes
1939 refuses to compare function prototypes, yet the compiler appears
1940 to build calls that are flagged as invalid by C's comptypes. */
1941 if (!c_dialect_objc ()
1942 && TREE_CODE (function) == NOP_EXPR
1943 && TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR
1944 && TREE_CODE (tem = TREE_OPERAND (tem, 0)) == FUNCTION_DECL
1945 && !comptypes (fntype, TREE_TYPE (tem)))
1947 tree return_type = TREE_TYPE (fntype);
1948 tree trap = build_function_call (built_in_decls[BUILT_IN_TRAP],
1951 /* This situation leads to run-time undefined behavior. We can't,
1952 therefore, simply error unless we can prove that all possible
1953 executions of the program must execute the code. */
1954 warning ("function called through a non-compatible type");
1956 /* We can, however, treat "undefined" any way we please.
1957 Call abort to encourage the user to fix the program. */
1958 inform ("if this code is reached, the program will abort");
1960 if (VOID_TYPE_P (return_type))
1966 if (AGGREGATE_TYPE_P (return_type))
1967 rhs = build_compound_literal (return_type,
1968 build_constructor (return_type,
1971 rhs = fold (build1 (NOP_EXPR, return_type, integer_zero_node));
1973 return build2 (COMPOUND_EXPR, return_type, trap, rhs);
1977 /* Convert the parameters to the types declared in the
1978 function prototype, or apply default promotions. */
1981 = convert_arguments (TYPE_ARG_TYPES (fntype), params, function, fundecl);
1983 if (coerced_params == error_mark_node)
1984 return error_mark_node;
1986 /* Check that the arguments to the function are valid. */
1988 check_function_arguments (TYPE_ATTRIBUTES (fntype), coerced_params);
1990 result = build3 (CALL_EXPR, TREE_TYPE (fntype),
1991 function, coerced_params, NULL_TREE);
1992 TREE_SIDE_EFFECTS (result) = 1;
1994 if (require_constant_value)
1996 result = fold_initializer (result);
1998 if (TREE_CONSTANT (result)
1999 && (name == NULL_TREE
2000 || strncmp (IDENTIFIER_POINTER (name), "__builtin_", 10) != 0))
2001 pedwarn_init ("initializer element is not constant");
2004 result = fold (result);
2006 if (VOID_TYPE_P (TREE_TYPE (result)))
2008 return require_complete_type (result);
2011 /* Convert the argument expressions in the list VALUES
2012 to the types in the list TYPELIST. The result is a list of converted
2013 argument expressions, unless there are too few arguments in which
2014 case it is error_mark_node.
2016 If TYPELIST is exhausted, or when an element has NULL as its type,
2017 perform the default conversions.
2019 PARMLIST is the chain of parm decls for the function being called.
2020 It may be 0, if that info is not available.
2021 It is used only for generating error messages.
2023 FUNCTION is a tree for the called function. It is used only for
2024 error messages, where it is formatted with %qE.
2026 This is also where warnings about wrong number of args are generated.
2028 Both VALUES and the returned value are chains of TREE_LIST nodes
2029 with the elements of the list in the TREE_VALUE slots of those nodes. */
2032 convert_arguments (tree typelist, tree values, tree function, tree fundecl)
2034 tree typetail, valtail;
2039 /* Change pointer to function to the function itself for
2041 if (TREE_CODE (function) == ADDR_EXPR
2042 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
2043 function = TREE_OPERAND (function, 0);
2045 /* Handle an ObjC selector specially for diagnostics. */
2046 selector = objc_message_selector ();
2048 /* Scan the given expressions and types, producing individual
2049 converted arguments and pushing them on RESULT in reverse order. */
2051 for (valtail = values, typetail = typelist, parmnum = 0;
2053 valtail = TREE_CHAIN (valtail), parmnum++)
2055 tree type = typetail ? TREE_VALUE (typetail) : 0;
2056 tree val = TREE_VALUE (valtail);
2057 tree rname = function;
2058 int argnum = parmnum + 1;
2060 if (type == void_type_node)
2062 error ("too many arguments to function %qE", function);
2066 if (selector && argnum > 2)
2072 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
2073 /* Do not use STRIP_NOPS here! We do not want an enumerator with value 0
2074 to convert automatically to a pointer. */
2075 if (TREE_CODE (val) == NON_LVALUE_EXPR)
2076 val = TREE_OPERAND (val, 0);
2078 val = default_function_array_conversion (val);
2080 val = require_complete_type (val);
2084 /* Formal parm type is specified by a function prototype. */
2087 if (!COMPLETE_TYPE_P (type))
2089 error ("type of formal parameter %d is incomplete", parmnum + 1);
2094 /* Optionally warn about conversions that
2095 differ from the default conversions. */
2096 if (warn_conversion || warn_traditional)
2098 unsigned int formal_prec = TYPE_PRECISION (type);
2100 if (INTEGRAL_TYPE_P (type)
2101 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
2102 warning ("passing argument %d of %qE as integer "
2103 "rather than floating due to prototype",
2105 if (INTEGRAL_TYPE_P (type)
2106 && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
2107 warning ("passing argument %d of %qE as integer "
2108 "rather than complex due to prototype",
2110 else if (TREE_CODE (type) == COMPLEX_TYPE
2111 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
2112 warning ("passing argument %d of %qE as complex "
2113 "rather than floating due to prototype",
2115 else if (TREE_CODE (type) == REAL_TYPE
2116 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
2117 warning ("passing argument %d of %qE as floating "
2118 "rather than integer due to prototype",
2120 else if (TREE_CODE (type) == COMPLEX_TYPE
2121 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
2122 warning ("passing argument %d of %qE as complex "
2123 "rather than integer due to prototype",
2125 else if (TREE_CODE (type) == REAL_TYPE
2126 && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
2127 warning ("passing argument %d of %qE as floating "
2128 "rather than complex due to prototype",
2130 /* ??? At some point, messages should be written about
2131 conversions between complex types, but that's too messy
2133 else if (TREE_CODE (type) == REAL_TYPE
2134 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
2136 /* Warn if any argument is passed as `float',
2137 since without a prototype it would be `double'. */
2138 if (formal_prec == TYPE_PRECISION (float_type_node))
2139 warning ("passing argument %d of %qE as %<float%> "
2140 "rather than %<double%> due to prototype",
2143 /* Detect integer changing in width or signedness.
2144 These warnings are only activated with
2145 -Wconversion, not with -Wtraditional. */
2146 else if (warn_conversion && INTEGRAL_TYPE_P (type)
2147 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
2149 tree would_have_been = default_conversion (val);
2150 tree type1 = TREE_TYPE (would_have_been);
2152 if (TREE_CODE (type) == ENUMERAL_TYPE
2153 && (TYPE_MAIN_VARIANT (type)
2154 == TYPE_MAIN_VARIANT (TREE_TYPE (val))))
2155 /* No warning if function asks for enum
2156 and the actual arg is that enum type. */
2158 else if (formal_prec != TYPE_PRECISION (type1))
2159 warning ("passing argument %d of %qE with different "
2160 "width due to prototype", argnum, rname);
2161 else if (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (type1))
2163 /* Don't complain if the formal parameter type
2164 is an enum, because we can't tell now whether
2165 the value was an enum--even the same enum. */
2166 else if (TREE_CODE (type) == ENUMERAL_TYPE)
2168 else if (TREE_CODE (val) == INTEGER_CST
2169 && int_fits_type_p (val, type))
2170 /* Change in signedness doesn't matter
2171 if a constant value is unaffected. */
2173 /* Likewise for a constant in a NOP_EXPR. */
2174 else if (TREE_CODE (val) == NOP_EXPR
2175 && TREE_CODE (TREE_OPERAND (val, 0)) == INTEGER_CST
2176 && int_fits_type_p (TREE_OPERAND (val, 0), type))
2178 /* If the value is extended from a narrower
2179 unsigned type, it doesn't matter whether we
2180 pass it as signed or unsigned; the value
2181 certainly is the same either way. */
2182 else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type)
2183 && TYPE_UNSIGNED (TREE_TYPE (val)))
2185 else if (TYPE_UNSIGNED (type))
2186 warning ("passing argument %d of %qE as unsigned "
2187 "due to prototype", argnum, rname);
2189 warning ("passing argument %d of %qE as signed "
2190 "due to prototype", argnum, rname);
2194 parmval = convert_for_assignment (type, val, ic_argpass,
2198 if (targetm.calls.promote_prototypes (fundecl ? TREE_TYPE (fundecl) : 0)
2199 && INTEGRAL_TYPE_P (type)
2200 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
2201 parmval = default_conversion (parmval);
2203 result = tree_cons (NULL_TREE, parmval, result);
2205 else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
2206 && (TYPE_PRECISION (TREE_TYPE (val))
2207 < TYPE_PRECISION (double_type_node)))
2208 /* Convert `float' to `double'. */
2209 result = tree_cons (NULL_TREE, convert (double_type_node, val), result);
2211 /* Convert `short' and `char' to full-size `int'. */
2212 result = tree_cons (NULL_TREE, default_conversion (val), result);
2215 typetail = TREE_CHAIN (typetail);
2218 if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
2220 error ("too few arguments to function %qE", function);
2221 return error_mark_node;
2224 return nreverse (result);
2227 /* This is the entry point used by the parser
2228 for binary operators in the input.
2229 In addition to constructing the expression,
2230 we check for operands that were written with other binary operators
2231 in a way that is likely to confuse the user. */
2234 parser_build_binary_op (enum tree_code code, struct c_expr arg1,
2237 struct c_expr result;
2239 enum tree_code code1 = arg1.original_code;
2240 enum tree_code code2 = arg2.original_code;
2242 result.value = build_binary_op (code, arg1.value, arg2.value, 1);
2243 result.original_code = code;
2245 if (TREE_CODE (result.value) == ERROR_MARK)
2248 /* Check for cases such as x+y<<z which users are likely
2250 if (warn_parentheses)
2252 if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
2254 if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
2255 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2256 warning ("suggest parentheses around + or - inside shift");
2259 if (code == TRUTH_ORIF_EXPR)
2261 if (code1 == TRUTH_ANDIF_EXPR
2262 || code2 == TRUTH_ANDIF_EXPR)
2263 warning ("suggest parentheses around && within ||");
2266 if (code == BIT_IOR_EXPR)
2268 if (code1 == BIT_AND_EXPR || code1 == BIT_XOR_EXPR
2269 || code1 == PLUS_EXPR || code1 == MINUS_EXPR
2270 || code2 == BIT_AND_EXPR || code2 == BIT_XOR_EXPR
2271 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2272 warning ("suggest parentheses around arithmetic in operand of |");
2273 /* Check cases like x|y==z */
2274 if (TREE_CODE_CLASS (code1) == tcc_comparison
2275 || TREE_CODE_CLASS (code2) == tcc_comparison)
2276 warning ("suggest parentheses around comparison in operand of |");
2279 if (code == BIT_XOR_EXPR)
2281 if (code1 == BIT_AND_EXPR
2282 || code1 == PLUS_EXPR || code1 == MINUS_EXPR
2283 || code2 == BIT_AND_EXPR
2284 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2285 warning ("suggest parentheses around arithmetic in operand of ^");
2286 /* Check cases like x^y==z */
2287 if (TREE_CODE_CLASS (code1) == tcc_comparison
2288 || TREE_CODE_CLASS (code2) == tcc_comparison)
2289 warning ("suggest parentheses around comparison in operand of ^");
2292 if (code == BIT_AND_EXPR)
2294 if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
2295 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2296 warning ("suggest parentheses around + or - in operand of &");
2297 /* Check cases like x&y==z */
2298 if (TREE_CODE_CLASS (code1) == tcc_comparison
2299 || TREE_CODE_CLASS (code2) == tcc_comparison)
2300 warning ("suggest parentheses around comparison in operand of &");
2302 /* Similarly, check for cases like 1<=i<=10 that are probably errors. */
2303 if (TREE_CODE_CLASS (code) == tcc_comparison
2304 && (TREE_CODE_CLASS (code1) == tcc_comparison
2305 || TREE_CODE_CLASS (code2) == tcc_comparison))
2306 warning ("comparisons like X<=Y<=Z do not have their mathematical meaning");
2310 unsigned_conversion_warning (result.value, arg1.value);
2311 unsigned_conversion_warning (result.value, arg2.value);
2312 overflow_warning (result.value);
2317 /* Return a tree for the difference of pointers OP0 and OP1.
2318 The resulting tree has type int. */
2321 pointer_diff (tree op0, tree op1)
2323 tree restype = ptrdiff_type_node;
2325 tree target_type = TREE_TYPE (TREE_TYPE (op0));
2326 tree con0, con1, lit0, lit1;
2327 tree orig_op1 = op1;
2329 if (pedantic || warn_pointer_arith)
2331 if (TREE_CODE (target_type) == VOID_TYPE)
2332 pedwarn ("pointer of type %<void *%> used in subtraction");
2333 if (TREE_CODE (target_type) == FUNCTION_TYPE)
2334 pedwarn ("pointer to a function used in subtraction");
2337 /* If the conversion to ptrdiff_type does anything like widening or
2338 converting a partial to an integral mode, we get a convert_expression
2339 that is in the way to do any simplifications.
2340 (fold-const.c doesn't know that the extra bits won't be needed.
2341 split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a
2342 different mode in place.)
2343 So first try to find a common term here 'by hand'; we want to cover
2344 at least the cases that occur in legal static initializers. */
2345 con0 = TREE_CODE (op0) == NOP_EXPR ? TREE_OPERAND (op0, 0) : op0;
2346 con1 = TREE_CODE (op1) == NOP_EXPR ? TREE_OPERAND (op1, 0) : op1;
2348 if (TREE_CODE (con0) == PLUS_EXPR)
2350 lit0 = TREE_OPERAND (con0, 1);
2351 con0 = TREE_OPERAND (con0, 0);
2354 lit0 = integer_zero_node;
2356 if (TREE_CODE (con1) == PLUS_EXPR)
2358 lit1 = TREE_OPERAND (con1, 1);
2359 con1 = TREE_OPERAND (con1, 0);
2362 lit1 = integer_zero_node;
2364 if (operand_equal_p (con0, con1, 0))
2371 /* First do the subtraction as integers;
2372 then drop through to build the divide operator.
2373 Do not do default conversions on the minus operator
2374 in case restype is a short type. */
2376 op0 = build_binary_op (MINUS_EXPR, convert (restype, op0),
2377 convert (restype, op1), 0);
2378 /* This generates an error if op1 is pointer to incomplete type. */
2379 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1))))
2380 error ("arithmetic on pointer to an incomplete type");
2382 /* This generates an error if op0 is pointer to incomplete type. */
2383 op1 = c_size_in_bytes (target_type);
2385 /* Divide by the size, in easiest possible way. */
2386 return fold (build2 (EXACT_DIV_EXPR, restype, op0, convert (restype, op1)));
2389 /* Construct and perhaps optimize a tree representation
2390 for a unary operation. CODE, a tree_code, specifies the operation
2391 and XARG is the operand.
2392 For any CODE other than ADDR_EXPR, FLAG nonzero suppresses
2393 the default promotions (such as from short to int).
2394 For ADDR_EXPR, the default promotions are not applied; FLAG nonzero
2395 allows non-lvalues; this is only used to handle conversion of non-lvalue
2396 arrays to pointers in C99. */
2399 build_unary_op (enum tree_code code, tree xarg, int flag)
2401 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
2404 enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
2406 int noconvert = flag;
2408 if (typecode == ERROR_MARK)
2409 return error_mark_node;
2410 if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE)
2411 typecode = INTEGER_TYPE;
2416 /* This is used for unary plus, because a CONVERT_EXPR
2417 is enough to prevent anybody from looking inside for
2418 associativity, but won't generate any code. */
2419 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2420 || typecode == COMPLEX_TYPE
2421 || typecode == VECTOR_TYPE))
2423 error ("wrong type argument to unary plus");
2424 return error_mark_node;
2426 else if (!noconvert)
2427 arg = default_conversion (arg);
2428 arg = non_lvalue (arg);
2432 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2433 || typecode == COMPLEX_TYPE
2434 || typecode == VECTOR_TYPE))
2436 error ("wrong type argument to unary minus");
2437 return error_mark_node;
2439 else if (!noconvert)
2440 arg = default_conversion (arg);
2444 if (typecode == INTEGER_TYPE || typecode == VECTOR_TYPE)
2447 arg = default_conversion (arg);
2449 else if (typecode == COMPLEX_TYPE)
2453 pedwarn ("ISO C does not support %<~%> for complex conjugation");
2455 arg = default_conversion (arg);
2459 error ("wrong type argument to bit-complement");
2460 return error_mark_node;
2465 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE))
2467 error ("wrong type argument to abs");
2468 return error_mark_node;
2470 else if (!noconvert)
2471 arg = default_conversion (arg);
2475 /* Conjugating a real value is a no-op, but allow it anyway. */
2476 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2477 || typecode == COMPLEX_TYPE))
2479 error ("wrong type argument to conjugation");
2480 return error_mark_node;
2482 else if (!noconvert)
2483 arg = default_conversion (arg);
2486 case TRUTH_NOT_EXPR:
2487 if (typecode != INTEGER_TYPE
2488 && typecode != REAL_TYPE && typecode != POINTER_TYPE
2489 && typecode != COMPLEX_TYPE
2490 /* These will convert to a pointer. */
2491 && typecode != ARRAY_TYPE && typecode != FUNCTION_TYPE)
2493 error ("wrong type argument to unary exclamation mark");
2494 return error_mark_node;
2496 arg = lang_hooks.truthvalue_conversion (arg);
2497 return invert_truthvalue (arg);
2503 if (TREE_CODE (arg) == COMPLEX_CST)
2504 return TREE_REALPART (arg);
2505 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2506 return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2511 if (TREE_CODE (arg) == COMPLEX_CST)
2512 return TREE_IMAGPART (arg);
2513 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2514 return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2516 return convert (TREE_TYPE (arg), integer_zero_node);
2518 case PREINCREMENT_EXPR:
2519 case POSTINCREMENT_EXPR:
2520 case PREDECREMENT_EXPR:
2521 case POSTDECREMENT_EXPR:
2523 /* Increment or decrement the real part of the value,
2524 and don't change the imaginary part. */
2525 if (typecode == COMPLEX_TYPE)
2530 pedwarn ("ISO C does not support %<++%> and %<--%>"
2531 " on complex types");
2533 arg = stabilize_reference (arg);
2534 real = build_unary_op (REALPART_EXPR, arg, 1);
2535 imag = build_unary_op (IMAGPART_EXPR, arg, 1);
2536 return build2 (COMPLEX_EXPR, TREE_TYPE (arg),
2537 build_unary_op (code, real, 1), imag);
2540 /* Report invalid types. */
2542 if (typecode != POINTER_TYPE
2543 && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
2545 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2546 error ("wrong type argument to increment");
2548 error ("wrong type argument to decrement");
2550 return error_mark_node;
2555 tree result_type = TREE_TYPE (arg);
2557 arg = get_unwidened (arg, 0);
2558 argtype = TREE_TYPE (arg);
2560 /* Compute the increment. */
2562 if (typecode == POINTER_TYPE)
2564 /* If pointer target is an undefined struct,
2565 we just cannot know how to do the arithmetic. */
2566 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type)))
2568 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2569 error ("increment of pointer to unknown structure");
2571 error ("decrement of pointer to unknown structure");
2573 else if ((pedantic || warn_pointer_arith)
2574 && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE
2575 || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE))
2577 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2578 pedwarn ("wrong type argument to increment");
2580 pedwarn ("wrong type argument to decrement");
2583 inc = c_size_in_bytes (TREE_TYPE (result_type));
2586 inc = integer_one_node;
2588 inc = convert (argtype, inc);
2590 /* Complain about anything else that is not a true lvalue. */
2591 if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
2592 || code == POSTINCREMENT_EXPR)
2595 return error_mark_node;
2597 /* Report a read-only lvalue. */
2598 if (TREE_READONLY (arg))
2599 readonly_error (arg,
2600 ((code == PREINCREMENT_EXPR
2601 || code == POSTINCREMENT_EXPR)
2602 ? lv_increment : lv_decrement));
2604 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
2605 val = boolean_increment (code, arg);
2607 val = build2 (code, TREE_TYPE (arg), arg, inc);
2608 TREE_SIDE_EFFECTS (val) = 1;
2609 val = convert (result_type, val);
2610 if (TREE_CODE (val) != code)
2611 TREE_NO_WARNING (val) = 1;
2616 /* Note that this operation never does default_conversion. */
2618 /* Let &* cancel out to simplify resulting code. */
2619 if (TREE_CODE (arg) == INDIRECT_REF)
2621 /* Don't let this be an lvalue. */
2622 if (lvalue_p (TREE_OPERAND (arg, 0)))
2623 return non_lvalue (TREE_OPERAND (arg, 0));
2624 return TREE_OPERAND (arg, 0);
2627 /* For &x[y], return x+y */
2628 if (TREE_CODE (arg) == ARRAY_REF)
2630 if (!c_mark_addressable (TREE_OPERAND (arg, 0)))
2631 return error_mark_node;
2632 return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
2633 TREE_OPERAND (arg, 1), 1);
2636 /* Anything not already handled and not a true memory reference
2637 or a non-lvalue array is an error. */
2638 else if (typecode != FUNCTION_TYPE && !flag
2639 && !lvalue_or_else (arg, lv_addressof))
2640 return error_mark_node;
2642 /* Ordinary case; arg is a COMPONENT_REF or a decl. */
2643 argtype = TREE_TYPE (arg);
2645 /* If the lvalue is const or volatile, merge that into the type
2646 to which the address will point. Note that you can't get a
2647 restricted pointer by taking the address of something, so we
2648 only have to deal with `const' and `volatile' here. */
2649 if ((DECL_P (arg) || REFERENCE_CLASS_P (arg))
2650 && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg)))
2651 argtype = c_build_type_variant (argtype,
2652 TREE_READONLY (arg),
2653 TREE_THIS_VOLATILE (arg));
2655 if (!c_mark_addressable (arg))
2656 return error_mark_node;
2658 gcc_assert (TREE_CODE (arg) != COMPONENT_REF
2659 || !DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)));
2661 argtype = build_pointer_type (argtype);
2663 /* ??? Cope with user tricks that amount to offsetof. Delete this
2664 when we have proper support for integer constant expressions. */
2665 val = get_base_address (arg);
2666 if (val && TREE_CODE (val) == INDIRECT_REF
2667 && integer_zerop (TREE_OPERAND (val, 0)))
2668 return fold_convert (argtype, fold_offsetof (arg));
2670 val = build1 (ADDR_EXPR, argtype, arg);
2672 if (TREE_CODE (arg) == COMPOUND_LITERAL_EXPR)
2673 TREE_INVARIANT (val) = TREE_CONSTANT (val) = 1;
2682 argtype = TREE_TYPE (arg);
2683 val = build1 (code, argtype, arg);
2684 return require_constant_value ? fold_initializer (val) : fold (val);
2687 /* Return nonzero if REF is an lvalue valid for this language.
2688 Lvalues can be assigned, unless their type has TYPE_READONLY.
2689 Lvalues can have their address taken, unless they have C_DECL_REGISTER. */
2694 enum tree_code code = TREE_CODE (ref);
2701 return lvalue_p (TREE_OPERAND (ref, 0));
2703 case COMPOUND_LITERAL_EXPR:
2713 return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
2714 && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
2717 return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
2724 /* Return nonzero if REF is an lvalue valid for this language;
2725 otherwise, print an error message and return zero. USE says
2726 how the lvalue is being used and so selects the error message. */
2729 lvalue_or_else (tree ref, enum lvalue_use use)
2731 int win = lvalue_p (ref);
2738 error ("invalid lvalue in assignment");
2741 error ("invalid lvalue in increment");
2744 error ("invalid lvalue in decrement");
2747 error ("invalid lvalue in unary %<&%>");
2750 error ("invalid lvalue in asm statement");
2761 /* Give an error for storing in something that is 'const'. */
2764 readonly_error (tree arg, enum lvalue_use use)
2766 gcc_assert (use == lv_assign || use == lv_increment || use == lv_decrement);
2767 /* Using this macro rather than (for example) arrays of messages
2768 ensures that all the format strings are checked at compile
2770 #define READONLY_MSG(A, I, D) (use == lv_assign \
2772 : (use == lv_increment ? (I) : (D)))
2773 if (TREE_CODE (arg) == COMPONENT_REF)
2775 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
2776 readonly_error (TREE_OPERAND (arg, 0), use);
2778 error (READONLY_MSG (N_("assignment of read-only member %qs"),
2779 N_("increment of read-only member %qs"),
2780 N_("decrement of read-only member %qs")),
2781 IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
2783 else if (TREE_CODE (arg) == VAR_DECL)
2784 error (READONLY_MSG (N_("assignment of read-only variable %qs"),
2785 N_("increment of read-only variable %qs"),
2786 N_("decrement of read-only variable %qs")),
2787 IDENTIFIER_POINTER (DECL_NAME (arg)));
2789 error (READONLY_MSG (N_("assignment of read-only location"),
2790 N_("increment of read-only location"),
2791 N_("decrement of read-only location")));
2794 /* Mark EXP saying that we need to be able to take the
2795 address of it; it should not be allocated in a register.
2796 Returns true if successful. */
2799 c_mark_addressable (tree exp)
2804 switch (TREE_CODE (x))
2807 if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
2810 ("cannot take address of bit-field %qD", TREE_OPERAND (x, 1));
2814 /* ... fall through ... */
2820 x = TREE_OPERAND (x, 0);
2823 case COMPOUND_LITERAL_EXPR:
2825 TREE_ADDRESSABLE (x) = 1;
2832 if (C_DECL_REGISTER (x)
2833 && DECL_NONLOCAL (x))
2835 if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x))
2838 ("global register variable %qD used in nested function", x);
2841 pedwarn ("register variable %qD used in nested function", x);
2843 else if (C_DECL_REGISTER (x))
2845 if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x))
2846 error ("address of global register variable %qD requested", x);
2848 error ("address of register variable %qD requested", x);
2854 TREE_ADDRESSABLE (x) = 1;
2861 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
2864 build_conditional_expr (tree ifexp, tree op1, tree op2)
2868 enum tree_code code1;
2869 enum tree_code code2;
2870 tree result_type = NULL;
2871 tree orig_op1 = op1, orig_op2 = op2;
2873 ifexp = lang_hooks.truthvalue_conversion (default_conversion (ifexp));
2875 /* Promote both alternatives. */
2877 if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
2878 op1 = default_conversion (op1);
2879 if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
2880 op2 = default_conversion (op2);
2882 if (TREE_CODE (ifexp) == ERROR_MARK
2883 || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
2884 || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
2885 return error_mark_node;
2887 type1 = TREE_TYPE (op1);
2888 code1 = TREE_CODE (type1);
2889 type2 = TREE_TYPE (op2);
2890 code2 = TREE_CODE (type2);
2892 /* C90 does not permit non-lvalue arrays in conditional expressions.
2893 In C99 they will be pointers by now. */
2894 if (code1 == ARRAY_TYPE || code2 == ARRAY_TYPE)
2896 error ("non-lvalue array in conditional expression");
2897 return error_mark_node;
2900 /* Quickly detect the usual case where op1 and op2 have the same type
2902 if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
2905 result_type = type1;
2907 result_type = TYPE_MAIN_VARIANT (type1);
2909 else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE
2910 || code1 == COMPLEX_TYPE)
2911 && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
2912 || code2 == COMPLEX_TYPE))
2914 result_type = common_type (type1, type2);
2916 /* If -Wsign-compare, warn here if type1 and type2 have
2917 different signedness. We'll promote the signed to unsigned
2918 and later code won't know it used to be different.
2919 Do this check on the original types, so that explicit casts
2920 will be considered, but default promotions won't. */
2921 if (warn_sign_compare && !skip_evaluation)
2923 int unsigned_op1 = TYPE_UNSIGNED (TREE_TYPE (orig_op1));
2924 int unsigned_op2 = TYPE_UNSIGNED (TREE_TYPE (orig_op2));
2926 if (unsigned_op1 ^ unsigned_op2)
2928 /* Do not warn if the result type is signed, since the
2929 signed type will only be chosen if it can represent
2930 all the values of the unsigned type. */
2931 if (!TYPE_UNSIGNED (result_type))
2933 /* Do not warn if the signed quantity is an unsuffixed
2934 integer literal (or some static constant expression
2935 involving such literals) and it is non-negative. */
2936 else if ((unsigned_op2 && tree_expr_nonnegative_p (op1))
2937 || (unsigned_op1 && tree_expr_nonnegative_p (op2)))
2940 warning ("signed and unsigned type in conditional expression");
2944 else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
2946 if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
2947 pedwarn ("ISO C forbids conditional expr with only one void side");
2948 result_type = void_type_node;
2950 else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
2952 if (comp_target_types (type1, type2, 1))
2953 result_type = common_pointer_type (type1, type2);
2954 else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node
2955 && TREE_CODE (orig_op1) != NOP_EXPR)
2956 result_type = qualify_type (type2, type1);
2957 else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node
2958 && TREE_CODE (orig_op2) != NOP_EXPR)
2959 result_type = qualify_type (type1, type2);
2960 else if (VOID_TYPE_P (TREE_TYPE (type1)))
2962 if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
2963 pedwarn ("ISO C forbids conditional expr between "
2964 "%<void *%> and function pointer");
2965 result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
2966 TREE_TYPE (type2)));
2968 else if (VOID_TYPE_P (TREE_TYPE (type2)))
2970 if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
2971 pedwarn ("ISO C forbids conditional expr between "
2972 "%<void *%> and function pointer");
2973 result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
2974 TREE_TYPE (type1)));
2978 pedwarn ("pointer type mismatch in conditional expression");
2979 result_type = build_pointer_type (void_type_node);
2982 else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
2984 if (!integer_zerop (op2))
2985 pedwarn ("pointer/integer type mismatch in conditional expression");
2988 op2 = null_pointer_node;
2990 result_type = type1;
2992 else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
2994 if (!integer_zerop (op1))
2995 pedwarn ("pointer/integer type mismatch in conditional expression");
2998 op1 = null_pointer_node;
3000 result_type = type2;
3005 if (flag_cond_mismatch)
3006 result_type = void_type_node;
3009 error ("type mismatch in conditional expression");
3010 return error_mark_node;
3014 /* Merge const and volatile flags of the incoming types. */
3016 = build_type_variant (result_type,
3017 TREE_READONLY (op1) || TREE_READONLY (op2),
3018 TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
3020 if (result_type != TREE_TYPE (op1))
3021 op1 = convert_and_check (result_type, op1);
3022 if (result_type != TREE_TYPE (op2))
3023 op2 = convert_and_check (result_type, op2);
3025 if (TREE_CODE (ifexp) == INTEGER_CST)
3026 return non_lvalue (integer_zerop (ifexp) ? op2 : op1);
3028 return fold (build3 (COND_EXPR, result_type, ifexp, op1, op2));
3031 /* Return a compound expression that performs two expressions and
3032 returns the value of the second of them. */
3035 build_compound_expr (tree expr1, tree expr2)
3037 /* Convert arrays and functions to pointers. */
3038 expr2 = default_function_array_conversion (expr2);
3040 if (!TREE_SIDE_EFFECTS (expr1))
3042 /* The left-hand operand of a comma expression is like an expression
3043 statement: with -Wextra or -Wunused, we should warn if it doesn't have
3044 any side-effects, unless it was explicitly cast to (void). */
3045 if (warn_unused_value
3046 && !(TREE_CODE (expr1) == CONVERT_EXPR
3047 && VOID_TYPE_P (TREE_TYPE (expr1))))
3048 warning ("left-hand operand of comma expression has no effect");
3051 /* With -Wunused, we should also warn if the left-hand operand does have
3052 side-effects, but computes a value which is not used. For example, in
3053 `foo() + bar(), baz()' the result of the `+' operator is not used,
3054 so we should issue a warning. */
3055 else if (warn_unused_value)
3056 warn_if_unused_value (expr1, input_location);
3058 return build2 (COMPOUND_EXPR, TREE_TYPE (expr2), expr1, expr2);
3061 /* Build an expression representing a cast to type TYPE of expression EXPR. */
3064 build_c_cast (tree type, tree expr)
3068 if (type == error_mark_node || expr == error_mark_node)
3069 return error_mark_node;
3071 /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
3072 only in <protocol> qualifications. But when constructing cast expressions,
3073 the protocols do matter and must be kept around. */
3074 if (objc_is_object_ptr (type) && objc_is_object_ptr (TREE_TYPE (expr)))
3075 return build1 (NOP_EXPR, type, expr);
3077 type = TYPE_MAIN_VARIANT (type);
3079 if (TREE_CODE (type) == ARRAY_TYPE)
3081 error ("cast specifies array type");
3082 return error_mark_node;
3085 if (TREE_CODE (type) == FUNCTION_TYPE)
3087 error ("cast specifies function type");
3088 return error_mark_node;
3091 if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
3095 if (TREE_CODE (type) == RECORD_TYPE
3096 || TREE_CODE (type) == UNION_TYPE)
3097 pedwarn ("ISO C forbids casting nonscalar to the same type");
3100 else if (TREE_CODE (type) == UNION_TYPE)
3103 value = default_function_array_conversion (value);
3105 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3106 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
3107 TYPE_MAIN_VARIANT (TREE_TYPE (value))))
3115 pedwarn ("ISO C forbids casts to union type");
3116 t = digest_init (type,
3117 build_constructor (type,
3118 build_tree_list (field, value)),
3120 TREE_CONSTANT (t) = TREE_CONSTANT (value);
3121 TREE_INVARIANT (t) = TREE_INVARIANT (value);
3124 error ("cast to union type from type not present in union");
3125 return error_mark_node;
3131 /* If casting to void, avoid the error that would come
3132 from default_conversion in the case of a non-lvalue array. */
3133 if (type == void_type_node)
3134 return build1 (CONVERT_EXPR, type, value);
3136 /* Convert functions and arrays to pointers,
3137 but don't convert any other types. */
3138 value = default_function_array_conversion (value);
3139 otype = TREE_TYPE (value);
3141 /* Optionally warn about potentially worrisome casts. */
3144 && TREE_CODE (type) == POINTER_TYPE
3145 && TREE_CODE (otype) == POINTER_TYPE)
3147 tree in_type = type;
3148 tree in_otype = otype;
3152 /* Check that the qualifiers on IN_TYPE are a superset of
3153 the qualifiers of IN_OTYPE. The outermost level of
3154 POINTER_TYPE nodes is uninteresting and we stop as soon
3155 as we hit a non-POINTER_TYPE node on either type. */
3158 in_otype = TREE_TYPE (in_otype);
3159 in_type = TREE_TYPE (in_type);
3161 /* GNU C allows cv-qualified function types. 'const'
3162 means the function is very pure, 'volatile' means it
3163 can't return. We need to warn when such qualifiers
3164 are added, not when they're taken away. */
3165 if (TREE_CODE (in_otype) == FUNCTION_TYPE
3166 && TREE_CODE (in_type) == FUNCTION_TYPE)
3167 added |= (TYPE_QUALS (in_type) & ~TYPE_QUALS (in_otype));
3169 discarded |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type));
3171 while (TREE_CODE (in_type) == POINTER_TYPE
3172 && TREE_CODE (in_otype) == POINTER_TYPE);
3175 warning ("cast adds new qualifiers to function type");
3178 /* There are qualifiers present in IN_OTYPE that are not
3179 present in IN_TYPE. */
3180 warning ("cast discards qualifiers from pointer target type");
3183 /* Warn about possible alignment problems. */
3184 if (STRICT_ALIGNMENT && warn_cast_align
3185 && TREE_CODE (type) == POINTER_TYPE
3186 && TREE_CODE (otype) == POINTER_TYPE
3187 && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
3188 && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3189 /* Don't warn about opaque types, where the actual alignment
3190 restriction is unknown. */
3191 && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
3192 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
3193 && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
3194 && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
3195 warning ("cast increases required alignment of target type");
3197 if (TREE_CODE (type) == INTEGER_TYPE
3198 && TREE_CODE (otype) == POINTER_TYPE
3199 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3200 && !TREE_CONSTANT (value))
3201 warning ("cast from pointer to integer of different size");
3203 if (warn_bad_function_cast
3204 && TREE_CODE (value) == CALL_EXPR
3205 && TREE_CODE (type) != TREE_CODE (otype))
3206 warning ("cast from function call of type %qT to non-matching "
3207 "type %qT", otype, type);
3209 if (TREE_CODE (type) == POINTER_TYPE
3210 && TREE_CODE (otype) == INTEGER_TYPE
3211 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3212 /* Don't warn about converting any constant. */
3213 && !TREE_CONSTANT (value))
3214 warning ("cast to pointer from integer of different size");
3216 if (TREE_CODE (type) == POINTER_TYPE
3217 && TREE_CODE (otype) == POINTER_TYPE
3218 && TREE_CODE (expr) == ADDR_EXPR
3219 && DECL_P (TREE_OPERAND (expr, 0))
3220 && flag_strict_aliasing && warn_strict_aliasing
3221 && !VOID_TYPE_P (TREE_TYPE (type)))
3223 /* Casting the address of a decl to non void pointer. Warn
3224 if the cast breaks type based aliasing. */
3225 if (!COMPLETE_TYPE_P (TREE_TYPE (type)))
3226 warning ("type-punning to incomplete type might break strict-aliasing rules");
3229 HOST_WIDE_INT set1 = get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
3230 HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type));
3232 if (!alias_sets_conflict_p (set1, set2))
3233 warning ("dereferencing type-punned pointer will break strict-aliasing rules");
3234 else if (warn_strict_aliasing > 1
3235 && !alias_sets_might_conflict_p (set1, set2))
3236 warning ("dereferencing type-punned pointer might break strict-aliasing rules");
3240 /* If pedantic, warn for conversions between function and object
3241 pointer types, except for converting a null pointer constant
3242 to function pointer type. */
3244 && TREE_CODE (type) == POINTER_TYPE
3245 && TREE_CODE (otype) == POINTER_TYPE
3246 && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE
3247 && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE)
3248 pedwarn ("ISO C forbids conversion of function pointer to object pointer type");
3251 && TREE_CODE (type) == POINTER_TYPE
3252 && TREE_CODE (otype) == POINTER_TYPE
3253 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
3254 && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3255 && !(integer_zerop (value) && TREE_TYPE (otype) == void_type_node
3256 && TREE_CODE (expr) != NOP_EXPR))
3257 pedwarn ("ISO C forbids conversion of object pointer to function pointer type");
3260 /* Replace a nonvolatile const static variable with its value. */
3261 if (optimize && TREE_CODE (value) == VAR_DECL)
3262 value = decl_constant_value (value);
3263 value = convert (type, value);
3265 /* Ignore any integer overflow caused by the cast. */
3266 if (TREE_CODE (value) == INTEGER_CST)
3268 if (EXPR_P (ovalue))
3269 /* If OVALUE had overflow set, then so will VALUE, so it
3270 is safe to overwrite. */
3271 TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3273 TREE_OVERFLOW (value) = 0;
3275 if (CONSTANT_CLASS_P (ovalue))
3276 /* Similarly, constant_overflow cannot have become
3278 TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3282 /* Don't let a cast be an lvalue. */
3284 value = non_lvalue (value);
3289 /* Interpret a cast of expression EXPR to type TYPE. */
3291 c_cast_expr (struct c_type_name *type_name, tree expr)
3294 int saved_wsp = warn_strict_prototypes;
3296 /* This avoids warnings about unprototyped casts on
3297 integers. E.g. "#define SIG_DFL (void(*)())0". */
3298 if (TREE_CODE (expr) == INTEGER_CST)
3299 warn_strict_prototypes = 0;
3300 type = groktypename (type_name);
3301 warn_strict_prototypes = saved_wsp;
3303 return build_c_cast (type, expr);
3307 /* Build an assignment expression of lvalue LHS from value RHS.
3308 MODIFYCODE is the code for a binary operator that we use
3309 to combine the old value of LHS with RHS to get the new value.
3310 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment. */
3313 build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
3317 tree lhstype = TREE_TYPE (lhs);
3318 tree olhstype = lhstype;
3320 /* Types that aren't fully specified cannot be used in assignments. */
3321 lhs = require_complete_type (lhs);
3323 /* Avoid duplicate error messages from operands that had errors. */
3324 if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
3325 return error_mark_node;
3327 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3328 /* Do not use STRIP_NOPS here. We do not want an enumerator
3329 whose value is 0 to count as a null pointer constant. */
3330 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3331 rhs = TREE_OPERAND (rhs, 0);
3335 /* If a binary op has been requested, combine the old LHS value with the RHS
3336 producing the value we should actually store into the LHS. */
3338 if (modifycode != NOP_EXPR)
3340 lhs = stabilize_reference (lhs);
3341 newrhs = build_binary_op (modifycode, lhs, rhs, 1);
3344 if (!lvalue_or_else (lhs, lv_assign))
3345 return error_mark_node;
3347 /* Give an error for storing in something that is 'const'. */
3349 if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
3350 || ((TREE_CODE (lhstype) == RECORD_TYPE
3351 || TREE_CODE (lhstype) == UNION_TYPE)
3352 && C_TYPE_FIELDS_READONLY (lhstype)))
3353 readonly_error (lhs, lv_assign);
3355 /* If storing into a structure or union member,
3356 it has probably been given type `int'.
3357 Compute the type that would go with
3358 the actual amount of storage the member occupies. */
3360 if (TREE_CODE (lhs) == COMPONENT_REF
3361 && (TREE_CODE (lhstype) == INTEGER_TYPE
3362 || TREE_CODE (lhstype) == BOOLEAN_TYPE
3363 || TREE_CODE (lhstype) == REAL_TYPE
3364 || TREE_CODE (lhstype) == ENUMERAL_TYPE))
3365 lhstype = TREE_TYPE (get_unwidened (lhs, 0));
3367 /* If storing in a field that is in actuality a short or narrower than one,
3368 we must store in the field in its actual type. */
3370 if (lhstype != TREE_TYPE (lhs))
3372 lhs = copy_node (lhs);
3373 TREE_TYPE (lhs) = lhstype;
3376 /* Convert new value to destination type. */
3378 newrhs = convert_for_assignment (lhstype, newrhs, ic_assign,
3379 NULL_TREE, NULL_TREE, 0);
3380 if (TREE_CODE (newrhs) == ERROR_MARK)
3381 return error_mark_node;
3383 /* Scan operands. */
3385 result = build2 (MODIFY_EXPR, lhstype, lhs, newrhs);
3386 TREE_SIDE_EFFECTS (result) = 1;
3388 /* If we got the LHS in a different type for storing in,
3389 convert the result back to the nominal type of LHS
3390 so that the value we return always has the same type
3391 as the LHS argument. */
3393 if (olhstype == TREE_TYPE (result))
3395 return convert_for_assignment (olhstype, result, ic_assign,
3396 NULL_TREE, NULL_TREE, 0);
3399 /* Convert value RHS to type TYPE as preparation for an assignment
3400 to an lvalue of type TYPE.
3401 The real work of conversion is done by `convert'.
3402 The purpose of this function is to generate error messages
3403 for assignments that are not allowed in C.
3404 ERRTYPE says whether it is argument passing, assignment,
3405 initialization or return.
3407 FUNCTION is a tree for the function being called.
3408 PARMNUM is the number of the argument, for printing in error messages. */
3411 convert_for_assignment (tree type, tree rhs, enum impl_conv errtype,
3412 tree fundecl, tree function, int parmnum)
3414 enum tree_code codel = TREE_CODE (type);
3416 enum tree_code coder;
3417 tree rname = NULL_TREE;
3419 if (errtype == ic_argpass || errtype == ic_argpass_nonproto)
3422 /* Change pointer to function to the function itself for
3424 if (TREE_CODE (function) == ADDR_EXPR
3425 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
3426 function = TREE_OPERAND (function, 0);
3428 /* Handle an ObjC selector specially for diagnostics. */
3429 selector = objc_message_selector ();
3431 if (selector && parmnum > 2)
3438 /* This macro is used to emit diagnostics to ensure that all format
3439 strings are complete sentences, visible to gettext and checked at
3441 #define WARN_FOR_ASSIGNMENT(AR, AS, IN, RE) \
3446 pedwarn (AR, parmnum, rname); \
3448 case ic_argpass_nonproto: \
3449 warning (AR, parmnum, rname); \
3461 gcc_unreachable (); \
3465 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3466 /* Do not use STRIP_NOPS here. We do not want an enumerator
3467 whose value is 0 to count as a null pointer constant. */
3468 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3469 rhs = TREE_OPERAND (rhs, 0);
3471 if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
3472 || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE)
3473 rhs = default_conversion (rhs);
3474 else if (optimize && TREE_CODE (rhs) == VAR_DECL)
3475 rhs = decl_constant_value_for_broken_optimization (rhs);
3477 rhstype = TREE_TYPE (rhs);
3478 coder = TREE_CODE (rhstype);
3480 if (coder == ERROR_MARK)
3481 return error_mark_node;
3483 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
3485 overflow_warning (rhs);
3486 /* Check for Objective-C protocols. This will automatically
3487 issue a warning if there are protocol violations. No need to
3488 use the return value. */
3489 if (c_dialect_objc ())
3490 objc_comptypes (type, rhstype, 0);
3494 if (coder == VOID_TYPE)
3496 /* Except for passing an argument to an unprototyped function,
3497 this is a constraint violation. When passing an argument to
3498 an unprototyped function, it is compile-time undefined;
3499 making it a constraint in that case was rejected in
3501 error ("void value not ignored as it ought to be");
3502 return error_mark_node;
3504 /* A type converts to a reference to it.
3505 This code doesn't fully support references, it's just for the
3506 special case of va_start and va_copy. */
3507 if (codel == REFERENCE_TYPE
3508 && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1)
3510 if (!lvalue_p (rhs))
3512 error ("cannot pass rvalue to reference parameter");
3513 return error_mark_node;
3515 if (!c_mark_addressable (rhs))
3516 return error_mark_node;
3517 rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
3519 /* We already know that these two types are compatible, but they
3520 may not be exactly identical. In fact, `TREE_TYPE (type)' is
3521 likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
3522 likely to be va_list, a typedef to __builtin_va_list, which
3523 is different enough that it will cause problems later. */
3524 if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
3525 rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
3527 rhs = build1 (NOP_EXPR, type, rhs);
3530 /* Some types can interconvert without explicit casts. */
3531 else if (codel == VECTOR_TYPE && coder == VECTOR_TYPE
3532 && vector_types_convertible_p (type, TREE_TYPE (rhs)))
3533 return convert (type, rhs);
3534 /* Arithmetic types all interconvert, and enum is treated like int. */
3535 else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
3536 || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
3537 || codel == BOOLEAN_TYPE)
3538 && (coder == INTEGER_TYPE || coder == REAL_TYPE
3539 || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE
3540 || coder == BOOLEAN_TYPE))
3541 return convert_and_check (type, rhs);
3543 /* Conversion to a transparent union from its member types.
3544 This applies only to function arguments. */
3545 else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type)
3546 && (errtype == ic_argpass || errtype == ic_argpass_nonproto))
3549 tree marginal_memb_type = 0;
3551 for (memb_types = TYPE_FIELDS (type); memb_types;
3552 memb_types = TREE_CHAIN (memb_types))
3554 tree memb_type = TREE_TYPE (memb_types);
3556 if (comptypes (TYPE_MAIN_VARIANT (memb_type),
3557 TYPE_MAIN_VARIANT (rhstype)))
3560 if (TREE_CODE (memb_type) != POINTER_TYPE)
3563 if (coder == POINTER_TYPE)
3565 tree ttl = TREE_TYPE (memb_type);
3566 tree ttr = TREE_TYPE (rhstype);
3568 /* Any non-function converts to a [const][volatile] void *
3569 and vice versa; otherwise, targets must be the same.
3570 Meanwhile, the lhs target must have all the qualifiers of
3572 if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3573 || comp_target_types (memb_type, rhstype, 0))
3575 /* If this type won't generate any warnings, use it. */
3576 if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
3577 || ((TREE_CODE (ttr) == FUNCTION_TYPE
3578 && TREE_CODE (ttl) == FUNCTION_TYPE)
3579 ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
3580 == TYPE_QUALS (ttr))
3581 : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
3582 == TYPE_QUALS (ttl))))
3585 /* Keep looking for a better type, but remember this one. */
3586 if (!marginal_memb_type)
3587 marginal_memb_type = memb_type;
3591 /* Can convert integer zero to any pointer type. */
3592 if (integer_zerop (rhs)
3593 || (TREE_CODE (rhs) == NOP_EXPR
3594 && integer_zerop (TREE_OPERAND (rhs, 0))))
3596 rhs = null_pointer_node;
3601 if (memb_types || marginal_memb_type)
3605 /* We have only a marginally acceptable member type;
3606 it needs a warning. */
3607 tree ttl = TREE_TYPE (marginal_memb_type);
3608 tree ttr = TREE_TYPE (rhstype);
3610 /* Const and volatile mean something different for function
3611 types, so the usual warnings are not appropriate. */
3612 if (TREE_CODE (ttr) == FUNCTION_TYPE
3613 && TREE_CODE (ttl) == FUNCTION_TYPE)
3615 /* Because const and volatile on functions are
3616 restrictions that say the function will not do
3617 certain things, it is okay to use a const or volatile
3618 function where an ordinary one is wanted, but not
3620 if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
3621 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE "
3622 "makes qualified function "
3623 "pointer from unqualified"),
3624 N_("assignment makes qualified "
3625 "function pointer from "
3627 N_("initialization makes qualified "
3628 "function pointer from "
3630 N_("return makes qualified function "
3631 "pointer from unqualified"));
3633 else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
3634 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE discards "
3635 "qualifiers from pointer target type"),
3636 N_("assignment discards qualifiers "
3637 "from pointer target type"),
3638 N_("initialization discards qualifiers "
3639 "from pointer target type"),
3640 N_("return discards qualifiers from "
3641 "pointer target type"));
3644 if (pedantic && !DECL_IN_SYSTEM_HEADER (fundecl))
3645 pedwarn ("ISO C prohibits argument conversion to union type");
3647 return build1 (NOP_EXPR, type, rhs);
3651 /* Conversions among pointers */
3652 else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
3653 && (coder == codel))
3655 tree ttl = TREE_TYPE (type);
3656 tree ttr = TREE_TYPE (rhstype);
3657 bool is_opaque_pointer;
3658 int target_cmp = 0; /* Cache comp_target_types () result. */
3660 /* Opaque pointers are treated like void pointers. */
3661 is_opaque_pointer = (targetm.vector_opaque_p (type)
3662 || targetm.vector_opaque_p (rhstype))
3663 && TREE_CODE (ttl) == VECTOR_TYPE
3664 && TREE_CODE (ttr) == VECTOR_TYPE;
3666 /* Any non-function converts to a [const][volatile] void *
3667 and vice versa; otherwise, targets must be the same.
3668 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
3669 if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3670 || (target_cmp = comp_target_types (type, rhstype, 0))
3671 || is_opaque_pointer
3672 || (c_common_unsigned_type (TYPE_MAIN_VARIANT (ttl))
3673 == c_common_unsigned_type (TYPE_MAIN_VARIANT (ttr))))
3676 && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
3679 /* Check TREE_CODE to catch cases like (void *) (char *) 0
3680 which are not ANSI null ptr constants. */
3681 && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
3682 && TREE_CODE (ttl) == FUNCTION_TYPE)))
3683 WARN_FOR_ASSIGNMENT (N_("ISO C forbids passing argument %d of "
3684 "%qE between function pointer "
3686 N_("ISO C forbids assignment between "
3687 "function pointer and %<void *%>"),
3688 N_("ISO C forbids initialization between "
3689 "function pointer and %<void *%>"),
3690 N_("ISO C forbids return between function "
3691 "pointer and %<void *%>"));
3692 /* Const and volatile mean something different for function types,
3693 so the usual warnings are not appropriate. */
3694 else if (TREE_CODE (ttr) != FUNCTION_TYPE
3695 && TREE_CODE (ttl) != FUNCTION_TYPE)
3697 if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
3698 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE discards "
3699 "qualifiers from pointer target type"),
3700 N_("assignment discards qualifiers "
3701 "from pointer target type"),
3702 N_("initialization discards qualifiers "
3703 "from pointer target type"),
3704 N_("return discards qualifiers from "
3705 "pointer target type"));
3706 /* If this is not a case of ignoring a mismatch in signedness,
3708 else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3711 /* If there is a mismatch, do warn. */
3713 WARN_FOR_ASSIGNMENT (N_("pointer targets in passing argument "
3714 "%d of %qE differ in signedness"),
3715 N_("pointer targets in assignment "
3716 "differ in signedness"),
3717 N_("pointer targets in initialization "
3718 "differ in signedness"),
3719 N_("pointer targets in return differ "
3722 else if (TREE_CODE (ttl) == FUNCTION_TYPE
3723 && TREE_CODE (ttr) == FUNCTION_TYPE)
3725 /* Because const and volatile on functions are restrictions
3726 that say the function will not do certain things,
3727 it is okay to use a const or volatile function
3728 where an ordinary one is wanted, but not vice-versa. */
3729 if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
3730 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE makes "
3731 "qualified function pointer "
3732 "from unqualified"),
3733 N_("assignment makes qualified function "
3734 "pointer from unqualified"),
3735 N_("initialization makes qualified "
3736 "function pointer from unqualified"),
3737 N_("return makes qualified function "
3738 "pointer from unqualified"));
3742 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE from "
3743 "incompatible pointer type"),
3744 N_("assignment from incompatible pointer type"),
3745 N_("initialization from incompatible "
3747 N_("return from incompatible pointer type"));
3748 return convert (type, rhs);
3750 else if (codel == POINTER_TYPE && coder == ARRAY_TYPE)
3752 /* ??? This should not be an error when inlining calls to
3753 unprototyped functions. */
3754 error ("invalid use of non-lvalue array");
3755 return error_mark_node;
3757 else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
3759 /* An explicit constant 0 can convert to a pointer,
3760 or one that results from arithmetic, even including
3761 a cast to integer type. */
3762 if (!(TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
3764 !(TREE_CODE (rhs) == NOP_EXPR
3765 && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
3766 && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
3767 && integer_zerop (TREE_OPERAND (rhs, 0))))
3768 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE makes "
3769 "pointer from integer without a cast"),
3770 N_("assignment makes pointer from integer "
3772 N_("initialization makes pointer from "
3773 "integer without a cast"),
3774 N_("return makes pointer from integer "
3777 return convert (type, rhs);
3779 else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
3781 WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE makes integer "
3782 "from pointer without a cast"),
3783 N_("assignment makes integer from pointer "
3785 N_("initialization makes integer from pointer "
3787 N_("return makes integer from pointer "
3789 return convert (type, rhs);
3791 else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
3792 return convert (type, rhs);
3797 case ic_argpass_nonproto:
3798 /* ??? This should not be an error when inlining calls to
3799 unprototyped functions. */
3800 error ("incompatible type for argument %d of %qE", parmnum, rname);
3803 error ("incompatible types in assignment");
3806 error ("incompatible types in initialization");
3809 error ("incompatible types in return");
3815 return error_mark_node;
3818 /* Convert VALUE for assignment into inlined parameter PARM. ARGNUM
3819 is used for error and waring reporting and indicates which argument
3820 is being processed. */
3823 c_convert_parm_for_inlining (tree parm, tree value, tree fn, int argnum)
3827 /* If FN was prototyped, the value has been converted already
3828 in convert_arguments. */
3829 if (!value || TYPE_ARG_TYPES (TREE_TYPE (fn)))
3832 type = TREE_TYPE (parm);
3833 ret = convert_for_assignment (type, value,
3834 ic_argpass_nonproto, fn,
3836 if (targetm.calls.promote_prototypes (TREE_TYPE (fn))
3837 && INTEGRAL_TYPE_P (type)
3838 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
3839 ret = default_conversion (ret);
3843 /* If VALUE is a compound expr all of whose expressions are constant, then
3844 return its value. Otherwise, return error_mark_node.
3846 This is for handling COMPOUND_EXPRs as initializer elements
3847 which is allowed with a warning when -pedantic is specified. */
3850 valid_compound_expr_initializer (tree value, tree endtype)
3852 if (TREE_CODE (value) == COMPOUND_EXPR)
3854 if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
3856 return error_mark_node;
3857 return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
3860 else if (!initializer_constant_valid_p (value, endtype))
3861 return error_mark_node;
3866 /* Perform appropriate conversions on the initial value of a variable,
3867 store it in the declaration DECL,
3868 and print any error messages that are appropriate.
3869 If the init is invalid, store an ERROR_MARK. */
3872 store_init_value (tree decl, tree init)
3876 /* If variable's type was invalidly declared, just ignore it. */
3878 type = TREE_TYPE (decl);
3879 if (TREE_CODE (type) == ERROR_MARK)
3882 /* Digest the specified initializer into an expression. */
3884 value = digest_init (type, init, true, TREE_STATIC (decl));
3886 /* Store the expression if valid; else report error. */
3888 if (warn_traditional && !in_system_header
3889 && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && !TREE_STATIC (decl))
3890 warning ("traditional C rejects automatic aggregate initialization");
3892 DECL_INITIAL (decl) = value;
3894 /* ANSI wants warnings about out-of-range constant initializers. */
3895 STRIP_TYPE_NOPS (value);
3896 constant_expression_warning (value);
3898 /* Check if we need to set array size from compound literal size. */
3899 if (TREE_CODE (type) == ARRAY_TYPE
3900 && TYPE_DOMAIN (type) == 0
3901 && value != error_mark_node)
3903 tree inside_init = init;
3905 if (TREE_CODE (init) == NON_LVALUE_EXPR)
3906 inside_init = TREE_OPERAND (init, 0);
3907 inside_init = fold (inside_init);
3909 if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
3911 tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
3913 if (TYPE_DOMAIN (TREE_TYPE (decl)))
3915 /* For int foo[] = (int [3]){1}; we need to set array size
3916 now since later on array initializer will be just the
3917 brace enclosed list of the compound literal. */
3918 TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (decl));
3920 layout_decl (decl, 0);
3926 /* Methods for storing and printing names for error messages. */
3928 /* Implement a spelling stack that allows components of a name to be pushed
3929 and popped. Each element on the stack is this structure. */
3941 #define SPELLING_STRING 1
3942 #define SPELLING_MEMBER 2
3943 #define SPELLING_BOUNDS 3
3945 static struct spelling *spelling; /* Next stack element (unused). */
3946 static struct spelling *spelling_base; /* Spelling stack base. */
3947 static int spelling_size; /* Size of the spelling stack. */
3949 /* Macros to save and restore the spelling stack around push_... functions.
3950 Alternative to SAVE_SPELLING_STACK. */
3952 #define SPELLING_DEPTH() (spelling - spelling_base)
3953 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
3955 /* Push an element on the spelling stack with type KIND and assign VALUE
3958 #define PUSH_SPELLING(KIND, VALUE, MEMBER) \
3960 int depth = SPELLING_DEPTH (); \
3962 if (depth >= spelling_size) \
3964 spelling_size += 10; \
3965 spelling_base = XRESIZEVEC (struct spelling, spelling_base, \
3967 RESTORE_SPELLING_DEPTH (depth); \
3970 spelling->kind = (KIND); \
3971 spelling->MEMBER = (VALUE); \
3975 /* Push STRING on the stack. Printed literally. */
3978 push_string (const char *string)
3980 PUSH_SPELLING (SPELLING_STRING, string, u.s);
3983 /* Push a member name on the stack. Printed as '.' STRING. */
3986 push_member_name (tree decl)
3988 const char *const string
3989 = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
3990 PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
3993 /* Push an array bounds on the stack. Printed as [BOUNDS]. */
3996 push_array_bounds (int bounds)
3998 PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
4001 /* Compute the maximum size in bytes of the printed spelling. */
4004 spelling_length (void)
4009 for (p = spelling_base; p < spelling; p++)
4011 if (p->kind == SPELLING_BOUNDS)
4014 size += strlen (p->u.s) + 1;
4020 /* Print the spelling to BUFFER and return it. */
4023 print_spelling (char *buffer)
4028 for (p = spelling_base; p < spelling; p++)
4029 if (p->kind == SPELLING_BOUNDS)
4031 sprintf (d, "[%d]", p->u.i);
4037 if (p->kind == SPELLING_MEMBER)
4039 for (s = p->u.s; (*d = *s++); d++)
4046 /* Issue an error message for a bad initializer component.
4047 MSGID identifies the message.
4048 The component name is taken from the spelling stack. */
4051 error_init (const char *msgid)
4055 error ("%s", _(msgid));
4056 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4058 error ("(near initialization for %qs)", ofwhat);
4061 /* Issue a pedantic warning for a bad initializer component.
4062 MSGID identifies the message.
4063 The component name is taken from the spelling stack. */
4066 pedwarn_init (const char *msgid)
4070 pedwarn ("%s", _(msgid));
4071 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4073 pedwarn ("(near initialization for %qs)", ofwhat);
4076 /* Issue a warning for a bad initializer component.
4077 MSGID identifies the message.
4078 The component name is taken from the spelling stack. */
4081 warning_init (const char *msgid)
4085 warning ("%s", _(msgid));
4086 ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4088 warning ("(near initialization for %qs)", ofwhat);
4091 /* If TYPE is an array type and EXPR is a parenthesized string
4092 constant, warn if pedantic that EXPR is being used to initialize an
4093 object of type TYPE. */
4096 maybe_warn_string_init (tree type, struct c_expr expr)
4099 && TREE_CODE (type) == ARRAY_TYPE
4100 && TREE_CODE (expr.value) == STRING_CST
4101 && expr.original_code != STRING_CST)
4102 pedwarn_init ("array initialized from parenthesized string constant");
4105 /* Digest the parser output INIT as an initializer for type TYPE.
4106 Return a C expression of type TYPE to represent the initial value.
4108 If INIT is a string constant, STRICT_STRING is true if it is
4109 unparenthesized or we should not warn here for it being parenthesized.
4110 For other types of INIT, STRICT_STRING is not used.
4112 REQUIRE_CONSTANT requests an error if non-constant initializers or
4113 elements are seen. */
4116 digest_init (tree type, tree init, bool strict_string, int require_constant)
4118 enum tree_code code = TREE_CODE (type);
4119 tree inside_init = init;
4121 if (type == error_mark_node
4122 || init == error_mark_node
4123 || TREE_TYPE (init) == error_mark_node)
4124 return error_mark_node;
4126 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4127 /* Do not use STRIP_NOPS here. We do not want an enumerator
4128 whose value is 0 to count as a null pointer constant. */
4129 if (TREE_CODE (init) == NON_LVALUE_EXPR)
4130 inside_init = TREE_OPERAND (init, 0);
4132 inside_init = fold (inside_init);
4134 /* Initialization of an array of chars from a string constant
4135 optionally enclosed in braces. */
4137 if (code == ARRAY_TYPE && inside_init
4138 && TREE_CODE (inside_init) == STRING_CST)
4140 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
4141 /* Note that an array could be both an array of character type
4142 and an array of wchar_t if wchar_t is signed char or unsigned
4144 bool char_array = (typ1 == char_type_node
4145 || typ1 == signed_char_type_node
4146 || typ1 == unsigned_char_type_node);
4147 bool wchar_array = !!comptypes (typ1, wchar_type_node);
4148 if (char_array || wchar_array)
4152 expr.value = inside_init;
4153 expr.original_code = (strict_string ? STRING_CST : ERROR_MARK);
4154 maybe_warn_string_init (type, expr);
4157 = (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4160 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4161 TYPE_MAIN_VARIANT (type)))
4164 if (!wchar_array && !char_string)
4166 error_init ("char-array initialized from wide string");
4167 return error_mark_node;
4169 if (char_string && !char_array)
4171 error_init ("wchar_t-array initialized from non-wide string");
4172 return error_mark_node;
4175 TREE_TYPE (inside_init) = type;
4176 if (TYPE_DOMAIN (type) != 0
4177 && TYPE_SIZE (type) != 0
4178 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
4179 /* Subtract 1 (or sizeof (wchar_t))
4180 because it's ok to ignore the terminating null char
4181 that is counted in the length of the constant. */
4182 && 0 > compare_tree_int (TYPE_SIZE_UNIT (type),
4183 TREE_STRING_LENGTH (inside_init)
4184 - ((TYPE_PRECISION (typ1)
4185 != TYPE_PRECISION (char_type_node))
4186 ? (TYPE_PRECISION (wchar_type_node)
4189 pedwarn_init ("initializer-string for array of chars is too long");
4193 else if (INTEGRAL_TYPE_P (typ1))
4195 error_init ("array of inappropriate type initialized "
4196 "from string constant");
4197 return error_mark_node;
4201 /* Build a VECTOR_CST from a *constant* vector constructor. If the
4202 vector constructor is not constant (e.g. {1,2,3,foo()}) then punt
4203 below and handle as a constructor. */
4204 if (code == VECTOR_TYPE
4205 && TREE_CODE (TREE_TYPE (inside_init)) == VECTOR_TYPE
4206 && vector_types_convertible_p (TREE_TYPE (inside_init), type)
4207 && TREE_CONSTANT (inside_init))
4209 if (TREE_CODE (inside_init) == VECTOR_CST
4210 && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4211 TYPE_MAIN_VARIANT (type)))
4214 return build_vector (type, CONSTRUCTOR_ELTS (inside_init));
4217 /* Any type can be initialized
4218 from an expression of the same type, optionally with braces. */
4220 if (inside_init && TREE_TYPE (inside_init) != 0
4221 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4222 TYPE_MAIN_VARIANT (type))
4223 || (code == ARRAY_TYPE
4224 && comptypes (TREE_TYPE (inside_init), type))
4225 || (code == VECTOR_TYPE
4226 && comptypes (TREE_TYPE (inside_init), type))
4227 || (code == POINTER_TYPE
4228 && TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4229 && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
4231 || (code == POINTER_TYPE
4232 && TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE
4233 && comptypes (TREE_TYPE (inside_init),
4234 TREE_TYPE (type)))))
4236 if (code == POINTER_TYPE)
4238 inside_init = default_function_array_conversion (inside_init);
4240 if (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE)
4242 error_init ("invalid use of non-lvalue array");
4243 return error_mark_node;
4247 if (code == VECTOR_TYPE)
4248 /* Although the types are compatible, we may require a
4250 inside_init = convert (type, inside_init);
4252 if (require_constant && !flag_isoc99
4253 && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
4255 /* As an extension, allow initializing objects with static storage
4256 duration with compound literals (which are then treated just as
4257 the brace enclosed list they contain). */
4258 tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
4259 inside_init = DECL_INITIAL (decl);
4262 if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
4263 && TREE_CODE (inside_init) != CONSTRUCTOR)
4265 error_init ("array initialized from non-constant array expression");
4266 return error_mark_node;
4269 if (optimize && TREE_CODE (inside_init) == VAR_DECL)
4270 inside_init = decl_constant_value_for_broken_optimization (inside_init);
4272 /* Compound expressions can only occur here if -pedantic or
4273 -pedantic-errors is specified. In the later case, we always want
4274 an error. In the former case, we simply want a warning. */
4275 if (require_constant && pedantic
4276 && TREE_CODE (inside_init) == COMPOUND_EXPR)
4279 = valid_compound_expr_initializer (inside_init,
4280 TREE_TYPE (inside_init));
4281 if (inside_init == error_mark_node)
4282 error_init ("initializer element is not constant");
4284 pedwarn_init ("initializer element is not constant");
4285 if (flag_pedantic_errors)
4286 inside_init = error_mark_node;
4288 else if (require_constant
4289 && !initializer_constant_valid_p (inside_init,
4290 TREE_TYPE (inside_init)))
4292 error_init ("initializer element is not constant");
4293 inside_init = error_mark_node;
4299 /* Handle scalar types, including conversions. */
4301 if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
4302 || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE
4303 || code == VECTOR_TYPE)
4305 /* Note that convert_for_assignment calls default_conversion
4306 for arrays and functions. We must not call it in the
4307 case where inside_init is a null pointer constant. */
4309 = convert_for_assignment (type, init, ic_init,
4310 NULL_TREE, NULL_TREE, 0);
4312 /* Check to see if we have already given an error message. */
4313 if (inside_init == error_mark_node)
4315 else if (require_constant && !TREE_CONSTANT (inside_init))
4317 error_init ("initializer element is not constant");
4318 inside_init = error_mark_node;
4320 else if (require_constant
4321 && !initializer_constant_valid_p (inside_init,
4322 TREE_TYPE (inside_init)))
4324 error_init ("initializer element is not computable at load time");
4325 inside_init = error_mark_node;
4331 /* Come here only for records and arrays. */
4333 if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4335 error_init ("variable-sized object may not be initialized");
4336 return error_mark_node;
4339 error_init ("invalid initializer");
4340 return error_mark_node;
4343 /* Handle initializers that use braces. */
4345 /* Type of object we are accumulating a constructor for.
4346 This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */
4347 static tree constructor_type;
4349 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4351 static tree constructor_fields;
4353 /* For an ARRAY_TYPE, this is the specified index
4354 at which to store the next element we get. */
4355 static tree constructor_index;
4357 /* For an ARRAY_TYPE, this is the maximum index. */
4358 static tree constructor_max_index;
4360 /* For a RECORD_TYPE, this is the first field not yet written out. */
4361 static tree constructor_unfilled_fields;
4363 /* For an ARRAY_TYPE, this is the index of the first element
4364 not yet written out. */
4365 static tree constructor_unfilled_index;
4367 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4368 This is so we can generate gaps between fields, when appropriate. */
4369 static tree constructor_bit_index;
4371 /* If we are saving up the elements rather than allocating them,
4372 this is the list of elements so far (in reverse order,
4373 most recent first). */
4374 static tree constructor_elements;
4376 /* 1 if constructor should be incrementally stored into a constructor chain,
4377 0 if all the elements should be kept in AVL tree. */
4378 static int constructor_incremental;
4380 /* 1 if so far this constructor's elements are all compile-time constants. */
4381 static int constructor_constant;
4383 /* 1 if so far this constructor's elements are all valid address constants. */
4384 static int constructor_simple;
4386 /* 1 if this constructor is erroneous so far. */
4387 static int constructor_erroneous;
4389 /* Structure for managing pending initializer elements, organized as an
4394 struct init_node *left, *right;
4395 struct init_node *parent;
4401 /* Tree of pending elements at this constructor level.
4402 These are elements encountered out of order
4403 which belong at places we haven't reached yet in actually
4405 Will never hold tree nodes across GC runs. */
4406 static struct init_node *constructor_pending_elts;
4408 /* The SPELLING_DEPTH of this constructor. */
4409 static int constructor_depth;
4411 /* 0 if implicitly pushing constructor levels is allowed. */
4412 int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages. */
4414 /* DECL node for which an initializer is being read.
4415 0 means we are reading a constructor expression
4416 such as (struct foo) {...}. */
4417 static tree constructor_decl;
4419 /* Nonzero if this is an initializer for a top-level decl. */
4420 static int constructor_top_level;
4422 /* Nonzero if there were any member designators in this initializer. */
4423 static int constructor_designated;
4425 /* Nesting depth of designator list. */
4426 static int designator_depth;
4428 /* Nonzero if there were diagnosed errors in this designator list. */
4429 static int designator_errorneous;
4432 /* This stack has a level for each implicit or explicit level of
4433 structuring in the initializer, including the outermost one. It
4434 saves the values of most of the variables above. */
4436 struct constructor_range_stack;
4438 struct constructor_stack
4440 struct constructor_stack *next;
4445 tree unfilled_index;
4446 tree unfilled_fields;
4449 struct init_node *pending_elts;
4452 /* If value nonzero, this value should replace the entire
4453 constructor at this level. */
4454 struct c_expr replacement_value;
4455 struct constructor_range_stack *range_stack;
4465 struct constructor_stack *constructor_stack;
4467 /* This stack represents designators from some range designator up to
4468 the last designator in the list. */
4470 struct constructor_range_stack
4472 struct constructor_range_stack *next, *prev;
4473 struct constructor_stack *stack;
4480 struct constructor_range_stack *constructor_range_stack;
4482 /* This stack records separate initializers that are nested.
4483 Nested initializers can't happen in ANSI C, but GNU C allows them
4484 in cases like { ... (struct foo) { ... } ... }. */
4486 struct initializer_stack
4488 struct initializer_stack *next;
4490 struct constructor_stack *constructor_stack;
4491 struct constructor_range_stack *constructor_range_stack;
4493 struct spelling *spelling;
4494 struct spelling *spelling_base;
4497 char require_constant_value;
4498 char require_constant_elements;
4501 struct initializer_stack *initializer_stack;
4503 /* Prepare to parse and output the initializer for variable DECL. */
4506 start_init (tree decl, tree asmspec_tree ATTRIBUTE_UNUSED, int top_level)
4509 struct initializer_stack *p = xmalloc (sizeof (struct initializer_stack));
4511 p->decl = constructor_decl;
4512 p->require_constant_value = require_constant_value;
4513 p->require_constant_elements = require_constant_elements;
4514 p->constructor_stack = constructor_stack;
4515 p->constructor_range_stack = constructor_range_stack;
4516 p->elements = constructor_elements;
4517 p->spelling = spelling;
4518 p->spelling_base = spelling_base;
4519 p->spelling_size = spelling_size;
4520 p->top_level = constructor_top_level;
4521 p->next = initializer_stack;
4522 initializer_stack = p;
4524 constructor_decl = decl;
4525 constructor_designated = 0;
4526 constructor_top_level = top_level;
4530 require_constant_value = TREE_STATIC (decl);
4531 require_constant_elements
4532 = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
4533 /* For a scalar, you can always use any value to initialize,
4534 even within braces. */
4535 && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
4536 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
4537 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
4538 || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
4539 locus = IDENTIFIER_POINTER (DECL_NAME (decl));
4543 require_constant_value = 0;
4544 require_constant_elements = 0;
4545 locus = "(anonymous)";
4548 constructor_stack = 0;
4549 constructor_range_stack = 0;
4551 missing_braces_mentioned = 0;
4555 RESTORE_SPELLING_DEPTH (0);
4558 push_string (locus);
4564 struct initializer_stack *p = initializer_stack;
4566 /* Free the whole constructor stack of this initializer. */
4567 while (constructor_stack)
4569 struct constructor_stack *q = constructor_stack;
4570 constructor_stack = q->next;
4574 gcc_assert (!constructor_range_stack);
4576 /* Pop back to the data of the outer initializer (if any). */
4577 free (spelling_base);
4579 constructor_decl = p->decl;
4580 require_constant_value = p->require_constant_value;
4581 require_constant_elements = p->require_constant_elements;
4582 constructor_stack = p->constructor_stack;
4583 constructor_range_stack = p->constructor_range_stack;
4584 constructor_elements = p->elements;
4585 spelling = p->spelling;
4586 spelling_base = p->spelling_base;
4587 spelling_size = p->spelling_size;
4588 constructor_top_level = p->top_level;
4589 initializer_stack = p->next;
4593 /* Call here when we see the initializer is surrounded by braces.
4594 This is instead of a call to push_init_level;
4595 it is matched by a call to pop_init_level.
4597 TYPE is the type to initialize, for a constructor expression.
4598 For an initializer for a decl, TYPE is zero. */
4601 really_start_incremental_init (tree type)
4603 struct constructor_stack *p = XNEW (struct constructor_stack);
4606 type = TREE_TYPE (constructor_decl);
4608 if (targetm.vector_opaque_p (type))
4609 error ("opaque vector types cannot be initialized");
4611 p->type = constructor_type;
4612 p->fields = constructor_fields;
4613 p->index = constructor_index;
4614 p->max_index = constructor_max_index;
4615 p->unfilled_index = constructor_unfilled_index;
4616 p->unfilled_fields = constructor_unfilled_fields;
4617 p->bit_index = constructor_bit_index;
4618 p->elements = constructor_elements;
4619 p->constant = constructor_constant;
4620 p->simple = constructor_simple;
4621 p->erroneous = constructor_erroneous;
4622 p->pending_elts = constructor_pending_elts;
4623 p->depth = constructor_depth;
4624 p->replacement_value.value = 0;
4625 p->replacement_value.original_code = ERROR_MARK;
4629 p->incremental = constructor_incremental;
4630 p->designated = constructor_designated;
4632 constructor_stack = p;
4634 constructor_constant = 1;
4635 constructor_simple = 1;
4636 constructor_depth = SPELLING_DEPTH ();
4637 constructor_elements = 0;
4638 constructor_pending_elts = 0;
4639 constructor_type = type;
4640 constructor_incremental = 1;
4641 constructor_designated = 0;
4642 designator_depth = 0;
4643 designator_errorneous = 0;
4645 if (TREE_CODE (constructor_type) == RECORD_TYPE
4646 || TREE_CODE (constructor_type) == UNION_TYPE)
4648 constructor_fields = TYPE_FIELDS (constructor_type);
4649 /* Skip any nameless bit fields at the beginning. */
4650 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
4651 && DECL_NAME (constructor_fields) == 0)
4652 constructor_fields = TREE_CHAIN (constructor_fields);
4654 constructor_unfilled_fields = constructor_fields;
4655 constructor_bit_index = bitsize_zero_node;
4657 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4659 if (TYPE_DOMAIN (constructor_type))
4661 constructor_max_index
4662 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
4664 /* Detect non-empty initializations of zero-length arrays. */
4665 if (constructor_max_index == NULL_TREE
4666 && TYPE_SIZE (constructor_type))
4667 constructor_max_index = build_int_cst (NULL_TREE, -1);
4669 /* constructor_max_index needs to be an INTEGER_CST. Attempts
4670 to initialize VLAs will cause a proper error; avoid tree
4671 checking errors as well by setting a safe value. */
4672 if (constructor_max_index
4673 && TREE_CODE (constructor_max_index) != INTEGER_CST)
4674 constructor_max_index = build_int_cst (NULL_TREE, -1);
4677 = convert (bitsizetype,
4678 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
4681 constructor_index = bitsize_zero_node;
4683 constructor_unfilled_index = constructor_index;
4685 else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
4687 /* Vectors are like simple fixed-size arrays. */
4688 constructor_max_index =
4689 build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
4690 constructor_index = convert (bitsizetype, bitsize_zero_node);
4691 constructor_unfilled_index = constructor_index;
4695 /* Handle the case of int x = {5}; */
4696 constructor_fields = constructor_type;
4697 constructor_unfilled_fields = constructor_type;
4701 /* Push down into a subobject, for initialization.
4702 If this is for an explicit set of braces, IMPLICIT is 0.
4703 If it is because the next element belongs at a lower level,
4704 IMPLICIT is 1 (or 2 if the push is because of designator list). */
4707 push_init_level (int implicit)
4709 struct constructor_stack *p;
4710 tree value = NULL_TREE;
4712 /* If we've exhausted any levels that didn't have braces,
4714 while (constructor_stack->implicit)
4716 if ((TREE_CODE (constructor_type) == RECORD_TYPE
4717 || TREE_CODE (constructor_type) == UNION_TYPE)
4718 && constructor_fields == 0)
4719 process_init_element (pop_init_level (1));
4720 else if (TREE_CODE (constructor_type) == ARRAY_TYPE
4721 && constructor_max_index
4722 && tree_int_cst_lt (constructor_max_index, constructor_index))
4723 process_init_element (pop_init_level (1));
4728 /* Unless this is an explicit brace, we need to preserve previous
4732 if ((TREE_CODE (constructor_type) == RECORD_TYPE
4733 || TREE_CODE (constructor_type) == UNION_TYPE)
4734 && constructor_fields)
4735 value = find_init_member (constructor_fields);
4736 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4737 value = find_init_member (constructor_index);
4740 p = XNEW (struct constructor_stack);
4741 p->type = constructor_type;
4742 p->fields = constructor_fields;
4743 p->index = constructor_index;
4744 p->max_index = constructor_max_index;
4745 p->unfilled_index = constructor_unfilled_index;
4746 p->unfilled_fields = constructor_unfilled_fields;
4747 p->bit_index = constructor_bit_index;
4748 p->elements = constructor_elements;
4749 p->constant = constructor_constant;
4750 p->simple = constructor_simple;
4751 p->erroneous = constructor_erroneous;
4752 p->pending_elts = constructor_pending_elts;
4753 p->depth = constructor_depth;
4754 p->replacement_value.value = 0;
4755 p->replacement_value.original_code = ERROR_MARK;
4756 p->implicit = implicit;
4758 p->incremental = constructor_incremental;
4759 p->designated = constructor_designated;
4760 p->next = constructor_stack;
4762 constructor_stack = p;
4764 constructor_constant = 1;
4765 constructor_simple = 1;
4766 constructor_depth = SPELLING_DEPTH ();
4767 constructor_elements = 0;
4768 constructor_incremental = 1;
4769 constructor_designated = 0;
4770 constructor_pending_elts = 0;
4773 p->range_stack = constructor_range_stack;
4774 constructor_range_stack = 0;
4775 designator_depth = 0;
4776 designator_errorneous = 0;
4779 /* Don't die if an entire brace-pair level is superfluous
4780 in the containing level. */
4781 if (constructor_type == 0)
4783 else if (TREE_CODE (constructor_type) == RECORD_TYPE
4784 || TREE_CODE (constructor_type) == UNION_TYPE)
4786 /* Don't die if there are extra init elts at the end. */
4787 if (constructor_fields == 0)
4788 constructor_type = 0;
4791 constructor_type = TREE_TYPE (constructor_fields);
4792 push_member_name (constructor_fields);
4793 constructor_depth++;
4796 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4798 constructor_type = TREE_TYPE (constructor_type);
4799 push_array_bounds (tree_low_cst (constructor_index, 0));
4800 constructor_depth++;
4803 if (constructor_type == 0)
4805 error_init ("extra brace group at end of initializer");
4806 constructor_fields = 0;
4807 constructor_unfilled_fields = 0;
4811 if (value && TREE_CODE (value) == CONSTRUCTOR)
4813 constructor_constant = TREE_CONSTANT (value);
4814 constructor_simple = TREE_STATIC (value);
4815 constructor_elements = CONSTRUCTOR_ELTS (value);
4816 if (constructor_elements
4817 && (TREE_CODE (constructor_type) == RECORD_TYPE
4818 || TREE_CODE (constructor_type) == ARRAY_TYPE))
4819 set_nonincremental_init ();
4822 if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
4824 missing_braces_mentioned = 1;
4825 warning_init ("missing braces around initializer");
4828 if (TREE_CODE (constructor_type) == RECORD_TYPE
4829 || TREE_CODE (constructor_type) == UNION_TYPE)
4831 constructor_fields = TYPE_FIELDS (constructor_type);
4832 /* Skip any nameless bit fields at the beginning. */
4833 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
4834 && DECL_NAME (constructor_fields) == 0)
4835 constructor_fields = TREE_CHAIN (constructor_fields);
4837 constructor_unfilled_fields = constructor_fields;
4838 constructor_bit_index = bitsize_zero_node;
4840 else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
4842 /* Vectors are like simple fixed-size arrays. */
4843 constructor_max_index =
4844 build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
4845 constructor_index = convert (bitsizetype, integer_zero_node);
4846 constructor_unfilled_index = constructor_index;
4848 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4850 if (TYPE_DOMAIN (constructor_type))
4852 constructor_max_index
4853 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
4855 /* Detect non-empty initializations of zero-length arrays. */
4856 if (constructor_max_index == NULL_TREE
4857 && TYPE_SIZE (constructor_type))
4858 constructor_max_index = build_int_cst (NULL_TREE, -1);
4860 /* constructor_max_index needs to be an INTEGER_CST. Attempts
4861 to initialize VLAs will cause a proper error; avoid tree
4862 checking errors as well by setting a safe value. */
4863 if (constructor_max_index
4864 && TREE_CODE (constructor_max_index) != INTEGER_CST)
4865 constructor_max_index = build_int_cst (NULL_TREE, -1);
4868 = convert (bitsizetype,
4869 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
4872 constructor_index = bitsize_zero_node;
4874 constructor_unfilled_index = constructor_index;
4875 if (value && TREE_CODE (value) == STRING_CST)
4877 /* We need to split the char/wchar array into individual
4878 characters, so that we don't have to special case it
4880 set_nonincremental_init_from_string (value);
4885 warning_init ("braces around scalar initializer");
4886 constructor_fields = constructor_type;
4887 constructor_unfilled_fields = constructor_type;
4891 /* At the end of an implicit or explicit brace level,
4892 finish up that level of constructor. If a single expression
4893 with redundant braces initialized that level, return the
4894 c_expr structure for that expression. Otherwise, the original_code
4895 element is set to ERROR_MARK.
4896 If we were outputting the elements as they are read, return 0 as the value
4897 from inner levels (process_init_element ignores that),
4898 but return error_mark_node as the value from the outermost level
4899 (that's what we want to put in DECL_INITIAL).
4900 Otherwise, return a CONSTRUCTOR expression as the value. */
4903 pop_init_level (int implicit)
4905 struct constructor_stack *p;
4908 ret.original_code = ERROR_MARK;
4912 /* When we come to an explicit close brace,
4913 pop any inner levels that didn't have explicit braces. */
4914 while (constructor_stack->implicit)
4915 process_init_element (pop_init_level (1));
4917 gcc_assert (!constructor_range_stack);
4920 /* Now output all pending elements. */
4921 constructor_incremental = 1;
4922 output_pending_init_elements (1);
4924 p = constructor_stack;
4926 /* Error for initializing a flexible array member, or a zero-length
4927 array member in an inappropriate context. */
4928 if (constructor_type && constructor_fields
4929 && TREE_CODE (constructor_type) == ARRAY_TYPE
4930 && TYPE_DOMAIN (constructor_type)
4931 && !TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
4933 /* Silently discard empty initializations. The parser will
4934 already have pedwarned for empty brackets. */
4935 if (integer_zerop (constructor_unfilled_index))
4936 constructor_type = NULL_TREE;
4939 gcc_assert (!TYPE_SIZE (constructor_type));
4941 if (constructor_depth > 2)
4942 error_init ("initialization of flexible array member in a nested context");
4944 pedwarn_init ("initialization of a flexible array member");
4946 /* We have already issued an error message for the existence
4947 of a flexible array member not at the end of the structure.
4948 Discard the initializer so that we do not abort later. */
4949 if (TREE_CHAIN (constructor_fields) != NULL_TREE)
4950 constructor_type = NULL_TREE;
4954 /* Warn when some struct elements are implicitly initialized to zero. */
4955 if (warn_missing_field_initializers
4957 && TREE_CODE (constructor_type) == RECORD_TYPE
4958 && constructor_unfilled_fields)
4960 /* Do not warn for flexible array members or zero-length arrays. */
4961 while (constructor_unfilled_fields
4962 && (!DECL_SIZE (constructor_unfilled_fields)
4963 || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
4964 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
4966 /* Do not warn if this level of the initializer uses member
4967 designators; it is likely to be deliberate. */
4968 if (constructor_unfilled_fields && !constructor_designated)
4970 push_member_name (constructor_unfilled_fields);
4971 warning_init ("missing initializer");
4972 RESTORE_SPELLING_DEPTH (constructor_depth);
4976 /* Pad out the end of the structure. */
4977 if (p->replacement_value.value)
4978 /* If this closes a superfluous brace pair,
4979 just pass out the element between them. */
4980 ret = p->replacement_value;
4981 else if (constructor_type == 0)
4983 else if (TREE_CODE (constructor_type) != RECORD_TYPE
4984 && TREE_CODE (constructor_type) != UNION_TYPE
4985 && TREE_CODE (constructor_type) != ARRAY_TYPE
4986 && TREE_CODE (constructor_type) != VECTOR_TYPE)
4988 /* A nonincremental scalar initializer--just return
4989 the element, after verifying there is just one. */
4990 if (constructor_elements == 0)
4992 if (!constructor_erroneous)
4993 error_init ("empty scalar initializer");
4994 ret.value = error_mark_node;
4996 else if (TREE_CHAIN (constructor_elements) != 0)
4998 error_init ("extra elements in scalar initializer");
4999 ret.value = TREE_VALUE (constructor_elements);
5002 ret.value = TREE_VALUE (constructor_elements);
5006 if (constructor_erroneous)
5007 ret.value = error_mark_node;
5010 ret.value = build_constructor (constructor_type,
5011 nreverse (constructor_elements));
5012 if (constructor_constant)
5013 TREE_CONSTANT (ret.value) = TREE_INVARIANT (ret.value) = 1;
5014 if (constructor_constant && constructor_simple)
5015 TREE_STATIC (ret.value) = 1;
5019 constructor_type = p->type;
5020 constructor_fields = p->fields;
5021 constructor_index = p->index;
5022 constructor_max_index = p->max_index;
5023 constructor_unfilled_index = p->unfilled_index;
5024 constructor_unfilled_fields = p->unfilled_fields;
5025 constructor_bit_index = p->bit_index;
5026 constructor_elements = p->elements;
5027 constructor_constant = p->constant;
5028 constructor_simple = p->simple;
5029 constructor_erroneous = p->erroneous;
5030 constructor_incremental = p->incremental;
5031 constructor_designated = p->designated;
5032 constructor_pending_elts = p->pending_elts;
5033 constructor_depth = p->depth;
5035 constructor_range_stack = p->range_stack;
5036 RESTORE_SPELLING_DEPTH (constructor_depth);
5038 constructor_stack = p->next;
5043 if (constructor_stack == 0)
5045 ret.value = error_mark_node;
5053 /* Common handling for both array range and field name designators.
5054 ARRAY argument is nonzero for array ranges. Returns zero for success. */
5057 set_designator (int array)
5060 enum tree_code subcode;
5062 /* Don't die if an entire brace-pair level is superfluous
5063 in the containing level. */
5064 if (constructor_type == 0)
5067 /* If there were errors in this designator list already, bail out
5069 if (designator_errorneous)
5072 if (!designator_depth)
5074 gcc_assert (!constructor_range_stack);
5076 /* Designator list starts at the level of closest explicit
5078 while (constructor_stack->implicit)
5079 process_init_element (pop_init_level (1));
5080 constructor_designated = 1;
5084 if (constructor_no_implicit)
5086 error_init ("initialization designators may not nest");
5090 switch (TREE_CODE (constructor_type))
5094 subtype = TREE_TYPE (constructor_fields);
5095 if (subtype != error_mark_node)
5096 subtype = TYPE_MAIN_VARIANT (subtype);
5099 subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
5105 subcode = TREE_CODE (subtype);
5106 if (array && subcode != ARRAY_TYPE)
5108 error_init ("array index in non-array initializer");
5111 else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
5113 error_init ("field name not in record or union initializer");
5117 constructor_designated = 1;
5118 push_init_level (2);
5122 /* If there are range designators in designator list, push a new designator
5123 to constructor_range_stack. RANGE_END is end of such stack range or
5124 NULL_TREE if there is no range designator at this level. */
5127 push_range_stack (tree range_end)
5129 struct constructor_range_stack *p;
5131 p = GGC_NEW (struct constructor_range_stack);
5132 p->prev = constructor_range_stack;
5134 p->fields = constructor_fields;
5135 p->range_start = constructor_index;
5136 p->index = constructor_index;
5137 p->stack = constructor_stack;
5138 p->range_end = range_end;
5139 if (constructor_range_stack)
5140 constructor_range_stack->next = p;
5141 constructor_range_stack = p;
5144 /* Within an array initializer, specify the next index to be initialized.
5145 FIRST is that index. If LAST is nonzero, then initialize a range
5146 of indices, running from FIRST through LAST. */
5149 set_init_index (tree first, tree last)
5151 if (set_designator (1))
5154 designator_errorneous = 1;
5156 if (!INTEGRAL_TYPE_P (TREE_TYPE (first))
5157 || (last && !INTEGRAL_TYPE_P (TREE_TYPE (last))))
5159 error_init ("array index in initializer not of integer type");
5163 while ((TREE_CODE (first) == NOP_EXPR
5164 || TREE_CODE (first) == CONVERT_EXPR
5165 || TREE_CODE (first) == NON_LVALUE_EXPR)
5166 && (TYPE_MODE (TREE_TYPE (first))
5167 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
5168 first = TREE_OPERAND (first, 0);
5171 while ((TREE_CODE (last) == NOP_EXPR
5172 || TREE_CODE (last) == CONVERT_EXPR
5173 || TREE_CODE (last) == NON_LVALUE_EXPR)
5174 && (TYPE_MODE (TREE_TYPE (last))
5175 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
5176 last = TREE_OPERAND (last, 0);
5178 if (TREE_CODE (first) != INTEGER_CST)
5179 error_init ("nonconstant array index in initializer");
5180 else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
5181 error_init ("nonconstant array index in initializer");
5182 else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
5183 error_init ("array index in non-array initializer");
5184 else if (tree_int_cst_sgn (first) == -1)
5185 error_init ("array index in initializer exceeds array bounds");
5186 else if (constructor_max_index
5187 && tree_int_cst_lt (constructor_max_index, first))
5188 error_init ("array index in initializer exceeds array bounds");
5191 constructor_index = convert (bitsizetype, first);
5195 if (tree_int_cst_equal (first, last))
5197 else if (tree_int_cst_lt (last, first))
5199 error_init ("empty index range in initializer");
5204 last = convert (bitsizetype, last);
5205 if (constructor_max_index != 0
5206 && tree_int_cst_lt (constructor_max_index, last))
5208 error_init ("array index range in initializer exceeds array bounds");
5215 designator_errorneous = 0;
5216 if (constructor_range_stack || last)
5217 push_range_stack (last);
5221 /* Within a struct initializer, specify the next field to be initialized. */
5224 set_init_label (tree fieldname)
5228 if (set_designator (0))
5231 designator_errorneous = 1;
5233 if (TREE_CODE (constructor_type) != RECORD_TYPE
5234 && TREE_CODE (constructor_type) != UNION_TYPE)
5236 error_init ("field name not in record or union initializer");
5240 for (tail = TYPE_FIELDS (constructor_type); tail;
5241 tail = TREE_CHAIN (tail))
5243 if (DECL_NAME (tail) == fieldname)
5248 error ("unknown field %qs specified in initializer",
5249 IDENTIFIER_POINTER (fieldname));
5252 constructor_fields = tail;
5254 designator_errorneous = 0;
5255 if (constructor_range_stack)
5256 push_range_stack (NULL_TREE);
5260 /* Add a new initializer to the tree of pending initializers. PURPOSE
5261 identifies the initializer, either array index or field in a structure.
5262 VALUE is the value of that index or field. */
5265 add_pending_init (tree purpose, tree value)
5267 struct init_node *p, **q, *r;
5269 q = &constructor_pending_elts;
5272 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5277 if (tree_int_cst_lt (purpose, p->purpose))
5279 else if (tree_int_cst_lt (p->purpose, purpose))
5283 if (TREE_SIDE_EFFECTS (p->value))
5284 warning_init ("initialized field with side-effects overwritten");
5294 bitpos = bit_position (purpose);
5298 if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5300 else if (p->purpose != purpose)
5304 if (TREE_SIDE_EFFECTS (p->value))
5305 warning_init ("initialized field with side-effects overwritten");
5312 r = GGC_NEW (struct init_node);
5313 r->purpose = purpose;
5324 struct init_node *s;
5328 if (p->balance == 0)
5330 else if (p->balance < 0)
5337 p->left->parent = p;
5354 constructor_pending_elts = r;
5359 struct init_node *t = r->right;
5363 r->right->parent = r;
5368 p->left->parent = p;
5371 p->balance = t->balance < 0;
5372 r->balance = -(t->balance > 0);
5387 constructor_pending_elts = t;
5393 /* p->balance == +1; growth of left side balances the node. */
5398 else /* r == p->right */
5400 if (p->balance == 0)
5401 /* Growth propagation from right side. */
5403 else if (p->balance > 0)
5410 p->right->parent = p;
5427 constructor_pending_elts = r;
5429 else /* r->balance == -1 */
5432 struct init_node *t = r->left;
5436 r->left->parent = r;
5441 p->right->parent = p;
5444 r->balance = (t->balance < 0);
5445 p->balance = -(t->balance > 0);
5460 constructor_pending_elts = t;
5466 /* p->balance == -1; growth of right side balances the node. */
5477 /* Build AVL tree from a sorted chain. */
5480 set_nonincremental_init (void)
5484 if (TREE_CODE (constructor_type) != RECORD_TYPE
5485 && TREE_CODE (constructor_type) != ARRAY_TYPE)
5488 for (chain = constructor_elements; chain; chain = TREE_CHAIN (chain))
5489 add_pending_init (TREE_PURPOSE (chain), TREE_VALUE (chain));
5490 constructor_elements = 0;
5491 if (TREE_CODE (constructor_type) == RECORD_TYPE)
5493 constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
5494 /* Skip any nameless bit fields at the beginning. */
5495 while (constructor_unfilled_fields != 0
5496 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5497 && DECL_NAME (constructor_unfilled_fields) == 0)
5498 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5501 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5503 if (TYPE_DOMAIN (constructor_type))
5504 constructor_unfilled_index
5505 = convert (bitsizetype,
5506 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5508 constructor_unfilled_index = bitsize_zero_node;
5510 constructor_incremental = 0;
5513 /* Build AVL tree from a string constant. */
5516 set_nonincremental_init_from_string (tree str)
5518 tree value, purpose, type;
5519 HOST_WIDE_INT val[2];
5520 const char *p, *end;
5521 int byte, wchar_bytes, charwidth, bitpos;
5523 gcc_assert (TREE_CODE (constructor_type) == ARRAY_TYPE);
5525 if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
5526 == TYPE_PRECISION (char_type_node))
5530 gcc_assert (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
5531 == TYPE_PRECISION (wchar_type_node));
5532 wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
5534 charwidth = TYPE_PRECISION (char_type_node);
5535 type = TREE_TYPE (constructor_type);
5536 p = TREE_STRING_POINTER (str);
5537 end = p + TREE_STRING_LENGTH (str);
5539 for (purpose = bitsize_zero_node;
5540 p < end && !tree_int_cst_lt (constructor_max_index, purpose);
5541 purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
5543 if (wchar_bytes == 1)
5545 val[1] = (unsigned char) *p++;
5552 for (byte = 0; byte < wchar_bytes; byte++)
5554 if (BYTES_BIG_ENDIAN)
5555 bitpos = (wchar_bytes - byte - 1) * charwidth;
5557 bitpos = byte * charwidth;
5558 val[bitpos < HOST_BITS_PER_WIDE_INT]
5559 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
5560 << (bitpos % HOST_BITS_PER_WIDE_INT);
5564 if (!TYPE_UNSIGNED (type))
5566 bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
5567 if (bitpos < HOST_BITS_PER_WIDE_INT)
5569 if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
5571 val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
5575 else if (bitpos == HOST_BITS_PER_WIDE_INT)
5580 else if (val[0] & (((HOST_WIDE_INT) 1)
5581 << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
5582 val[0] |= ((HOST_WIDE_INT) -1)
5583 << (bitpos - HOST_BITS_PER_WIDE_INT);
5586 value = build_int_cst_wide (type, val[1], val[0]);
5587 add_pending_init (purpose, value);
5590 constructor_incremental = 0;
5593 /* Return value of FIELD in pending initializer or zero if the field was
5594 not initialized yet. */
5597 find_init_member (tree field)
5599 struct init_node *p;
5601 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5603 if (constructor_incremental
5604 && tree_int_cst_lt (field, constructor_unfilled_index))
5605 set_nonincremental_init ();
5607 p = constructor_pending_elts;
5610 if (tree_int_cst_lt (field, p->purpose))
5612 else if (tree_int_cst_lt (p->purpose, field))
5618 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
5620 tree bitpos = bit_position (field);
5622 if (constructor_incremental
5623 && (!constructor_unfilled_fields
5624 || tree_int_cst_lt (bitpos,
5625 bit_position (constructor_unfilled_fields))))
5626 set_nonincremental_init ();
5628 p = constructor_pending_elts;
5631 if (field == p->purpose)
5633 else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5639 else if (TREE_CODE (constructor_type) == UNION_TYPE)
5641 if (constructor_elements
5642 && TREE_PURPOSE (constructor_elements) == field)
5643 return TREE_VALUE (constructor_elements);
5648 /* "Output" the next constructor element.
5649 At top level, really output it to assembler code now.
5650 Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
5651 TYPE is the data type that the containing data type wants here.
5652 FIELD is the field (a FIELD_DECL) or the index that this element fills.
5653 If VALUE is a string constant, STRICT_STRING is true if it is
5654 unparenthesized or we should not warn here for it being parenthesized.
5655 For other types of VALUE, STRICT_STRING is not used.
5657 PENDING if non-nil means output pending elements that belong
5658 right after this element. (PENDING is normally 1;
5659 it is 0 while outputting pending elements, to avoid recursion.) */
5662 output_init_element (tree value, bool strict_string, tree type, tree field,
5665 if (type == error_mark_node || value == error_mark_node)
5667 constructor_erroneous = 1;
5670 if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
5671 || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
5672 && !(TREE_CODE (value) == STRING_CST
5673 && TREE_CODE (type) == ARRAY_TYPE
5674 && INTEGRAL_TYPE_P (TREE_TYPE (type)))
5675 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
5676 TYPE_MAIN_VARIANT (type))))
5677 value = default_conversion (value);
5679 if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR
5680 && require_constant_value && !flag_isoc99 && pending)
5682 /* As an extension, allow initializing objects with static storage
5683 duration with compound literals (which are then treated just as
5684 the brace enclosed list they contain). */
5685 tree decl = COMPOUND_LITERAL_EXPR_DECL (value);
5686 value = DECL_INITIAL (decl);
5689 if (value == error_mark_node)
5690 constructor_erroneous = 1;
5691 else if (!TREE_CONSTANT (value))
5692 constructor_constant = 0;
5693 else if (!initializer_constant_valid_p (value, TREE_TYPE (value))
5694 || ((TREE_CODE (constructor_type) == RECORD_TYPE
5695 || TREE_CODE (constructor_type) == UNION_TYPE)
5696 && DECL_C_BIT_FIELD (field)
5697 && TREE_CODE (value) != INTEGER_CST))
5698 constructor_simple = 0;
5700 if (!initializer_constant_valid_p (value, TREE_TYPE (value)))
5702 if (require_constant_value)
5704 error_init ("initializer element is not constant");
5705 value = error_mark_node;
5707 else if (require_constant_elements)
5708 pedwarn ("initializer element is not computable at load time");
5711 /* If this field is empty (and not at the end of structure),
5712 don't do anything other than checking the initializer. */
5714 && (TREE_TYPE (field) == error_mark_node
5715 || (COMPLETE_TYPE_P (TREE_TYPE (field))
5716 && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
5717 && (TREE_CODE (constructor_type) == ARRAY_TYPE
5718 || TREE_CHAIN (field)))))
5721 value = digest_init (type, value, strict_string, require_constant_value);
5722 if (value == error_mark_node)
5724 constructor_erroneous = 1;
5728 /* If this element doesn't come next in sequence,
5729 put it on constructor_pending_elts. */
5730 if (TREE_CODE (constructor_type) == ARRAY_TYPE
5731 && (!constructor_incremental
5732 || !tree_int_cst_equal (field, constructor_unfilled_index)))
5734 if (constructor_incremental
5735 && tree_int_cst_lt (field, constructor_unfilled_index))
5736 set_nonincremental_init ();
5738 add_pending_init (field, value);
5741 else if (TREE_CODE (constructor_type) == RECORD_TYPE
5742 && (!constructor_incremental
5743 || field != constructor_unfilled_fields))
5745 /* We do this for records but not for unions. In a union,
5746 no matter which field is specified, it can be initialized
5747 right away since it starts at the beginning of the union. */
5748 if (constructor_incremental)
5750 if (!constructor_unfilled_fields)
5751 set_nonincremental_init ();
5754 tree bitpos, unfillpos;
5756 bitpos = bit_position (field);
5757 unfillpos = bit_position (constructor_unfilled_fields);
5759 if (tree_int_cst_lt (bitpos, unfillpos))
5760 set_nonincremental_init ();
5764 add_pending_init (field, value);
5767 else if (TREE_CODE (constructor_type) == UNION_TYPE
5768 && constructor_elements)
5770 if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements)))
5771 warning_init ("initialized field with side-effects overwritten");
5773 /* We can have just one union field set. */
5774 constructor_elements = 0;
5777 /* Otherwise, output this element either to
5778 constructor_elements or to the assembler file. */
5780 if (field && TREE_CODE (field) == INTEGER_CST)
5781 field = copy_node (field);
5782 constructor_elements
5783 = tree_cons (field, value, constructor_elements);
5785 /* Advance the variable that indicates sequential elements output. */
5786 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5787 constructor_unfilled_index
5788 = size_binop (PLUS_EXPR, constructor_unfilled_index,
5790 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
5792 constructor_unfilled_fields
5793 = TREE_CHAIN (constructor_unfilled_fields);
5795 /* Skip any nameless bit fields. */
5796 while (constructor_unfilled_fields != 0
5797 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5798 && DECL_NAME (constructor_unfilled_fields) == 0)
5799 constructor_unfilled_fields =
5800 TREE_CHAIN (constructor_unfilled_fields);
5802 else if (TREE_CODE (constructor_type) == UNION_TYPE)
5803 constructor_unfilled_fields = 0;
5805 /* Now output any pending elements which have become next. */
5807 output_pending_init_elements (0);
5810 /* Output any pending elements which have become next.
5811 As we output elements, constructor_unfilled_{fields,index}
5812 advances, which may cause other elements to become next;
5813 if so, they too are output.
5815 If ALL is 0, we return when there are
5816 no more pending elements to output now.
5818 If ALL is 1, we output space as necessary so that
5819 we can output all the pending elements. */
5822 output_pending_init_elements (int all)
5824 struct init_node *elt = constructor_pending_elts;
5829 /* Look through the whole pending tree.
5830 If we find an element that should be output now,
5831 output it. Otherwise, set NEXT to the element
5832 that comes first among those still pending. */
5837 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5839 if (tree_int_cst_equal (elt->purpose,
5840 constructor_unfilled_index))
5841 output_init_element (elt->value, true,
5842 TREE_TYPE (constructor_type),
5843 constructor_unfilled_index, 0);
5844 else if (tree_int_cst_lt (constructor_unfilled_index,
5847 /* Advance to the next smaller node. */
5852 /* We have reached the smallest node bigger than the
5853 current unfilled index. Fill the space first. */
5854 next = elt->purpose;
5860 /* Advance to the next bigger node. */
5865 /* We have reached the biggest node in a subtree. Find
5866 the parent of it, which is the next bigger node. */
5867 while (elt->parent && elt->parent->right == elt)
5870 if (elt && tree_int_cst_lt (constructor_unfilled_index,
5873 next = elt->purpose;
5879 else if (TREE_CODE (constructor_type) == RECORD_TYPE
5880 || TREE_CODE (constructor_type) == UNION_TYPE)
5882 tree ctor_unfilled_bitpos, elt_bitpos;
5884 /* If the current record is complete we are done. */
5885 if (constructor_unfilled_fields == 0)
5888 ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
5889 elt_bitpos = bit_position (elt->purpose);
5890 /* We can't compare fields here because there might be empty
5891 fields in between. */
5892 if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
5894 constructor_unfilled_fields = elt->purpose;
5895 output_init_element (elt->value, true, TREE_TYPE (elt->purpose),
5898 else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
5900 /* Advance to the next smaller node. */
5905 /* We have reached the smallest node bigger than the
5906 current unfilled field. Fill the space first. */
5907 next = elt->purpose;
5913 /* Advance to the next bigger node. */
5918 /* We have reached the biggest node in a subtree. Find
5919 the parent of it, which is the next bigger node. */
5920 while (elt->parent && elt->parent->right == elt)
5924 && (tree_int_cst_lt (ctor_unfilled_bitpos,
5925 bit_position (elt->purpose))))
5927 next = elt->purpose;
5935 /* Ordinarily return, but not if we want to output all
5936 and there are elements left. */
5937 if (!(all && next != 0))
5940 /* If it's not incremental, just skip over the gap, so that after
5941 jumping to retry we will output the next successive element. */
5942 if (TREE_CODE (constructor_type) == RECORD_TYPE
5943 || TREE_CODE (constructor_type) == UNION_TYPE)
5944 constructor_unfilled_fields = next;
5945 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5946 constructor_unfilled_index = next;
5948 /* ELT now points to the node in the pending tree with the next
5949 initializer to output. */
5953 /* Add one non-braced element to the current constructor level.
5954 This adjusts the current position within the constructor's type.
5955 This may also start or terminate implicit levels
5956 to handle a partly-braced initializer.
5958 Once this has found the correct level for the new element,
5959 it calls output_init_element. */
5962 process_init_element (struct c_expr value)
5964 tree orig_value = value.value;
5965 int string_flag = orig_value != 0 && TREE_CODE (orig_value) == STRING_CST;
5966 bool strict_string = value.original_code == STRING_CST;
5968 designator_depth = 0;
5969 designator_errorneous = 0;
5971 /* Handle superfluous braces around string cst as in
5972 char x[] = {"foo"}; */
5975 && TREE_CODE (constructor_type) == ARRAY_TYPE
5976 && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type))
5977 && integer_zerop (constructor_unfilled_index))
5979 if (constructor_stack->replacement_value.value)
5980 error_init ("excess elements in char array initializer");
5981 constructor_stack->replacement_value = value;
5985 if (constructor_stack->replacement_value.value != 0)
5987 error_init ("excess elements in struct initializer");
5991 /* Ignore elements of a brace group if it is entirely superfluous
5992 and has already been diagnosed. */
5993 if (constructor_type == 0)
5996 /* If we've exhausted any levels that didn't have braces,
5998 while (constructor_stack->implicit)
6000 if ((TREE_CODE (constructor_type) == RECORD_TYPE
6001 || TREE_CODE (constructor_type) == UNION_TYPE)
6002 && constructor_fields == 0)
6003 process_init_element (pop_init_level (1));
6004 else if (TREE_CODE (constructor_type) == ARRAY_TYPE
6005 && (constructor_max_index == 0
6006 || tree_int_cst_lt (constructor_max_index,
6007 constructor_index)))
6008 process_init_element (pop_init_level (1));
6013 /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */
6014 if (constructor_range_stack)
6016 /* If value is a compound literal and we'll be just using its
6017 content, don't put it into a SAVE_EXPR. */
6018 if (TREE_CODE (value.value) != COMPOUND_LITERAL_EXPR
6019 || !require_constant_value
6021 value.value = save_expr (value.value);
6026 if (TREE_CODE (constructor_type) == RECORD_TYPE)
6029 enum tree_code fieldcode;
6031 if (constructor_fields == 0)
6033 pedwarn_init ("excess elements in struct initializer");
6037 fieldtype = TREE_TYPE (constructor_fields);
6038 if (fieldtype != error_mark_node)
6039 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6040 fieldcode = TREE_CODE (fieldtype);
6042 /* Error for non-static initialization of a flexible array member. */
6043 if (fieldcode == ARRAY_TYPE
6044 && !require_constant_value
6045 && TYPE_SIZE (fieldtype) == NULL_TREE
6046 && TREE_CHAIN (constructor_fields) == NULL_TREE)
6048 error_init ("non-static initialization of a flexible array member");
6052 /* Accept a string constant to initialize a subarray. */
6053 if (value.value != 0
6054 && fieldcode == ARRAY_TYPE
6055 && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
6057 value.value = orig_value;
6058 /* Otherwise, if we have come to a subaggregate,
6059 and we don't have an element of its type, push into it. */
6060 else if (value.value != 0 && !constructor_no_implicit
6061 && value.value != error_mark_node
6062 && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
6063 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6064 || fieldcode == UNION_TYPE))
6066 push_init_level (1);
6072 push_member_name (constructor_fields);
6073 output_init_element (value.value, strict_string,
6074 fieldtype, constructor_fields, 1);
6075 RESTORE_SPELLING_DEPTH (constructor_depth);
6078 /* Do the bookkeeping for an element that was
6079 directly output as a constructor. */
6081 /* For a record, keep track of end position of last field. */
6082 if (DECL_SIZE (constructor_fields))
6083 constructor_bit_index
6084 = size_binop (PLUS_EXPR,
6085 bit_position (constructor_fields),
6086 DECL_SIZE (constructor_fields));
6088 /* If the current field was the first one not yet written out,
6089 it isn't now, so update. */
6090 if (constructor_unfilled_fields == constructor_fields)
6092 constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6093 /* Skip any nameless bit fields. */
6094 while (constructor_unfilled_fields != 0
6095 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6096 && DECL_NAME (constructor_unfilled_fields) == 0)
6097 constructor_unfilled_fields =
6098 TREE_CHAIN (constructor_unfilled_fields);
6102 constructor_fields = TREE_CHAIN (constructor_fields);
6103 /* Skip any nameless bit fields at the beginning. */
6104 while (constructor_fields != 0
6105 && DECL_C_BIT_FIELD (constructor_fields)
6106 && DECL_NAME (constructor_fields) == 0)
6107 constructor_fields = TREE_CHAIN (constructor_fields);
6109 else if (TREE_CODE (constructor_type) == UNION_TYPE)
6112 enum tree_code fieldcode;
6114 if (constructor_fields == 0)
6116 pedwarn_init ("excess elements in union initializer");
6120 fieldtype = TREE_TYPE (constructor_fields);
6121 if (fieldtype != error_mark_node)
6122 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6123 fieldcode = TREE_CODE (fieldtype);
6125 /* Warn that traditional C rejects initialization of unions.
6126 We skip the warning if the value is zero. This is done
6127 under the assumption that the zero initializer in user
6128 code appears conditioned on e.g. __STDC__ to avoid
6129 "missing initializer" warnings and relies on default
6130 initialization to zero in the traditional C case.
6131 We also skip the warning if the initializer is designated,
6132 again on the assumption that this must be conditional on
6133 __STDC__ anyway (and we've already complained about the
6134 member-designator already). */
6135 if (warn_traditional && !in_system_header && !constructor_designated
6136 && !(value.value && (integer_zerop (value.value)
6137 || real_zerop (value.value))))
6138 warning ("traditional C rejects initialization of unions");
6140 /* Accept a string constant to initialize a subarray. */
6141 if (value.value != 0
6142 && fieldcode == ARRAY_TYPE
6143 && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
6145 value.value = orig_value;
6146 /* Otherwise, if we have come to a subaggregate,
6147 and we don't have an element of its type, push into it. */
6148 else if (value.value != 0 && !constructor_no_implicit
6149 && value.value != error_mark_node
6150 && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
6151 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6152 || fieldcode == UNION_TYPE))
6154 push_init_level (1);
6160 push_member_name (constructor_fields);
6161 output_init_element (value.value, strict_string,
6162 fieldtype, constructor_fields, 1);
6163 RESTORE_SPELLING_DEPTH (constructor_depth);
6166 /* Do the bookkeeping for an element that was
6167 directly output as a constructor. */
6169 constructor_bit_index = DECL_SIZE (constructor_fields);
6170 constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6173 constructor_fields = 0;
6175 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6177 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6178 enum tree_code eltcode = TREE_CODE (elttype);
6180 /* Accept a string constant to initialize a subarray. */
6181 if (value.value != 0
6182 && eltcode == ARRAY_TYPE
6183 && INTEGRAL_TYPE_P (TREE_TYPE (elttype))
6185 value.value = orig_value;
6186 /* Otherwise, if we have come to a subaggregate,
6187 and we don't have an element of its type, push into it. */
6188 else if (value.value != 0 && !constructor_no_implicit
6189 && value.value != error_mark_node
6190 && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != elttype
6191 && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
6192 || eltcode == UNION_TYPE))
6194 push_init_level (1);
6198 if (constructor_max_index != 0
6199 && (tree_int_cst_lt (constructor_max_index, constructor_index)
6200 || integer_all_onesp (constructor_max_index)))
6202 pedwarn_init ("excess elements in array initializer");
6206 /* Now output the actual element. */
6209 push_array_bounds (tree_low_cst (constructor_index, 0));
6210 output_init_element (value.value, strict_string,
6211 elttype, constructor_index, 1);
6212 RESTORE_SPELLING_DEPTH (constructor_depth);
6216 = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6219 /* If we are doing the bookkeeping for an element that was
6220 directly output as a constructor, we must update
6221 constructor_unfilled_index. */
6222 constructor_unfilled_index = constructor_index;
6224 else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
6226 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6228 /* Do a basic check of initializer size. Note that vectors
6229 always have a fixed size derived from their type. */
6230 if (tree_int_cst_lt (constructor_max_index, constructor_index))
6232 pedwarn_init ("excess elements in vector initializer");
6236 /* Now output the actual element. */
6238 output_init_element (value.value, strict_string,
6239 elttype, constructor_index, 1);
6242 = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6245 /* If we are doing the bookkeeping for an element that was
6246 directly output as a constructor, we must update
6247 constructor_unfilled_index. */
6248 constructor_unfilled_index = constructor_index;
6251 /* Handle the sole element allowed in a braced initializer
6252 for a scalar variable. */
6253 else if (constructor_fields == 0)
6255 pedwarn_init ("excess elements in scalar initializer");
6261 output_init_element (value.value, strict_string,
6262 constructor_type, NULL_TREE, 1);
6263 constructor_fields = 0;
6266 /* Handle range initializers either at this level or anywhere higher
6267 in the designator stack. */
6268 if (constructor_range_stack)
6270 struct constructor_range_stack *p, *range_stack;
6273 range_stack = constructor_range_stack;
6274 constructor_range_stack = 0;
6275 while (constructor_stack != range_stack->stack)
6277 gcc_assert (constructor_stack->implicit);
6278 process_init_element (pop_init_level (1));
6280 for (p = range_stack;
6281 !p->range_end || tree_int_cst_equal (p->index, p->range_end);
6284 gcc_assert (constructor_stack->implicit);
6285 process_init_element (pop_init_level (1));
6288 p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
6289 if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
6294 constructor_index = p->index;
6295 constructor_fields = p->fields;
6296 if (finish && p->range_end && p->index == p->range_start)
6304 push_init_level (2);
6305 p->stack = constructor_stack;
6306 if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
6307 p->index = p->range_start;
6311 constructor_range_stack = range_stack;
6318 constructor_range_stack = 0;
6321 /* Build a complete asm-statement, whose components are a CV_QUALIFIER
6322 (guaranteed to be 'volatile' or null) and ARGS (represented using
6323 an ASM_EXPR node). */
6325 build_asm_stmt (tree cv_qualifier, tree args)
6327 if (!ASM_VOLATILE_P (args) && cv_qualifier)
6328 ASM_VOLATILE_P (args) = 1;
6329 return add_stmt (args);
6332 /* Build an asm-expr, whose components are a STRING, some OUTPUTS,
6333 some INPUTS, and some CLOBBERS. The latter three may be NULL.
6334 SIMPLE indicates whether there was anything at all after the
6335 string in the asm expression -- asm("blah") and asm("blah" : )
6336 are subtly different. We use a ASM_EXPR node to represent this. */
6338 build_asm_expr (tree string, tree outputs, tree inputs, tree clobbers,
6344 const char *constraint;
6345 bool allows_mem, allows_reg, is_inout;
6349 ninputs = list_length (inputs);
6350 noutputs = list_length (outputs);
6352 /* Remove output conversions that change the type but not the mode. */
6353 for (i = 0, tail = outputs; tail; ++i, tail = TREE_CHAIN (tail))
6355 tree output = TREE_VALUE (tail);
6356 STRIP_NOPS (output);
6357 TREE_VALUE (tail) = output;
6358 lvalue_or_else (output, lv_asm);
6360 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
6362 if (!parse_output_constraint (&constraint, i, ninputs, noutputs,
6363 &allows_mem, &allows_reg, &is_inout))
6365 /* By marking this operand as erroneous, we will not try
6366 to process this operand again in expand_asm_operands. */
6367 TREE_VALUE (tail) = error_mark_node;
6371 /* If the operand is a DECL that is going to end up in
6372 memory, assume it is addressable. This is a bit more
6373 conservative than it would ideally be; the exact test is
6374 buried deep in expand_asm_operands and depends on the
6375 DECL_RTL for the OPERAND -- which we don't have at this
6377 if (!allows_reg && DECL_P (output))
6378 c_mark_addressable (output);
6381 /* Perform default conversions on array and function inputs.
6382 Don't do this for other types as it would screw up operands
6383 expected to be in memory. */
6384 for (tail = inputs; tail; tail = TREE_CHAIN (tail))
6385 TREE_VALUE (tail) = default_function_array_conversion (TREE_VALUE (tail));
6387 args = build_stmt (ASM_EXPR, string, outputs, inputs, clobbers);
6389 /* Simple asm statements are treated as volatile. */
6392 ASM_VOLATILE_P (args) = 1;
6393 ASM_INPUT_P (args) = 1;
6398 /* Generate a goto statement to LABEL. */
6401 c_finish_goto_label (tree label)
6403 tree decl = lookup_label (label);
6407 TREE_USED (decl) = 1;
6408 return add_stmt (build1 (GOTO_EXPR, void_type_node, decl));
6411 /* Generate a computed goto statement to EXPR. */
6414 c_finish_goto_ptr (tree expr)
6417 pedwarn ("ISO C forbids %<goto *expr;%>");
6418 expr = convert (ptr_type_node, expr);
6419 return add_stmt (build1 (GOTO_EXPR, void_type_node, expr));
6422 /* Generate a C `return' statement. RETVAL is the expression for what
6423 to return, or a null pointer for `return;' with no value. */
6426 c_finish_return (tree retval)
6428 tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
6430 if (TREE_THIS_VOLATILE (current_function_decl))
6431 warning ("function declared %<noreturn%> has a %<return%> statement");
6435 current_function_returns_null = 1;
6436 if ((warn_return_type || flag_isoc99)
6437 && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
6438 pedwarn_c99 ("%<return%> with no value, in "
6439 "function returning non-void");
6441 else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
6443 current_function_returns_null = 1;
6444 if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
6445 pedwarn ("%<return%> with a value, in function returning void");
6449 tree t = convert_for_assignment (valtype, retval, ic_return,
6450 NULL_TREE, NULL_TREE, 0);
6451 tree res = DECL_RESULT (current_function_decl);
6454 current_function_returns_value = 1;
6455 if (t == error_mark_node)
6458 inner = t = convert (TREE_TYPE (res), t);
6460 /* Strip any conversions, additions, and subtractions, and see if
6461 we are returning the address of a local variable. Warn if so. */
6464 switch (TREE_CODE (inner))
6466 case NOP_EXPR: case NON_LVALUE_EXPR: case CONVERT_EXPR:
6468 inner = TREE_OPERAND (inner, 0);
6472 /* If the second operand of the MINUS_EXPR has a pointer
6473 type (or is converted from it), this may be valid, so
6474 don't give a warning. */
6476 tree op1 = TREE_OPERAND (inner, 1);
6478 while (!POINTER_TYPE_P (TREE_TYPE (op1))
6479 && (TREE_CODE (op1) == NOP_EXPR
6480 || TREE_CODE (op1) == NON_LVALUE_EXPR
6481 || TREE_CODE (op1) == CONVERT_EXPR))
6482 op1 = TREE_OPERAND (op1, 0);
6484 if (POINTER_TYPE_P (TREE_TYPE (op1)))
6487 inner = TREE_OPERAND (inner, 0);
6492 inner = TREE_OPERAND (inner, 0);
6494 while (REFERENCE_CLASS_P (inner)
6495 && TREE_CODE (inner) != INDIRECT_REF)
6496 inner = TREE_OPERAND (inner, 0);
6499 && !DECL_EXTERNAL (inner)
6500 && !TREE_STATIC (inner)
6501 && DECL_CONTEXT (inner) == current_function_decl)
6502 warning ("function returns address of local variable");
6512 retval = build2 (MODIFY_EXPR, TREE_TYPE (res), res, t);
6515 return add_stmt (build_stmt (RETURN_EXPR, retval));
6519 /* The SWITCH_STMT being built. */
6522 /* The original type of the testing expression, i.e. before the
6523 default conversion is applied. */
6526 /* A splay-tree mapping the low element of a case range to the high
6527 element, or NULL_TREE if there is no high element. Used to
6528 determine whether or not a new case label duplicates an old case
6529 label. We need a tree, rather than simply a hash table, because
6530 of the GNU case range extension. */
6533 /* The next node on the stack. */
6534 struct c_switch *next;
6537 /* A stack of the currently active switch statements. The innermost
6538 switch statement is on the top of the stack. There is no need to
6539 mark the stack for garbage collection because it is only active
6540 during the processing of the body of a function, and we never
6541 collect at that point. */
6543 struct c_switch *c_switch_stack;
6545 /* Start a C switch statement, testing expression EXP. Return the new
6549 c_start_case (tree exp)
6551 enum tree_code code;
6552 tree type, orig_type = error_mark_node;
6553 struct c_switch *cs;
6555 if (exp != error_mark_node)
6557 code = TREE_CODE (TREE_TYPE (exp));
6558 orig_type = TREE_TYPE (exp);
6560 if (!INTEGRAL_TYPE_P (orig_type)
6561 && code != ERROR_MARK)
6563 error ("switch quantity not an integer");
6564 exp = integer_zero_node;
6568 type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
6570 if (warn_traditional && !in_system_header
6571 && (type == long_integer_type_node
6572 || type == long_unsigned_type_node))
6573 warning ("%<long%> switch expression not converted to "
6574 "%<int%> in ISO C");
6576 exp = default_conversion (exp);
6577 type = TREE_TYPE (exp);
6581 /* Add this new SWITCH_STMT to the stack. */
6582 cs = XNEW (struct c_switch);
6583 cs->switch_stmt = build_stmt ((enum tree_code) SWITCH_STMT, exp, NULL_TREE,
6585 cs->orig_type = orig_type;
6586 cs->cases = splay_tree_new (case_compare, NULL, NULL);
6587 cs->next = c_switch_stack;
6588 c_switch_stack = cs;
6590 return add_stmt (cs->switch_stmt);
6593 /* Process a case label. */
6596 do_case (tree low_value, tree high_value)
6598 tree label = NULL_TREE;
6602 label = c_add_case_label (c_switch_stack->cases,
6603 SWITCH_COND (c_switch_stack->switch_stmt),
6604 c_switch_stack->orig_type,
6605 low_value, high_value);
6606 if (label == error_mark_node)
6610 error ("case label not within a switch statement");
6612 error ("%<default%> label not within a switch statement");
6617 /* Finish the switch statement. */
6620 c_finish_case (tree body)
6622 struct c_switch *cs = c_switch_stack;
6624 SWITCH_BODY (cs->switch_stmt) = body;
6626 /* Emit warnings as needed. */
6627 c_do_switch_warnings (cs->cases, cs->switch_stmt);
6629 /* Pop the stack. */
6630 c_switch_stack = cs->next;
6631 splay_tree_delete (cs->cases);
6635 /* Emit an if statement. IF_LOCUS is the location of the 'if'. COND,
6636 THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK
6637 may be null. NESTED_IF is true if THEN_BLOCK contains another IF
6638 statement, and was not surrounded with parenthesis. */
6641 c_finish_if_stmt (location_t if_locus, tree cond, tree then_block,
6642 tree else_block, bool nested_if)
6646 /* Diagnose an ambiguous else if if-then-else is nested inside if-then. */
6647 if (warn_parentheses && nested_if && else_block == NULL)
6649 tree inner_if = then_block;
6651 /* We know from the grammar productions that there is an IF nested
6652 within THEN_BLOCK. Due to labels and c99 conditional declarations,
6653 it might not be exactly THEN_BLOCK, but should be the last
6654 non-container statement within. */
6656 switch (TREE_CODE (inner_if))
6661 inner_if = BIND_EXPR_BODY (inner_if);
6663 case STATEMENT_LIST:
6664 inner_if = expr_last (then_block);
6666 case TRY_FINALLY_EXPR:
6667 case TRY_CATCH_EXPR:
6668 inner_if = TREE_OPERAND (inner_if, 0);
6675 if (COND_EXPR_ELSE (inner_if))
6676 warning ("%Hsuggest explicit braces to avoid ambiguous %<else%>",
6680 /* Diagnose ";" via the special empty statement node that we create. */
6683 if (TREE_CODE (then_block) == NOP_EXPR && !TREE_TYPE (then_block))
6686 warning ("%Hempty body in an if-statement",
6687 EXPR_LOCUS (then_block));
6688 then_block = alloc_stmt_list ();
6691 && TREE_CODE (else_block) == NOP_EXPR
6692 && !TREE_TYPE (else_block))
6694 warning ("%Hempty body in an else-statement",
6695 EXPR_LOCUS (else_block));
6696 else_block = alloc_stmt_list ();
6700 stmt = build3 (COND_EXPR, NULL_TREE, cond, then_block, else_block);
6701 SET_EXPR_LOCATION (stmt, if_locus);
6705 /* Emit a general-purpose loop construct. START_LOCUS is the location of
6706 the beginning of the loop. COND is the loop condition. COND_IS_FIRST
6707 is false for DO loops. INCR is the FOR increment expression. BODY is
6708 the statement controlled by the loop. BLAB is the break label. CLAB is
6709 the continue label. Everything is allowed to be NULL. */
6712 c_finish_loop (location_t start_locus, tree cond, tree incr, tree body,
6713 tree blab, tree clab, bool cond_is_first)
6715 tree entry = NULL, exit = NULL, t;
6717 /* Detect do { ... } while (0) and don't generate loop construct. */
6718 if (cond && !cond_is_first && integer_zerop (cond))
6720 if (cond_is_first || cond)
6722 tree top = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
6724 /* If we have an exit condition, then we build an IF with gotos either
6725 out of the loop, or to the top of it. If there's no exit condition,
6726 then we just build a jump back to the top. */
6727 exit = build_and_jump (&LABEL_EXPR_LABEL (top));
6731 /* Canonicalize the loop condition to the end. This means
6732 generating a branch to the loop condition. Reuse the
6733 continue label, if possible. */
6738 entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
6739 t = build_and_jump (&LABEL_EXPR_LABEL (entry));
6742 t = build1 (GOTO_EXPR, void_type_node, clab);
6743 SET_EXPR_LOCATION (t, start_locus);
6747 t = build_and_jump (&blab);
6748 exit = build3 (COND_EXPR, void_type_node, cond, exit, t);
6751 SET_EXPR_LOCATION (exit, start_locus);
6753 SET_EXPR_LOCATION (exit, input_location);
6762 add_stmt (build1 (LABEL_EXPR, void_type_node, clab));
6770 add_stmt (build1 (LABEL_EXPR, void_type_node, blab));
6774 c_finish_bc_stmt (tree *label_p, bool is_break)
6776 tree label = *label_p;
6779 *label_p = label = create_artificial_label ();
6780 else if (TREE_CODE (label) != LABEL_DECL)
6783 error ("break statement not within loop or switch");
6785 error ("continue statement not within a loop");
6789 return add_stmt (build1 (GOTO_EXPR, void_type_node, label));
6792 /* A helper routine for c_process_expr_stmt and c_finish_stmt_expr. */
6795 emit_side_effect_warnings (tree expr)
6797 if (expr == error_mark_node)
6799 else if (!TREE_SIDE_EFFECTS (expr))
6801 if (!VOID_TYPE_P (TREE_TYPE (expr)) && !TREE_NO_WARNING (expr))
6802 warning ("%Hstatement with no effect",
6803 EXPR_HAS_LOCATION (expr) ? EXPR_LOCUS (expr) : &input_location);
6805 else if (warn_unused_value)
6806 warn_if_unused_value (expr, input_location);
6809 /* Process an expression as if it were a complete statement. Emit
6810 diagnostics, but do not call ADD_STMT. */
6813 c_process_expr_stmt (tree expr)
6818 /* Do default conversion if safe and possibly important,
6819 in case within ({...}). */
6820 if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
6821 && (flag_isoc99 || lvalue_p (expr)))
6822 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
6823 expr = default_conversion (expr);
6825 if (warn_sequence_point)
6826 verify_sequence_points (expr);
6828 if (TREE_TYPE (expr) != error_mark_node
6829 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
6830 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
6831 error ("expression statement has incomplete type");
6833 /* If we're not processing a statement expression, warn about unused values.
6834 Warnings for statement expressions will be emitted later, once we figure
6835 out which is the result. */
6836 if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
6837 && (extra_warnings || warn_unused_value))
6838 emit_side_effect_warnings (expr);
6840 /* If the expression is not of a type to which we cannot assign a line
6841 number, wrap the thing in a no-op NOP_EXPR. */
6842 if (DECL_P (expr) || CONSTANT_CLASS_P (expr))
6843 expr = build1 (NOP_EXPR, TREE_TYPE (expr), expr);
6846 SET_EXPR_LOCATION (expr, input_location);
6851 /* Emit an expression as a statement. */
6854 c_finish_expr_stmt (tree expr)
6857 return add_stmt (c_process_expr_stmt (expr));
6862 /* Do the opposite and emit a statement as an expression. To begin,
6863 create a new binding level and return it. */
6866 c_begin_stmt_expr (void)
6870 /* We must force a BLOCK for this level so that, if it is not expanded
6871 later, there is a way to turn off the entire subtree of blocks that
6872 are contained in it. */
6874 ret = c_begin_compound_stmt (true);
6876 /* Mark the current statement list as belonging to a statement list. */
6877 STATEMENT_LIST_STMT_EXPR (ret) = 1;
6883 c_finish_stmt_expr (tree body)
6885 tree last, type, tmp, val;
6888 body = c_end_compound_stmt (body, true);
6890 /* Locate the last statement in BODY. See c_end_compound_stmt
6891 about always returning a BIND_EXPR. */
6892 last_p = &BIND_EXPR_BODY (body);
6893 last = BIND_EXPR_BODY (body);
6896 if (TREE_CODE (last) == STATEMENT_LIST)
6898 tree_stmt_iterator i;
6900 /* This can happen with degenerate cases like ({ }). No value. */
6901 if (!TREE_SIDE_EFFECTS (last))
6904 /* If we're supposed to generate side effects warnings, process
6905 all of the statements except the last. */
6906 if (extra_warnings || warn_unused_value)
6908 for (i = tsi_start (last); !tsi_one_before_end_p (i); tsi_next (&i))
6909 emit_side_effect_warnings (tsi_stmt (i));
6912 i = tsi_last (last);
6913 last_p = tsi_stmt_ptr (i);
6917 /* If the end of the list is exception related, then the list was split
6918 by a call to push_cleanup. Continue searching. */
6919 if (TREE_CODE (last) == TRY_FINALLY_EXPR
6920 || TREE_CODE (last) == TRY_CATCH_EXPR)
6922 last_p = &TREE_OPERAND (last, 0);
6924 goto continue_searching;
6927 /* In the case that the BIND_EXPR is not necessary, return the
6928 expression out from inside it. */
6929 if (last == error_mark_node
6930 || (last == BIND_EXPR_BODY (body)
6931 && BIND_EXPR_VARS (body) == NULL))
6934 /* Extract the type of said expression. */
6935 type = TREE_TYPE (last);
6937 /* If we're not returning a value at all, then the BIND_EXPR that
6938 we already have is a fine expression to return. */
6939 if (!type || VOID_TYPE_P (type))
6942 /* Now that we've located the expression containing the value, it seems
6943 silly to make voidify_wrapper_expr repeat the process. Create a
6944 temporary of the appropriate type and stick it in a TARGET_EXPR. */
6945 tmp = create_tmp_var_raw (type, NULL);
6947 /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt. This avoids
6948 tree_expr_nonnegative_p giving up immediately. */
6950 if (TREE_CODE (val) == NOP_EXPR
6951 && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0)))
6952 val = TREE_OPERAND (val, 0);
6954 *last_p = build2 (MODIFY_EXPR, void_type_node, tmp, val);
6955 SET_EXPR_LOCUS (*last_p, EXPR_LOCUS (last));
6957 return build4 (TARGET_EXPR, type, tmp, body, NULL_TREE, NULL_TREE);
6960 /* Begin and end compound statements. This is as simple as pushing
6961 and popping new statement lists from the tree. */
6964 c_begin_compound_stmt (bool do_scope)
6966 tree stmt = push_stmt_list ();
6973 c_end_compound_stmt (tree stmt, bool do_scope)
6979 if (c_dialect_objc ())
6980 objc_clear_super_receiver ();
6981 block = pop_scope ();
6984 stmt = pop_stmt_list (stmt);
6985 stmt = c_build_bind_expr (block, stmt);
6987 /* If this compound statement is nested immediately inside a statement
6988 expression, then force a BIND_EXPR to be created. Otherwise we'll
6989 do the wrong thing for ({ { 1; } }) or ({ 1; { } }). In particular,
6990 STATEMENT_LISTs merge, and thus we can lose track of what statement
6993 && STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
6994 && TREE_CODE (stmt) != BIND_EXPR)
6996 stmt = build3 (BIND_EXPR, void_type_node, NULL, stmt, NULL);
6997 TREE_SIDE_EFFECTS (stmt) = 1;
7003 /* Queue a cleanup. CLEANUP is an expression/statement to be executed
7004 when the current scope is exited. EH_ONLY is true when this is not
7005 meant to apply to normal control flow transfer. */
7008 push_cleanup (tree ARG_UNUSED (decl), tree cleanup, bool eh_only)
7010 enum tree_code code;
7014 code = eh_only ? TRY_CATCH_EXPR : TRY_FINALLY_EXPR;
7015 stmt = build_stmt (code, NULL, cleanup);
7017 stmt_expr = STATEMENT_LIST_STMT_EXPR (cur_stmt_list);
7018 list = push_stmt_list ();
7019 TREE_OPERAND (stmt, 0) = list;
7020 STATEMENT_LIST_STMT_EXPR (list) = stmt_expr;
7023 /* Build a binary-operation expression without default conversions.
7024 CODE is the kind of expression to build.
7025 This function differs from `build' in several ways:
7026 the data type of the result is computed and recorded in it,
7027 warnings are generated if arg data types are invalid,
7028 special handling for addition and subtraction of pointers is known,
7029 and some optimization is done (operations on narrow ints
7030 are done in the narrower type when that gives the same result).
7031 Constant folding is also done before the result is returned.
7033 Note that the operands will never have enumeral types, or function
7034 or array types, because either they will have the default conversions
7035 performed or they have both just been converted to some other type in which
7036 the arithmetic is to be done. */
7039 build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
7043 enum tree_code code0, code1;
7046 /* Expression code to give to the expression when it is built.
7047 Normally this is CODE, which is what the caller asked for,
7048 but in some special cases we change it. */
7049 enum tree_code resultcode = code;
7051 /* Data type in which the computation is to be performed.
7052 In the simplest cases this is the common type of the arguments. */
7053 tree result_type = NULL;
7055 /* Nonzero means operands have already been type-converted
7056 in whatever way is necessary.
7057 Zero means they need to be converted to RESULT_TYPE. */
7060 /* Nonzero means create the expression with this type, rather than
7062 tree build_type = 0;
7064 /* Nonzero means after finally constructing the expression
7065 convert it to this type. */
7066 tree final_type = 0;
7068 /* Nonzero if this is an operation like MIN or MAX which can
7069 safely be computed in short if both args are promoted shorts.
7070 Also implies COMMON.
7071 -1 indicates a bitwise operation; this makes a difference
7072 in the exact conditions for when it is safe to do the operation
7073 in a narrower mode. */
7076 /* Nonzero if this is a comparison operation;
7077 if both args are promoted shorts, compare the original shorts.
7078 Also implies COMMON. */
7079 int short_compare = 0;
7081 /* Nonzero if this is a right-shift operation, which can be computed on the
7082 original short and then promoted if the operand is a promoted short. */
7083 int short_shift = 0;
7085 /* Nonzero means set RESULT_TYPE to the common type of the args. */
7090 op0 = default_conversion (orig_op0);
7091 op1 = default_conversion (orig_op1);
7099 type0 = TREE_TYPE (op0);
7100 type1 = TREE_TYPE (op1);
7102 /* The expression codes of the data types of the arguments tell us
7103 whether the arguments are integers, floating, pointers, etc. */
7104 code0 = TREE_CODE (type0);
7105 code1 = TREE_CODE (type1);
7107 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
7108 STRIP_TYPE_NOPS (op0);
7109 STRIP_TYPE_NOPS (op1);
7111 /* If an error was already reported for one of the arguments,
7112 avoid reporting another error. */
7114 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
7115 return error_mark_node;
7120 /* Handle the pointer + int case. */
7121 if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
7122 return pointer_int_sum (PLUS_EXPR, op0, op1);
7123 else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
7124 return pointer_int_sum (PLUS_EXPR, op1, op0);
7130 /* Subtraction of two similar pointers.
7131 We must subtract them as integers, then divide by object size. */
7132 if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
7133 && comp_target_types (type0, type1, 1))
7134 return pointer_diff (op0, op1);
7135 /* Handle pointer minus int. Just like pointer plus int. */
7136 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
7137 return pointer_int_sum (MINUS_EXPR, op0, op1);
7146 case TRUNC_DIV_EXPR:
7148 case FLOOR_DIV_EXPR:
7149 case ROUND_DIV_EXPR:
7150 case EXACT_DIV_EXPR:
7151 /* Floating point division by zero is a legitimate way to obtain
7152 infinities and NaNs. */
7153 if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
7154 warning ("division by zero");
7156 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
7157 || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
7158 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
7159 || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
7161 if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
7162 code0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
7163 if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)
7164 code1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
7166 if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
7167 resultcode = RDIV_EXPR;
7169 /* Although it would be tempting to shorten always here, that
7170 loses on some targets, since the modulo instruction is
7171 undefined if the quotient can't be represented in the
7172 computation mode. We shorten only if unsigned or if
7173 dividing by something we know != -1. */
7174 shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
7175 || (TREE_CODE (op1) == INTEGER_CST
7176 && !integer_all_onesp (op1)));
7184 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7186 else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
7190 case TRUNC_MOD_EXPR:
7191 case FLOOR_MOD_EXPR:
7192 if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
7193 warning ("division by zero");
7195 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7197 /* Although it would be tempting to shorten always here, that loses
7198 on some targets, since the modulo instruction is undefined if the
7199 quotient can't be represented in the computation mode. We shorten
7200 only if unsigned or if dividing by something we know != -1. */
7201 shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
7202 || (TREE_CODE (op1) == INTEGER_CST
7203 && !integer_all_onesp (op1)));
7208 case TRUTH_ANDIF_EXPR:
7209 case TRUTH_ORIF_EXPR:
7210 case TRUTH_AND_EXPR:
7212 case TRUTH_XOR_EXPR:
7213 if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
7214 || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
7215 && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
7216 || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
7218 /* Result of these operations is always an int,
7219 but that does not mean the operands should be
7220 converted to ints! */
7221 result_type = integer_type_node;
7222 op0 = lang_hooks.truthvalue_conversion (op0);
7223 op1 = lang_hooks.truthvalue_conversion (op1);
7228 /* Shift operations: result has same type as first operand;
7229 always convert second operand to int.
7230 Also set SHORT_SHIFT if shifting rightward. */
7233 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7235 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
7237 if (tree_int_cst_sgn (op1) < 0)
7238 warning ("right shift count is negative");
7241 if (!integer_zerop (op1))
7244 if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
7245 warning ("right shift count >= width of type");
7249 /* Use the type of the value to be shifted. */
7250 result_type = type0;
7251 /* Convert the shift-count to an integer, regardless of size
7252 of value being shifted. */
7253 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
7254 op1 = convert (integer_type_node, op1);
7255 /* Avoid converting op1 to result_type later. */
7261 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7263 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
7265 if (tree_int_cst_sgn (op1) < 0)
7266 warning ("left shift count is negative");
7268 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
7269 warning ("left shift count >= width of type");
7272 /* Use the type of the value to be shifted. */
7273 result_type = type0;
7274 /* Convert the shift-count to an integer, regardless of size
7275 of value being shifted. */
7276 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
7277 op1 = convert (integer_type_node, op1);
7278 /* Avoid converting op1 to result_type later. */
7285 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7287 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
7289 if (tree_int_cst_sgn (op1) < 0)
7290 warning ("shift count is negative");
7291 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
7292 warning ("shift count >= width of type");
7295 /* Use the type of the value to be shifted. */
7296 result_type = type0;
7297 /* Convert the shift-count to an integer, regardless of size
7298 of value being shifted. */
7299 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
7300 op1 = convert (integer_type_node, op1);
7301 /* Avoid converting op1 to result_type later. */
7308 if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
7309 warning ("comparing floating point with == or != is unsafe");
7310 /* Result of comparison is always int,
7311 but don't convert the args to int! */
7312 build_type = integer_type_node;
7313 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
7314 || code0 == COMPLEX_TYPE)
7315 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
7316 || code1 == COMPLEX_TYPE))
7318 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
7320 tree tt0 = TREE_TYPE (type0);
7321 tree tt1 = TREE_TYPE (type1);
7322 /* Anything compares with void *. void * compares with anything.
7323 Otherwise, the targets must be compatible
7324 and both must be object or both incomplete. */
7325 if (comp_target_types (type0, type1, 1))
7326 result_type = common_pointer_type (type0, type1);
7327 else if (VOID_TYPE_P (tt0))
7329 /* op0 != orig_op0 detects the case of something
7330 whose value is 0 but which isn't a valid null ptr const. */
7331 if (pedantic && (!integer_zerop (op0) || op0 != orig_op0)
7332 && TREE_CODE (tt1) == FUNCTION_TYPE)
7333 pedwarn ("ISO C forbids comparison of %<void *%>"
7334 " with function pointer");
7336 else if (VOID_TYPE_P (tt1))
7338 if (pedantic && (!integer_zerop (op1) || op1 != orig_op1)
7339 && TREE_CODE (tt0) == FUNCTION_TYPE)
7340 pedwarn ("ISO C forbids comparison of %<void *%>"
7341 " with function pointer");
7344 pedwarn ("comparison of distinct pointer types lacks a cast");
7346 if (result_type == NULL_TREE)
7347 result_type = ptr_type_node;
7349 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
7350 && integer_zerop (op1))
7351 result_type = type0;
7352 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
7353 && integer_zerop (op0))
7354 result_type = type1;
7355 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
7357 result_type = type0;
7358 pedwarn ("comparison between pointer and integer");
7360 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
7362 result_type = type1;
7363 pedwarn ("comparison between pointer and integer");
7369 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
7370 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
7372 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
7374 if (comp_target_types (type0, type1, 1))
7376 result_type = common_pointer_type (type0, type1);
7378 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
7379 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
7383 result_type = ptr_type_node;
7384 pedwarn ("comparison of distinct pointer types lacks a cast");
7393 build_type = integer_type_node;
7394 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
7395 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
7397 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
7399 if (comp_target_types (type0, type1, 1))
7401 result_type = common_pointer_type (type0, type1);
7402 if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
7403 != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
7404 pedwarn ("comparison of complete and incomplete pointers");
7406 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
7407 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
7411 result_type = ptr_type_node;
7412 pedwarn ("comparison of distinct pointer types lacks a cast");
7415 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
7416 && integer_zerop (op1))
7418 result_type = type0;
7419 if (pedantic || extra_warnings)
7420 pedwarn ("ordered comparison of pointer with integer zero");
7422 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
7423 && integer_zerop (op0))
7425 result_type = type1;
7427 pedwarn ("ordered comparison of pointer with integer zero");
7429 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
7431 result_type = type0;
7432 pedwarn ("comparison between pointer and integer");
7434 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
7436 result_type = type1;
7437 pedwarn ("comparison between pointer and integer");
7441 case UNORDERED_EXPR:
7449 build_type = integer_type_node;
7450 if (code0 != REAL_TYPE || code1 != REAL_TYPE)
7452 error ("unordered comparison on non-floating point argument");
7453 return error_mark_node;
7462 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
7463 return error_mark_node;
7465 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
7466 || code0 == VECTOR_TYPE)
7468 (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
7469 || code1 == VECTOR_TYPE))
7471 int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
7473 if (shorten || common || short_compare)
7474 result_type = common_type (type0, type1);
7476 /* For certain operations (which identify themselves by shorten != 0)
7477 if both args were extended from the same smaller type,
7478 do the arithmetic in that type and then extend.
7480 shorten !=0 and !=1 indicates a bitwise operation.
7481 For them, this optimization is safe only if
7482 both args are zero-extended or both are sign-extended.
7483 Otherwise, we might change the result.
7484 Eg, (short)-1 | (unsigned short)-1 is (int)-1
7485 but calculated in (unsigned short) it would be (unsigned short)-1. */
7487 if (shorten && none_complex)
7489 int unsigned0, unsigned1;
7490 tree arg0 = get_narrower (op0, &unsigned0);
7491 tree arg1 = get_narrower (op1, &unsigned1);
7492 /* UNS is 1 if the operation to be done is an unsigned one. */
7493 int uns = TYPE_UNSIGNED (result_type);
7496 final_type = result_type;
7498 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
7499 but it *requires* conversion to FINAL_TYPE. */
7501 if ((TYPE_PRECISION (TREE_TYPE (op0))
7502 == TYPE_PRECISION (TREE_TYPE (arg0)))
7503 && TREE_TYPE (op0) != final_type)
7504 unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
7505 if ((TYPE_PRECISION (TREE_TYPE (op1))
7506 == TYPE_PRECISION (TREE_TYPE (arg1)))
7507 && TREE_TYPE (op1) != final_type)
7508 unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
7510 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
7512 /* For bitwise operations, signedness of nominal type
7513 does not matter. Consider only how operands were extended. */
7517 /* Note that in all three cases below we refrain from optimizing
7518 an unsigned operation on sign-extended args.
7519 That would not be valid. */
7521 /* Both args variable: if both extended in same way
7522 from same width, do it in that width.
7523 Do it unsigned if args were zero-extended. */
7524 if ((TYPE_PRECISION (TREE_TYPE (arg0))
7525 < TYPE_PRECISION (result_type))
7526 && (TYPE_PRECISION (TREE_TYPE (arg1))
7527 == TYPE_PRECISION (TREE_TYPE (arg0)))
7528 && unsigned0 == unsigned1
7529 && (unsigned0 || !uns))
7531 = c_common_signed_or_unsigned_type
7532 (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
7533 else if (TREE_CODE (arg0) == INTEGER_CST
7534 && (unsigned1 || !uns)
7535 && (TYPE_PRECISION (TREE_TYPE (arg1))
7536 < TYPE_PRECISION (result_type))
7538 = c_common_signed_or_unsigned_type (unsigned1,
7540 int_fits_type_p (arg0, type)))
7542 else if (TREE_CODE (arg1) == INTEGER_CST
7543 && (unsigned0 || !uns)
7544 && (TYPE_PRECISION (TREE_TYPE (arg0))
7545 < TYPE_PRECISION (result_type))
7547 = c_common_signed_or_unsigned_type (unsigned0,
7549 int_fits_type_p (arg1, type)))
7553 /* Shifts can be shortened if shifting right. */
7558 tree arg0 = get_narrower (op0, &unsigned_arg);
7560 final_type = result_type;
7562 if (arg0 == op0 && final_type == TREE_TYPE (op0))
7563 unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0));
7565 if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
7566 /* We can shorten only if the shift count is less than the
7567 number of bits in the smaller type size. */
7568 && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
7569 /* We cannot drop an unsigned shift after sign-extension. */
7570 && (!TYPE_UNSIGNED (final_type) || unsigned_arg))
7572 /* Do an unsigned shift if the operand was zero-extended. */
7574 = c_common_signed_or_unsigned_type (unsigned_arg,
7576 /* Convert value-to-be-shifted to that type. */
7577 if (TREE_TYPE (op0) != result_type)
7578 op0 = convert (result_type, op0);
7583 /* Comparison operations are shortened too but differently.
7584 They identify themselves by setting short_compare = 1. */
7588 /* Don't write &op0, etc., because that would prevent op0
7589 from being kept in a register.
7590 Instead, make copies of the our local variables and
7591 pass the copies by reference, then copy them back afterward. */
7592 tree xop0 = op0, xop1 = op1, xresult_type = result_type;
7593 enum tree_code xresultcode = resultcode;
7595 = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
7600 op0 = xop0, op1 = xop1;
7602 resultcode = xresultcode;
7604 if (warn_sign_compare && skip_evaluation == 0)
7606 int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
7607 int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
7608 int unsignedp0, unsignedp1;
7609 tree primop0 = get_narrower (op0, &unsignedp0);
7610 tree primop1 = get_narrower (op1, &unsignedp1);
7614 STRIP_TYPE_NOPS (xop0);
7615 STRIP_TYPE_NOPS (xop1);
7617 /* Give warnings for comparisons between signed and unsigned
7618 quantities that may fail.
7620 Do the checking based on the original operand trees, so that
7621 casts will be considered, but default promotions won't be.
7623 Do not warn if the comparison is being done in a signed type,
7624 since the signed type will only be chosen if it can represent
7625 all the values of the unsigned type. */
7626 if (!TYPE_UNSIGNED (result_type))
7628 /* Do not warn if both operands are the same signedness. */
7629 else if (op0_signed == op1_signed)
7636 sop = xop0, uop = xop1;
7638 sop = xop1, uop = xop0;
7640 /* Do not warn if the signed quantity is an
7641 unsuffixed integer literal (or some static
7642 constant expression involving such literals or a
7643 conditional expression involving such literals)
7644 and it is non-negative. */
7645 if (tree_expr_nonnegative_p (sop))
7647 /* Do not warn if the comparison is an equality operation,
7648 the unsigned quantity is an integral constant, and it
7649 would fit in the result if the result were signed. */
7650 else if (TREE_CODE (uop) == INTEGER_CST
7651 && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
7653 (uop, c_common_signed_type (result_type)))
7655 /* Do not warn if the unsigned quantity is an enumeration
7656 constant and its maximum value would fit in the result
7657 if the result were signed. */
7658 else if (TREE_CODE (uop) == INTEGER_CST
7659 && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
7661 (TYPE_MAX_VALUE (TREE_TYPE (uop)),
7662 c_common_signed_type (result_type)))
7665 warning ("comparison between signed and unsigned");
7668 /* Warn if two unsigned values are being compared in a size
7669 larger than their original size, and one (and only one) is the
7670 result of a `~' operator. This comparison will always fail.
7672 Also warn if one operand is a constant, and the constant
7673 does not have all bits set that are set in the ~ operand
7674 when it is extended. */
7676 if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
7677 != (TREE_CODE (primop1) == BIT_NOT_EXPR))
7679 if (TREE_CODE (primop0) == BIT_NOT_EXPR)
7680 primop0 = get_narrower (TREE_OPERAND (primop0, 0),
7683 primop1 = get_narrower (TREE_OPERAND (primop1, 0),
7686 if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
7689 HOST_WIDE_INT constant, mask;
7690 int unsignedp, bits;
7692 if (host_integerp (primop0, 0))
7695 unsignedp = unsignedp1;
7696 constant = tree_low_cst (primop0, 0);
7701 unsignedp = unsignedp0;
7702 constant = tree_low_cst (primop1, 0);
7705 bits = TYPE_PRECISION (TREE_TYPE (primop));
7706 if (bits < TYPE_PRECISION (result_type)
7707 && bits < HOST_BITS_PER_WIDE_INT && unsignedp)
7709 mask = (~(HOST_WIDE_INT) 0) << bits;
7710 if ((mask & constant) != mask)
7711 warning ("comparison of promoted ~unsigned with constant");
7714 else if (unsignedp0 && unsignedp1
7715 && (TYPE_PRECISION (TREE_TYPE (primop0))
7716 < TYPE_PRECISION (result_type))
7717 && (TYPE_PRECISION (TREE_TYPE (primop1))
7718 < TYPE_PRECISION (result_type)))
7719 warning ("comparison of promoted ~unsigned with unsigned");
7725 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
7726 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
7727 Then the expression will be built.
7728 It will be given type FINAL_TYPE if that is nonzero;
7729 otherwise, it will be given type RESULT_TYPE. */
7733 binary_op_error (code);
7734 return error_mark_node;
7739 if (TREE_TYPE (op0) != result_type)
7740 op0 = convert (result_type, op0);
7741 if (TREE_TYPE (op1) != result_type)
7742 op1 = convert (result_type, op1);
7744 /* This can happen if one operand has a vector type, and the other
7745 has a different type. */
7746 if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK)
7747 return error_mark_node;
7750 if (build_type == NULL_TREE)
7751 build_type = result_type;
7754 tree result = build2 (resultcode, build_type, op0, op1);
7756 /* Treat expressions in initializers specially as they can't trap. */
7757 result = require_constant_value ? fold_initializer (result)
7760 if (final_type != 0)
7761 result = convert (final_type, result);