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.
28 There are also routines to build RETURN_STMT nodes and CASE_STMT nodes,
29 and to process initializations in declarations (since they work
30 like a strange sort of assignment). */
34 #include "coretypes.h"
48 /* Nonzero if we've already printed a "missing braces around initializer"
49 message within this initializer. */
50 static int missing_braces_mentioned;
52 static int require_constant_value;
53 static int require_constant_elements;
55 static tree qualify_type (tree, tree);
56 static int same_translation_unit_p (tree, tree);
57 static int tagged_types_tu_compatible_p (tree, tree, int);
58 static int comp_target_types (tree, tree, int);
59 static int function_types_compatible_p (tree, tree, int);
60 static int type_lists_compatible_p (tree, tree, int);
61 static tree decl_constant_value_for_broken_optimization (tree);
62 static tree default_function_array_conversion (tree);
63 static tree lookup_field (tree, tree);
64 static tree convert_arguments (tree, tree, tree, tree);
65 static tree pointer_diff (tree, tree);
66 static tree unary_complex_lvalue (enum tree_code, tree, int);
67 static void pedantic_lvalue_warning (enum tree_code);
68 static tree internal_build_compound_expr (tree, int);
69 static tree convert_for_assignment (tree, tree, const char *, tree, tree,
71 static void warn_for_assignment (const char *, const char *, tree, int);
72 static tree valid_compound_expr_initializer (tree, tree);
73 static void push_string (const char *);
74 static void push_member_name (tree);
75 static void push_array_bounds (int);
76 static int spelling_length (void);
77 static char *print_spelling (char *);
78 static void warning_init (const char *);
79 static tree digest_init (tree, tree, int);
80 static void output_init_element (tree, tree, tree, int);
81 static void output_pending_init_elements (int);
82 static int set_designator (int);
83 static void push_range_stack (tree);
84 static void add_pending_init (tree, tree);
85 static void set_nonincremental_init (void);
86 static void set_nonincremental_init_from_string (tree);
87 static tree find_init_member (tree);
89 /* Do `exp = require_complete_type (exp);' to make sure exp
90 does not have an incomplete type. (That includes void types.) */
93 require_complete_type (tree value)
95 tree type = TREE_TYPE (value);
97 if (value == error_mark_node || type == error_mark_node)
98 return error_mark_node;
100 /* First, detect a valid value with a complete type. */
101 if (COMPLETE_TYPE_P (type))
104 c_incomplete_type_error (value, type);
105 return error_mark_node;
108 /* Print an error message for invalid use of an incomplete type.
109 VALUE is the expression that was used (or 0 if that isn't known)
110 and TYPE is the type that was invalid. */
113 c_incomplete_type_error (tree value, tree type)
115 const char *type_code_string;
117 /* Avoid duplicate error message. */
118 if (TREE_CODE (type) == ERROR_MARK)
121 if (value != 0 && (TREE_CODE (value) == VAR_DECL
122 || TREE_CODE (value) == PARM_DECL))
123 error ("`%s' has an incomplete type",
124 IDENTIFIER_POINTER (DECL_NAME (value)));
128 /* We must print an error message. Be clever about what it says. */
130 switch (TREE_CODE (type))
133 type_code_string = "struct";
137 type_code_string = "union";
141 type_code_string = "enum";
145 error ("invalid use of void expression");
149 if (TYPE_DOMAIN (type))
151 if (TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL)
153 error ("invalid use of flexible array member");
156 type = TREE_TYPE (type);
159 error ("invalid use of array with unspecified bounds");
166 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
167 error ("invalid use of undefined type `%s %s'",
168 type_code_string, IDENTIFIER_POINTER (TYPE_NAME (type)));
170 /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
171 error ("invalid use of incomplete typedef `%s'",
172 IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
176 /* Given a type, apply default promotions wrt unnamed function
177 arguments and return the new type. */
180 c_type_promotes_to (tree type)
182 if (TYPE_MAIN_VARIANT (type) == float_type_node)
183 return double_type_node;
185 if (c_promoting_integer_type_p (type))
187 /* Preserve unsignedness if not really getting any wider. */
188 if (TREE_UNSIGNED (type)
189 && (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
190 return unsigned_type_node;
191 return integer_type_node;
197 /* Return a variant of TYPE which has all the type qualifiers of LIKE
198 as well as those of TYPE. */
201 qualify_type (tree type, tree like)
203 return c_build_qualified_type (type,
204 TYPE_QUALS (type) | TYPE_QUALS (like));
207 /* Return the common type of two types.
208 We assume that comptypes has already been done and returned 1;
209 if that isn't so, this may crash. In particular, we assume that qualifiers
212 This is the type for the result of most arithmetic operations
213 if the operands have the given two types. */
216 common_type (tree t1, tree t2)
218 enum tree_code code1;
219 enum tree_code code2;
222 /* Save time if the two types are the same. */
224 if (t1 == t2) return t1;
226 /* If one type is nonsense, use the other. */
227 if (t1 == error_mark_node)
229 if (t2 == error_mark_node)
232 /* Merge the attributes. */
233 attributes = (*targetm.merge_type_attributes) (t1, t2);
235 /* Treat an enum type as the unsigned integer type of the same width. */
237 if (TREE_CODE (t1) == ENUMERAL_TYPE)
238 t1 = c_common_type_for_size (TYPE_PRECISION (t1), 1);
239 if (TREE_CODE (t2) == ENUMERAL_TYPE)
240 t2 = c_common_type_for_size (TYPE_PRECISION (t2), 1);
242 code1 = TREE_CODE (t1);
243 code2 = TREE_CODE (t2);
245 /* If one type is complex, form the common type of the non-complex
246 components, then make that complex. Use T1 or T2 if it is the
248 if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
250 tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
251 tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
252 tree subtype = common_type (subtype1, subtype2);
254 if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
255 return build_type_attribute_variant (t1, attributes);
256 else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
257 return build_type_attribute_variant (t2, attributes);
259 return build_type_attribute_variant (build_complex_type (subtype),
267 /* If only one is real, use it as the result. */
269 if (code1 == REAL_TYPE && code2 != REAL_TYPE)
270 return build_type_attribute_variant (t1, attributes);
272 if (code2 == REAL_TYPE && code1 != REAL_TYPE)
273 return build_type_attribute_variant (t2, attributes);
275 /* Both real or both integers; use the one with greater precision. */
277 if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
278 return build_type_attribute_variant (t1, attributes);
279 else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
280 return build_type_attribute_variant (t2, attributes);
282 /* Same precision. Prefer longs to ints even when same size. */
284 if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
285 || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
287 t1 = build_qualified_type (long_unsigned_type_node,
289 return build_type_attribute_variant (t1, attributes);
292 if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
293 || TYPE_MAIN_VARIANT (t2) == long_integer_type_node)
297 /* But preserve unsignedness from the other type,
298 since long cannot hold all the values of an unsigned int. */
299 if (TREE_UNSIGNED (t1) || TREE_UNSIGNED (t2))
300 ntype = long_unsigned_type_node;
302 ntype = long_integer_type_node;
304 ntype = build_qualified_type (ntype, TYPE_QUALS (t1));
305 return build_type_attribute_variant (ntype, attributes);
308 /* Likewise, prefer long double to double even if same size. */
309 if (TYPE_MAIN_VARIANT (t1) == long_double_type_node
310 || TYPE_MAIN_VARIANT (t2) == long_double_type_node)
312 t1 = build_qualified_type (long_double_type_node,
314 return build_type_attribute_variant (t1, attributes);
317 /* Otherwise prefer the unsigned one. */
319 if (TREE_UNSIGNED (t1))
320 return build_type_attribute_variant (t1, attributes);
322 return build_type_attribute_variant (t2, attributes);
325 /* For two pointers, do this recursively on the target type,
326 and combine the qualifiers of the two types' targets. */
327 /* This code was turned off; I don't know why.
328 But ANSI C specifies doing this with the qualifiers.
329 So I turned it on again. */
331 tree pointed_to_1 = TREE_TYPE (t1);
332 tree pointed_to_2 = TREE_TYPE (t2);
333 tree target = common_type (TYPE_MAIN_VARIANT (pointed_to_1),
334 TYPE_MAIN_VARIANT (pointed_to_2));
335 t1 = build_pointer_type (c_build_qualified_type
337 TYPE_QUALS (pointed_to_1) |
338 TYPE_QUALS (pointed_to_2)));
339 return build_type_attribute_variant (t1, attributes);
344 tree elt = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
345 /* Save space: see if the result is identical to one of the args. */
346 if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
347 return build_type_attribute_variant (t1, attributes);
348 if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2))
349 return build_type_attribute_variant (t2, attributes);
350 /* Merge the element types, and have a size if either arg has one. */
351 t1 = build_array_type (elt, TYPE_DOMAIN (TYPE_DOMAIN (t1) ? t1 : t2));
352 return build_type_attribute_variant (t1, attributes);
356 /* Function types: prefer the one that specified arg types.
357 If both do, merge the arg types. Also merge the return types. */
359 tree valtype = common_type (TREE_TYPE (t1), TREE_TYPE (t2));
360 tree p1 = TYPE_ARG_TYPES (t1);
361 tree p2 = TYPE_ARG_TYPES (t2);
366 /* Save space: see if the result is identical to one of the args. */
367 if (valtype == TREE_TYPE (t1) && ! TYPE_ARG_TYPES (t2))
368 return build_type_attribute_variant (t1, attributes);
369 if (valtype == TREE_TYPE (t2) && ! TYPE_ARG_TYPES (t1))
370 return build_type_attribute_variant (t2, attributes);
372 /* Simple way if one arg fails to specify argument types. */
373 if (TYPE_ARG_TYPES (t1) == 0)
375 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2));
376 return build_type_attribute_variant (t1, attributes);
378 if (TYPE_ARG_TYPES (t2) == 0)
380 t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1));
381 return build_type_attribute_variant (t1, attributes);
384 /* If both args specify argument types, we must merge the two
385 lists, argument by argument. */
388 declare_parm_level ();
390 len = list_length (p1);
393 for (i = 0; i < len; i++)
394 newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
399 p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n))
401 /* A null type means arg type is not specified.
402 Take whatever the other function type has. */
403 if (TREE_VALUE (p1) == 0)
405 TREE_VALUE (n) = TREE_VALUE (p2);
408 if (TREE_VALUE (p2) == 0)
410 TREE_VALUE (n) = TREE_VALUE (p1);
414 /* Given wait (union {union wait *u; int *i} *)
415 and wait (union wait *),
416 prefer union wait * as type of parm. */
417 if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE
418 && TREE_VALUE (p1) != TREE_VALUE (p2))
421 for (memb = TYPE_FIELDS (TREE_VALUE (p1));
422 memb; memb = TREE_CHAIN (memb))
423 if (comptypes (TREE_TYPE (memb), TREE_VALUE (p2),
426 TREE_VALUE (n) = TREE_VALUE (p2);
428 pedwarn ("function types not truly compatible in ISO C");
432 if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE
433 && TREE_VALUE (p2) != TREE_VALUE (p1))
436 for (memb = TYPE_FIELDS (TREE_VALUE (p2));
437 memb; memb = TREE_CHAIN (memb))
438 if (comptypes (TREE_TYPE (memb), TREE_VALUE (p1),
441 TREE_VALUE (n) = TREE_VALUE (p1);
443 pedwarn ("function types not truly compatible in ISO C");
447 TREE_VALUE (n) = common_type (TREE_VALUE (p1), TREE_VALUE (p2));
453 t1 = build_function_type (valtype, newargs);
454 /* ... falls through ... */
458 return build_type_attribute_variant (t1, attributes);
463 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
464 or various other operations. Return 2 if they are compatible
465 but a warning may be needed if you use them together. */
468 comptypes (tree type1, tree type2, int flags)
474 /* Suppress errors caused by previously reported errors. */
476 if (t1 == t2 || !t1 || !t2
477 || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK)
480 /* If either type is the internal version of sizetype, return the
482 if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1)
483 && TYPE_DOMAIN (t1) != 0)
484 t1 = TYPE_DOMAIN (t1);
486 if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2)
487 && TYPE_DOMAIN (t2) != 0)
488 t2 = TYPE_DOMAIN (t2);
490 /* Enumerated types are compatible with integer types, but this is
491 not transitive: two enumerated types in the same translation unit
492 are compatible with each other only if they are the same type. */
494 if (TREE_CODE (t1) == ENUMERAL_TYPE && TREE_CODE (t2) != ENUMERAL_TYPE)
495 t1 = c_common_type_for_size (TYPE_PRECISION (t1), TREE_UNSIGNED (t1));
496 else if (TREE_CODE (t2) == ENUMERAL_TYPE && TREE_CODE (t1) != ENUMERAL_TYPE)
497 t2 = c_common_type_for_size (TYPE_PRECISION (t2), TREE_UNSIGNED (t2));
502 /* Different classes of types can't be compatible. */
504 if (TREE_CODE (t1) != TREE_CODE (t2))
507 /* Qualifiers must match. */
509 if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
512 /* Allow for two different type nodes which have essentially the same
513 definition. Note that we already checked for equality of the type
514 qualifiers (just above). */
516 if (TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
519 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
520 if (! (attrval = (*targetm.comp_type_attributes) (t1, t2)))
523 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
526 switch (TREE_CODE (t1))
529 /* We must give ObjC the first crack at comparing pointers, since
530 protocol qualifiers may be involved. */
531 if (c_dialect_objc () && (val = objc_comptypes (t1, t2, 0)) >= 0)
533 val = (TREE_TYPE (t1) == TREE_TYPE (t2)
534 ? 1 : comptypes (TREE_TYPE (t1), TREE_TYPE (t2), flags));
538 val = function_types_compatible_p (t1, t2, flags);
543 tree d1 = TYPE_DOMAIN (t1);
544 tree d2 = TYPE_DOMAIN (t2);
545 bool d1_variable, d2_variable;
546 bool d1_zero, d2_zero;
549 /* Target types must match incl. qualifiers. */
550 if (TREE_TYPE (t1) != TREE_TYPE (t2)
551 && 0 == (val = comptypes (TREE_TYPE (t1), TREE_TYPE (t2),
555 /* Sizes must match unless one is missing or variable. */
556 if (d1 == 0 || d2 == 0 || d1 == d2)
559 d1_zero = ! TYPE_MAX_VALUE (d1);
560 d2_zero = ! TYPE_MAX_VALUE (d2);
562 d1_variable = (! d1_zero
563 && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
564 || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
565 d2_variable = (! d2_zero
566 && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
567 || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
569 if (d1_variable || d2_variable)
571 if (d1_zero && d2_zero)
573 if (d1_zero || d2_zero
574 || ! tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2))
575 || ! tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2)))
582 /* We are dealing with two distinct structs. In assorted Objective-C
583 corner cases, however, these can still be deemed equivalent. */
584 if (c_dialect_objc () && objc_comptypes (t1, t2, 0) == 1)
589 if (val != 1 && !same_translation_unit_p (t1, t2))
590 val = tagged_types_tu_compatible_p (t1, t2, flags);
594 /* The target might allow certain vector types to be compatible. */
595 val = (*targetm.vector_opaque_p) (t1)
596 || (*targetm.vector_opaque_p) (t2);
602 return attrval == 2 && val == 1 ? 2 : val;
605 /* Return 1 if TTL and TTR are pointers to types that are equivalent,
606 ignoring their qualifiers. REFLEXIVE is only used by ObjC - set it
607 to 1 or 0 depending if the check of the pointer types is meant to
608 be reflexive or not (typically, assignments are not reflexive,
609 while comparisons are reflexive).
613 comp_target_types (tree ttl, tree ttr, int reflexive)
617 /* Give objc_comptypes a crack at letting these types through. */
618 if ((val = objc_comptypes (ttl, ttr, reflexive)) >= 0)
621 val = comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (ttl)),
622 TYPE_MAIN_VARIANT (TREE_TYPE (ttr)), COMPARE_STRICT);
624 if (val == 2 && pedantic)
625 pedwarn ("types are not quite compatible");
629 /* Subroutines of `comptypes'. */
631 /* Determine whether two types derive from the same translation unit.
632 If the CONTEXT chain ends in a null, that type's context is still
633 being parsed, so if two types have context chains ending in null,
634 they're in the same translation unit. */
636 same_translation_unit_p (tree t1, tree t2)
638 while (t1 && TREE_CODE (t1) != TRANSLATION_UNIT_DECL)
639 switch (TREE_CODE_CLASS (TREE_CODE (t1)))
641 case 'd': t1 = DECL_CONTEXT (t1); break;
642 case 't': t1 = TYPE_CONTEXT (t1); break;
643 case 'b': t1 = BLOCK_SUPERCONTEXT (t1); break;
647 while (t2 && TREE_CODE (t2) != TRANSLATION_UNIT_DECL)
648 switch (TREE_CODE_CLASS (TREE_CODE (t2)))
650 case 'd': t2 = DECL_CONTEXT (t1); break;
651 case 't': t2 = TYPE_CONTEXT (t2); break;
652 case 'b': t2 = BLOCK_SUPERCONTEXT (t2); break;
659 /* The C standard says that two structures in different translation
660 units are compatible with each other only if the types of their
661 fields are compatible (among other things). So, consider two copies
662 of this structure: */
664 struct tagged_tu_seen {
665 const struct tagged_tu_seen * next;
670 /* Can they be compatible with each other? We choose to break the
671 recursion by allowing those types to be compatible. */
673 static const struct tagged_tu_seen * tagged_tu_seen_base;
675 /* Return 1 if two 'struct', 'union', or 'enum' types T1 and T2 are
676 compatible. If the two types are not the same (which has been
677 checked earlier), this can only happen when multiple translation
678 units are being compiled. See C99 6.2.7 paragraph 1 for the exact
682 tagged_types_tu_compatible_p (tree t1, tree t2, int flags)
685 bool needs_warning = false;
687 /* We have to verify that the tags of the types are the same. This
688 is harder than it looks because this may be a typedef, so we have
689 to go look at the original type. It may even be a typedef of a
691 while (TYPE_NAME (t1)
692 && TREE_CODE (TYPE_NAME (t1)) == TYPE_DECL
693 && DECL_ORIGINAL_TYPE (TYPE_NAME (t1)))
694 t1 = DECL_ORIGINAL_TYPE (TYPE_NAME (t1));
696 while (TYPE_NAME (t2)
697 && TREE_CODE (TYPE_NAME (t2)) == TYPE_DECL
698 && DECL_ORIGINAL_TYPE (TYPE_NAME (t2)))
699 t2 = DECL_ORIGINAL_TYPE (TYPE_NAME (t2));
701 /* C90 didn't have the requirement that the two tags be the same. */
702 if (flag_isoc99 && TYPE_NAME (t1) != TYPE_NAME (t2))
705 /* C90 didn't say what happened if one or both of the types were
706 incomplete; we choose to follow C99 rules here, which is that they
708 if (TYPE_SIZE (t1) == NULL
709 || TYPE_SIZE (t2) == NULL)
713 const struct tagged_tu_seen * tts_i;
714 for (tts_i = tagged_tu_seen_base; tts_i != NULL; tts_i = tts_i->next)
715 if (tts_i->t1 == t1 && tts_i->t2 == t2)
719 switch (TREE_CODE (t1))
723 if (list_length (TYPE_VALUES (t1)) != list_length (TYPE_VALUES (t2)))
726 for (s1 = TYPE_VALUES (t1); s1; s1 = TREE_CHAIN (s1))
728 s2 = purpose_member (TREE_PURPOSE (s1), TYPE_VALUES (t2));
730 || simple_cst_equal (TREE_VALUE (s1), TREE_VALUE (s2)) != 1)
738 if (list_length (TYPE_FIELDS (t1)) != list_length (TYPE_FIELDS (t2)))
741 for (s1 = TYPE_FIELDS (t1); s1; s1 = TREE_CHAIN (s1))
744 struct tagged_tu_seen tts;
746 tts.next = tagged_tu_seen_base;
749 tagged_tu_seen_base = &tts;
751 if (DECL_NAME (s1) != NULL)
752 for (s2 = TYPE_VALUES (t2); s2; s2 = TREE_CHAIN (s2))
753 if (DECL_NAME (s1) == DECL_NAME (s2))
756 result = comptypes (TREE_TYPE (s1), TREE_TYPE (s2), flags);
760 needs_warning = true;
762 if (TREE_CODE (s1) == FIELD_DECL
763 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
764 DECL_FIELD_BIT_OFFSET (s2)) != 1)
770 tagged_tu_seen_base = tts.next;
774 return needs_warning ? 2 : 1;
779 struct tagged_tu_seen tts;
781 tts.next = tagged_tu_seen_base;
784 tagged_tu_seen_base = &tts;
786 for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2);
788 s1 = TREE_CHAIN (s1), s2 = TREE_CHAIN (s2))
791 if (TREE_CODE (s1) != TREE_CODE (s2)
792 || DECL_NAME (s1) != DECL_NAME (s2))
794 result = comptypes (TREE_TYPE (s1), TREE_TYPE (s2), flags);
798 needs_warning = true;
800 if (TREE_CODE (s1) == FIELD_DECL
801 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
802 DECL_FIELD_BIT_OFFSET (s2)) != 1)
805 tagged_tu_seen_base = tts.next;
808 return needs_warning ? 2 : 1;
816 /* Return 1 if two function types F1 and F2 are compatible.
817 If either type specifies no argument types,
818 the other must specify a fixed number of self-promoting arg types.
819 Otherwise, if one type specifies only the number of arguments,
820 the other must specify that number of self-promoting arg types.
821 Otherwise, the argument types must match. */
824 function_types_compatible_p (tree f1, tree f2, int flags)
827 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
832 ret1 = TREE_TYPE (f1);
833 ret2 = TREE_TYPE (f2);
835 /* 'volatile' qualifiers on a function's return type mean the function
837 if (pedantic && TYPE_VOLATILE (ret1) != TYPE_VOLATILE (ret2))
838 pedwarn ("function return types not compatible due to `volatile'");
839 if (TYPE_VOLATILE (ret1))
840 ret1 = build_qualified_type (TYPE_MAIN_VARIANT (ret1),
841 TYPE_QUALS (ret1) & ~TYPE_QUAL_VOLATILE);
842 if (TYPE_VOLATILE (ret2))
843 ret2 = build_qualified_type (TYPE_MAIN_VARIANT (ret2),
844 TYPE_QUALS (ret2) & ~TYPE_QUAL_VOLATILE);
845 val = comptypes (ret1, ret2, flags);
849 args1 = TYPE_ARG_TYPES (f1);
850 args2 = TYPE_ARG_TYPES (f2);
852 /* An unspecified parmlist matches any specified parmlist
853 whose argument types don't need default promotions. */
857 if (!self_promoting_args_p (args2))
859 /* If one of these types comes from a non-prototype fn definition,
860 compare that with the other type's arglist.
861 If they don't match, ask for a warning (but no error). */
862 if (TYPE_ACTUAL_ARG_TYPES (f1)
863 && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1),
870 if (!self_promoting_args_p (args1))
872 if (TYPE_ACTUAL_ARG_TYPES (f2)
873 && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2),
879 /* Both types have argument lists: compare them and propagate results. */
880 val1 = type_lists_compatible_p (args1, args2, flags);
881 return val1 != 1 ? val1 : val;
884 /* Check two lists of types for compatibility,
885 returning 0 for incompatible, 1 for compatible,
886 or 2 for compatible with warning. */
889 type_lists_compatible_p (tree args1, tree args2, int flags)
891 /* 1 if no need for warning yet, 2 if warning cause has been seen. */
897 if (args1 == 0 && args2 == 0)
899 /* If one list is shorter than the other,
900 they fail to match. */
901 if (args1 == 0 || args2 == 0)
903 /* A null pointer instead of a type
904 means there is supposed to be an argument
905 but nothing is specified about what type it has.
906 So match anything that self-promotes. */
907 if (TREE_VALUE (args1) == 0)
909 if (c_type_promotes_to (TREE_VALUE (args2)) != TREE_VALUE (args2))
912 else if (TREE_VALUE (args2) == 0)
914 if (c_type_promotes_to (TREE_VALUE (args1)) != TREE_VALUE (args1))
917 /* If one of the lists has an error marker, ignore this arg. */
918 else if (TREE_CODE (TREE_VALUE (args1)) == ERROR_MARK
919 || TREE_CODE (TREE_VALUE (args2)) == ERROR_MARK)
921 else if (! (newval = comptypes (TYPE_MAIN_VARIANT (TREE_VALUE (args1)),
922 TYPE_MAIN_VARIANT (TREE_VALUE (args2)),
925 /* Allow wait (union {union wait *u; int *i} *)
926 and wait (union wait *) to be compatible. */
927 if (TREE_CODE (TREE_VALUE (args1)) == UNION_TYPE
928 && (TYPE_NAME (TREE_VALUE (args1)) == 0
929 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args1)))
930 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args1))) == INTEGER_CST
931 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args1)),
932 TYPE_SIZE (TREE_VALUE (args2))))
935 for (memb = TYPE_FIELDS (TREE_VALUE (args1));
936 memb; memb = TREE_CHAIN (memb))
937 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args2),
943 else if (TREE_CODE (TREE_VALUE (args2)) == UNION_TYPE
944 && (TYPE_NAME (TREE_VALUE (args2)) == 0
945 || TYPE_TRANSPARENT_UNION (TREE_VALUE (args2)))
946 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args2))) == INTEGER_CST
947 && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args2)),
948 TYPE_SIZE (TREE_VALUE (args1))))
951 for (memb = TYPE_FIELDS (TREE_VALUE (args2));
952 memb; memb = TREE_CHAIN (memb))
953 if (comptypes (TREE_TYPE (memb), TREE_VALUE (args1),
963 /* comptypes said ok, but record if it said to warn. */
967 args1 = TREE_CHAIN (args1);
968 args2 = TREE_CHAIN (args2);
972 /* Compute the size to increment a pointer by. */
975 c_size_in_bytes (tree type)
977 enum tree_code code = TREE_CODE (type);
979 if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
980 return size_one_node;
982 if (!COMPLETE_OR_VOID_TYPE_P (type))
984 error ("arithmetic on pointer to an incomplete type");
985 return size_one_node;
988 /* Convert in case a char is more than one unit. */
989 return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
990 size_int (TYPE_PRECISION (char_type_node)
994 /* Return either DECL or its known constant value (if it has one). */
997 decl_constant_value (tree decl)
999 if (/* Don't change a variable array bound or initial value to a constant
1000 in a place where a variable is invalid. */
1001 current_function_decl != 0
1002 && ! TREE_THIS_VOLATILE (decl)
1003 && TREE_READONLY (decl)
1004 && DECL_INITIAL (decl) != 0
1005 && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
1006 /* This is invalid if initial value is not constant.
1007 If it has either a function call, a memory reference,
1008 or a variable, then re-evaluating it could give different results. */
1009 && TREE_CONSTANT (DECL_INITIAL (decl))
1010 /* Check for cases where this is sub-optimal, even though valid. */
1011 && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
1012 return DECL_INITIAL (decl);
1016 /* Return either DECL or its known constant value (if it has one), but
1017 return DECL if pedantic or DECL has mode BLKmode. This is for
1018 bug-compatibility with the old behavior of decl_constant_value
1019 (before GCC 3.0); every use of this function is a bug and it should
1020 be removed before GCC 3.1. It is not appropriate to use pedantic
1021 in a way that affects optimization, and BLKmode is probably not the
1022 right test for avoiding misoptimizations either. */
1025 decl_constant_value_for_broken_optimization (tree decl)
1027 if (pedantic || DECL_MODE (decl) == BLKmode)
1030 return decl_constant_value (decl);
1034 /* Perform the default conversion of arrays and functions to pointers.
1035 Return the result of converting EXP. For any other expression, just
1039 default_function_array_conversion (tree exp)
1042 tree type = TREE_TYPE (exp);
1043 enum tree_code code = TREE_CODE (type);
1046 /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
1049 Do not use STRIP_NOPS here! It will remove conversions from pointer
1050 to integer and cause infinite recursion. */
1052 while (TREE_CODE (exp) == NON_LVALUE_EXPR
1053 || (TREE_CODE (exp) == NOP_EXPR
1054 && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
1056 if (TREE_CODE (exp) == NON_LVALUE_EXPR)
1058 exp = TREE_OPERAND (exp, 0);
1061 /* Preserve the original expression code. */
1062 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (exp))))
1063 C_SET_EXP_ORIGINAL_CODE (exp, C_EXP_ORIGINAL_CODE (orig_exp));
1065 if (code == FUNCTION_TYPE)
1067 return build_unary_op (ADDR_EXPR, exp, 0);
1069 if (code == ARRAY_TYPE)
1072 tree restype = TREE_TYPE (type);
1078 if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'r' || DECL_P (exp))
1080 constp = TREE_READONLY (exp);
1081 volatilep = TREE_THIS_VOLATILE (exp);
1084 if (TYPE_QUALS (type) || constp || volatilep)
1086 = c_build_qualified_type (restype,
1088 | (constp * TYPE_QUAL_CONST)
1089 | (volatilep * TYPE_QUAL_VOLATILE));
1091 if (TREE_CODE (exp) == INDIRECT_REF)
1092 return convert (TYPE_POINTER_TO (restype),
1093 TREE_OPERAND (exp, 0));
1095 if (TREE_CODE (exp) == COMPOUND_EXPR)
1097 tree op1 = default_conversion (TREE_OPERAND (exp, 1));
1098 return build (COMPOUND_EXPR, TREE_TYPE (op1),
1099 TREE_OPERAND (exp, 0), op1);
1102 lvalue_array_p = !not_lvalue && lvalue_p (exp);
1103 if (!flag_isoc99 && !lvalue_array_p)
1105 /* Before C99, non-lvalue arrays do not decay to pointers.
1106 Normally, using such an array would be invalid; but it can
1107 be used correctly inside sizeof or as a statement expression.
1108 Thus, do not give an error here; an error will result later. */
1112 ptrtype = build_pointer_type (restype);
1114 if (TREE_CODE (exp) == VAR_DECL)
1116 /* ??? This is not really quite correct
1117 in that the type of the operand of ADDR_EXPR
1118 is not the target type of the type of the ADDR_EXPR itself.
1119 Question is, can this lossage be avoided? */
1120 adr = build1 (ADDR_EXPR, ptrtype, exp);
1121 if (!c_mark_addressable (exp))
1122 return error_mark_node;
1123 TREE_CONSTANT (adr) = staticp (exp);
1124 TREE_SIDE_EFFECTS (adr) = 0; /* Default would be, same as EXP. */
1127 /* This way is better for a COMPONENT_REF since it can
1128 simplify the offset for a component. */
1129 adr = build_unary_op (ADDR_EXPR, exp, 1);
1130 return convert (ptrtype, adr);
1135 /* Perform default promotions for C data used in expressions.
1136 Arrays and functions are converted to pointers;
1137 enumeral types or short or char, to int.
1138 In addition, manifest constants symbols are replaced by their values. */
1141 default_conversion (tree exp)
1144 tree type = TREE_TYPE (exp);
1145 enum tree_code code = TREE_CODE (type);
1147 if (code == FUNCTION_TYPE || code == ARRAY_TYPE)
1148 return default_function_array_conversion (exp);
1150 /* Constants can be used directly unless they're not loadable. */
1151 if (TREE_CODE (exp) == CONST_DECL)
1152 exp = DECL_INITIAL (exp);
1154 /* Replace a nonvolatile const static variable with its value unless
1155 it is an array, in which case we must be sure that taking the
1156 address of the array produces consistent results. */
1157 else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE)
1159 exp = decl_constant_value_for_broken_optimization (exp);
1160 type = TREE_TYPE (exp);
1163 /* Strip NON_LVALUE_EXPRs and no-op conversions, since we aren't using as
1166 Do not use STRIP_NOPS here! It will remove conversions from pointer
1167 to integer and cause infinite recursion. */
1169 while (TREE_CODE (exp) == NON_LVALUE_EXPR
1170 || (TREE_CODE (exp) == NOP_EXPR
1171 && TREE_TYPE (TREE_OPERAND (exp, 0)) == TREE_TYPE (exp)))
1172 exp = TREE_OPERAND (exp, 0);
1174 /* Preserve the original expression code. */
1175 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (exp))))
1176 C_SET_EXP_ORIGINAL_CODE (exp, C_EXP_ORIGINAL_CODE (orig_exp));
1178 /* Normally convert enums to int,
1179 but convert wide enums to something wider. */
1180 if (code == ENUMERAL_TYPE)
1182 type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
1183 TYPE_PRECISION (integer_type_node)),
1184 ((TYPE_PRECISION (type)
1185 >= TYPE_PRECISION (integer_type_node))
1186 && TREE_UNSIGNED (type)));
1188 return convert (type, exp);
1191 if (TREE_CODE (exp) == COMPONENT_REF
1192 && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1))
1193 /* If it's thinner than an int, promote it like a
1194 c_promoting_integer_type_p, otherwise leave it alone. */
1195 && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
1196 TYPE_PRECISION (integer_type_node)))
1197 return convert (integer_type_node, exp);
1199 if (c_promoting_integer_type_p (type))
1201 /* Preserve unsignedness if not really getting any wider. */
1202 if (TREE_UNSIGNED (type)
1203 && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1204 return convert (unsigned_type_node, exp);
1206 return convert (integer_type_node, exp);
1209 if (code == VOID_TYPE)
1211 error ("void value not ignored as it ought to be");
1212 return error_mark_node;
1217 /* Look up COMPONENT in a structure or union DECL.
1219 If the component name is not found, returns NULL_TREE. Otherwise,
1220 the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL
1221 stepping down the chain to the component, which is in the last
1222 TREE_VALUE of the list. Normally the list is of length one, but if
1223 the component is embedded within (nested) anonymous structures or
1224 unions, the list steps down the chain to the component. */
1227 lookup_field (tree decl, tree component)
1229 tree type = TREE_TYPE (decl);
1232 /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
1233 to the field elements. Use a binary search on this array to quickly
1234 find the element. Otherwise, do a linear search. TYPE_LANG_SPECIFIC
1235 will always be set for structures which have many elements. */
1237 if (TYPE_LANG_SPECIFIC (type))
1240 tree *field_array = &TYPE_LANG_SPECIFIC (type)->s->elts[0];
1242 field = TYPE_FIELDS (type);
1244 top = TYPE_LANG_SPECIFIC (type)->s->len;
1245 while (top - bot > 1)
1247 half = (top - bot + 1) >> 1;
1248 field = field_array[bot+half];
1250 if (DECL_NAME (field) == NULL_TREE)
1252 /* Step through all anon unions in linear fashion. */
1253 while (DECL_NAME (field_array[bot]) == NULL_TREE)
1255 field = field_array[bot++];
1256 if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1257 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
1259 tree anon = lookup_field (field, component);
1262 return tree_cons (NULL_TREE, field, anon);
1266 /* Entire record is only anon unions. */
1270 /* Restart the binary search, with new lower bound. */
1274 if (DECL_NAME (field) == component)
1276 if (DECL_NAME (field) < component)
1282 if (DECL_NAME (field_array[bot]) == component)
1283 field = field_array[bot];
1284 else if (DECL_NAME (field) != component)
1289 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1291 if (DECL_NAME (field) == NULL_TREE
1292 && (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1293 || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE))
1295 tree anon = lookup_field (field, component);
1298 return tree_cons (NULL_TREE, field, anon);
1301 if (DECL_NAME (field) == component)
1305 if (field == NULL_TREE)
1309 return tree_cons (NULL_TREE, field, NULL_TREE);
1312 /* Make an expression to refer to the COMPONENT field of
1313 structure or union value DATUM. COMPONENT is an IDENTIFIER_NODE. */
1316 build_component_ref (tree datum, tree component)
1318 tree type = TREE_TYPE (datum);
1319 enum tree_code code = TREE_CODE (type);
1323 /* See if there is a field or component with name COMPONENT. */
1325 if (code == RECORD_TYPE || code == UNION_TYPE)
1327 if (!COMPLETE_TYPE_P (type))
1329 c_incomplete_type_error (NULL_TREE, type);
1330 return error_mark_node;
1333 field = lookup_field (datum, component);
1337 error ("%s has no member named `%s'",
1338 code == RECORD_TYPE ? "structure" : "union",
1339 IDENTIFIER_POINTER (component));
1340 return error_mark_node;
1343 /* Chain the COMPONENT_REFs if necessary down to the FIELD.
1344 This might be better solved in future the way the C++ front
1345 end does it - by giving the anonymous entities each a
1346 separate name and type, and then have build_component_ref
1347 recursively call itself. We can't do that here. */
1350 tree subdatum = TREE_VALUE (field);
1352 if (TREE_TYPE (subdatum) == error_mark_node)
1353 return error_mark_node;
1355 ref = build (COMPONENT_REF, TREE_TYPE (subdatum), datum, subdatum);
1356 if (TREE_READONLY (datum) || TREE_READONLY (subdatum))
1357 TREE_READONLY (ref) = 1;
1358 if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (subdatum))
1359 TREE_THIS_VOLATILE (ref) = 1;
1361 if (TREE_DEPRECATED (subdatum))
1362 warn_deprecated_use (subdatum);
1366 field = TREE_CHAIN (field);
1372 else if (code != ERROR_MARK)
1373 error ("request for member `%s' in something not a structure or union",
1374 IDENTIFIER_POINTER (component));
1376 return error_mark_node;
1379 /* Given an expression PTR for a pointer, return an expression
1380 for the value pointed to.
1381 ERRORSTRING is the name of the operator to appear in error messages. */
1384 build_indirect_ref (tree ptr, const char *errorstring)
1386 tree pointer = default_conversion (ptr);
1387 tree type = TREE_TYPE (pointer);
1389 if (TREE_CODE (type) == POINTER_TYPE)
1391 if (TREE_CODE (pointer) == ADDR_EXPR
1392 && (TREE_TYPE (TREE_OPERAND (pointer, 0))
1393 == TREE_TYPE (type)))
1394 return TREE_OPERAND (pointer, 0);
1397 tree t = TREE_TYPE (type);
1398 tree ref = build1 (INDIRECT_REF, TYPE_MAIN_VARIANT (t), pointer);
1400 if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE)
1402 error ("dereferencing pointer to incomplete type");
1403 return error_mark_node;
1405 if (VOID_TYPE_P (t) && skip_evaluation == 0)
1406 warning ("dereferencing `void *' pointer");
1408 /* We *must* set TREE_READONLY when dereferencing a pointer to const,
1409 so that we get the proper error message if the result is used
1410 to assign to. Also, &* is supposed to be a no-op.
1411 And ANSI C seems to specify that the type of the result
1412 should be the const type. */
1413 /* A de-reference of a pointer to const is not a const. It is valid
1414 to change it via some other pointer. */
1415 TREE_READONLY (ref) = TYPE_READONLY (t);
1416 TREE_SIDE_EFFECTS (ref)
1417 = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer);
1418 TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
1422 else if (TREE_CODE (pointer) != ERROR_MARK)
1423 error ("invalid type argument of `%s'", errorstring);
1424 return error_mark_node;
1427 /* This handles expressions of the form "a[i]", which denotes
1430 This is logically equivalent in C to *(a+i), but we may do it differently.
1431 If A is a variable or a member, we generate a primitive ARRAY_REF.
1432 This avoids forcing the array out of registers, and can work on
1433 arrays that are not lvalues (for example, members of structures returned
1437 build_array_ref (tree array, tree index)
1441 error ("subscript missing in array reference");
1442 return error_mark_node;
1445 if (TREE_TYPE (array) == error_mark_node
1446 || TREE_TYPE (index) == error_mark_node)
1447 return error_mark_node;
1449 if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE
1450 && TREE_CODE (array) != INDIRECT_REF)
1454 /* Subscripting with type char is likely to lose
1455 on a machine where chars are signed.
1456 So warn on any machine, but optionally.
1457 Don't warn for unsigned char since that type is safe.
1458 Don't warn for signed char because anyone who uses that
1459 must have done so deliberately. */
1460 if (warn_char_subscripts
1461 && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1462 warning ("array subscript has type `char'");
1464 /* Apply default promotions *after* noticing character types. */
1465 index = default_conversion (index);
1467 /* Require integer *after* promotion, for sake of enums. */
1468 if (TREE_CODE (TREE_TYPE (index)) != INTEGER_TYPE)
1470 error ("array subscript is not an integer");
1471 return error_mark_node;
1474 /* An array that is indexed by a non-constant
1475 cannot be stored in a register; we must be able to do
1476 address arithmetic on its address.
1477 Likewise an array of elements of variable size. */
1478 if (TREE_CODE (index) != INTEGER_CST
1479 || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
1480 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
1482 if (!c_mark_addressable (array))
1483 return error_mark_node;
1485 /* An array that is indexed by a constant value which is not within
1486 the array bounds cannot be stored in a register either; because we
1487 would get a crash in store_bit_field/extract_bit_field when trying
1488 to access a non-existent part of the register. */
1489 if (TREE_CODE (index) == INTEGER_CST
1490 && TYPE_VALUES (TREE_TYPE (array))
1491 && ! int_fits_type_p (index, TYPE_VALUES (TREE_TYPE (array))))
1493 if (!c_mark_addressable (array))
1494 return error_mark_node;
1500 while (TREE_CODE (foo) == COMPONENT_REF)
1501 foo = TREE_OPERAND (foo, 0);
1502 if (TREE_CODE (foo) == VAR_DECL && DECL_REGISTER (foo))
1503 pedwarn ("ISO C forbids subscripting `register' array");
1504 else if (! flag_isoc99 && ! lvalue_p (foo))
1505 pedwarn ("ISO C90 forbids subscripting non-lvalue array");
1508 type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (array)));
1509 rval = build (ARRAY_REF, type, array, index);
1510 /* Array ref is const/volatile if the array elements are
1511 or if the array is. */
1512 TREE_READONLY (rval)
1513 |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
1514 | TREE_READONLY (array));
1515 TREE_SIDE_EFFECTS (rval)
1516 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1517 | TREE_SIDE_EFFECTS (array));
1518 TREE_THIS_VOLATILE (rval)
1519 |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
1520 /* This was added by rms on 16 Nov 91.
1521 It fixes vol struct foo *a; a->elts[1]
1522 in an inline function.
1523 Hope it doesn't break something else. */
1524 | TREE_THIS_VOLATILE (array));
1525 return require_complete_type (fold (rval));
1529 tree ar = default_conversion (array);
1530 tree ind = default_conversion (index);
1532 /* Do the same warning check as above, but only on the part that's
1533 syntactically the index and only if it is also semantically
1535 if (warn_char_subscripts
1536 && TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE
1537 && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1538 warning ("subscript has type `char'");
1540 /* Put the integer in IND to simplify error checking. */
1541 if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
1548 if (ar == error_mark_node)
1551 if (TREE_CODE (TREE_TYPE (ar)) != POINTER_TYPE
1552 || TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) == FUNCTION_TYPE)
1554 error ("subscripted value is neither array nor pointer");
1555 return error_mark_node;
1557 if (TREE_CODE (TREE_TYPE (ind)) != INTEGER_TYPE)
1559 error ("array subscript is not an integer");
1560 return error_mark_node;
1563 return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, ind, 0),
1568 /* Build an external reference to identifier ID. FUN indicates
1569 whether this will be used for a function call. */
1571 build_external_ref (tree id, int fun)
1574 tree decl = lookup_name (id);
1575 tree objc_ivar = lookup_objc_ivar (id);
1577 if (decl && decl != error_mark_node)
1579 /* Properly declared variable or function reference. */
1582 else if (decl != objc_ivar && !DECL_FILE_SCOPE_P (decl))
1584 warning ("local declaration of `%s' hides instance variable",
1585 IDENTIFIER_POINTER (id));
1594 /* Implicit function declaration. */
1595 ref = implicitly_declare (id);
1596 else if (decl == error_mark_node)
1597 /* Don't complain about something that's already been
1598 complained about. */
1599 return error_mark_node;
1602 undeclared_variable (id);
1603 return error_mark_node;
1606 if (TREE_TYPE (ref) == error_mark_node)
1607 return error_mark_node;
1609 if (TREE_DEPRECATED (ref))
1610 warn_deprecated_use (ref);
1612 if (!skip_evaluation)
1613 assemble_external (ref);
1614 TREE_USED (ref) = 1;
1616 if (TREE_CODE (ref) == CONST_DECL)
1618 ref = DECL_INITIAL (ref);
1619 TREE_CONSTANT (ref) = 1;
1621 else if (current_function_decl != 0
1622 && !DECL_FILE_SCOPE_P (current_function_decl)
1623 && (TREE_CODE (ref) == VAR_DECL
1624 || TREE_CODE (ref) == PARM_DECL
1625 || TREE_CODE (ref) == FUNCTION_DECL))
1627 tree context = decl_function_context (ref);
1629 if (context != 0 && context != current_function_decl)
1630 DECL_NONLOCAL (ref) = 1;
1636 /* Build a function call to function FUNCTION with parameters PARAMS.
1637 PARAMS is a list--a chain of TREE_LIST nodes--in which the
1638 TREE_VALUE of each node is a parameter-expression.
1639 FUNCTION's data type may be a function type or a pointer-to-function. */
1642 build_function_call (tree function, tree params)
1644 tree fntype, fundecl = 0;
1645 tree coerced_params;
1646 tree name = NULL_TREE, result;
1649 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
1650 STRIP_TYPE_NOPS (function);
1652 /* Convert anything with function type to a pointer-to-function. */
1653 if (TREE_CODE (function) == FUNCTION_DECL)
1655 name = DECL_NAME (function);
1657 /* Differs from default_conversion by not setting TREE_ADDRESSABLE
1658 (because calling an inline function does not mean the function
1659 needs to be separately compiled). */
1660 fntype = build_type_variant (TREE_TYPE (function),
1661 TREE_READONLY (function),
1662 TREE_THIS_VOLATILE (function));
1664 function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
1667 function = default_conversion (function);
1669 fntype = TREE_TYPE (function);
1671 if (TREE_CODE (fntype) == ERROR_MARK)
1672 return error_mark_node;
1674 if (!(TREE_CODE (fntype) == POINTER_TYPE
1675 && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
1677 error ("called object is not a function");
1678 return error_mark_node;
1681 if (fundecl && TREE_THIS_VOLATILE (fundecl))
1682 current_function_returns_abnormally = 1;
1684 /* fntype now gets the type of function pointed to. */
1685 fntype = TREE_TYPE (fntype);
1687 /* Check that the function is called through a compatible prototype.
1688 If it is not, replace the call by a trap, wrapped up in a compound
1689 expression if necessary. This has the nice side-effect to prevent
1690 the tree-inliner from generating invalid assignment trees which may
1691 blow up in the RTL expander later.
1693 ??? This doesn't work for Objective-C because objc_comptypes
1694 refuses to compare function prototypes, yet the compiler appears
1695 to build calls that are flagged as invalid by C's comptypes. */
1696 if (! c_dialect_objc ()
1697 && TREE_CODE (function) == NOP_EXPR
1698 && TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR
1699 && TREE_CODE (tem = TREE_OPERAND (tem, 0)) == FUNCTION_DECL
1700 && ! comptypes (fntype, TREE_TYPE (tem), COMPARE_STRICT))
1702 tree return_type = TREE_TYPE (fntype);
1703 tree trap = build_function_call (built_in_decls[BUILT_IN_TRAP],
1706 /* This situation leads to run-time undefined behavior. We can't,
1707 therefore, simply error unless we can prove that all possible
1708 executions of the program must execute the code. */
1709 warning ("function called through a non-compatible type");
1711 /* We can, however, treat "undefined" any way we please.
1712 Call abort to encourage the user to fix the program. */
1713 inform ("if this code is reached, the program will abort");
1715 if (VOID_TYPE_P (return_type))
1721 if (AGGREGATE_TYPE_P (return_type))
1722 rhs = build_compound_literal (return_type,
1723 build_constructor (return_type,
1726 rhs = fold (build1 (NOP_EXPR, return_type, integer_zero_node));
1728 return build (COMPOUND_EXPR, return_type, trap, rhs);
1732 /* Convert the parameters to the types declared in the
1733 function prototype, or apply default promotions. */
1736 = convert_arguments (TYPE_ARG_TYPES (fntype), params, name, fundecl);
1738 /* Check that the arguments to the function are valid. */
1740 check_function_arguments (TYPE_ATTRIBUTES (fntype), coerced_params);
1742 /* Recognize certain built-in functions so we can make tree-codes
1743 other than CALL_EXPR. We do this when it enables fold-const.c
1744 to do something useful. */
1746 if (TREE_CODE (function) == ADDR_EXPR
1747 && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL
1748 && DECL_BUILT_IN (TREE_OPERAND (function, 0)))
1750 result = expand_tree_builtin (TREE_OPERAND (function, 0),
1751 params, coerced_params);
1756 result = build (CALL_EXPR, TREE_TYPE (fntype),
1757 function, coerced_params, NULL_TREE);
1758 TREE_SIDE_EFFECTS (result) = 1;
1760 if (require_constant_value)
1762 result = fold_initializer (result);
1764 if (TREE_CONSTANT (result)
1765 && (name == NULL_TREE
1766 || strncmp (IDENTIFIER_POINTER (name), "__builtin_", 10) != 0))
1767 pedwarn_init ("initializer element is not constant");
1770 result = fold (result);
1772 if (VOID_TYPE_P (TREE_TYPE (result)))
1774 return require_complete_type (result);
1777 /* Convert the argument expressions in the list VALUES
1778 to the types in the list TYPELIST. The result is a list of converted
1779 argument expressions.
1781 If TYPELIST is exhausted, or when an element has NULL as its type,
1782 perform the default conversions.
1784 PARMLIST is the chain of parm decls for the function being called.
1785 It may be 0, if that info is not available.
1786 It is used only for generating error messages.
1788 NAME is an IDENTIFIER_NODE or 0. It is used only for error messages.
1790 This is also where warnings about wrong number of args are generated.
1792 Both VALUES and the returned value are chains of TREE_LIST nodes
1793 with the elements of the list in the TREE_VALUE slots of those nodes. */
1796 convert_arguments (tree typelist, tree values, tree name, tree fundecl)
1798 tree typetail, valtail;
1802 /* Scan the given expressions and types, producing individual
1803 converted arguments and pushing them on RESULT in reverse order. */
1805 for (valtail = values, typetail = typelist, parmnum = 0;
1807 valtail = TREE_CHAIN (valtail), parmnum++)
1809 tree type = typetail ? TREE_VALUE (typetail) : 0;
1810 tree val = TREE_VALUE (valtail);
1812 if (type == void_type_node)
1815 error ("too many arguments to function `%s'",
1816 IDENTIFIER_POINTER (name));
1818 error ("too many arguments to function");
1822 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1823 /* Do not use STRIP_NOPS here! We do not want an enumerator with value 0
1824 to convert automatically to a pointer. */
1825 if (TREE_CODE (val) == NON_LVALUE_EXPR)
1826 val = TREE_OPERAND (val, 0);
1828 val = default_function_array_conversion (val);
1830 val = require_complete_type (val);
1834 /* Formal parm type is specified by a function prototype. */
1837 if (!COMPLETE_TYPE_P (type))
1839 error ("type of formal parameter %d is incomplete", parmnum + 1);
1844 /* Optionally warn about conversions that
1845 differ from the default conversions. */
1846 if (warn_conversion || warn_traditional)
1848 int formal_prec = TYPE_PRECISION (type);
1850 if (INTEGRAL_TYPE_P (type)
1851 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1852 warn_for_assignment ("%s as integer rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1853 if (INTEGRAL_TYPE_P (type)
1854 && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
1855 warn_for_assignment ("%s as integer rather than complex due to prototype", (char *) 0, name, parmnum + 1);
1856 else if (TREE_CODE (type) == COMPLEX_TYPE
1857 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1858 warn_for_assignment ("%s as complex rather than floating due to prototype", (char *) 0, name, parmnum + 1);
1859 else if (TREE_CODE (type) == REAL_TYPE
1860 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1861 warn_for_assignment ("%s as floating rather than integer due to prototype", (char *) 0, name, parmnum + 1);
1862 else if (TREE_CODE (type) == COMPLEX_TYPE
1863 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1864 warn_for_assignment ("%s as complex rather than integer due to prototype", (char *) 0, name, parmnum + 1);
1865 else if (TREE_CODE (type) == REAL_TYPE
1866 && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
1867 warn_for_assignment ("%s as floating rather than complex due to prototype", (char *) 0, name, parmnum + 1);
1868 /* ??? At some point, messages should be written about
1869 conversions between complex types, but that's too messy
1871 else if (TREE_CODE (type) == REAL_TYPE
1872 && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
1874 /* Warn if any argument is passed as `float',
1875 since without a prototype it would be `double'. */
1876 if (formal_prec == TYPE_PRECISION (float_type_node))
1877 warn_for_assignment ("%s as `float' rather than `double' due to prototype", (char *) 0, name, parmnum + 1);
1879 /* Detect integer changing in width or signedness.
1880 These warnings are only activated with
1881 -Wconversion, not with -Wtraditional. */
1882 else if (warn_conversion && INTEGRAL_TYPE_P (type)
1883 && INTEGRAL_TYPE_P (TREE_TYPE (val)))
1885 tree would_have_been = default_conversion (val);
1886 tree type1 = TREE_TYPE (would_have_been);
1888 if (TREE_CODE (type) == ENUMERAL_TYPE
1889 && (TYPE_MAIN_VARIANT (type)
1890 == TYPE_MAIN_VARIANT (TREE_TYPE (val))))
1891 /* No warning if function asks for enum
1892 and the actual arg is that enum type. */
1894 else if (formal_prec != TYPE_PRECISION (type1))
1895 warn_for_assignment ("%s with different width due to prototype", (char *) 0, name, parmnum + 1);
1896 else if (TREE_UNSIGNED (type) == TREE_UNSIGNED (type1))
1898 /* Don't complain if the formal parameter type
1899 is an enum, because we can't tell now whether
1900 the value was an enum--even the same enum. */
1901 else if (TREE_CODE (type) == ENUMERAL_TYPE)
1903 else if (TREE_CODE (val) == INTEGER_CST
1904 && int_fits_type_p (val, type))
1905 /* Change in signedness doesn't matter
1906 if a constant value is unaffected. */
1908 /* Likewise for a constant in a NOP_EXPR. */
1909 else if (TREE_CODE (val) == NOP_EXPR
1910 && TREE_CODE (TREE_OPERAND (val, 0)) == INTEGER_CST
1911 && int_fits_type_p (TREE_OPERAND (val, 0), type))
1913 /* If the value is extended from a narrower
1914 unsigned type, it doesn't matter whether we
1915 pass it as signed or unsigned; the value
1916 certainly is the same either way. */
1917 else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type)
1918 && TREE_UNSIGNED (TREE_TYPE (val)))
1920 else if (TREE_UNSIGNED (type))
1921 warn_for_assignment ("%s as unsigned due to prototype", (char *) 0, name, parmnum + 1);
1923 warn_for_assignment ("%s as signed due to prototype", (char *) 0, name, parmnum + 1);
1927 parmval = convert_for_assignment (type, val,
1928 (char *) 0, /* arg passing */
1929 fundecl, name, parmnum + 1);
1931 if (targetm.calls.promote_prototypes (fundecl ? TREE_TYPE (fundecl) : 0)
1932 && INTEGRAL_TYPE_P (type)
1933 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
1934 parmval = default_conversion (parmval);
1936 result = tree_cons (NULL_TREE, parmval, result);
1938 else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
1939 && (TYPE_PRECISION (TREE_TYPE (val))
1940 < TYPE_PRECISION (double_type_node)))
1941 /* Convert `float' to `double'. */
1942 result = tree_cons (NULL_TREE, convert (double_type_node, val), result);
1944 /* Convert `short' and `char' to full-size `int'. */
1945 result = tree_cons (NULL_TREE, default_conversion (val), result);
1948 typetail = TREE_CHAIN (typetail);
1951 if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
1954 error ("too few arguments to function `%s'",
1955 IDENTIFIER_POINTER (name));
1957 error ("too few arguments to function");
1960 return nreverse (result);
1963 /* This is the entry point used by the parser
1964 for binary operators in the input.
1965 In addition to constructing the expression,
1966 we check for operands that were written with other binary operators
1967 in a way that is likely to confuse the user. */
1970 parser_build_binary_op (enum tree_code code, tree arg1, tree arg2)
1972 tree result = build_binary_op (code, arg1, arg2, 1);
1975 char class1 = TREE_CODE_CLASS (TREE_CODE (arg1));
1976 char class2 = TREE_CODE_CLASS (TREE_CODE (arg2));
1977 enum tree_code code1 = ERROR_MARK;
1978 enum tree_code code2 = ERROR_MARK;
1980 if (TREE_CODE (result) == ERROR_MARK)
1981 return error_mark_node;
1983 if (IS_EXPR_CODE_CLASS (class1))
1984 code1 = C_EXP_ORIGINAL_CODE (arg1);
1985 if (IS_EXPR_CODE_CLASS (class2))
1986 code2 = C_EXP_ORIGINAL_CODE (arg2);
1988 /* Check for cases such as x+y<<z which users are likely
1989 to misinterpret. If parens are used, C_EXP_ORIGINAL_CODE
1990 is cleared to prevent these warnings. */
1991 if (warn_parentheses)
1993 if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
1995 if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
1996 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
1997 warning ("suggest parentheses around + or - inside shift");
2000 if (code == TRUTH_ORIF_EXPR)
2002 if (code1 == TRUTH_ANDIF_EXPR
2003 || code2 == TRUTH_ANDIF_EXPR)
2004 warning ("suggest parentheses around && within ||");
2007 if (code == BIT_IOR_EXPR)
2009 if (code1 == BIT_AND_EXPR || code1 == BIT_XOR_EXPR
2010 || code1 == PLUS_EXPR || code1 == MINUS_EXPR
2011 || code2 == BIT_AND_EXPR || code2 == BIT_XOR_EXPR
2012 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2013 warning ("suggest parentheses around arithmetic in operand of |");
2014 /* Check cases like x|y==z */
2015 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
2016 warning ("suggest parentheses around comparison in operand of |");
2019 if (code == BIT_XOR_EXPR)
2021 if (code1 == BIT_AND_EXPR
2022 || code1 == PLUS_EXPR || code1 == MINUS_EXPR
2023 || code2 == BIT_AND_EXPR
2024 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2025 warning ("suggest parentheses around arithmetic in operand of ^");
2026 /* Check cases like x^y==z */
2027 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
2028 warning ("suggest parentheses around comparison in operand of ^");
2031 if (code == BIT_AND_EXPR)
2033 if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
2034 || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2035 warning ("suggest parentheses around + or - in operand of &");
2036 /* Check cases like x&y==z */
2037 if (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<')
2038 warning ("suggest parentheses around comparison in operand of &");
2042 /* Similarly, check for cases like 1<=i<=10 that are probably errors. */
2043 if (TREE_CODE_CLASS (code) == '<' && extra_warnings
2044 && (TREE_CODE_CLASS (code1) == '<' || TREE_CODE_CLASS (code2) == '<'))
2045 warning ("comparisons like X<=Y<=Z do not have their mathematical meaning");
2047 unsigned_conversion_warning (result, arg1);
2048 unsigned_conversion_warning (result, arg2);
2049 overflow_warning (result);
2051 class = TREE_CODE_CLASS (TREE_CODE (result));
2053 /* Record the code that was specified in the source,
2054 for the sake of warnings about confusing nesting. */
2055 if (IS_EXPR_CODE_CLASS (class))
2056 C_SET_EXP_ORIGINAL_CODE (result, code);
2059 int flag = TREE_CONSTANT (result);
2060 /* We used to use NOP_EXPR rather than NON_LVALUE_EXPR
2061 so that convert_for_assignment wouldn't strip it.
2062 That way, we got warnings for things like p = (1 - 1).
2063 But it turns out we should not get those warnings. */
2064 result = build1 (NON_LVALUE_EXPR, TREE_TYPE (result), result);
2065 C_SET_EXP_ORIGINAL_CODE (result, code);
2066 TREE_CONSTANT (result) = flag;
2073 /* Return true if `t' is known to be non-negative. */
2076 c_tree_expr_nonnegative_p (tree t)
2078 if (TREE_CODE (t) == STMT_EXPR)
2080 t = COMPOUND_BODY (STMT_EXPR_STMT (t));
2082 /* Find the last statement in the chain, ignoring the final
2083 * scope statement */
2084 while (TREE_CHAIN (t) != NULL_TREE
2085 && TREE_CODE (TREE_CHAIN (t)) != SCOPE_STMT)
2087 return tree_expr_nonnegative_p (TREE_OPERAND (t, 0));
2089 return tree_expr_nonnegative_p (t);
2092 /* Return a tree for the difference of pointers OP0 and OP1.
2093 The resulting tree has type int. */
2096 pointer_diff (tree op0, tree op1)
2098 tree result, folded;
2099 tree restype = ptrdiff_type_node;
2101 tree target_type = TREE_TYPE (TREE_TYPE (op0));
2102 tree con0, con1, lit0, lit1;
2103 tree orig_op1 = op1;
2105 if (pedantic || warn_pointer_arith)
2107 if (TREE_CODE (target_type) == VOID_TYPE)
2108 pedwarn ("pointer of type `void *' used in subtraction");
2109 if (TREE_CODE (target_type) == FUNCTION_TYPE)
2110 pedwarn ("pointer to a function used in subtraction");
2113 /* If the conversion to ptrdiff_type does anything like widening or
2114 converting a partial to an integral mode, we get a convert_expression
2115 that is in the way to do any simplifications.
2116 (fold-const.c doesn't know that the extra bits won't be needed.
2117 split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a
2118 different mode in place.)
2119 So first try to find a common term here 'by hand'; we want to cover
2120 at least the cases that occur in legal static initializers. */
2121 con0 = TREE_CODE (op0) == NOP_EXPR ? TREE_OPERAND (op0, 0) : op0;
2122 con1 = TREE_CODE (op1) == NOP_EXPR ? TREE_OPERAND (op1, 0) : op1;
2124 if (TREE_CODE (con0) == PLUS_EXPR)
2126 lit0 = TREE_OPERAND (con0, 1);
2127 con0 = TREE_OPERAND (con0, 0);
2130 lit0 = integer_zero_node;
2132 if (TREE_CODE (con1) == PLUS_EXPR)
2134 lit1 = TREE_OPERAND (con1, 1);
2135 con1 = TREE_OPERAND (con1, 0);
2138 lit1 = integer_zero_node;
2140 if (operand_equal_p (con0, con1, 0))
2147 /* First do the subtraction as integers;
2148 then drop through to build the divide operator.
2149 Do not do default conversions on the minus operator
2150 in case restype is a short type. */
2152 op0 = build_binary_op (MINUS_EXPR, convert (restype, op0),
2153 convert (restype, op1), 0);
2154 /* This generates an error if op1 is pointer to incomplete type. */
2155 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1))))
2156 error ("arithmetic on pointer to an incomplete type");
2158 /* This generates an error if op0 is pointer to incomplete type. */
2159 op1 = c_size_in_bytes (target_type);
2161 /* Divide by the size, in easiest possible way. */
2163 result = build (EXACT_DIV_EXPR, restype, op0, convert (restype, op1));
2165 folded = fold (result);
2166 if (folded == result)
2167 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
2171 /* Construct and perhaps optimize a tree representation
2172 for a unary operation. CODE, a tree_code, specifies the operation
2173 and XARG is the operand.
2174 For any CODE other than ADDR_EXPR, FLAG nonzero suppresses
2175 the default promotions (such as from short to int).
2176 For ADDR_EXPR, the default promotions are not applied; FLAG nonzero
2177 allows non-lvalues; this is only used to handle conversion of non-lvalue
2178 arrays to pointers in C99. */
2181 build_unary_op (enum tree_code code, tree xarg, int flag)
2183 /* No default_conversion here. It causes trouble for ADDR_EXPR. */
2186 enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
2188 int noconvert = flag;
2190 if (typecode == ERROR_MARK)
2191 return error_mark_node;
2192 if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE)
2193 typecode = INTEGER_TYPE;
2198 /* This is used for unary plus, because a CONVERT_EXPR
2199 is enough to prevent anybody from looking inside for
2200 associativity, but won't generate any code. */
2201 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2202 || typecode == COMPLEX_TYPE))
2204 error ("wrong type argument to unary plus");
2205 return error_mark_node;
2207 else if (!noconvert)
2208 arg = default_conversion (arg);
2209 arg = non_lvalue (arg);
2213 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2214 || typecode == COMPLEX_TYPE
2215 || typecode == VECTOR_TYPE))
2217 error ("wrong type argument to unary minus");
2218 return error_mark_node;
2220 else if (!noconvert)
2221 arg = default_conversion (arg);
2225 if (typecode == INTEGER_TYPE || typecode == VECTOR_TYPE)
2228 arg = default_conversion (arg);
2230 else if (typecode == COMPLEX_TYPE)
2234 pedwarn ("ISO C does not support `~' for complex conjugation");
2236 arg = default_conversion (arg);
2240 error ("wrong type argument to bit-complement");
2241 return error_mark_node;
2246 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE))
2248 error ("wrong type argument to abs");
2249 return error_mark_node;
2251 else if (!noconvert)
2252 arg = default_conversion (arg);
2256 /* Conjugating a real value is a no-op, but allow it anyway. */
2257 if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2258 || typecode == COMPLEX_TYPE))
2260 error ("wrong type argument to conjugation");
2261 return error_mark_node;
2263 else if (!noconvert)
2264 arg = default_conversion (arg);
2267 case TRUTH_NOT_EXPR:
2268 if (typecode != INTEGER_TYPE
2269 && typecode != REAL_TYPE && typecode != POINTER_TYPE
2270 && typecode != COMPLEX_TYPE
2271 /* These will convert to a pointer. */
2272 && typecode != ARRAY_TYPE && typecode != FUNCTION_TYPE)
2274 error ("wrong type argument to unary exclamation mark");
2275 return error_mark_node;
2277 arg = c_common_truthvalue_conversion (arg);
2278 return invert_truthvalue (arg);
2284 if (TREE_CODE (arg) == COMPLEX_CST)
2285 return TREE_REALPART (arg);
2286 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2287 return fold (build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2292 if (TREE_CODE (arg) == COMPLEX_CST)
2293 return TREE_IMAGPART (arg);
2294 else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2295 return fold (build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg));
2297 return convert (TREE_TYPE (arg), integer_zero_node);
2299 case PREINCREMENT_EXPR:
2300 case POSTINCREMENT_EXPR:
2301 case PREDECREMENT_EXPR:
2302 case POSTDECREMENT_EXPR:
2303 /* Handle complex lvalues (when permitted)
2304 by reduction to simpler cases. */
2306 val = unary_complex_lvalue (code, arg, 0);
2310 /* Increment or decrement the real part of the value,
2311 and don't change the imaginary part. */
2312 if (typecode == COMPLEX_TYPE)
2317 pedwarn ("ISO C does not support `++' and `--' on complex types");
2319 arg = stabilize_reference (arg);
2320 real = build_unary_op (REALPART_EXPR, arg, 1);
2321 imag = build_unary_op (IMAGPART_EXPR, arg, 1);
2322 return build (COMPLEX_EXPR, TREE_TYPE (arg),
2323 build_unary_op (code, real, 1), imag);
2326 /* Report invalid types. */
2328 if (typecode != POINTER_TYPE
2329 && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
2331 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2332 error ("wrong type argument to increment");
2334 error ("wrong type argument to decrement");
2336 return error_mark_node;
2341 tree result_type = TREE_TYPE (arg);
2343 arg = get_unwidened (arg, 0);
2344 argtype = TREE_TYPE (arg);
2346 /* Compute the increment. */
2348 if (typecode == POINTER_TYPE)
2350 /* If pointer target is an undefined struct,
2351 we just cannot know how to do the arithmetic. */
2352 if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type)))
2354 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2355 error ("increment of pointer to unknown structure");
2357 error ("decrement of pointer to unknown structure");
2359 else if ((pedantic || warn_pointer_arith)
2360 && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE
2361 || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE))
2363 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2364 pedwarn ("wrong type argument to increment");
2366 pedwarn ("wrong type argument to decrement");
2369 inc = c_size_in_bytes (TREE_TYPE (result_type));
2372 inc = integer_one_node;
2374 inc = convert (argtype, inc);
2376 /* Handle incrementing a cast-expression. */
2379 switch (TREE_CODE (arg))
2384 case FIX_TRUNC_EXPR:
2385 case FIX_FLOOR_EXPR:
2386 case FIX_ROUND_EXPR:
2388 pedantic_lvalue_warning (CONVERT_EXPR);
2389 /* If the real type has the same machine representation
2390 as the type it is cast to, we can make better output
2391 by adding directly to the inside of the cast. */
2392 if ((TREE_CODE (TREE_TYPE (arg))
2393 == TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))))
2394 && (TYPE_MODE (TREE_TYPE (arg))
2395 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (arg, 0)))))
2396 arg = TREE_OPERAND (arg, 0);
2399 tree incremented, modify, value;
2400 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
2401 value = boolean_increment (code, arg);
2404 arg = stabilize_reference (arg);
2405 if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
2408 value = save_expr (arg);
2409 incremented = build (((code == PREINCREMENT_EXPR
2410 || code == POSTINCREMENT_EXPR)
2411 ? PLUS_EXPR : MINUS_EXPR),
2412 argtype, value, inc);
2413 TREE_SIDE_EFFECTS (incremented) = 1;
2414 modify = build_modify_expr (arg, NOP_EXPR, incremented);
2415 value = build (COMPOUND_EXPR, TREE_TYPE (arg), modify, value);
2417 TREE_USED (value) = 1;
2427 /* Complain about anything else that is not a true lvalue. */
2428 if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
2429 || code == POSTINCREMENT_EXPR)
2430 ? "invalid lvalue in increment"
2431 : "invalid lvalue in decrement")))
2432 return error_mark_node;
2434 /* Report a read-only lvalue. */
2435 if (TREE_READONLY (arg))
2436 readonly_error (arg,
2437 ((code == PREINCREMENT_EXPR
2438 || code == POSTINCREMENT_EXPR)
2439 ? "increment" : "decrement"));
2441 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
2442 val = boolean_increment (code, arg);
2444 val = build (code, TREE_TYPE (arg), arg, inc);
2445 TREE_SIDE_EFFECTS (val) = 1;
2446 val = convert (result_type, val);
2447 if (TREE_CODE (val) != code)
2448 TREE_NO_UNUSED_WARNING (val) = 1;
2453 /* Note that this operation never does default_conversion. */
2455 /* Let &* cancel out to simplify resulting code. */
2456 if (TREE_CODE (arg) == INDIRECT_REF)
2458 /* Don't let this be an lvalue. */
2459 if (lvalue_p (TREE_OPERAND (arg, 0)))
2460 return non_lvalue (TREE_OPERAND (arg, 0));
2461 return TREE_OPERAND (arg, 0);
2464 /* For &x[y], return x+y */
2465 if (TREE_CODE (arg) == ARRAY_REF)
2467 if (!c_mark_addressable (TREE_OPERAND (arg, 0)))
2468 return error_mark_node;
2469 return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
2470 TREE_OPERAND (arg, 1), 1);
2473 /* Handle complex lvalues (when permitted)
2474 by reduction to simpler cases. */
2475 val = unary_complex_lvalue (code, arg, flag);
2479 /* Anything not already handled and not a true memory reference
2480 or a non-lvalue array is an error. */
2481 else if (typecode != FUNCTION_TYPE && !flag
2482 && !lvalue_or_else (arg, "invalid lvalue in unary `&'"))
2483 return error_mark_node;
2485 /* Ordinary case; arg is a COMPONENT_REF or a decl. */
2486 argtype = TREE_TYPE (arg);
2488 /* If the lvalue is const or volatile, merge that into the type
2489 to which the address will point. Note that you can't get a
2490 restricted pointer by taking the address of something, so we
2491 only have to deal with `const' and `volatile' here. */
2492 if ((DECL_P (arg) || TREE_CODE_CLASS (TREE_CODE (arg)) == 'r')
2493 && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg)))
2494 argtype = c_build_type_variant (argtype,
2495 TREE_READONLY (arg),
2496 TREE_THIS_VOLATILE (arg));
2498 argtype = build_pointer_type (argtype);
2500 if (!c_mark_addressable (arg))
2501 return error_mark_node;
2506 if (TREE_CODE (arg) == COMPONENT_REF)
2508 tree field = TREE_OPERAND (arg, 1);
2510 addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), flag);
2512 if (DECL_C_BIT_FIELD (field))
2514 error ("attempt to take address of bit-field structure member `%s'",
2515 IDENTIFIER_POINTER (DECL_NAME (field)));
2516 return error_mark_node;
2519 addr = fold (build (PLUS_EXPR, argtype,
2520 convert (argtype, addr),
2521 convert (argtype, byte_position (field))));
2524 addr = build1 (code, argtype, arg);
2526 /* Address of a static or external variable or
2527 file-scope function counts as a constant. */
2529 && ! (TREE_CODE (arg) == FUNCTION_DECL
2530 && !DECL_FILE_SCOPE_P (arg)))
2531 TREE_CONSTANT (addr) = 1;
2540 argtype = TREE_TYPE (arg);
2541 val = build1 (code, argtype, arg);
2542 return require_constant_value ? fold_initializer (val) : fold (val);
2545 /* Return nonzero if REF is an lvalue valid for this language.
2546 Lvalues can be assigned, unless their type has TYPE_READONLY.
2547 Lvalues can have their address taken, unless they have DECL_REGISTER. */
2552 enum tree_code code = TREE_CODE (ref);
2559 return lvalue_p (TREE_OPERAND (ref, 0));
2561 case COMPOUND_LITERAL_EXPR:
2571 return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
2572 && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
2576 return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
2583 /* Return nonzero if REF is an lvalue valid for this language;
2584 otherwise, print an error message and return zero. */
2587 lvalue_or_else (tree ref, const char *msgid)
2589 int win = lvalue_p (ref);
2592 error ("%s", msgid);
2597 /* Apply unary lvalue-demanding operator CODE to the expression ARG
2598 for certain kinds of expressions which are not really lvalues
2599 but which we can accept as lvalues. If FLAG is nonzero, then
2600 non-lvalues are OK since we may be converting a non-lvalue array to
2603 If ARG is not a kind of expression we can handle, return zero. */
2606 unary_complex_lvalue (enum tree_code code, tree arg, int flag)
2608 /* Handle (a, b) used as an "lvalue". */
2609 if (TREE_CODE (arg) == COMPOUND_EXPR)
2611 tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
2613 /* If this returns a function type, it isn't really being used as
2614 an lvalue, so don't issue a warning about it. */
2615 if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE && !flag)
2616 pedantic_lvalue_warning (COMPOUND_EXPR);
2618 return build (COMPOUND_EXPR, TREE_TYPE (real_result),
2619 TREE_OPERAND (arg, 0), real_result);
2622 /* Handle (a ? b : c) used as an "lvalue". */
2623 if (TREE_CODE (arg) == COND_EXPR)
2626 pedantic_lvalue_warning (COND_EXPR);
2627 if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE && !flag)
2628 pedantic_lvalue_warning (COMPOUND_EXPR);
2630 return (build_conditional_expr
2631 (TREE_OPERAND (arg, 0),
2632 build_unary_op (code, TREE_OPERAND (arg, 1), flag),
2633 build_unary_op (code, TREE_OPERAND (arg, 2), flag)));
2639 /* If pedantic, warn about improper lvalue. CODE is either COND_EXPR
2640 COMPOUND_EXPR, or CONVERT_EXPR (for casts). */
2643 pedantic_lvalue_warning (enum tree_code code)
2648 pedwarn ("use of conditional expressions as lvalues is deprecated");
2651 pedwarn ("use of compound expressions as lvalues is deprecated");
2654 pedwarn ("use of cast expressions as lvalues is deprecated");
2659 /* Warn about storing in something that is `const'. */
2662 readonly_error (tree arg, const char *msgid)
2664 if (TREE_CODE (arg) == COMPONENT_REF)
2666 if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
2667 readonly_error (TREE_OPERAND (arg, 0), msgid);
2669 error ("%s of read-only member `%s'", _(msgid),
2670 IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
2672 else if (TREE_CODE (arg) == VAR_DECL)
2673 error ("%s of read-only variable `%s'", _(msgid),
2674 IDENTIFIER_POINTER (DECL_NAME (arg)));
2676 error ("%s of read-only location", _(msgid));
2679 /* Mark EXP saying that we need to be able to take the
2680 address of it; it should not be allocated in a register.
2681 Returns true if successful. */
2684 c_mark_addressable (tree exp)
2689 switch (TREE_CODE (x))
2692 if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
2694 error ("cannot take address of bit-field `%s'",
2695 IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (x, 1))));
2699 /* ... fall through ... */
2705 x = TREE_OPERAND (x, 0);
2708 case COMPOUND_LITERAL_EXPR:
2710 TREE_ADDRESSABLE (x) = 1;
2717 if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
2718 && DECL_NONLOCAL (x))
2720 if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x))
2722 error ("global register variable `%s' used in nested function",
2723 IDENTIFIER_POINTER (DECL_NAME (x)));
2726 pedwarn ("register variable `%s' used in nested function",
2727 IDENTIFIER_POINTER (DECL_NAME (x)));
2729 else if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x))
2731 if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x))
2733 error ("address of global register variable `%s' requested",
2734 IDENTIFIER_POINTER (DECL_NAME (x)));
2738 /* If we are making this addressable due to its having
2739 volatile components, give a different error message. Also
2740 handle the case of an unnamed parameter by not trying
2741 to give the name. */
2743 else if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (x)))
2745 error ("cannot put object with volatile field into register");
2749 pedwarn ("address of register variable `%s' requested",
2750 IDENTIFIER_POINTER (DECL_NAME (x)));
2752 put_var_into_stack (x, /*rescan=*/true);
2756 TREE_ADDRESSABLE (x) = 1;
2763 /* Build and return a conditional expression IFEXP ? OP1 : OP2. */
2766 build_conditional_expr (tree ifexp, tree op1, tree op2)
2770 enum tree_code code1;
2771 enum tree_code code2;
2772 tree result_type = NULL;
2773 tree orig_op1 = op1, orig_op2 = op2;
2775 ifexp = c_common_truthvalue_conversion (default_conversion (ifexp));
2777 /* Promote both alternatives. */
2779 if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
2780 op1 = default_conversion (op1);
2781 if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
2782 op2 = default_conversion (op2);
2784 if (TREE_CODE (ifexp) == ERROR_MARK
2785 || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
2786 || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
2787 return error_mark_node;
2789 type1 = TREE_TYPE (op1);
2790 code1 = TREE_CODE (type1);
2791 type2 = TREE_TYPE (op2);
2792 code2 = TREE_CODE (type2);
2794 /* Quickly detect the usual case where op1 and op2 have the same type
2796 if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
2799 result_type = type1;
2801 result_type = TYPE_MAIN_VARIANT (type1);
2803 else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE
2804 || code1 == COMPLEX_TYPE)
2805 && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
2806 || code2 == COMPLEX_TYPE))
2808 result_type = common_type (type1, type2);
2810 /* If -Wsign-compare, warn here if type1 and type2 have
2811 different signedness. We'll promote the signed to unsigned
2812 and later code won't know it used to be different.
2813 Do this check on the original types, so that explicit casts
2814 will be considered, but default promotions won't. */
2815 if (warn_sign_compare && !skip_evaluation)
2817 int unsigned_op1 = TREE_UNSIGNED (TREE_TYPE (orig_op1));
2818 int unsigned_op2 = TREE_UNSIGNED (TREE_TYPE (orig_op2));
2820 if (unsigned_op1 ^ unsigned_op2)
2822 /* Do not warn if the result type is signed, since the
2823 signed type will only be chosen if it can represent
2824 all the values of the unsigned type. */
2825 if (! TREE_UNSIGNED (result_type))
2827 /* Do not warn if the signed quantity is an unsuffixed
2828 integer literal (or some static constant expression
2829 involving such literals) and it is non-negative. */
2830 else if ((unsigned_op2 && c_tree_expr_nonnegative_p (op1))
2831 || (unsigned_op1 && c_tree_expr_nonnegative_p (op2)))
2834 warning ("signed and unsigned type in conditional expression");
2838 else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
2840 if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
2841 pedwarn ("ISO C forbids conditional expr with only one void side");
2842 result_type = void_type_node;
2844 else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
2846 if (comp_target_types (type1, type2, 1))
2847 result_type = common_type (type1, type2);
2848 else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node
2849 && TREE_CODE (orig_op1) != NOP_EXPR)
2850 result_type = qualify_type (type2, type1);
2851 else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node
2852 && TREE_CODE (orig_op2) != NOP_EXPR)
2853 result_type = qualify_type (type1, type2);
2854 else if (VOID_TYPE_P (TREE_TYPE (type1)))
2856 if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
2857 pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
2858 result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
2859 TREE_TYPE (type2)));
2861 else if (VOID_TYPE_P (TREE_TYPE (type2)))
2863 if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
2864 pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
2865 result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
2866 TREE_TYPE (type1)));
2870 pedwarn ("pointer type mismatch in conditional expression");
2871 result_type = build_pointer_type (void_type_node);
2874 else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
2876 if (! integer_zerop (op2))
2877 pedwarn ("pointer/integer type mismatch in conditional expression");
2880 op2 = null_pointer_node;
2882 result_type = type1;
2884 else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
2886 if (!integer_zerop (op1))
2887 pedwarn ("pointer/integer type mismatch in conditional expression");
2890 op1 = null_pointer_node;
2892 result_type = type2;
2897 if (flag_cond_mismatch)
2898 result_type = void_type_node;
2901 error ("type mismatch in conditional expression");
2902 return error_mark_node;
2906 /* Merge const and volatile flags of the incoming types. */
2908 = build_type_variant (result_type,
2909 TREE_READONLY (op1) || TREE_READONLY (op2),
2910 TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
2912 if (result_type != TREE_TYPE (op1))
2913 op1 = convert_and_check (result_type, op1);
2914 if (result_type != TREE_TYPE (op2))
2915 op2 = convert_and_check (result_type, op2);
2917 if (TREE_CODE (ifexp) == INTEGER_CST)
2918 return pedantic_non_lvalue (integer_zerop (ifexp) ? op2 : op1);
2920 return fold (build (COND_EXPR, result_type, ifexp, op1, op2));
2923 /* Given a list of expressions, return a compound expression
2924 that performs them all and returns the value of the last of them. */
2927 build_compound_expr (tree list)
2929 return internal_build_compound_expr (list, TRUE);
2933 internal_build_compound_expr (tree list, int first_p)
2937 if (TREE_CHAIN (list) == 0)
2939 /* Convert arrays and functions to pointers when there
2940 really is a comma operator. */
2943 = default_function_array_conversion (TREE_VALUE (list));
2945 /* Don't let (0, 0) be null pointer constant. */
2946 if (!first_p && integer_zerop (TREE_VALUE (list)))
2947 return non_lvalue (TREE_VALUE (list));
2948 return TREE_VALUE (list);
2951 rest = internal_build_compound_expr (TREE_CHAIN (list), FALSE);
2953 if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)))
2955 /* The left-hand operand of a comma expression is like an expression
2956 statement: with -Wextra or -Wunused, we should warn if it doesn't have
2957 any side-effects, unless it was explicitly cast to (void). */
2958 if (warn_unused_value
2959 && ! (TREE_CODE (TREE_VALUE (list)) == CONVERT_EXPR
2960 && VOID_TYPE_P (TREE_TYPE (TREE_VALUE (list)))))
2961 warning ("left-hand operand of comma expression has no effect");
2964 /* With -Wunused, we should also warn if the left-hand operand does have
2965 side-effects, but computes a value which is not used. For example, in
2966 `foo() + bar(), baz()' the result of the `+' operator is not used,
2967 so we should issue a warning. */
2968 else if (warn_unused_value)
2969 warn_if_unused_value (TREE_VALUE (list));
2971 return build (COMPOUND_EXPR, TREE_TYPE (rest), TREE_VALUE (list), rest);
2974 /* Build an expression representing a cast to type TYPE of expression EXPR. */
2977 build_c_cast (tree type, tree expr)
2981 if (type == error_mark_node || expr == error_mark_node)
2982 return error_mark_node;
2984 /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
2985 only in <protocol> qualifications. But when constructing cast expressions,
2986 the protocols do matter and must be kept around. */
2987 if (!c_dialect_objc () || !objc_is_object_ptr (type))
2988 type = TYPE_MAIN_VARIANT (type);
2990 if (TREE_CODE (type) == ARRAY_TYPE)
2992 error ("cast specifies array type");
2993 return error_mark_node;
2996 if (TREE_CODE (type) == FUNCTION_TYPE)
2998 error ("cast specifies function type");
2999 return error_mark_node;
3002 if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
3006 if (TREE_CODE (type) == RECORD_TYPE
3007 || TREE_CODE (type) == UNION_TYPE)
3008 pedwarn ("ISO C forbids casting nonscalar to the same type");
3011 else if (TREE_CODE (type) == UNION_TYPE)
3014 value = default_function_array_conversion (value);
3016 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3017 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
3018 TYPE_MAIN_VARIANT (TREE_TYPE (value)), COMPARE_STRICT))
3026 pedwarn ("ISO C forbids casts to union type");
3027 t = digest_init (type,
3028 build_constructor (type,
3029 build_tree_list (field, value)),
3031 TREE_CONSTANT (t) = TREE_CONSTANT (value);
3034 error ("cast to union type from type not present in union");
3035 return error_mark_node;
3041 /* If casting to void, avoid the error that would come
3042 from default_conversion in the case of a non-lvalue array. */
3043 if (type == void_type_node)
3044 return build1 (CONVERT_EXPR, type, value);
3046 /* Convert functions and arrays to pointers,
3047 but don't convert any other types. */
3048 value = default_function_array_conversion (value);
3049 otype = TREE_TYPE (value);
3051 /* Optionally warn about potentially worrisome casts. */
3054 && TREE_CODE (type) == POINTER_TYPE
3055 && TREE_CODE (otype) == POINTER_TYPE)
3057 tree in_type = type;
3058 tree in_otype = otype;
3062 /* Check that the qualifiers on IN_TYPE are a superset of
3063 the qualifiers of IN_OTYPE. The outermost level of
3064 POINTER_TYPE nodes is uninteresting and we stop as soon
3065 as we hit a non-POINTER_TYPE node on either type. */
3068 in_otype = TREE_TYPE (in_otype);
3069 in_type = TREE_TYPE (in_type);
3071 /* GNU C allows cv-qualified function types. 'const'
3072 means the function is very pure, 'volatile' means it
3073 can't return. We need to warn when such qualifiers
3074 are added, not when they're taken away. */
3075 if (TREE_CODE (in_otype) == FUNCTION_TYPE
3076 && TREE_CODE (in_type) == FUNCTION_TYPE)
3077 added |= (TYPE_QUALS (in_type) & ~TYPE_QUALS (in_otype));
3079 discarded |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type));
3081 while (TREE_CODE (in_type) == POINTER_TYPE
3082 && TREE_CODE (in_otype) == POINTER_TYPE);
3085 warning ("cast adds new qualifiers to function type");
3088 /* There are qualifiers present in IN_OTYPE that are not
3089 present in IN_TYPE. */
3090 warning ("cast discards qualifiers from pointer target type");
3093 /* Warn about possible alignment problems. */
3094 if (STRICT_ALIGNMENT && warn_cast_align
3095 && TREE_CODE (type) == POINTER_TYPE
3096 && TREE_CODE (otype) == POINTER_TYPE
3097 && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
3098 && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3099 /* Don't warn about opaque types, where the actual alignment
3100 restriction is unknown. */
3101 && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
3102 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
3103 && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
3104 && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
3105 warning ("cast increases required alignment of target type");
3107 if (TREE_CODE (type) == INTEGER_TYPE
3108 && TREE_CODE (otype) == POINTER_TYPE
3109 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3110 && !TREE_CONSTANT (value))
3111 warning ("cast from pointer to integer of different size");
3113 if (warn_bad_function_cast
3114 && TREE_CODE (value) == CALL_EXPR
3115 && TREE_CODE (type) != TREE_CODE (otype))
3116 warning ("cast does not match function type");
3118 if (TREE_CODE (type) == POINTER_TYPE
3119 && TREE_CODE (otype) == INTEGER_TYPE
3120 && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3121 /* Don't warn about converting any constant. */
3122 && !TREE_CONSTANT (value))
3123 warning ("cast to pointer from integer of different size");
3125 if (TREE_CODE (type) == POINTER_TYPE
3126 && TREE_CODE (otype) == POINTER_TYPE
3127 && TREE_CODE (expr) == ADDR_EXPR
3128 && DECL_P (TREE_OPERAND (expr, 0))
3129 && flag_strict_aliasing && warn_strict_aliasing
3130 && !VOID_TYPE_P (TREE_TYPE (type)))
3132 /* Casting the address of a decl to non void pointer. Warn
3133 if the cast breaks type based aliasing. */
3134 if (!COMPLETE_TYPE_P (TREE_TYPE (type)))
3135 warning ("type-punning to incomplete type might break strict-aliasing rules");
3136 else if (!alias_sets_conflict_p
3137 (get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0))),
3138 get_alias_set (TREE_TYPE (type))))
3139 warning ("dereferencing type-punned pointer will break strict-aliasing rules");
3142 /* If pedantic, warn for conversions between function and object
3143 pointer types, except for converting a null pointer constant
3144 to function pointer type. */
3146 && TREE_CODE (type) == POINTER_TYPE
3147 && TREE_CODE (otype) == POINTER_TYPE
3148 && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE
3149 && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE)
3150 pedwarn ("ISO C forbids conversion of function pointer to object pointer type");
3153 && TREE_CODE (type) == POINTER_TYPE
3154 && TREE_CODE (otype) == POINTER_TYPE
3155 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
3156 && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3157 && !(integer_zerop (value) && TREE_TYPE (otype) == void_type_node
3158 && TREE_CODE (expr) != NOP_EXPR))
3159 pedwarn ("ISO C forbids conversion of object pointer to function pointer type");
3162 /* Replace a nonvolatile const static variable with its value. */
3163 if (optimize && TREE_CODE (value) == VAR_DECL)
3164 value = decl_constant_value (value);
3165 value = convert (type, value);
3167 /* Ignore any integer overflow caused by the cast. */
3168 if (TREE_CODE (value) == INTEGER_CST)
3170 TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3171 TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3175 /* Pedantically, don't let (void *) (FOO *) 0 be a null pointer constant. */
3176 if (pedantic && TREE_CODE (value) == INTEGER_CST
3177 && TREE_CODE (expr) == INTEGER_CST
3178 && TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE)
3179 value = non_lvalue (value);
3181 /* If pedantic, don't let a cast be an lvalue. */
3182 if (value == expr && pedantic)
3183 value = non_lvalue (value);
3188 /* Interpret a cast of expression EXPR to type TYPE. */
3190 c_cast_expr (tree type, tree expr)
3192 int saved_wsp = warn_strict_prototypes;
3194 /* This avoids warnings about unprototyped casts on
3195 integers. E.g. "#define SIG_DFL (void(*)())0". */
3196 if (TREE_CODE (expr) == INTEGER_CST)
3197 warn_strict_prototypes = 0;
3198 type = groktypename (type);
3199 warn_strict_prototypes = saved_wsp;
3201 return build_c_cast (type, expr);
3205 /* Build an assignment expression of lvalue LHS from value RHS.
3206 MODIFYCODE is the code for a binary operator that we use
3207 to combine the old value of LHS with RHS to get the new value.
3208 Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment. */
3211 build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
3215 tree lhstype = TREE_TYPE (lhs);
3216 tree olhstype = lhstype;
3218 /* Types that aren't fully specified cannot be used in assignments. */
3219 lhs = require_complete_type (lhs);
3221 /* Avoid duplicate error messages from operands that had errors. */
3222 if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
3223 return error_mark_node;
3225 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3226 /* Do not use STRIP_NOPS here. We do not want an enumerator
3227 whose value is 0 to count as a null pointer constant. */
3228 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3229 rhs = TREE_OPERAND (rhs, 0);
3233 /* Handle control structure constructs used as "lvalues". */
3235 switch (TREE_CODE (lhs))
3237 /* Handle (a, b) used as an "lvalue". */
3239 pedantic_lvalue_warning (COMPOUND_EXPR);
3240 newrhs = build_modify_expr (TREE_OPERAND (lhs, 1), modifycode, rhs);
3241 if (TREE_CODE (newrhs) == ERROR_MARK)
3242 return error_mark_node;
3243 return build (COMPOUND_EXPR, lhstype,
3244 TREE_OPERAND (lhs, 0), newrhs);
3246 /* Handle (a ? b : c) used as an "lvalue". */
3248 pedantic_lvalue_warning (COND_EXPR);
3249 rhs = save_expr (rhs);
3251 /* Produce (a ? (b = rhs) : (c = rhs))
3252 except that the RHS goes through a save-expr
3253 so the code to compute it is only emitted once. */
3255 = build_conditional_expr (TREE_OPERAND (lhs, 0),
3256 build_modify_expr (TREE_OPERAND (lhs, 1),
3258 build_modify_expr (TREE_OPERAND (lhs, 2),
3260 if (TREE_CODE (cond) == ERROR_MARK)
3262 /* Make sure the code to compute the rhs comes out
3263 before the split. */
3264 return build (COMPOUND_EXPR, TREE_TYPE (lhs),
3265 /* But cast it to void to avoid an "unused" error. */
3266 convert (void_type_node, rhs), cond);
3272 /* If a binary op has been requested, combine the old LHS value with the RHS
3273 producing the value we should actually store into the LHS. */
3275 if (modifycode != NOP_EXPR)
3277 lhs = stabilize_reference (lhs);
3278 newrhs = build_binary_op (modifycode, lhs, rhs, 1);
3281 /* Handle a cast used as an "lvalue".
3282 We have already performed any binary operator using the value as cast.
3283 Now convert the result to the cast type of the lhs,
3284 and then true type of the lhs and store it there;
3285 then convert result back to the cast type to be the value
3286 of the assignment. */
3288 switch (TREE_CODE (lhs))
3293 case FIX_TRUNC_EXPR:
3294 case FIX_FLOOR_EXPR:
3295 case FIX_ROUND_EXPR:
3297 newrhs = default_function_array_conversion (newrhs);
3299 tree inner_lhs = TREE_OPERAND (lhs, 0);
3301 result = build_modify_expr (inner_lhs, NOP_EXPR,
3302 convert (TREE_TYPE (inner_lhs),
3303 convert (lhstype, newrhs)));
3304 if (TREE_CODE (result) == ERROR_MARK)
3306 pedantic_lvalue_warning (CONVERT_EXPR);
3307 return convert (TREE_TYPE (lhs), result);
3314 /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
3315 Reject anything strange now. */
3317 if (!lvalue_or_else (lhs, "invalid lvalue in assignment"))
3318 return error_mark_node;
3320 /* Warn about storing in something that is `const'. */
3322 if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
3323 || ((TREE_CODE (lhstype) == RECORD_TYPE
3324 || TREE_CODE (lhstype) == UNION_TYPE)
3325 && C_TYPE_FIELDS_READONLY (lhstype)))
3326 readonly_error (lhs, "assignment");
3328 /* If storing into a structure or union member,
3329 it has probably been given type `int'.
3330 Compute the type that would go with
3331 the actual amount of storage the member occupies. */
3333 if (TREE_CODE (lhs) == COMPONENT_REF
3334 && (TREE_CODE (lhstype) == INTEGER_TYPE
3335 || TREE_CODE (lhstype) == BOOLEAN_TYPE
3336 || TREE_CODE (lhstype) == REAL_TYPE
3337 || TREE_CODE (lhstype) == ENUMERAL_TYPE))
3338 lhstype = TREE_TYPE (get_unwidened (lhs, 0));
3340 /* If storing in a field that is in actuality a short or narrower than one,
3341 we must store in the field in its actual type. */
3343 if (lhstype != TREE_TYPE (lhs))
3345 lhs = copy_node (lhs);
3346 TREE_TYPE (lhs) = lhstype;
3349 /* Convert new value to destination type. */
3351 newrhs = convert_for_assignment (lhstype, newrhs, _("assignment"),
3352 NULL_TREE, NULL_TREE, 0);
3353 if (TREE_CODE (newrhs) == ERROR_MARK)
3354 return error_mark_node;
3358 result = build (MODIFY_EXPR, lhstype, lhs, newrhs);
3359 TREE_SIDE_EFFECTS (result) = 1;
3361 /* If we got the LHS in a different type for storing in,
3362 convert the result back to the nominal type of LHS
3363 so that the value we return always has the same type
3364 as the LHS argument. */
3366 if (olhstype == TREE_TYPE (result))
3368 return convert_for_assignment (olhstype, result, _("assignment"),
3369 NULL_TREE, NULL_TREE, 0);
3372 /* Convert value RHS to type TYPE as preparation for an assignment
3373 to an lvalue of type TYPE.
3374 The real work of conversion is done by `convert'.
3375 The purpose of this function is to generate error messages
3376 for assignments that are not allowed in C.
3377 ERRTYPE is a string to use in error messages:
3378 "assignment", "return", etc. If it is null, this is parameter passing
3379 for a function call (and different error messages are output).
3381 FUNNAME is the name of the function being called,
3382 as an IDENTIFIER_NODE, or null.
3383 PARMNUM is the number of the argument, for printing in error messages. */
3386 convert_for_assignment (tree type, tree rhs, const char *errtype,
3387 tree fundecl, tree funname, int parmnum)
3389 enum tree_code codel = TREE_CODE (type);
3391 enum tree_code coder;
3393 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
3394 /* Do not use STRIP_NOPS here. We do not want an enumerator
3395 whose value is 0 to count as a null pointer constant. */
3396 if (TREE_CODE (rhs) == NON_LVALUE_EXPR)
3397 rhs = TREE_OPERAND (rhs, 0);
3399 if (TREE_CODE (TREE_TYPE (rhs)) == ARRAY_TYPE
3400 || TREE_CODE (TREE_TYPE (rhs)) == FUNCTION_TYPE)
3401 rhs = default_conversion (rhs);
3402 else if (optimize && TREE_CODE (rhs) == VAR_DECL)
3403 rhs = decl_constant_value_for_broken_optimization (rhs);
3405 rhstype = TREE_TYPE (rhs);
3406 coder = TREE_CODE (rhstype);
3408 if (coder == ERROR_MARK)
3409 return error_mark_node;
3411 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
3413 overflow_warning (rhs);
3414 /* Check for Objective-C protocols. This will automatically
3415 issue a warning if there are protocol violations. No need to
3416 use the return value. */
3417 if (c_dialect_objc ())
3418 objc_comptypes (type, rhstype, 0);
3422 if (coder == VOID_TYPE)
3424 error ("void value not ignored as it ought to be");
3425 return error_mark_node;
3427 /* A type converts to a reference to it.
3428 This code doesn't fully support references, it's just for the
3429 special case of va_start and va_copy. */
3430 if (codel == REFERENCE_TYPE
3431 && comptypes (TREE_TYPE (type), TREE_TYPE (rhs), COMPARE_STRICT) == 1)
3433 if (!lvalue_p (rhs))
3435 error ("cannot pass rvalue to reference parameter");
3436 return error_mark_node;
3438 if (!c_mark_addressable (rhs))
3439 return error_mark_node;
3440 rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
3442 /* We already know that these two types are compatible, but they
3443 may not be exactly identical. In fact, `TREE_TYPE (type)' is
3444 likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
3445 likely to be va_list, a typedef to __builtin_va_list, which
3446 is different enough that it will cause problems later. */
3447 if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
3448 rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
3450 rhs = build1 (NOP_EXPR, type, rhs);
3453 /* Some types can interconvert without explicit casts. */
3454 else if (codel == VECTOR_TYPE && coder == VECTOR_TYPE
3455 && ((*targetm.vector_opaque_p) (type)
3456 || (*targetm.vector_opaque_p) (rhstype)))
3457 return convert (type, rhs);
3458 /* Arithmetic types all interconvert, and enum is treated like int. */
3459 else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
3460 || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
3461 || codel == BOOLEAN_TYPE)
3462 && (coder == INTEGER_TYPE || coder == REAL_TYPE
3463 || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE
3464 || coder == BOOLEAN_TYPE))
3465 return convert_and_check (type, rhs);
3467 /* Conversion to a transparent union from its member types.
3468 This applies only to function arguments. */
3469 else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) && ! errtype)
3472 tree marginal_memb_type = 0;
3474 for (memb_types = TYPE_FIELDS (type); memb_types;
3475 memb_types = TREE_CHAIN (memb_types))
3477 tree memb_type = TREE_TYPE (memb_types);
3479 if (comptypes (TYPE_MAIN_VARIANT (memb_type),
3480 TYPE_MAIN_VARIANT (rhstype), COMPARE_STRICT))
3483 if (TREE_CODE (memb_type) != POINTER_TYPE)
3486 if (coder == POINTER_TYPE)
3488 tree ttl = TREE_TYPE (memb_type);
3489 tree ttr = TREE_TYPE (rhstype);
3491 /* Any non-function converts to a [const][volatile] void *
3492 and vice versa; otherwise, targets must be the same.
3493 Meanwhile, the lhs target must have all the qualifiers of
3495 if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3496 || comp_target_types (memb_type, rhstype, 0))
3498 /* If this type won't generate any warnings, use it. */
3499 if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
3500 || ((TREE_CODE (ttr) == FUNCTION_TYPE
3501 && TREE_CODE (ttl) == FUNCTION_TYPE)
3502 ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
3503 == TYPE_QUALS (ttr))
3504 : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
3505 == TYPE_QUALS (ttl))))
3508 /* Keep looking for a better type, but remember this one. */
3509 if (! marginal_memb_type)
3510 marginal_memb_type = memb_type;
3514 /* Can convert integer zero to any pointer type. */
3515 if (integer_zerop (rhs)
3516 || (TREE_CODE (rhs) == NOP_EXPR
3517 && integer_zerop (TREE_OPERAND (rhs, 0))))
3519 rhs = null_pointer_node;
3524 if (memb_types || marginal_memb_type)
3528 /* We have only a marginally acceptable member type;
3529 it needs a warning. */
3530 tree ttl = TREE_TYPE (marginal_memb_type);
3531 tree ttr = TREE_TYPE (rhstype);
3533 /* Const and volatile mean something different for function
3534 types, so the usual warnings are not appropriate. */
3535 if (TREE_CODE (ttr) == FUNCTION_TYPE
3536 && TREE_CODE (ttl) == FUNCTION_TYPE)
3538 /* Because const and volatile on functions are
3539 restrictions that say the function will not do
3540 certain things, it is okay to use a const or volatile
3541 function where an ordinary one is wanted, but not
3543 if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
3544 warn_for_assignment ("%s makes qualified function pointer from unqualified",
3545 errtype, funname, parmnum);
3547 else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
3548 warn_for_assignment ("%s discards qualifiers from pointer target type",
3553 if (pedantic && ! DECL_IN_SYSTEM_HEADER (fundecl))
3554 pedwarn ("ISO C prohibits argument conversion to union type");
3556 return build1 (NOP_EXPR, type, rhs);
3560 /* Conversions among pointers */
3561 else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
3562 && (coder == codel))
3564 tree ttl = TREE_TYPE (type);
3565 tree ttr = TREE_TYPE (rhstype);
3566 bool is_opaque_pointer;
3567 int target_cmp = 0; /* Cache comp_target_types () result. */
3569 /* Opaque pointers are treated like void pointers. */
3570 is_opaque_pointer = ((*targetm.vector_opaque_p) (type)
3571 || (*targetm.vector_opaque_p) (rhstype))
3572 && TREE_CODE (ttl) == VECTOR_TYPE
3573 && TREE_CODE (ttr) == VECTOR_TYPE;
3575 /* Any non-function converts to a [const][volatile] void *
3576 and vice versa; otherwise, targets must be the same.
3577 Meanwhile, the lhs target must have all the qualifiers of the rhs. */
3578 if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3579 || (target_cmp = comp_target_types (type, rhstype, 0))
3580 || is_opaque_pointer
3581 || (c_common_unsigned_type (TYPE_MAIN_VARIANT (ttl))
3582 == c_common_unsigned_type (TYPE_MAIN_VARIANT (ttr))))
3585 && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
3588 /* Check TREE_CODE to catch cases like (void *) (char *) 0
3589 which are not ANSI null ptr constants. */
3590 && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
3591 && TREE_CODE (ttl) == FUNCTION_TYPE)))
3592 warn_for_assignment ("ISO C forbids %s between function pointer and `void *'",
3593 errtype, funname, parmnum);
3594 /* Const and volatile mean something different for function types,
3595 so the usual warnings are not appropriate. */
3596 else if (TREE_CODE (ttr) != FUNCTION_TYPE
3597 && TREE_CODE (ttl) != FUNCTION_TYPE)
3599 if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
3600 warn_for_assignment ("%s discards qualifiers from pointer target type",
3601 errtype, funname, parmnum);
3602 /* If this is not a case of ignoring a mismatch in signedness,
3604 else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3607 /* If there is a mismatch, do warn. */
3609 warn_for_assignment ("pointer targets in %s differ in signedness",
3610 errtype, funname, parmnum);
3612 else if (TREE_CODE (ttl) == FUNCTION_TYPE
3613 && TREE_CODE (ttr) == FUNCTION_TYPE)
3615 /* Because const and volatile on functions are restrictions
3616 that say the function will not do certain things,
3617 it is okay to use a const or volatile function
3618 where an ordinary one is wanted, but not vice-versa. */
3619 if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
3620 warn_for_assignment ("%s makes qualified function pointer from unqualified",
3621 errtype, funname, parmnum);
3625 warn_for_assignment ("%s from incompatible pointer type",
3626 errtype, funname, parmnum);
3627 return convert (type, rhs);
3629 else if (codel == POINTER_TYPE && coder == ARRAY_TYPE)
3631 error ("invalid use of non-lvalue array");
3632 return error_mark_node;
3634 else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
3636 /* An explicit constant 0 can convert to a pointer,
3637 or one that results from arithmetic, even including
3638 a cast to integer type. */
3639 if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
3641 ! (TREE_CODE (rhs) == NOP_EXPR
3642 && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
3643 && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
3644 && integer_zerop (TREE_OPERAND (rhs, 0))))
3645 warn_for_assignment ("%s makes pointer from integer without a cast",
3646 errtype, funname, parmnum);
3648 return convert (type, rhs);
3650 else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
3652 warn_for_assignment ("%s makes integer from pointer without a cast",
3653 errtype, funname, parmnum);
3654 return convert (type, rhs);
3656 else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
3657 return convert (type, rhs);
3663 tree selector = objc_message_selector ();
3665 if (selector && parmnum > 2)
3666 error ("incompatible type for argument %d of `%s'",
3667 parmnum - 2, IDENTIFIER_POINTER (selector));
3669 error ("incompatible type for argument %d of `%s'",
3670 parmnum, IDENTIFIER_POINTER (funname));
3673 error ("incompatible type for argument %d of indirect function call",
3677 error ("incompatible types in %s", errtype);
3679 return error_mark_node;
3682 /* Convert VALUE for assignment into inlined parameter PARM. ARGNUM
3683 is used for error and waring reporting and indicates which argument
3684 is being processed. */
3687 c_convert_parm_for_inlining (tree parm, tree value, tree fn, int argnum)
3691 /* If FN was prototyped, the value has been converted already
3692 in convert_arguments. */
3693 if (! value || TYPE_ARG_TYPES (TREE_TYPE (fn)))
3696 type = TREE_TYPE (parm);
3697 ret = convert_for_assignment (type, value,
3698 (char *) 0 /* arg passing */, fn,
3699 DECL_NAME (fn), argnum);
3700 if (targetm.calls.promote_prototypes (TREE_TYPE (fn))
3701 && INTEGRAL_TYPE_P (type)
3702 && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
3703 ret = default_conversion (ret);
3707 /* Print a warning using MSGID.
3708 It gets OPNAME as its one parameter.
3709 if OPNAME is null and ARGNUM is 0, it is replaced by "passing arg of `FUNCTION'".
3710 Otherwise if OPNAME is null, it is replaced by "passing arg ARGNUM of `FUNCTION'".
3711 FUNCTION and ARGNUM are handled specially if we are building an
3712 Objective-C selector. */
3715 warn_for_assignment (const char *msgid, const char *opname, tree function,
3720 tree selector = objc_message_selector ();
3723 if (selector && argnum > 2)
3725 function = selector;
3732 /* Function name is known; supply it. */
3733 const char *const argstring = _("passing arg of `%s'");
3734 new_opname = alloca (IDENTIFIER_LENGTH (function)
3735 + strlen (argstring) + 1 + 1);
3736 sprintf (new_opname, argstring,
3737 IDENTIFIER_POINTER (function));
3741 /* Function name unknown (call through ptr). */
3742 const char *const argnofun = _("passing arg of pointer to function");
3743 new_opname = alloca (strlen (argnofun) + 1 + 1);
3744 sprintf (new_opname, argnofun);
3749 /* Function name is known; supply it. */
3750 const char *const argstring = _("passing arg %d of `%s'");
3751 new_opname = alloca (IDENTIFIER_LENGTH (function)
3752 + strlen (argstring) + 1 + 25 /*%d*/ + 1);
3753 sprintf (new_opname, argstring, argnum,
3754 IDENTIFIER_POINTER (function));
3758 /* Function name unknown (call through ptr); just give arg number. */
3759 const char *const argnofun = _("passing arg %d of pointer to function");
3760 new_opname = alloca (strlen (argnofun) + 1 + 25 /*%d*/ + 1);
3761 sprintf (new_opname, argnofun, argnum);
3763 opname = new_opname;
3765 pedwarn (msgid, opname);
3768 /* If VALUE is a compound expr all of whose expressions are constant, then
3769 return its value. Otherwise, return error_mark_node.
3771 This is for handling COMPOUND_EXPRs as initializer elements
3772 which is allowed with a warning when -pedantic is specified. */
3775 valid_compound_expr_initializer (tree value, tree endtype)
3777 if (TREE_CODE (value) == COMPOUND_EXPR)
3779 if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
3781 return error_mark_node;
3782 return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
3785 else if (! TREE_CONSTANT (value)
3786 && ! initializer_constant_valid_p (value, endtype))
3787 return error_mark_node;
3792 /* Perform appropriate conversions on the initial value of a variable,
3793 store it in the declaration DECL,
3794 and print any error messages that are appropriate.
3795 If the init is invalid, store an ERROR_MARK. */
3798 store_init_value (tree decl, tree init)
3802 /* If variable's type was invalidly declared, just ignore it. */
3804 type = TREE_TYPE (decl);
3805 if (TREE_CODE (type) == ERROR_MARK)
3808 /* Digest the specified initializer into an expression. */
3810 value = digest_init (type, init, TREE_STATIC (decl));
3812 /* Store the expression if valid; else report error. */
3814 if (warn_traditional && !in_system_header
3815 && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && ! TREE_STATIC (decl))
3816 warning ("traditional C rejects automatic aggregate initialization");
3818 DECL_INITIAL (decl) = value;
3820 /* ANSI wants warnings about out-of-range constant initializers. */
3821 STRIP_TYPE_NOPS (value);
3822 constant_expression_warning (value);
3824 /* Check if we need to set array size from compound literal size. */
3825 if (TREE_CODE (type) == ARRAY_TYPE
3826 && TYPE_DOMAIN (type) == 0
3827 && value != error_mark_node)
3829 tree inside_init = init;
3831 if (TREE_CODE (init) == NON_LVALUE_EXPR)
3832 inside_init = TREE_OPERAND (init, 0);
3833 inside_init = fold (inside_init);
3835 if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
3837 tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
3839 if (TYPE_DOMAIN (TREE_TYPE (decl)))
3841 /* For int foo[] = (int [3]){1}; we need to set array size
3842 now since later on array initializer will be just the
3843 brace enclosed list of the compound literal. */
3844 TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (decl));
3846 layout_decl (decl, 0);
3852 /* Methods for storing and printing names for error messages. */
3854 /* Implement a spelling stack that allows components of a name to be pushed
3855 and popped. Each element on the stack is this structure. */
3867 #define SPELLING_STRING 1
3868 #define SPELLING_MEMBER 2
3869 #define SPELLING_BOUNDS 3
3871 static struct spelling *spelling; /* Next stack element (unused). */
3872 static struct spelling *spelling_base; /* Spelling stack base. */
3873 static int spelling_size; /* Size of the spelling stack. */
3875 /* Macros to save and restore the spelling stack around push_... functions.
3876 Alternative to SAVE_SPELLING_STACK. */
3878 #define SPELLING_DEPTH() (spelling - spelling_base)
3879 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
3881 /* Push an element on the spelling stack with type KIND and assign VALUE
3884 #define PUSH_SPELLING(KIND, VALUE, MEMBER) \
3886 int depth = SPELLING_DEPTH (); \
3888 if (depth >= spelling_size) \
3890 spelling_size += 10; \
3891 if (spelling_base == 0) \
3892 spelling_base = xmalloc (spelling_size * sizeof (struct spelling)); \
3894 spelling_base = xrealloc (spelling_base, \
3895 spelling_size * sizeof (struct spelling)); \
3896 RESTORE_SPELLING_DEPTH (depth); \
3899 spelling->kind = (KIND); \
3900 spelling->MEMBER = (VALUE); \
3904 /* Push STRING on the stack. Printed literally. */
3907 push_string (const char *string)
3909 PUSH_SPELLING (SPELLING_STRING, string, u.s);
3912 /* Push a member name on the stack. Printed as '.' STRING. */
3915 push_member_name (tree decl)
3917 const char *const string
3918 = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
3919 PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
3922 /* Push an array bounds on the stack. Printed as [BOUNDS]. */
3925 push_array_bounds (int bounds)
3927 PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
3930 /* Compute the maximum size in bytes of the printed spelling. */
3933 spelling_length (void)
3938 for (p = spelling_base; p < spelling; p++)
3940 if (p->kind == SPELLING_BOUNDS)
3943 size += strlen (p->u.s) + 1;
3949 /* Print the spelling to BUFFER and return it. */
3952 print_spelling (char *buffer)
3957 for (p = spelling_base; p < spelling; p++)
3958 if (p->kind == SPELLING_BOUNDS)
3960 sprintf (d, "[%d]", p->u.i);
3966 if (p->kind == SPELLING_MEMBER)
3968 for (s = p->u.s; (*d = *s++); d++)
3975 /* Issue an error message for a bad initializer component.
3976 MSGID identifies the message.
3977 The component name is taken from the spelling stack. */
3980 error_init (const char *msgid)
3984 error ("%s", _(msgid));
3985 ofwhat = print_spelling (alloca (spelling_length () + 1));
3987 error ("(near initialization for `%s')", ofwhat);
3990 /* Issue a pedantic warning for a bad initializer component.
3991 MSGID identifies the message.
3992 The component name is taken from the spelling stack. */
3995 pedwarn_init (const char *msgid)
3999 pedwarn ("%s", _(msgid));
4000 ofwhat = print_spelling (alloca (spelling_length () + 1));
4002 pedwarn ("(near initialization for `%s')", ofwhat);
4005 /* Issue a warning for a bad initializer component.
4006 MSGID identifies the message.
4007 The component name is taken from the spelling stack. */
4010 warning_init (const char *msgid)
4014 warning ("%s", _(msgid));
4015 ofwhat = print_spelling (alloca (spelling_length () + 1));
4017 warning ("(near initialization for `%s')", ofwhat);
4020 /* Digest the parser output INIT as an initializer for type TYPE.
4021 Return a C expression of type TYPE to represent the initial value.
4023 REQUIRE_CONSTANT requests an error if non-constant initializers or
4024 elements are seen. */
4027 digest_init (tree type, tree init, int require_constant)
4029 enum tree_code code = TREE_CODE (type);
4030 tree inside_init = init;
4032 if (type == error_mark_node
4033 || init == error_mark_node
4034 || TREE_TYPE (init) == error_mark_node)
4035 return error_mark_node;
4037 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
4038 /* Do not use STRIP_NOPS here. We do not want an enumerator
4039 whose value is 0 to count as a null pointer constant. */
4040 if (TREE_CODE (init) == NON_LVALUE_EXPR)
4041 inside_init = TREE_OPERAND (init, 0);
4043 inside_init = fold (inside_init);
4045 /* Initialization of an array of chars from a string constant
4046 optionally enclosed in braces. */
4048 if (code == ARRAY_TYPE)
4050 tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
4051 if ((typ1 == char_type_node
4052 || typ1 == signed_char_type_node
4053 || typ1 == unsigned_char_type_node
4054 || typ1 == unsigned_wchar_type_node
4055 || typ1 == signed_wchar_type_node)
4056 && ((inside_init && TREE_CODE (inside_init) == STRING_CST)))
4058 if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4059 TYPE_MAIN_VARIANT (type), COMPARE_STRICT))
4062 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4064 && TYPE_PRECISION (typ1) == TYPE_PRECISION (char_type_node))
4066 error_init ("char-array initialized from wide string");
4067 return error_mark_node;
4069 if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4071 && TYPE_PRECISION (typ1) != TYPE_PRECISION (char_type_node))
4073 error_init ("int-array initialized from non-wide string");
4074 return error_mark_node;
4077 TREE_TYPE (inside_init) = type;
4078 if (TYPE_DOMAIN (type) != 0
4079 && TYPE_SIZE (type) != 0
4080 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
4081 /* Subtract 1 (or sizeof (wchar_t))
4082 because it's ok to ignore the terminating null char
4083 that is counted in the length of the constant. */
4084 && 0 > compare_tree_int (TYPE_SIZE_UNIT (type),
4085 TREE_STRING_LENGTH (inside_init)
4086 - ((TYPE_PRECISION (typ1)
4087 != TYPE_PRECISION (char_type_node))
4088 ? (TYPE_PRECISION (wchar_type_node)
4091 pedwarn_init ("initializer-string for array of chars is too long");
4097 /* Build a VECTOR_CST from a *constant* vector constructor. If the
4098 vector constructor is not constant (e.g. {1,2,3,foo()}) then punt
4099 below and handle as a constructor. */
4100 if (code == VECTOR_TYPE
4101 && comptypes (TREE_TYPE (inside_init), type, COMPARE_STRICT)
4102 && TREE_CONSTANT (inside_init))
4104 if (TREE_CODE (inside_init) == VECTOR_CST
4105 && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4106 TYPE_MAIN_VARIANT (type),
4110 return build_vector (type, CONSTRUCTOR_ELTS (inside_init));
4113 /* Any type can be initialized
4114 from an expression of the same type, optionally with braces. */
4116 if (inside_init && TREE_TYPE (inside_init) != 0
4117 && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4118 TYPE_MAIN_VARIANT (type), COMPARE_STRICT)
4119 || (code == ARRAY_TYPE
4120 && comptypes (TREE_TYPE (inside_init), type, COMPARE_STRICT))
4121 || (code == VECTOR_TYPE
4122 && comptypes (TREE_TYPE (inside_init), type, COMPARE_STRICT))
4123 || (code == POINTER_TYPE
4124 && TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4125 && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
4126 TREE_TYPE (type), COMPARE_STRICT))
4127 || (code == POINTER_TYPE
4128 && TREE_CODE (TREE_TYPE (inside_init)) == FUNCTION_TYPE
4129 && comptypes (TREE_TYPE (inside_init),
4130 TREE_TYPE (type), COMPARE_STRICT))))
4132 if (code == POINTER_TYPE)
4134 inside_init = default_function_array_conversion (inside_init);
4136 if (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE)
4138 error_init ("invalid use of non-lvalue array");
4139 return error_mark_node;
4143 if (code == VECTOR_TYPE)
4144 /* Although the types are compatible, we may require a
4146 inside_init = convert (type, inside_init);
4148 if (require_constant && !flag_isoc99
4149 && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
4151 /* As an extension, allow initializing objects with static storage
4152 duration with compound literals (which are then treated just as
4153 the brace enclosed list they contain). */
4154 tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
4155 inside_init = DECL_INITIAL (decl);
4158 if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
4159 && TREE_CODE (inside_init) != CONSTRUCTOR)
4161 error_init ("array initialized from non-constant array expression");
4162 return error_mark_node;
4165 if (optimize && TREE_CODE (inside_init) == VAR_DECL)
4166 inside_init = decl_constant_value_for_broken_optimization (inside_init);
4168 /* Compound expressions can only occur here if -pedantic or
4169 -pedantic-errors is specified. In the later case, we always want
4170 an error. In the former case, we simply want a warning. */
4171 if (require_constant && pedantic
4172 && TREE_CODE (inside_init) == COMPOUND_EXPR)
4175 = valid_compound_expr_initializer (inside_init,
4176 TREE_TYPE (inside_init));
4177 if (inside_init == error_mark_node)
4178 error_init ("initializer element is not constant");
4180 pedwarn_init ("initializer element is not constant");
4181 if (flag_pedantic_errors)
4182 inside_init = error_mark_node;
4184 else if (require_constant
4185 && (!TREE_CONSTANT (inside_init)
4186 /* This test catches things like `7 / 0' which
4187 result in an expression for which TREE_CONSTANT
4188 is true, but which is not actually something
4189 that is a legal constant. We really should not
4190 be using this function, because it is a part of
4191 the back-end. Instead, the expression should
4192 already have been turned into ERROR_MARK_NODE. */
4193 || !initializer_constant_valid_p (inside_init,
4194 TREE_TYPE (inside_init))))
4196 error_init ("initializer element is not constant");
4197 inside_init = error_mark_node;
4203 /* Handle scalar types, including conversions. */
4205 if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
4206 || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE)
4208 /* Note that convert_for_assignment calls default_conversion
4209 for arrays and functions. We must not call it in the
4210 case where inside_init is a null pointer constant. */
4212 = convert_for_assignment (type, init, _("initialization"),
4213 NULL_TREE, NULL_TREE, 0);
4215 if (require_constant && ! TREE_CONSTANT (inside_init))
4217 error_init ("initializer element is not constant");
4218 inside_init = error_mark_node;
4220 else if (require_constant
4221 && initializer_constant_valid_p (inside_init, TREE_TYPE (inside_init)) == 0)
4223 error_init ("initializer element is not computable at load time");
4224 inside_init = error_mark_node;
4230 /* Come here only for records and arrays. */
4232 if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4234 error_init ("variable-sized object may not be initialized");
4235 return error_mark_node;
4238 error_init ("invalid initializer");
4239 return error_mark_node;
4242 /* Handle initializers that use braces. */
4244 /* Type of object we are accumulating a constructor for.
4245 This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */
4246 static tree constructor_type;
4248 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4250 static tree constructor_fields;
4252 /* For an ARRAY_TYPE, this is the specified index
4253 at which to store the next element we get. */
4254 static tree constructor_index;
4256 /* For an ARRAY_TYPE, this is the maximum index. */
4257 static tree constructor_max_index;
4259 /* For a RECORD_TYPE, this is the first field not yet written out. */
4260 static tree constructor_unfilled_fields;
4262 /* For an ARRAY_TYPE, this is the index of the first element
4263 not yet written out. */
4264 static tree constructor_unfilled_index;
4266 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4267 This is so we can generate gaps between fields, when appropriate. */
4268 static tree constructor_bit_index;
4270 /* If we are saving up the elements rather than allocating them,
4271 this is the list of elements so far (in reverse order,
4272 most recent first). */
4273 static tree constructor_elements;
4275 /* 1 if constructor should be incrementally stored into a constructor chain,
4276 0 if all the elements should be kept in AVL tree. */
4277 static int constructor_incremental;
4279 /* 1 if so far this constructor's elements are all compile-time constants. */
4280 static int constructor_constant;
4282 /* 1 if so far this constructor's elements are all valid address constants. */
4283 static int constructor_simple;
4285 /* 1 if this constructor is erroneous so far. */
4286 static int constructor_erroneous;
4288 /* Structure for managing pending initializer elements, organized as an
4293 struct init_node *left, *right;
4294 struct init_node *parent;
4300 /* Tree of pending elements at this constructor level.
4301 These are elements encountered out of order
4302 which belong at places we haven't reached yet in actually
4304 Will never hold tree nodes across GC runs. */
4305 static struct init_node *constructor_pending_elts;
4307 /* The SPELLING_DEPTH of this constructor. */
4308 static int constructor_depth;
4310 /* 0 if implicitly pushing constructor levels is allowed. */
4311 int constructor_no_implicit = 0; /* 0 for C; 1 for some other languages. */
4313 /* DECL node for which an initializer is being read.
4314 0 means we are reading a constructor expression
4315 such as (struct foo) {...}. */
4316 static tree constructor_decl;
4318 /* start_init saves the ASMSPEC arg here for really_start_incremental_init. */
4319 static const char *constructor_asmspec;
4321 /* Nonzero if this is an initializer for a top-level decl. */
4322 static int constructor_top_level;
4324 /* Nonzero if there were any member designators in this initializer. */
4325 static int constructor_designated;
4327 /* Nesting depth of designator list. */
4328 static int designator_depth;
4330 /* Nonzero if there were diagnosed errors in this designator list. */
4331 static int designator_errorneous;
4334 /* This stack has a level for each implicit or explicit level of
4335 structuring in the initializer, including the outermost one. It
4336 saves the values of most of the variables above. */
4338 struct constructor_range_stack;
4340 struct constructor_stack
4342 struct constructor_stack *next;
4347 tree unfilled_index;
4348 tree unfilled_fields;
4351 struct init_node *pending_elts;
4354 /* If nonzero, this value should replace the entire
4355 constructor at this level. */
4356 tree replacement_value;
4357 struct constructor_range_stack *range_stack;
4367 struct constructor_stack *constructor_stack;
4369 /* This stack represents designators from some range designator up to
4370 the last designator in the list. */
4372 struct constructor_range_stack
4374 struct constructor_range_stack *next, *prev;
4375 struct constructor_stack *stack;
4382 struct constructor_range_stack *constructor_range_stack;
4384 /* This stack records separate initializers that are nested.
4385 Nested initializers can't happen in ANSI C, but GNU C allows them
4386 in cases like { ... (struct foo) { ... } ... }. */
4388 struct initializer_stack
4390 struct initializer_stack *next;
4392 const char *asmspec;
4393 struct constructor_stack *constructor_stack;
4394 struct constructor_range_stack *constructor_range_stack;
4396 struct spelling *spelling;
4397 struct spelling *spelling_base;
4400 char require_constant_value;
4401 char require_constant_elements;
4404 struct initializer_stack *initializer_stack;
4406 /* Prepare to parse and output the initializer for variable DECL. */
4409 start_init (tree decl, tree asmspec_tree, int top_level)
4412 struct initializer_stack *p = xmalloc (sizeof (struct initializer_stack));
4413 const char *asmspec = 0;
4416 asmspec = TREE_STRING_POINTER (asmspec_tree);
4418 p->decl = constructor_decl;
4419 p->asmspec = constructor_asmspec;
4420 p->require_constant_value = require_constant_value;
4421 p->require_constant_elements = require_constant_elements;
4422 p->constructor_stack = constructor_stack;
4423 p->constructor_range_stack = constructor_range_stack;
4424 p->elements = constructor_elements;
4425 p->spelling = spelling;
4426 p->spelling_base = spelling_base;
4427 p->spelling_size = spelling_size;
4428 p->top_level = constructor_top_level;
4429 p->next = initializer_stack;
4430 initializer_stack = p;
4432 constructor_decl = decl;
4433 constructor_asmspec = asmspec;
4434 constructor_designated = 0;
4435 constructor_top_level = top_level;
4439 require_constant_value = TREE_STATIC (decl);
4440 require_constant_elements
4441 = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
4442 /* For a scalar, you can always use any value to initialize,
4443 even within braces. */
4444 && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
4445 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
4446 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
4447 || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
4448 locus = IDENTIFIER_POINTER (DECL_NAME (decl));
4452 require_constant_value = 0;
4453 require_constant_elements = 0;
4454 locus = "(anonymous)";
4457 constructor_stack = 0;
4458 constructor_range_stack = 0;
4460 missing_braces_mentioned = 0;
4464 RESTORE_SPELLING_DEPTH (0);
4467 push_string (locus);
4473 struct initializer_stack *p = initializer_stack;
4475 /* Free the whole constructor stack of this initializer. */
4476 while (constructor_stack)
4478 struct constructor_stack *q = constructor_stack;
4479 constructor_stack = q->next;
4483 if (constructor_range_stack)
4486 /* Pop back to the data of the outer initializer (if any). */
4487 free (spelling_base);
4489 constructor_decl = p->decl;
4490 constructor_asmspec = p->asmspec;
4491 require_constant_value = p->require_constant_value;
4492 require_constant_elements = p->require_constant_elements;
4493 constructor_stack = p->constructor_stack;
4494 constructor_range_stack = p->constructor_range_stack;
4495 constructor_elements = p->elements;
4496 spelling = p->spelling;
4497 spelling_base = p->spelling_base;
4498 spelling_size = p->spelling_size;
4499 constructor_top_level = p->top_level;
4500 initializer_stack = p->next;
4504 /* Call here when we see the initializer is surrounded by braces.
4505 This is instead of a call to push_init_level;
4506 it is matched by a call to pop_init_level.
4508 TYPE is the type to initialize, for a constructor expression.
4509 For an initializer for a decl, TYPE is zero. */
4512 really_start_incremental_init (tree type)
4514 struct constructor_stack *p = xmalloc (sizeof (struct constructor_stack));
4517 type = TREE_TYPE (constructor_decl);
4519 if ((*targetm.vector_opaque_p) (type))
4520 error ("opaque vector types cannot be initialized");
4522 p->type = constructor_type;
4523 p->fields = constructor_fields;
4524 p->index = constructor_index;
4525 p->max_index = constructor_max_index;
4526 p->unfilled_index = constructor_unfilled_index;
4527 p->unfilled_fields = constructor_unfilled_fields;
4528 p->bit_index = constructor_bit_index;
4529 p->elements = constructor_elements;
4530 p->constant = constructor_constant;
4531 p->simple = constructor_simple;
4532 p->erroneous = constructor_erroneous;
4533 p->pending_elts = constructor_pending_elts;
4534 p->depth = constructor_depth;
4535 p->replacement_value = 0;
4539 p->incremental = constructor_incremental;
4540 p->designated = constructor_designated;
4542 constructor_stack = p;
4544 constructor_constant = 1;
4545 constructor_simple = 1;
4546 constructor_depth = SPELLING_DEPTH ();
4547 constructor_elements = 0;
4548 constructor_pending_elts = 0;
4549 constructor_type = type;
4550 constructor_incremental = 1;
4551 constructor_designated = 0;
4552 designator_depth = 0;
4553 designator_errorneous = 0;
4555 if (TREE_CODE (constructor_type) == RECORD_TYPE
4556 || TREE_CODE (constructor_type) == UNION_TYPE)
4558 constructor_fields = TYPE_FIELDS (constructor_type);
4559 /* Skip any nameless bit fields at the beginning. */
4560 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
4561 && DECL_NAME (constructor_fields) == 0)
4562 constructor_fields = TREE_CHAIN (constructor_fields);
4564 constructor_unfilled_fields = constructor_fields;
4565 constructor_bit_index = bitsize_zero_node;
4567 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4569 if (TYPE_DOMAIN (constructor_type))
4571 constructor_max_index
4572 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
4574 /* Detect non-empty initializations of zero-length arrays. */
4575 if (constructor_max_index == NULL_TREE
4576 && TYPE_SIZE (constructor_type))
4577 constructor_max_index = build_int_2 (-1, -1);
4579 /* constructor_max_index needs to be an INTEGER_CST. Attempts
4580 to initialize VLAs will cause a proper error; avoid tree
4581 checking errors as well by setting a safe value. */
4582 if (constructor_max_index
4583 && TREE_CODE (constructor_max_index) != INTEGER_CST)
4584 constructor_max_index = build_int_2 (-1, -1);
4587 = convert (bitsizetype,
4588 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
4591 constructor_index = bitsize_zero_node;
4593 constructor_unfilled_index = constructor_index;
4595 else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
4597 /* Vectors are like simple fixed-size arrays. */
4598 constructor_max_index =
4599 build_int_2 (TYPE_VECTOR_SUBPARTS (constructor_type) - 1, 0);
4600 constructor_index = convert (bitsizetype, bitsize_zero_node);
4601 constructor_unfilled_index = constructor_index;
4605 /* Handle the case of int x = {5}; */
4606 constructor_fields = constructor_type;
4607 constructor_unfilled_fields = constructor_type;
4611 /* Push down into a subobject, for initialization.
4612 If this is for an explicit set of braces, IMPLICIT is 0.
4613 If it is because the next element belongs at a lower level,
4614 IMPLICIT is 1 (or 2 if the push is because of designator list). */
4617 push_init_level (int implicit)
4619 struct constructor_stack *p;
4620 tree value = NULL_TREE;
4622 /* If we've exhausted any levels that didn't have braces,
4624 while (constructor_stack->implicit)
4626 if ((TREE_CODE (constructor_type) == RECORD_TYPE
4627 || TREE_CODE (constructor_type) == UNION_TYPE)
4628 && constructor_fields == 0)
4629 process_init_element (pop_init_level (1));
4630 else if (TREE_CODE (constructor_type) == ARRAY_TYPE
4631 && constructor_max_index
4632 && tree_int_cst_lt (constructor_max_index, constructor_index))
4633 process_init_element (pop_init_level (1));
4638 /* Unless this is an explicit brace, we need to preserve previous
4642 if ((TREE_CODE (constructor_type) == RECORD_TYPE
4643 || TREE_CODE (constructor_type) == UNION_TYPE)
4644 && constructor_fields)
4645 value = find_init_member (constructor_fields);
4646 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4647 value = find_init_member (constructor_index);
4650 p = xmalloc (sizeof (struct constructor_stack));
4651 p->type = constructor_type;
4652 p->fields = constructor_fields;
4653 p->index = constructor_index;
4654 p->max_index = constructor_max_index;
4655 p->unfilled_index = constructor_unfilled_index;
4656 p->unfilled_fields = constructor_unfilled_fields;
4657 p->bit_index = constructor_bit_index;
4658 p->elements = constructor_elements;
4659 p->constant = constructor_constant;
4660 p->simple = constructor_simple;
4661 p->erroneous = constructor_erroneous;
4662 p->pending_elts = constructor_pending_elts;
4663 p->depth = constructor_depth;
4664 p->replacement_value = 0;
4665 p->implicit = implicit;
4667 p->incremental = constructor_incremental;
4668 p->designated = constructor_designated;
4669 p->next = constructor_stack;
4671 constructor_stack = p;
4673 constructor_constant = 1;
4674 constructor_simple = 1;
4675 constructor_depth = SPELLING_DEPTH ();
4676 constructor_elements = 0;
4677 constructor_incremental = 1;
4678 constructor_designated = 0;
4679 constructor_pending_elts = 0;
4682 p->range_stack = constructor_range_stack;
4683 constructor_range_stack = 0;
4684 designator_depth = 0;
4685 designator_errorneous = 0;
4688 /* Don't die if an entire brace-pair level is superfluous
4689 in the containing level. */
4690 if (constructor_type == 0)
4692 else if (TREE_CODE (constructor_type) == RECORD_TYPE
4693 || TREE_CODE (constructor_type) == UNION_TYPE)
4695 /* Don't die if there are extra init elts at the end. */
4696 if (constructor_fields == 0)
4697 constructor_type = 0;
4700 constructor_type = TREE_TYPE (constructor_fields);
4701 push_member_name (constructor_fields);
4702 constructor_depth++;
4705 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4707 constructor_type = TREE_TYPE (constructor_type);
4708 push_array_bounds (tree_low_cst (constructor_index, 0));
4709 constructor_depth++;
4712 if (constructor_type == 0)
4714 error_init ("extra brace group at end of initializer");
4715 constructor_fields = 0;
4716 constructor_unfilled_fields = 0;
4720 if (value && TREE_CODE (value) == CONSTRUCTOR)
4722 constructor_constant = TREE_CONSTANT (value);
4723 constructor_simple = TREE_STATIC (value);
4724 constructor_elements = CONSTRUCTOR_ELTS (value);
4725 if (constructor_elements
4726 && (TREE_CODE (constructor_type) == RECORD_TYPE
4727 || TREE_CODE (constructor_type) == ARRAY_TYPE))
4728 set_nonincremental_init ();
4731 if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
4733 missing_braces_mentioned = 1;
4734 warning_init ("missing braces around initializer");
4737 if (TREE_CODE (constructor_type) == RECORD_TYPE
4738 || TREE_CODE (constructor_type) == UNION_TYPE)
4740 constructor_fields = TYPE_FIELDS (constructor_type);
4741 /* Skip any nameless bit fields at the beginning. */
4742 while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
4743 && DECL_NAME (constructor_fields) == 0)
4744 constructor_fields = TREE_CHAIN (constructor_fields);
4746 constructor_unfilled_fields = constructor_fields;
4747 constructor_bit_index = bitsize_zero_node;
4749 else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
4751 /* Vectors are like simple fixed-size arrays. */
4752 constructor_max_index =
4753 build_int_2 (TYPE_VECTOR_SUBPARTS (constructor_type) - 1, 0);
4754 constructor_index = convert (bitsizetype, integer_zero_node);
4755 constructor_unfilled_index = constructor_index;
4757 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4759 if (TYPE_DOMAIN (constructor_type))
4761 constructor_max_index
4762 = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
4764 /* Detect non-empty initializations of zero-length arrays. */
4765 if (constructor_max_index == NULL_TREE
4766 && TYPE_SIZE (constructor_type))
4767 constructor_max_index = build_int_2 (-1, -1);
4769 /* constructor_max_index needs to be an INTEGER_CST. Attempts
4770 to initialize VLAs will cause a proper error; avoid tree
4771 checking errors as well by setting a safe value. */
4772 if (constructor_max_index
4773 && TREE_CODE (constructor_max_index) != INTEGER_CST)
4774 constructor_max_index = build_int_2 (-1, -1);
4777 = convert (bitsizetype,
4778 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
4781 constructor_index = bitsize_zero_node;
4783 constructor_unfilled_index = constructor_index;
4784 if (value && TREE_CODE (value) == STRING_CST)
4786 /* We need to split the char/wchar array into individual
4787 characters, so that we don't have to special case it
4789 set_nonincremental_init_from_string (value);
4794 warning_init ("braces around scalar initializer");
4795 constructor_fields = constructor_type;
4796 constructor_unfilled_fields = constructor_type;
4800 /* At the end of an implicit or explicit brace level,
4801 finish up that level of constructor.
4802 If we were outputting the elements as they are read, return 0
4803 from inner levels (process_init_element ignores that),
4804 but return error_mark_node from the outermost level
4805 (that's what we want to put in DECL_INITIAL).
4806 Otherwise, return a CONSTRUCTOR expression. */
4809 pop_init_level (int implicit)
4811 struct constructor_stack *p;
4812 tree constructor = 0;
4816 /* When we come to an explicit close brace,
4817 pop any inner levels that didn't have explicit braces. */
4818 while (constructor_stack->implicit)
4819 process_init_element (pop_init_level (1));
4821 if (constructor_range_stack)
4825 /* Now output all pending elements. */
4826 constructor_incremental = 1;
4827 output_pending_init_elements (1);
4829 p = constructor_stack;
4831 /* Error for initializing a flexible array member, or a zero-length
4832 array member in an inappropriate context. */
4833 if (constructor_type && constructor_fields
4834 && TREE_CODE (constructor_type) == ARRAY_TYPE
4835 && TYPE_DOMAIN (constructor_type)
4836 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
4838 /* Silently discard empty initializations. The parser will
4839 already have pedwarned for empty brackets. */
4840 if (integer_zerop (constructor_unfilled_index))
4841 constructor_type = NULL_TREE;
4842 else if (! TYPE_SIZE (constructor_type))
4844 if (constructor_depth > 2)
4845 error_init ("initialization of flexible array member in a nested context");
4847 pedwarn_init ("initialization of a flexible array member");
4849 /* We have already issued an error message for the existence
4850 of a flexible array member not at the end of the structure.
4851 Discard the initializer so that we do not abort later. */
4852 if (TREE_CHAIN (constructor_fields) != NULL_TREE)
4853 constructor_type = NULL_TREE;
4856 /* Zero-length arrays are no longer special, so we should no longer
4861 /* Warn when some struct elements are implicitly initialized to zero. */
4864 && TREE_CODE (constructor_type) == RECORD_TYPE
4865 && constructor_unfilled_fields)
4867 /* Do not warn for flexible array members or zero-length arrays. */
4868 while (constructor_unfilled_fields
4869 && (! DECL_SIZE (constructor_unfilled_fields)
4870 || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
4871 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
4873 /* Do not warn if this level of the initializer uses member
4874 designators; it is likely to be deliberate. */
4875 if (constructor_unfilled_fields && !constructor_designated)
4877 push_member_name (constructor_unfilled_fields);
4878 warning_init ("missing initializer");
4879 RESTORE_SPELLING_DEPTH (constructor_depth);
4883 /* Pad out the end of the structure. */
4884 if (p->replacement_value)
4885 /* If this closes a superfluous brace pair,
4886 just pass out the element between them. */
4887 constructor = p->replacement_value;
4888 else if (constructor_type == 0)
4890 else if (TREE_CODE (constructor_type) != RECORD_TYPE
4891 && TREE_CODE (constructor_type) != UNION_TYPE
4892 && TREE_CODE (constructor_type) != ARRAY_TYPE
4893 && TREE_CODE (constructor_type) != VECTOR_TYPE)
4895 /* A nonincremental scalar initializer--just return
4896 the element, after verifying there is just one. */
4897 if (constructor_elements == 0)
4899 if (!constructor_erroneous)
4900 error_init ("empty scalar initializer");
4901 constructor = error_mark_node;
4903 else if (TREE_CHAIN (constructor_elements) != 0)
4905 error_init ("extra elements in scalar initializer");
4906 constructor = TREE_VALUE (constructor_elements);
4909 constructor = TREE_VALUE (constructor_elements);
4913 if (constructor_erroneous)
4914 constructor = error_mark_node;
4917 constructor = build_constructor (constructor_type,
4918 nreverse (constructor_elements));
4919 if (constructor_constant)
4920 TREE_CONSTANT (constructor) = 1;
4921 if (constructor_constant && constructor_simple)
4922 TREE_STATIC (constructor) = 1;
4926 constructor_type = p->type;
4927 constructor_fields = p->fields;
4928 constructor_index = p->index;
4929 constructor_max_index = p->max_index;
4930 constructor_unfilled_index = p->unfilled_index;
4931 constructor_unfilled_fields = p->unfilled_fields;
4932 constructor_bit_index = p->bit_index;
4933 constructor_elements = p->elements;
4934 constructor_constant = p->constant;
4935 constructor_simple = p->simple;
4936 constructor_erroneous = p->erroneous;
4937 constructor_incremental = p->incremental;
4938 constructor_designated = p->designated;
4939 constructor_pending_elts = p->pending_elts;
4940 constructor_depth = p->depth;
4942 constructor_range_stack = p->range_stack;
4943 RESTORE_SPELLING_DEPTH (constructor_depth);
4945 constructor_stack = p->next;
4948 if (constructor == 0)
4950 if (constructor_stack == 0)
4951 return error_mark_node;
4957 /* Common handling for both array range and field name designators.
4958 ARRAY argument is nonzero for array ranges. Returns zero for success. */
4961 set_designator (int array)
4964 enum tree_code subcode;
4966 /* Don't die if an entire brace-pair level is superfluous
4967 in the containing level. */
4968 if (constructor_type == 0)
4971 /* If there were errors in this designator list already, bail out silently. */
4972 if (designator_errorneous)
4975 if (!designator_depth)
4977 if (constructor_range_stack)
4980 /* Designator list starts at the level of closest explicit
4982 while (constructor_stack->implicit)
4983 process_init_element (pop_init_level (1));
4984 constructor_designated = 1;
4988 if (constructor_no_implicit)
4990 error_init ("initialization designators may not nest");
4994 if (TREE_CODE (constructor_type) == RECORD_TYPE
4995 || TREE_CODE (constructor_type) == UNION_TYPE)
4997 subtype = TREE_TYPE (constructor_fields);
4998 if (subtype != error_mark_node)
4999 subtype = TYPE_MAIN_VARIANT (subtype);
5001 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5003 subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
5008 subcode = TREE_CODE (subtype);
5009 if (array && subcode != ARRAY_TYPE)
5011 error_init ("array index in non-array initializer");
5014 else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
5016 error_init ("field name not in record or union initializer");
5020 constructor_designated = 1;
5021 push_init_level (2);
5025 /* If there are range designators in designator list, push a new designator
5026 to constructor_range_stack. RANGE_END is end of such stack range or
5027 NULL_TREE if there is no range designator at this level. */
5030 push_range_stack (tree range_end)
5032 struct constructor_range_stack *p;
5034 p = ggc_alloc (sizeof (struct constructor_range_stack));
5035 p->prev = constructor_range_stack;
5037 p->fields = constructor_fields;
5038 p->range_start = constructor_index;
5039 p->index = constructor_index;
5040 p->stack = constructor_stack;
5041 p->range_end = range_end;
5042 if (constructor_range_stack)
5043 constructor_range_stack->next = p;
5044 constructor_range_stack = p;
5047 /* Within an array initializer, specify the next index to be initialized.
5048 FIRST is that index. If LAST is nonzero, then initialize a range
5049 of indices, running from FIRST through LAST. */
5052 set_init_index (tree first, tree last)
5054 if (set_designator (1))
5057 designator_errorneous = 1;
5059 while ((TREE_CODE (first) == NOP_EXPR
5060 || TREE_CODE (first) == CONVERT_EXPR
5061 || TREE_CODE (first) == NON_LVALUE_EXPR)
5062 && (TYPE_MODE (TREE_TYPE (first))
5063 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (first, 0)))))
5064 first = TREE_OPERAND (first, 0);
5067 while ((TREE_CODE (last) == NOP_EXPR
5068 || TREE_CODE (last) == CONVERT_EXPR
5069 || TREE_CODE (last) == NON_LVALUE_EXPR)
5070 && (TYPE_MODE (TREE_TYPE (last))
5071 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (last, 0)))))
5072 last = TREE_OPERAND (last, 0);
5074 if (TREE_CODE (first) != INTEGER_CST)
5075 error_init ("nonconstant array index in initializer");
5076 else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
5077 error_init ("nonconstant array index in initializer");
5078 else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
5079 error_init ("array index in non-array initializer");
5080 else if (tree_int_cst_sgn (first) == -1)
5081 error_init ("array index in initializer exceeds array bounds");
5082 else if (constructor_max_index
5083 && tree_int_cst_lt (constructor_max_index, first))
5084 error_init ("array index in initializer exceeds array bounds");
5087 constructor_index = convert (bitsizetype, first);
5091 if (tree_int_cst_equal (first, last))
5093 else if (tree_int_cst_lt (last, first))
5095 error_init ("empty index range in initializer");
5100 last = convert (bitsizetype, last);
5101 if (constructor_max_index != 0
5102 && tree_int_cst_lt (constructor_max_index, last))
5104 error_init ("array index range in initializer exceeds array bounds");
5111 designator_errorneous = 0;
5112 if (constructor_range_stack || last)
5113 push_range_stack (last);
5117 /* Within a struct initializer, specify the next field to be initialized. */
5120 set_init_label (tree fieldname)
5124 if (set_designator (0))
5127 designator_errorneous = 1;
5129 if (TREE_CODE (constructor_type) != RECORD_TYPE
5130 && TREE_CODE (constructor_type) != UNION_TYPE)
5132 error_init ("field name not in record or union initializer");
5136 for (tail = TYPE_FIELDS (constructor_type); tail;
5137 tail = TREE_CHAIN (tail))
5139 if (DECL_NAME (tail) == fieldname)
5144 error ("unknown field `%s' specified in initializer",
5145 IDENTIFIER_POINTER (fieldname));
5148 constructor_fields = tail;
5150 designator_errorneous = 0;
5151 if (constructor_range_stack)
5152 push_range_stack (NULL_TREE);
5156 /* Add a new initializer to the tree of pending initializers. PURPOSE
5157 identifies the initializer, either array index or field in a structure.
5158 VALUE is the value of that index or field. */
5161 add_pending_init (tree purpose, tree value)
5163 struct init_node *p, **q, *r;
5165 q = &constructor_pending_elts;
5168 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5173 if (tree_int_cst_lt (purpose, p->purpose))
5175 else if (tree_int_cst_lt (p->purpose, purpose))
5179 if (TREE_SIDE_EFFECTS (p->value))
5180 warning_init ("initialized field with side-effects overwritten");
5190 bitpos = bit_position (purpose);
5194 if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5196 else if (p->purpose != purpose)
5200 if (TREE_SIDE_EFFECTS (p->value))
5201 warning_init ("initialized field with side-effects overwritten");
5208 r = ggc_alloc (sizeof (struct init_node));
5209 r->purpose = purpose;
5220 struct init_node *s;
5224 if (p->balance == 0)
5226 else if (p->balance < 0)
5233 p->left->parent = p;
5250 constructor_pending_elts = r;
5255 struct init_node *t = r->right;
5259 r->right->parent = r;
5264 p->left->parent = p;
5267 p->balance = t->balance < 0;
5268 r->balance = -(t->balance > 0);
5283 constructor_pending_elts = t;
5289 /* p->balance == +1; growth of left side balances the node. */
5294 else /* r == p->right */
5296 if (p->balance == 0)
5297 /* Growth propagation from right side. */
5299 else if (p->balance > 0)
5306 p->right->parent = p;
5323 constructor_pending_elts = r;
5325 else /* r->balance == -1 */
5328 struct init_node *t = r->left;
5332 r->left->parent = r;
5337 p->right->parent = p;
5340 r->balance = (t->balance < 0);
5341 p->balance = -(t->balance > 0);
5356 constructor_pending_elts = t;
5362 /* p->balance == -1; growth of right side balances the node. */
5373 /* Build AVL tree from a sorted chain. */
5376 set_nonincremental_init (void)
5380 if (TREE_CODE (constructor_type) != RECORD_TYPE
5381 && TREE_CODE (constructor_type) != ARRAY_TYPE)
5384 for (chain = constructor_elements; chain; chain = TREE_CHAIN (chain))
5385 add_pending_init (TREE_PURPOSE (chain), TREE_VALUE (chain));
5386 constructor_elements = 0;
5387 if (TREE_CODE (constructor_type) == RECORD_TYPE)
5389 constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
5390 /* Skip any nameless bit fields at the beginning. */
5391 while (constructor_unfilled_fields != 0
5392 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5393 && DECL_NAME (constructor_unfilled_fields) == 0)
5394 constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5397 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5399 if (TYPE_DOMAIN (constructor_type))
5400 constructor_unfilled_index
5401 = convert (bitsizetype,
5402 TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5404 constructor_unfilled_index = bitsize_zero_node;
5406 constructor_incremental = 0;
5409 /* Build AVL tree from a string constant. */
5412 set_nonincremental_init_from_string (tree str)
5414 tree value, purpose, type;
5415 HOST_WIDE_INT val[2];
5416 const char *p, *end;
5417 int byte, wchar_bytes, charwidth, bitpos;
5419 if (TREE_CODE (constructor_type) != ARRAY_TYPE)
5422 if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
5423 == TYPE_PRECISION (char_type_node))
5425 else if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
5426 == TYPE_PRECISION (wchar_type_node))
5427 wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
5431 charwidth = TYPE_PRECISION (char_type_node);
5432 type = TREE_TYPE (constructor_type);
5433 p = TREE_STRING_POINTER (str);
5434 end = p + TREE_STRING_LENGTH (str);
5436 for (purpose = bitsize_zero_node;
5437 p < end && !tree_int_cst_lt (constructor_max_index, purpose);
5438 purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
5440 if (wchar_bytes == 1)
5442 val[1] = (unsigned char) *p++;
5449 for (byte = 0; byte < wchar_bytes; byte++)
5451 if (BYTES_BIG_ENDIAN)
5452 bitpos = (wchar_bytes - byte - 1) * charwidth;
5454 bitpos = byte * charwidth;
5455 val[bitpos < HOST_BITS_PER_WIDE_INT]
5456 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
5457 << (bitpos % HOST_BITS_PER_WIDE_INT);
5461 if (!TREE_UNSIGNED (type))
5463 bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
5464 if (bitpos < HOST_BITS_PER_WIDE_INT)
5466 if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
5468 val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
5472 else if (bitpos == HOST_BITS_PER_WIDE_INT)
5477 else if (val[0] & (((HOST_WIDE_INT) 1)
5478 << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
5479 val[0] |= ((HOST_WIDE_INT) -1)
5480 << (bitpos - HOST_BITS_PER_WIDE_INT);
5483 value = build_int_2 (val[1], val[0]);
5484 TREE_TYPE (value) = type;
5485 add_pending_init (purpose, value);
5488 constructor_incremental = 0;
5491 /* Return value of FIELD in pending initializer or zero if the field was
5492 not initialized yet. */
5495 find_init_member (tree field)
5497 struct init_node *p;
5499 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5501 if (constructor_incremental
5502 && tree_int_cst_lt (field, constructor_unfilled_index))
5503 set_nonincremental_init ();
5505 p = constructor_pending_elts;
5508 if (tree_int_cst_lt (field, p->purpose))
5510 else if (tree_int_cst_lt (p->purpose, field))
5516 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
5518 tree bitpos = bit_position (field);
5520 if (constructor_incremental
5521 && (!constructor_unfilled_fields
5522 || tree_int_cst_lt (bitpos,
5523 bit_position (constructor_unfilled_fields))))
5524 set_nonincremental_init ();
5526 p = constructor_pending_elts;
5529 if (field == p->purpose)
5531 else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5537 else if (TREE_CODE (constructor_type) == UNION_TYPE)
5539 if (constructor_elements
5540 && TREE_PURPOSE (constructor_elements) == field)
5541 return TREE_VALUE (constructor_elements);
5546 /* "Output" the next constructor element.
5547 At top level, really output it to assembler code now.
5548 Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
5549 TYPE is the data type that the containing data type wants here.
5550 FIELD is the field (a FIELD_DECL) or the index that this element fills.
5552 PENDING if non-nil means output pending elements that belong
5553 right after this element. (PENDING is normally 1;
5554 it is 0 while outputting pending elements, to avoid recursion.) */
5557 output_init_element (tree value, tree type, tree field, int pending)
5559 if (type == error_mark_node)
5561 constructor_erroneous = 1;
5564 if (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE
5565 || (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
5566 && !(TREE_CODE (value) == STRING_CST
5567 && TREE_CODE (type) == ARRAY_TYPE
5568 && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
5569 && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
5570 TYPE_MAIN_VARIANT (type), COMPARE_STRICT)))
5571 value = default_conversion (value);
5573 if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR
5574 && require_constant_value && !flag_isoc99 && pending)
5576 /* As an extension, allow initializing objects with static storage
5577 duration with compound literals (which are then treated just as
5578 the brace enclosed list they contain). */
5579 tree decl = COMPOUND_LITERAL_EXPR_DECL (value);
5580 value = DECL_INITIAL (decl);
5583 if (value == error_mark_node)
5584 constructor_erroneous = 1;
5585 else if (!TREE_CONSTANT (value))
5586 constructor_constant = 0;
5587 else if (initializer_constant_valid_p (value, TREE_TYPE (value)) == 0
5588 || ((TREE_CODE (constructor_type) == RECORD_TYPE
5589 || TREE_CODE (constructor_type) == UNION_TYPE)
5590 && DECL_C_BIT_FIELD (field)
5591 && TREE_CODE (value) != INTEGER_CST))
5592 constructor_simple = 0;
5594 if (require_constant_value && ! TREE_CONSTANT (value))
5596 error_init ("initializer element is not constant");
5597 value = error_mark_node;
5599 else if (require_constant_elements
5600 && initializer_constant_valid_p (value, TREE_TYPE (value)) == 0)
5601 pedwarn ("initializer element is not computable at load time");
5603 /* If this field is empty (and not at the end of structure),
5604 don't do anything other than checking the initializer. */
5606 && (TREE_TYPE (field) == error_mark_node
5607 || (COMPLETE_TYPE_P (TREE_TYPE (field))
5608 && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
5609 && (TREE_CODE (constructor_type) == ARRAY_TYPE
5610 || TREE_CHAIN (field)))))
5613 value = digest_init (type, value, require_constant_value);
5614 if (value == error_mark_node)
5616 constructor_erroneous = 1;
5620 /* If this element doesn't come next in sequence,
5621 put it on constructor_pending_elts. */
5622 if (TREE_CODE (constructor_type) == ARRAY_TYPE
5623 && (!constructor_incremental
5624 || !tree_int_cst_equal (field, constructor_unfilled_index)))
5626 if (constructor_incremental
5627 && tree_int_cst_lt (field, constructor_unfilled_index))
5628 set_nonincremental_init ();
5630 add_pending_init (field, value);
5633 else if (TREE_CODE (constructor_type) == RECORD_TYPE
5634 && (!constructor_incremental
5635 || field != constructor_unfilled_fields))
5637 /* We do this for records but not for unions. In a union,
5638 no matter which field is specified, it can be initialized
5639 right away since it starts at the beginning of the union. */
5640 if (constructor_incremental)
5642 if (!constructor_unfilled_fields)
5643 set_nonincremental_init ();
5646 tree bitpos, unfillpos;
5648 bitpos = bit_position (field);
5649 unfillpos = bit_position (constructor_unfilled_fields);
5651 if (tree_int_cst_lt (bitpos, unfillpos))
5652 set_nonincremental_init ();
5656 add_pending_init (field, value);
5659 else if (TREE_CODE (constructor_type) == UNION_TYPE
5660 && constructor_elements)
5662 if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements)))
5663 warning_init ("initialized field with side-effects overwritten");
5665 /* We can have just one union field set. */
5666 constructor_elements = 0;
5669 /* Otherwise, output this element either to
5670 constructor_elements or to the assembler file. */
5672 if (field && TREE_CODE (field) == INTEGER_CST)
5673 field = copy_node (field);
5674 constructor_elements
5675 = tree_cons (field, value, constructor_elements);
5677 /* Advance the variable that indicates sequential elements output. */
5678 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5679 constructor_unfilled_index
5680 = size_binop (PLUS_EXPR, constructor_unfilled_index,
5682 else if (TREE_CODE (constructor_type) == RECORD_TYPE)
5684 constructor_unfilled_fields
5685 = TREE_CHAIN (constructor_unfilled_fields);
5687 /* Skip any nameless bit fields. */
5688 while (constructor_unfilled_fields != 0
5689 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5690 && DECL_NAME (constructor_unfilled_fields) == 0)
5691 constructor_unfilled_fields =
5692 TREE_CHAIN (constructor_unfilled_fields);
5694 else if (TREE_CODE (constructor_type) == UNION_TYPE)
5695 constructor_unfilled_fields = 0;
5697 /* Now output any pending elements which have become next. */
5699 output_pending_init_elements (0);
5702 /* Output any pending elements which have become next.
5703 As we output elements, constructor_unfilled_{fields,index}
5704 advances, which may cause other elements to become next;
5705 if so, they too are output.
5707 If ALL is 0, we return when there are
5708 no more pending elements to output now.
5710 If ALL is 1, we output space as necessary so that
5711 we can output all the pending elements. */
5714 output_pending_init_elements (int all)
5716 struct init_node *elt = constructor_pending_elts;
5721 /* Look through the whole pending tree.
5722 If we find an element that should be output now,
5723 output it. Otherwise, set NEXT to the element
5724 that comes first among those still pending. */
5729 if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5731 if (tree_int_cst_equal (elt->purpose,
5732 constructor_unfilled_index))
5733 output_init_element (elt->value,
5734 TREE_TYPE (constructor_type),
5735 constructor_unfilled_index, 0);
5736 else if (tree_int_cst_lt (constructor_unfilled_index,
5739 /* Advance to the next smaller node. */
5744 /* We have reached the smallest node bigger than the
5745 current unfilled index. Fill the space first. */
5746 next = elt->purpose;
5752 /* Advance to the next bigger node. */
5757 /* We have reached the biggest node in a subtree. Find
5758 the parent of it, which is the next bigger node. */
5759 while (elt->parent && elt->parent->right == elt)
5762 if (elt && tree_int_cst_lt (constructor_unfilled_index,
5765 next = elt->purpose;
5771 else if (TREE_CODE (constructor_type) == RECORD_TYPE
5772 || TREE_CODE (constructor_type) == UNION_TYPE)
5774 tree ctor_unfilled_bitpos, elt_bitpos;
5776 /* If the current record is complete we are done. */
5777 if (constructor_unfilled_fields == 0)
5780 ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
5781 elt_bitpos = bit_position (elt->purpose);
5782 /* We can't compare fields here because there might be empty
5783 fields in between. */
5784 if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
5786 constructor_unfilled_fields = elt->purpose;
5787 output_init_element (elt->value, TREE_TYPE (elt->purpose),
5790 else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
5792 /* Advance to the next smaller node. */
5797 /* We have reached the smallest node bigger than the
5798 current unfilled field. Fill the space first. */
5799 next = elt->purpose;
5805 /* Advance to the next bigger node. */
5810 /* We have reached the biggest node in a subtree. Find
5811 the parent of it, which is the next bigger node. */
5812 while (elt->parent && elt->parent->right == elt)
5816 && (tree_int_cst_lt (ctor_unfilled_bitpos,
5817 bit_position (elt->purpose))))
5819 next = elt->purpose;
5827 /* Ordinarily return, but not if we want to output all
5828 and there are elements left. */
5829 if (! (all && next != 0))
5832 /* If it's not incremental, just skip over the gap, so that after
5833 jumping to retry we will output the next successive element. */
5834 if (TREE_CODE (constructor_type) == RECORD_TYPE
5835 || TREE_CODE (constructor_type) == UNION_TYPE)
5836 constructor_unfilled_fields = next;
5837 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5838 constructor_unfilled_index = next;
5840 /* ELT now points to the node in the pending tree with the next
5841 initializer to output. */
5845 /* Add one non-braced element to the current constructor level.
5846 This adjusts the current position within the constructor's type.
5847 This may also start or terminate implicit levels
5848 to handle a partly-braced initializer.
5850 Once this has found the correct level for the new element,
5851 it calls output_init_element. */
5854 process_init_element (tree value)
5856 tree orig_value = value;
5857 int string_flag = value != 0 && TREE_CODE (value) == STRING_CST;
5859 designator_depth = 0;
5860 designator_errorneous = 0;
5862 /* Handle superfluous braces around string cst as in
5863 char x[] = {"foo"}; */
5866 && TREE_CODE (constructor_type) == ARRAY_TYPE
5867 && TREE_CODE (TREE_TYPE (constructor_type)) == INTEGER_TYPE
5868 && integer_zerop (constructor_unfilled_index))
5870 if (constructor_stack->replacement_value)
5871 error_init ("excess elements in char array initializer");
5872 constructor_stack->replacement_value = value;
5876 if (constructor_stack->replacement_value != 0)
5878 error_init ("excess elements in struct initializer");
5882 /* Ignore elements of a brace group if it is entirely superfluous
5883 and has already been diagnosed. */
5884 if (constructor_type == 0)
5887 /* If we've exhausted any levels that didn't have braces,
5889 while (constructor_stack->implicit)
5891 if ((TREE_CODE (constructor_type) == RECORD_TYPE
5892 || TREE_CODE (constructor_type) == UNION_TYPE)
5893 && constructor_fields == 0)
5894 process_init_element (pop_init_level (1));
5895 else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5896 && (constructor_max_index == 0
5897 || tree_int_cst_lt (constructor_max_index,
5898 constructor_index)))
5899 process_init_element (pop_init_level (1));
5904 /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */
5905 if (constructor_range_stack)
5907 /* If value is a compound literal and we'll be just using its
5908 content, don't put it into a SAVE_EXPR. */
5909 if (TREE_CODE (value) != COMPOUND_LITERAL_EXPR
5910 || !require_constant_value
5912 value = save_expr (value);
5917 if (TREE_CODE (constructor_type) == RECORD_TYPE)
5920 enum tree_code fieldcode;
5922 if (constructor_fields == 0)
5924 pedwarn_init ("excess elements in struct initializer");
5928 fieldtype = TREE_TYPE (constructor_fields);
5929 if (fieldtype != error_mark_node)
5930 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
5931 fieldcode = TREE_CODE (fieldtype);
5933 /* Error for non-static initialization of a flexible array member. */
5934 if (fieldcode == ARRAY_TYPE
5935 && !require_constant_value
5936 && TYPE_SIZE (fieldtype) == NULL_TREE
5937 && TREE_CHAIN (constructor_fields) == NULL_TREE)
5939 error_init ("non-static initialization of a flexible array member");
5943 /* Accept a string constant to initialize a subarray. */
5945 && fieldcode == ARRAY_TYPE
5946 && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
5949 /* Otherwise, if we have come to a subaggregate,
5950 and we don't have an element of its type, push into it. */
5951 else if (value != 0 && !constructor_no_implicit
5952 && value != error_mark_node
5953 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
5954 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
5955 || fieldcode == UNION_TYPE))
5957 push_init_level (1);
5963 push_member_name (constructor_fields);
5964 output_init_element (value, fieldtype, constructor_fields, 1);
5965 RESTORE_SPELLING_DEPTH (constructor_depth);
5968 /* Do the bookkeeping for an element that was
5969 directly output as a constructor. */
5971 /* For a record, keep track of end position of last field. */
5972 if (DECL_SIZE (constructor_fields))
5973 constructor_bit_index
5974 = size_binop (PLUS_EXPR,
5975 bit_position (constructor_fields),
5976 DECL_SIZE (constructor_fields));
5978 /* If the current field was the first one not yet written out,
5979 it isn't now, so update. */
5980 if (constructor_unfilled_fields == constructor_fields)
5982 constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
5983 /* Skip any nameless bit fields. */
5984 while (constructor_unfilled_fields != 0
5985 && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5986 && DECL_NAME (constructor_unfilled_fields) == 0)
5987 constructor_unfilled_fields =
5988 TREE_CHAIN (constructor_unfilled_fields);
5992 constructor_fields = TREE_CHAIN (constructor_fields);
5993 /* Skip any nameless bit fields at the beginning. */
5994 while (constructor_fields != 0
5995 && DECL_C_BIT_FIELD (constructor_fields)
5996 && DECL_NAME (constructor_fields) == 0)
5997 constructor_fields = TREE_CHAIN (constructor_fields);
5999 else if (TREE_CODE (constructor_type) == UNION_TYPE)
6002 enum tree_code fieldcode;
6004 if (constructor_fields == 0)
6006 pedwarn_init ("excess elements in union initializer");
6010 fieldtype = TREE_TYPE (constructor_fields);
6011 if (fieldtype != error_mark_node)
6012 fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6013 fieldcode = TREE_CODE (fieldtype);
6015 /* Warn that traditional C rejects initialization of unions.
6016 We skip the warning if the value is zero. This is done
6017 under the assumption that the zero initializer in user
6018 code appears conditioned on e.g. __STDC__ to avoid
6019 "missing initializer" warnings and relies on default
6020 initialization to zero in the traditional C case.
6021 We also skip the warning if the initializer is designated,
6022 again on the assumption that this must be conditional on
6023 __STDC__ anyway (and we've already complained about the
6024 member-designator already). */
6025 if (warn_traditional && !in_system_header && !constructor_designated
6026 && !(value && (integer_zerop (value) || real_zerop (value))))
6027 warning ("traditional C rejects initialization of unions");
6029 /* Accept a string constant to initialize a subarray. */
6031 && fieldcode == ARRAY_TYPE
6032 && TREE_CODE (TREE_TYPE (fieldtype)) == INTEGER_TYPE
6035 /* Otherwise, if we have come to a subaggregate,
6036 and we don't have an element of its type, push into it. */
6037 else if (value != 0 && !constructor_no_implicit
6038 && value != error_mark_node
6039 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype
6040 && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6041 || fieldcode == UNION_TYPE))
6043 push_init_level (1);
6049 push_member_name (constructor_fields);
6050 output_init_element (value, fieldtype, constructor_fields, 1);
6051 RESTORE_SPELLING_DEPTH (constructor_depth);
6054 /* Do the bookkeeping for an element that was
6055 directly output as a constructor. */
6057 constructor_bit_index = DECL_SIZE (constructor_fields);
6058 constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6061 constructor_fields = 0;
6063 else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6065 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6066 enum tree_code eltcode = TREE_CODE (elttype);
6068 /* Accept a string constant to initialize a subarray. */
6070 && eltcode == ARRAY_TYPE
6071 && TREE_CODE (TREE_TYPE (elttype)) == INTEGER_TYPE
6074 /* Otherwise, if we have come to a subaggregate,
6075 and we don't have an element of its type, push into it. */
6076 else if (value != 0 && !constructor_no_implicit
6077 && value != error_mark_node
6078 && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != elttype
6079 && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
6080 || eltcode == UNION_TYPE))
6082 push_init_level (1);
6086 if (constructor_max_index != 0
6087 && (tree_int_cst_lt (constructor_max_index, constructor_index)
6088 || integer_all_onesp (constructor_max_index)))
6090 pedwarn_init ("excess elements in array initializer");
6094 /* Now output the actual element. */
6097 push_array_bounds (tree_low_cst (constructor_index, 0));
6098 output_init_element (value, elttype, constructor_index, 1);
6099 RESTORE_SPELLING_DEPTH (constructor_depth);
6103 = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6106 /* If we are doing the bookkeeping for an element that was
6107 directly output as a constructor, we must update
6108 constructor_unfilled_index. */
6109 constructor_unfilled_index = constructor_index;
6111 else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
6113 tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6115 /* Do a basic check of initializer size. Note that vectors
6116 always have a fixed size derived from their type. */
6117 if (tree_int_cst_lt (constructor_max_index, constructor_index))
6119 pedwarn_init ("excess elements in vector initializer");
6123 /* Now output the actual element. */
6125 output_init_element (value, elttype, constructor_index, 1);
6128 = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6131 /* If we are doing the bookkeeping for an element that was
6132 directly output as a constructor, we must update
6133 constructor_unfilled_index. */
6134 constructor_unfilled_index = constructor_index;
6137 /* Handle the sole element allowed in a braced initializer
6138 for a scalar variable. */
6139 else if (constructor_fields == 0)
6141 pedwarn_init ("excess elements in scalar initializer");
6147 output_init_element (value, constructor_type, NULL_TREE, 1);
6148 constructor_fields = 0;
6151 /* Handle range initializers either at this level or anywhere higher
6152 in the designator stack. */
6153 if (constructor_range_stack)
6155 struct constructor_range_stack *p, *range_stack;
6158 range_stack = constructor_range_stack;
6159 constructor_range_stack = 0;
6160 while (constructor_stack != range_stack->stack)
6162 if (!constructor_stack->implicit)
6164 process_init_element (pop_init_level (1));
6166 for (p = range_stack;
6167 !p->range_end || tree_int_cst_equal (p->index, p->range_end);
6170 if (!constructor_stack->implicit)
6172 process_init_element (pop_init_level (1));
6175 p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
6176 if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
6181 constructor_index = p->index;
6182 constructor_fields = p->fields;
6183 if (finish && p->range_end && p->index == p->range_start)
6191 push_init_level (2);
6192 p->stack = constructor_stack;
6193 if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
6194 p->index = p->range_start;
6198 constructor_range_stack = range_stack;
6205 constructor_range_stack = 0;
6208 /* Build a simple asm-statement, from one string literal. */
6210 simple_asm_stmt (tree expr)
6214 if (TREE_CODE (expr) == ADDR_EXPR)
6215 expr = TREE_OPERAND (expr, 0);
6217 if (TREE_CODE (expr) == STRING_CST)
6221 /* Simple asm statements are treated as volatile. */
6222 stmt = add_stmt (build_stmt (ASM_STMT, ridpointers[(int) RID_VOLATILE],
6223 expr, NULL_TREE, NULL_TREE, NULL_TREE));
6224 ASM_INPUT_P (stmt) = 1;
6228 error ("argument of `asm' is not a constant string");
6232 /* Build an asm-statement, whose components are a CV_QUALIFIER, a
6233 STRING, some OUTPUTS, some INPUTS, and some CLOBBERS. */
6236 build_asm_stmt (tree cv_qualifier, tree string, tree outputs, tree inputs,
6241 if (TREE_CODE (string) != STRING_CST)
6243 error ("asm template is not a string constant");
6247 if (cv_qualifier != NULL_TREE
6248 && cv_qualifier != ridpointers[(int) RID_VOLATILE])
6250 warning ("%s qualifier ignored on asm",
6251 IDENTIFIER_POINTER (cv_qualifier));
6252 cv_qualifier = NULL_TREE;
6255 /* We can remove output conversions that change the type,
6256 but not the mode. */
6257 for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6259 tree output = TREE_VALUE (tail);
6261 STRIP_NOPS (output);
6262 TREE_VALUE (tail) = output;
6264 /* Allow conversions as LHS here. build_modify_expr as called below
6265 will do the right thing with them. */
6266 while (TREE_CODE (output) == NOP_EXPR
6267 || TREE_CODE (output) == CONVERT_EXPR
6268 || TREE_CODE (output) == FLOAT_EXPR
6269 || TREE_CODE (output) == FIX_TRUNC_EXPR
6270 || TREE_CODE (output) == FIX_FLOOR_EXPR
6271 || TREE_CODE (output) == FIX_ROUND_EXPR
6272 || TREE_CODE (output) == FIX_CEIL_EXPR)
6273 output = TREE_OPERAND (output, 0);
6275 lvalue_or_else (TREE_VALUE (tail), "invalid lvalue in asm statement");
6278 /* Remove output conversions that change the type but not the mode. */
6279 for (tail = outputs; tail; tail = TREE_CHAIN (tail))
6281 tree output = TREE_VALUE (tail);
6282 STRIP_NOPS (output);
6283 TREE_VALUE (tail) = output;
6286 /* Perform default conversions on array and function inputs.
6287 Don't do this for other types as it would screw up operands
6288 expected to be in memory. */
6289 for (tail = inputs; tail; tail = TREE_CHAIN (tail))
6290 TREE_VALUE (tail) = default_function_array_conversion (TREE_VALUE (tail));
6292 return add_stmt (build_stmt (ASM_STMT, cv_qualifier, string,
6293 outputs, inputs, clobbers));
6296 /* Expand an ASM statement with operands, handling output operands
6297 that are not variables or INDIRECT_REFS by transforming such
6298 cases into cases that expand_asm_operands can handle.
6300 Arguments are same as for expand_asm_operands. */
6303 c_expand_asm_operands (tree string, tree outputs, tree inputs,
6304 tree clobbers, int vol, location_t locus)
6306 int noutputs = list_length (outputs);
6308 /* o[I] is the place that output number I should be written. */
6309 tree *o = alloca (noutputs * sizeof (tree));
6312 /* Record the contents of OUTPUTS before it is modified. */
6313 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6315 o[i] = TREE_VALUE (tail);
6316 if (o[i] == error_mark_node)
6320 /* Generate the ASM_OPERANDS insn; store into the TREE_VALUEs of
6321 OUTPUTS some trees for where the values were actually stored. */
6322 expand_asm_operands (string, outputs, inputs, clobbers, vol, locus);
6324 /* Copy all the intermediate outputs into the specified outputs. */
6325 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
6327 if (o[i] != TREE_VALUE (tail))
6329 expand_expr (build_modify_expr (o[i], NOP_EXPR, TREE_VALUE (tail)),
6330 NULL_RTX, VOIDmode, EXPAND_NORMAL);
6333 /* Restore the original value so that it's correct the next
6334 time we expand this function. */
6335 TREE_VALUE (tail) = o[i];
6337 /* Detect modification of read-only values.
6338 (Otherwise done by build_modify_expr.) */
6341 tree type = TREE_TYPE (o[i]);
6342 if (TREE_READONLY (o[i])
6343 || TYPE_READONLY (type)
6344 || ((TREE_CODE (type) == RECORD_TYPE
6345 || TREE_CODE (type) == UNION_TYPE)
6346 && C_TYPE_FIELDS_READONLY (type)))
6347 readonly_error (o[i], "modification by `asm'");
6351 /* Those MODIFY_EXPRs could do autoincrements. */
6355 /* Expand a C `return' statement.
6356 RETVAL is the expression for what to return,
6357 or a null pointer for `return;' with no value. */
6360 c_expand_return (tree retval)
6362 tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
6364 if (TREE_THIS_VOLATILE (current_function_decl))
6365 warning ("function declared `noreturn' has a `return' statement");
6369 current_function_returns_null = 1;
6370 if ((warn_return_type || flag_isoc99)
6371 && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
6372 pedwarn_c99 ("`return' with no value, in function returning non-void");
6374 else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
6376 current_function_returns_null = 1;
6377 if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
6378 pedwarn ("`return' with a value, in function returning void");
6382 tree t = convert_for_assignment (valtype, retval, _("return"),
6383 NULL_TREE, NULL_TREE, 0);
6384 tree res = DECL_RESULT (current_function_decl);
6387 current_function_returns_value = 1;
6388 if (t == error_mark_node)
6391 inner = t = convert (TREE_TYPE (res), t);
6393 /* Strip any conversions, additions, and subtractions, and see if
6394 we are returning the address of a local variable. Warn if so. */
6397 switch (TREE_CODE (inner))
6399 case NOP_EXPR: case NON_LVALUE_EXPR: case CONVERT_EXPR:
6401 inner = TREE_OPERAND (inner, 0);
6405 /* If the second operand of the MINUS_EXPR has a pointer
6406 type (or is converted from it), this may be valid, so
6407 don't give a warning. */
6409 tree op1 = TREE_OPERAND (inner, 1);
6411 while (! POINTER_TYPE_P (TREE_TYPE (op1))
6412 && (TREE_CODE (op1) == NOP_EXPR
6413 || TREE_CODE (op1) == NON_LVALUE_EXPR
6414 || TREE_CODE (op1) == CONVERT_EXPR))
6415 op1 = TREE_OPERAND (op1, 0);
6417 if (POINTER_TYPE_P (TREE_TYPE (op1)))
6420 inner = TREE_OPERAND (inner, 0);
6425 inner = TREE_OPERAND (inner, 0);
6427 while (TREE_CODE_CLASS (TREE_CODE (inner)) == 'r')
6428 inner = TREE_OPERAND (inner, 0);
6430 if (TREE_CODE (inner) == VAR_DECL
6431 && ! DECL_EXTERNAL (inner)
6432 && ! TREE_STATIC (inner)
6433 && DECL_CONTEXT (inner) == current_function_decl)
6434 warning ("function returns address of local variable");
6444 retval = build (MODIFY_EXPR, TREE_TYPE (res), res, t);
6447 return add_stmt (build_return_stmt (retval));
6451 /* The SWITCH_STMT being built. */
6453 /* A splay-tree mapping the low element of a case range to the high
6454 element, or NULL_TREE if there is no high element. Used to
6455 determine whether or not a new case label duplicates an old case
6456 label. We need a tree, rather than simply a hash table, because
6457 of the GNU case range extension. */
6459 /* The next node on the stack. */
6460 struct c_switch *next;
6463 /* A stack of the currently active switch statements. The innermost
6464 switch statement is on the top of the stack. There is no need to
6465 mark the stack for garbage collection because it is only active
6466 during the processing of the body of a function, and we never
6467 collect at that point. */
6469 static struct c_switch *switch_stack;
6471 /* Start a C switch statement, testing expression EXP. Return the new
6475 c_start_case (tree exp)
6477 enum tree_code code;
6478 tree type, orig_type = error_mark_node;
6479 struct c_switch *cs;
6481 if (exp != error_mark_node)
6483 code = TREE_CODE (TREE_TYPE (exp));
6484 orig_type = TREE_TYPE (exp);
6486 if (! INTEGRAL_TYPE_P (orig_type)
6487 && code != ERROR_MARK)
6489 error ("switch quantity not an integer");
6490 exp = integer_zero_node;
6494 type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
6496 if (warn_traditional && !in_system_header
6497 && (type == long_integer_type_node
6498 || type == long_unsigned_type_node))
6499 warning ("`long' switch expression not converted to `int' in ISO C");
6501 exp = default_conversion (exp);
6502 type = TREE_TYPE (exp);
6506 /* Add this new SWITCH_STMT to the stack. */
6507 cs = xmalloc (sizeof (*cs));
6508 cs->switch_stmt = build_stmt (SWITCH_STMT, exp, NULL_TREE, orig_type);
6509 cs->cases = splay_tree_new (case_compare, NULL, NULL);
6510 cs->next = switch_stack;
6513 return add_stmt (switch_stack->switch_stmt);
6516 /* Process a case label. */
6519 do_case (tree low_value, tree high_value)
6521 tree label = NULL_TREE;
6525 bool switch_was_empty_p = (SWITCH_BODY (switch_stack->switch_stmt) == NULL_TREE);
6527 label = c_add_case_label (switch_stack->cases,
6528 SWITCH_COND (switch_stack->switch_stmt),
6529 low_value, high_value);
6530 if (label == error_mark_node)
6532 else if (switch_was_empty_p)
6534 /* Attach the first case label to the SWITCH_BODY. */
6535 SWITCH_BODY (switch_stack->switch_stmt) = TREE_CHAIN (switch_stack->switch_stmt);
6536 TREE_CHAIN (switch_stack->switch_stmt) = NULL_TREE;
6540 error ("case label not within a switch statement");
6542 error ("`default' label not within a switch statement");
6547 /* Finish the switch statement. */
6550 c_finish_case (void)
6552 struct c_switch *cs = switch_stack;
6554 /* Rechain the next statements to the SWITCH_STMT. */
6555 last_tree = cs->switch_stmt;
6557 /* Pop the stack. */
6558 switch_stack = switch_stack->next;
6559 splay_tree_delete (cs->cases);
6563 /* Build a binary-operation expression without default conversions.
6564 CODE is the kind of expression to build.
6565 This function differs from `build' in several ways:
6566 the data type of the result is computed and recorded in it,
6567 warnings are generated if arg data types are invalid,
6568 special handling for addition and subtraction of pointers is known,
6569 and some optimization is done (operations on narrow ints
6570 are done in the narrower type when that gives the same result).
6571 Constant folding is also done before the result is returned.
6573 Note that the operands will never have enumeral types, or function
6574 or array types, because either they will have the default conversions
6575 performed or they have both just been converted to some other type in which
6576 the arithmetic is to be done. */
6579 build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
6583 enum tree_code code0, code1;
6586 /* Expression code to give to the expression when it is built.
6587 Normally this is CODE, which is what the caller asked for,
6588 but in some special cases we change it. */
6589 enum tree_code resultcode = code;
6591 /* Data type in which the computation is to be performed.
6592 In the simplest cases this is the common type of the arguments. */
6593 tree result_type = NULL;
6595 /* Nonzero means operands have already been type-converted
6596 in whatever way is necessary.
6597 Zero means they need to be converted to RESULT_TYPE. */
6600 /* Nonzero means create the expression with this type, rather than
6602 tree build_type = 0;
6604 /* Nonzero means after finally constructing the expression
6605 convert it to this type. */
6606 tree final_type = 0;
6608 /* Nonzero if this is an operation like MIN or MAX which can
6609 safely be computed in short if both args are promoted shorts.
6610 Also implies COMMON.
6611 -1 indicates a bitwise operation; this makes a difference
6612 in the exact conditions for when it is safe to do the operation
6613 in a narrower mode. */
6616 /* Nonzero if this is a comparison operation;
6617 if both args are promoted shorts, compare the original shorts.
6618 Also implies COMMON. */
6619 int short_compare = 0;
6621 /* Nonzero if this is a right-shift operation, which can be computed on the
6622 original short and then promoted if the operand is a promoted short. */
6623 int short_shift = 0;
6625 /* Nonzero means set RESULT_TYPE to the common type of the args. */
6630 op0 = default_conversion (orig_op0);
6631 op1 = default_conversion (orig_op1);
6639 type0 = TREE_TYPE (op0);
6640 type1 = TREE_TYPE (op1);
6642 /* The expression codes of the data types of the arguments tell us
6643 whether the arguments are integers, floating, pointers, etc. */
6644 code0 = TREE_CODE (type0);
6645 code1 = TREE_CODE (type1);
6647 /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
6648 STRIP_TYPE_NOPS (op0);
6649 STRIP_TYPE_NOPS (op1);
6651 /* If an error was already reported for one of the arguments,
6652 avoid reporting another error. */
6654 if (code0 == ERROR_MARK || code1 == ERROR_MARK)
6655 return error_mark_node;
6660 /* Handle the pointer + int case. */
6661 if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
6662 return pointer_int_sum (PLUS_EXPR, op0, op1);
6663 else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
6664 return pointer_int_sum (PLUS_EXPR, op1, op0);
6670 /* Subtraction of two similar pointers.
6671 We must subtract them as integers, then divide by object size. */
6672 if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
6673 && comp_target_types (type0, type1, 1))
6674 return pointer_diff (op0, op1);
6675 /* Handle pointer minus int. Just like pointer plus int. */
6676 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
6677 return pointer_int_sum (MINUS_EXPR, op0, op1);
6686 case TRUNC_DIV_EXPR:
6688 case FLOOR_DIV_EXPR:
6689 case ROUND_DIV_EXPR:
6690 case EXACT_DIV_EXPR:
6691 /* Floating point division by zero is a legitimate way to obtain
6692 infinities and NaNs. */
6693 if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
6694 warning ("division by zero");
6696 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
6697 || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
6698 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
6699 || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
6701 if (!(code0 == INTEGER_TYPE && code1 == INTEGER_TYPE))
6702 resultcode = RDIV_EXPR;
6704 /* Although it would be tempting to shorten always here, that
6705 loses on some targets, since the modulo instruction is
6706 undefined if the quotient can't be represented in the
6707 computation mode. We shorten only if unsigned or if
6708 dividing by something we know != -1. */
6709 shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
6710 || (TREE_CODE (op1) == INTEGER_CST
6711 && ! integer_all_onesp (op1)));
6719 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6721 else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
6725 case TRUNC_MOD_EXPR:
6726 case FLOOR_MOD_EXPR:
6727 if (warn_div_by_zero && skip_evaluation == 0 && integer_zerop (op1))
6728 warning ("division by zero");
6730 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6732 /* Although it would be tempting to shorten always here, that loses
6733 on some targets, since the modulo instruction is undefined if the
6734 quotient can't be represented in the computation mode. We shorten
6735 only if unsigned or if dividing by something we know != -1. */
6736 shorten = (TREE_UNSIGNED (TREE_TYPE (orig_op0))
6737 || (TREE_CODE (op1) == INTEGER_CST
6738 && ! integer_all_onesp (op1)));
6743 case TRUTH_ANDIF_EXPR:
6744 case TRUTH_ORIF_EXPR:
6745 case TRUTH_AND_EXPR:
6747 case TRUTH_XOR_EXPR:
6748 if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
6749 || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
6750 && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
6751 || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
6753 /* Result of these operations is always an int,
6754 but that does not mean the operands should be
6755 converted to ints! */
6756 result_type = integer_type_node;
6757 op0 = c_common_truthvalue_conversion (op0);
6758 op1 = c_common_truthvalue_conversion (op1);
6763 /* Shift operations: result has same type as first operand;
6764 always convert second operand to int.
6765 Also set SHORT_SHIFT if shifting rightward. */
6768 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6770 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
6772 if (tree_int_cst_sgn (op1) < 0)
6773 warning ("right shift count is negative");
6776 if (! integer_zerop (op1))
6779 if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
6780 warning ("right shift count >= width of type");
6784 /* Use the type of the value to be shifted. */
6785 result_type = type0;
6786 /* Convert the shift-count to an integer, regardless of size
6787 of value being shifted. */
6788 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
6789 op1 = convert (integer_type_node, op1);
6790 /* Avoid converting op1 to result_type later. */
6796 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6798 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
6800 if (tree_int_cst_sgn (op1) < 0)
6801 warning ("left shift count is negative");
6803 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
6804 warning ("left shift count >= width of type");
6807 /* Use the type of the value to be shifted. */
6808 result_type = type0;
6809 /* Convert the shift-count to an integer, regardless of size
6810 of value being shifted. */
6811 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
6812 op1 = convert (integer_type_node, op1);
6813 /* Avoid converting op1 to result_type later. */
6820 if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
6822 if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
6824 if (tree_int_cst_sgn (op1) < 0)
6825 warning ("shift count is negative");
6826 else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
6827 warning ("shift count >= width of type");
6830 /* Use the type of the value to be shifted. */
6831 result_type = type0;
6832 /* Convert the shift-count to an integer, regardless of size
6833 of value being shifted. */
6834 if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
6835 op1 = convert (integer_type_node, op1);
6836 /* Avoid converting op1 to result_type later. */
6843 if (warn_float_equal && (code0 == REAL_TYPE || code1 == REAL_TYPE))
6844 warning ("comparing floating point with == or != is unsafe");
6845 /* Result of comparison is always int,
6846 but don't convert the args to int! */
6847 build_type = integer_type_node;
6848 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
6849 || code0 == COMPLEX_TYPE)
6850 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
6851 || code1 == COMPLEX_TYPE))
6853 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
6855 tree tt0 = TREE_TYPE (type0);
6856 tree tt1 = TREE_TYPE (type1);
6857 /* Anything compares with void *. void * compares with anything.
6858 Otherwise, the targets must be compatible
6859 and both must be object or both incomplete. */
6860 if (comp_target_types (type0, type1, 1))
6861 result_type = common_type (type0, type1);
6862 else if (VOID_TYPE_P (tt0))
6864 /* op0 != orig_op0 detects the case of something
6865 whose value is 0 but which isn't a valid null ptr const. */
6866 if (pedantic && (!integer_zerop (op0) || op0 != orig_op0)
6867 && TREE_CODE (tt1) == FUNCTION_TYPE)
6868 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
6870 else if (VOID_TYPE_P (tt1))
6872 if (pedantic && (!integer_zerop (op1) || op1 != orig_op1)
6873 && TREE_CODE (tt0) == FUNCTION_TYPE)
6874 pedwarn ("ISO C forbids comparison of `void *' with function pointer");
6877 pedwarn ("comparison of distinct pointer types lacks a cast");
6879 if (result_type == NULL_TREE)
6880 result_type = ptr_type_node;
6882 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
6883 && integer_zerop (op1))
6884 result_type = type0;
6885 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
6886 && integer_zerop (op0))
6887 result_type = type1;
6888 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
6890 result_type = type0;
6891 pedwarn ("comparison between pointer and integer");
6893 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
6895 result_type = type1;
6896 pedwarn ("comparison between pointer and integer");
6902 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
6903 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
6905 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
6907 if (comp_target_types (type0, type1, 1))
6909 result_type = common_type (type0, type1);
6911 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
6912 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
6916 result_type = ptr_type_node;
6917 pedwarn ("comparison of distinct pointer types lacks a cast");
6926 build_type = integer_type_node;
6927 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
6928 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
6930 else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
6932 if (comp_target_types (type0, type1, 1))
6934 result_type = common_type (type0, type1);
6935 if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
6936 != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
6937 pedwarn ("comparison of complete and incomplete pointers");
6939 && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
6940 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
6944 result_type = ptr_type_node;
6945 pedwarn ("comparison of distinct pointer types lacks a cast");
6948 else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
6949 && integer_zerop (op1))
6951 result_type = type0;
6952 if (pedantic || extra_warnings)
6953 pedwarn ("ordered comparison of pointer with integer zero");
6955 else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
6956 && integer_zerop (op0))
6958 result_type = type1;
6960 pedwarn ("ordered comparison of pointer with integer zero");
6962 else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
6964 result_type = type0;
6965 pedwarn ("comparison between pointer and integer");
6967 else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
6969 result_type = type1;
6970 pedwarn ("comparison between pointer and integer");
6974 case UNORDERED_EXPR:
6981 build_type = integer_type_node;
6982 if (code0 != REAL_TYPE || code1 != REAL_TYPE)
6984 error ("unordered comparison on non-floating point argument");
6985 return error_mark_node;
6994 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
6995 || code0 == VECTOR_TYPE)
6997 (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
6998 || code1 == VECTOR_TYPE))
7000 int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
7002 if (shorten || common || short_compare)
7003 result_type = common_type (type0, type1);
7005 /* For certain operations (which identify themselves by shorten != 0)
7006 if both args were extended from the same smaller type,
7007 do the arithmetic in that type and then extend.
7009 shorten !=0 and !=1 indicates a bitwise operation.
7010 For them, this optimization is safe only if
7011 both args are zero-extended or both are sign-extended.
7012 Otherwise, we might change the result.
7013 Eg, (short)-1 | (unsigned short)-1 is (int)-1
7014 but calculated in (unsigned short) it would be (unsigned short)-1. */
7016 if (shorten && none_complex)
7018 int unsigned0, unsigned1;
7019 tree arg0 = get_narrower (op0, &unsigned0);
7020 tree arg1 = get_narrower (op1, &unsigned1);
7021 /* UNS is 1 if the operation to be done is an unsigned one. */
7022 int uns = TREE_UNSIGNED (result_type);
7025 final_type = result_type;
7027 /* Handle the case that OP0 (or OP1) does not *contain* a conversion
7028 but it *requires* conversion to FINAL_TYPE. */
7030 if ((TYPE_PRECISION (TREE_TYPE (op0))
7031 == TYPE_PRECISION (TREE_TYPE (arg0)))
7032 && TREE_TYPE (op0) != final_type)
7033 unsigned0 = TREE_UNSIGNED (TREE_TYPE (op0));
7034 if ((TYPE_PRECISION (TREE_TYPE (op1))
7035 == TYPE_PRECISION (TREE_TYPE (arg1)))
7036 && TREE_TYPE (op1) != final_type)
7037 unsigned1 = TREE_UNSIGNED (TREE_TYPE (op1));
7039 /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
7041 /* For bitwise operations, signedness of nominal type
7042 does not matter. Consider only how operands were extended. */
7046 /* Note that in all three cases below we refrain from optimizing
7047 an unsigned operation on sign-extended args.
7048 That would not be valid. */
7050 /* Both args variable: if both extended in same way
7051 from same width, do it in that width.
7052 Do it unsigned if args were zero-extended. */
7053 if ((TYPE_PRECISION (TREE_TYPE (arg0))
7054 < TYPE_PRECISION (result_type))
7055 && (TYPE_PRECISION (TREE_TYPE (arg1))
7056 == TYPE_PRECISION (TREE_TYPE (arg0)))
7057 && unsigned0 == unsigned1
7058 && (unsigned0 || !uns))
7060 = c_common_signed_or_unsigned_type
7061 (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
7062 else if (TREE_CODE (arg0) == INTEGER_CST
7063 && (unsigned1 || !uns)
7064 && (TYPE_PRECISION (TREE_TYPE (arg1))
7065 < TYPE_PRECISION (result_type))
7067 = c_common_signed_or_unsigned_type (unsigned1,
7069 int_fits_type_p (arg0, type)))
7071 else if (TREE_CODE (arg1) == INTEGER_CST
7072 && (unsigned0 || !uns)
7073 && (TYPE_PRECISION (TREE_TYPE (arg0))
7074 < TYPE_PRECISION (result_type))
7076 = c_common_signed_or_unsigned_type (unsigned0,
7078 int_fits_type_p (arg1, type)))
7082 /* Shifts can be shortened if shifting right. */
7087 tree arg0 = get_narrower (op0, &unsigned_arg);
7089 final_type = result_type;
7091 if (arg0 == op0 && final_type == TREE_TYPE (op0))
7092 unsigned_arg = TREE_UNSIGNED (TREE_TYPE (op0));
7094 if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
7095 /* We can shorten only if the shift count is less than the
7096 number of bits in the smaller type size. */
7097 && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
7098 /* We cannot drop an unsigned shift after sign-extension. */
7099 && (!TREE_UNSIGNED (final_type) || unsigned_arg))
7101 /* Do an unsigned shift if the operand was zero-extended. */
7103 = c_common_signed_or_unsigned_type (unsigned_arg,
7105 /* Convert value-to-be-shifted to that type. */
7106 if (TREE_TYPE (op0) != result_type)
7107 op0 = convert (result_type, op0);
7112 /* Comparison operations are shortened too but differently.
7113 They identify themselves by setting short_compare = 1. */
7117 /* Don't write &op0, etc., because that would prevent op0
7118 from being kept in a register.
7119 Instead, make copies of the our local variables and
7120 pass the copies by reference, then copy them back afterward. */
7121 tree xop0 = op0, xop1 = op1, xresult_type = result_type;
7122 enum tree_code xresultcode = resultcode;
7124 = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
7129 op0 = xop0, op1 = xop1;
7131 resultcode = xresultcode;
7133 if (warn_sign_compare && skip_evaluation == 0)
7135 int op0_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op0));
7136 int op1_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op1));
7137 int unsignedp0, unsignedp1;
7138 tree primop0 = get_narrower (op0, &unsignedp0);
7139 tree primop1 = get_narrower (op1, &unsignedp1);
7143 STRIP_TYPE_NOPS (xop0);
7144 STRIP_TYPE_NOPS (xop1);
7146 /* Give warnings for comparisons between signed and unsigned
7147 quantities that may fail.
7149 Do the checking based on the original operand trees, so that
7150 casts will be considered, but default promotions won't be.
7152 Do not warn if the comparison is being done in a signed type,
7153 since the signed type will only be chosen if it can represent
7154 all the values of the unsigned type. */
7155 if (! TREE_UNSIGNED (result_type))
7157 /* Do not warn if both operands are the same signedness. */
7158 else if (op0_signed == op1_signed)
7165 sop = xop0, uop = xop1;
7167 sop = xop1, uop = xop0;
7169 /* Do not warn if the signed quantity is an
7170 unsuffixed integer literal (or some static
7171 constant expression involving such literals or a
7172 conditional expression involving such literals)
7173 and it is non-negative. */
7174 if (c_tree_expr_nonnegative_p (sop))
7176 /* Do not warn if the comparison is an equality operation,
7177 the unsigned quantity is an integral constant, and it
7178 would fit in the result if the result were signed. */
7179 else if (TREE_CODE (uop) == INTEGER_CST
7180 && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
7182 (uop, c_common_signed_type (result_type)))
7184 /* Do not warn if the unsigned quantity is an enumeration
7185 constant and its maximum value would fit in the result
7186 if the result were signed. */
7187 else if (TREE_CODE (uop) == INTEGER_CST
7188 && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
7190 (TYPE_MAX_VALUE (TREE_TYPE(uop)),
7191 c_common_signed_type (result_type)))
7194 warning ("comparison between signed and unsigned");
7197 /* Warn if two unsigned values are being compared in a size
7198 larger than their original size, and one (and only one) is the
7199 result of a `~' operator. This comparison will always fail.
7201 Also warn if one operand is a constant, and the constant
7202 does not have all bits set that are set in the ~ operand
7203 when it is extended. */
7205 if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
7206 != (TREE_CODE (primop1) == BIT_NOT_EXPR))
7208 if (TREE_CODE (primop0) == BIT_NOT_EXPR)
7209 primop0 = get_narrower (TREE_OPERAND (primop0, 0),
7212 primop1 = get_narrower (TREE_OPERAND (primop1, 0),
7215 if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
7218 HOST_WIDE_INT constant, mask;
7219 int unsignedp, bits;
7221 if (host_integerp (primop0, 0))
7224 unsignedp = unsignedp1;
7225 constant = tree_low_cst (primop0, 0);
7230 unsignedp = unsignedp0;
7231 constant = tree_low_cst (primop1, 0);
7234 bits = TYPE_PRECISION (TREE_TYPE (primop));
7235 if (bits < TYPE_PRECISION (result_type)
7236 && bits < HOST_BITS_PER_WIDE_INT && unsignedp)
7238 mask = (~ (HOST_WIDE_INT) 0) << bits;
7239 if ((mask & constant) != mask)
7240 warning ("comparison of promoted ~unsigned with constant");
7243 else if (unsignedp0 && unsignedp1
7244 && (TYPE_PRECISION (TREE_TYPE (primop0))
7245 < TYPE_PRECISION (result_type))
7246 && (TYPE_PRECISION (TREE_TYPE (primop1))
7247 < TYPE_PRECISION (result_type)))
7248 warning ("comparison of promoted ~unsigned with unsigned");
7254 /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
7255 If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
7256 Then the expression will be built.
7257 It will be given type FINAL_TYPE if that is nonzero;
7258 otherwise, it will be given type RESULT_TYPE. */
7262 binary_op_error (code);
7263 return error_mark_node;
7268 if (TREE_TYPE (op0) != result_type)
7269 op0 = convert (result_type, op0);
7270 if (TREE_TYPE (op1) != result_type)
7271 op1 = convert (result_type, op1);
7274 if (build_type == NULL_TREE)
7275 build_type = result_type;
7278 tree result = build (resultcode, build_type, op0, op1);
7281 /* Treat expressions in initializers specially as they can't trap. */
7282 folded = require_constant_value ? fold_initializer (result)
7284 if (folded == result)
7285 TREE_CONSTANT (folded) = TREE_CONSTANT (op0) & TREE_CONSTANT (op1);
7286 if (final_type != 0)
7287 return convert (final_type, folded);